LayoutTests/fast/js/resources/date-set-to-nan.js

   1 description(
   2 "This tests if the Date setters handle invalid parameters correctly resulting in a NaN date and if a recovery from such a NaN date is only possible by using the date.setTime() and date.set[[UTC]Full]Year() functions."
   3 );
   4
   5 var dateFunctionNameRoots = [
   6     "Time",
   7     "Milliseconds",
   8     "UTCMilliseconds",
   9     "Seconds",
  10     "UTCSeconds",
  11     "Minutes",
  12     "UTCMinutes",
  13     "Hours",
  14     "UTCHours",
  15     "Date",
  16     "UTCDate",
  17     "Month",
  18     "UTCMonth",
  19     "FullYear",
  20     "UTCFullYear",
  21     "Year"
  22 ];
  23
  24 var dateFunctionParameterNum = [
  25     1,
  26     1,
  27     1,
  28     2,
  29     2,
  30     3,
  31     3,
  32     4,
  33     4,
  34     1,
  35     1,
  36     2,
  37     2,
  38     3,
  39     3,
  40     1
  41 ];
  42
  43 var testValues = [
  44     0,
  45     Number.NaN,
  46     Number.POSITIVE_INFINITY,
  47     Number.NEGATIVE_INFINITY
  48 ];
  49
  50 function testDateFunctionWithValueNoRecoverNaN(functionNameRoot, steps)
  51 {
  52     var date = new Date();
  53     var setValue = date["get" + functionNameRoot]();
  54     date.setMilliseconds(Number.NaN);
  55     var params = [
  56         "",
  57         ", 0",
  58         ", 0, 0",
  59         ", 0, 0, 0"
  60     ];
  61     var setResult = (1 == steps) ?  date["set" + functionNameRoot](setValue)
  62                   : ((2 == steps) ? date["set" + functionNameRoot](setValue, 0)
  63                   : ((3 == steps) ? date["set" + functionNameRoot](setValue, 0, 0)
  64                   :                  date["set" + functionNameRoot](setValue, 0, 0, 0)));
  65     if (!isNaN(setResult)) {
  66         testFailed("date(NaN).set" + functionNameRoot + "(" + setValue + params[steps - 1]
  67                                    + ") was " + setResult + " instead of NaN");
  68         return false;
  69     }
  70     var getResult = date["get" + functionNameRoot]();
  71     if (!isNaN(getResult)) {
  72         testFailed("date.get" + functionNameRoot + "() was " + getResult + " instead of NaN");
  73         return false;
  74     }
  75     testPassed ("no recovering from NaN date using date.set" + functionNameRoot
  76         + "(arg0" + params[steps - 1] + ")");
  77     return true;
  78 }
  79
  80 function testDateFunctionWithValueRecoverTime(functionNameRoot)
  81 {
  82     var date = new Date();
  83     var setValue = date["get" + functionNameRoot]();
  84     date.setMilliseconds(Number.NaN);
  85     var setResult = date["set" + functionNameRoot](setValue);
  86     if (setValue != setResult) {
  87         testFailed("date(NaN).set" + functionNameRoot + "(" + setValue + ") was " + setResult + " instead of " + setValue);
  88         return false;
  89     }
  90     var getResult = date["get" + functionNameRoot]();
  91     if (getResult != setValue) {
  92         testFailed("date.get" + functionNameRoot + "() was " + getResult + " instead of " + setValue);
  93         return false;
  94     }
  95     testPassed ("recover from NaN date using date.set" + functionNameRoot + "()");
  96     return true;
  97 }
  98
  99 function testDateFunctionWithValueRecoverFullYear(functionNameRoot)
 100 {
 101     var result = true;
 102     var date = new Date();
 103     var setValue = date["get" + functionNameRoot]();
 104     date.setMilliseconds(Number.NaN);
 105     var setResult = date["set" + functionNameRoot](setValue);
 106     var getResult = date["get" + functionNameRoot]();
 107     if (getResult != setValue) {
 108         testFailed("date.get" + functionNameRoot + "() was " + getResult + " instead of " + setValue);
 109         result = false;
 110     }
 111     getResult = date.getMilliseconds();
 112     if (getResult != 0) {
 113         testFailed("date.getMilliseconds() was " + getResult + " instead of 0");
 114         result = false;
 115     }
 116     getResult = date.getSeconds();
 117     if (getResult != 0) {
 118         testFailed("date.getSeconds() was " + getResult + " instead of 0");
 119         result = false;
 120     }
 121     getResult = date.getMinutes();
 122     if (getResult != 0) {
 123         testFailed("date.getMinutes() was " + getResult + " instead of 0");
 124         result = false;
 125     }
 126     getResult = date.getHours();
 127     if (getResult != 0) {
 128         testFailed("date.getHours() was " + getResult + " instead of 0");
 129         result = false;
 130     }
 131     getResult = date.getDate();
 132     if (getResult != 1) {
 133         testFailed("date.getDate() was " + getResult + " instead of 1");
 134         result = false;
 135     }
 136     getResult = date.getMonth();
 137     if (getResult != 0) {
 138         testFailed("date.getMonth() was " + getResult + " instead of 0");
 139         result = false;
 140     }
 141     if (result)
 142         testPassed ("recover from NaN date using date.setFullYear()");
 143     else
 144         testFailed ("recover from NaN date using date.setFullYear()");
 145     return result;
 146 }
 147
 148 function testDateFunctionWithValueRecoverUTCFullYear(functionNameRoot)
 149 {
 150     var result = true;
 151     var date = new Date();
 152     var setValue = date["get" + functionNameRoot]();
 153     date.setMilliseconds(Number.NaN);
 154     var setResult = date["set" + functionNameRoot](setValue);
 155     var getResult = date["get" + functionNameRoot]();
 156     if (getResult != setValue) {
 157         testFailed("date.get" + functionNameRoot + "() was " + getResult + " instead of " + setValue);
 158         result = false;
 159     }
 160     getResult = date.getUTCMilliseconds();
 161     if (getResult != 0) {
 162         testFailed("date.getUTCMilliseconds() was " + getResult + " instead of 0");
 163         result = false;
 164     }
 165     getResult = date.getUTCSeconds();
 166     if (getResult != 0) {
 167         testFailed("date.getUTCSeconds() was " + getResult + " instead of 0");
 168         result = false;
 169     }
 170     getResult = date.getUTCMinutes();
 171     if (getResult != 0) {
 172         testFailed("date.getUTCMinutes() was " + getResult + " instead of 0");
 173         result = false;
 174     }
 175     getResult = date.getUTCHours();
 176     if (getResult != 0) {
 177         testFailed("date.getUTCHours() was " + getResult + " instead of 0");
 178         result = false;
 179     }
 180     getResult = date.getUTCDate();
 181     if (getResult != 1) {
 182         testFailed("date.getUTCDate() was " + getResult + " instead of 1");
 183         result = false;
 184     }
 185     getResult = date.getUTCMonth();
 186     if (getResult != 0) {
 187         testFailed("date.getUTCMonth() was " + getResult + " instead of 0");
 188         result = false;
 189     }
 190     if (result)
 191         testPassed ("recover from NaN date using date.setUTCFullYear()");
 192     else
 193         testFailed ("recover from NaN date using date.setUTCFullYear()");
 194     return result;
 195 }
 196
 197 function testDateFunctionWithValueRecoverYear(functionNameRoot)
 198 {
 199     var result = true;
 200     var is13Compatible = true;
 201
 202     var date = new Date();
 203     var setValue = date["get" + functionNameRoot]();
 204     var fullYears = date.getFullYear() - 1900;
 205     if (setValue != fullYears) {
 206         testFailed("date.get" + functionNameRoot + "() was " + setValue + " instead of " + fullYears);
 207         is13Compatible = false;
 208     } else
 209         testPassed("date.getYear() is compatible to JavaScript 1.3 and later");
 210
 211     date.setMilliseconds(Number.NaN);
 212     var setResult = date["set" + functionNameRoot](setValue + 1900);
 213     var getResult = date["get" + functionNameRoot]();
 214     if (getResult != setValue) {
 215         testFailed("date.get" + functionNameRoot + "() was " + getResult + " instead of " + setValue);
 216         result = false;
 217     }
 218     getResult = date.getMilliseconds();
 219     if (getResult != 0) {
 220         testFailed("date.getMilliseconds() was " + getResult + " instead of 0");
 221         result = false;
 222     }
 223     getResult = date.getSeconds();
 224     if (getResult != 0) {
 225         testFailed("date.getSeconds() was " + getResult + " instead of 0");
 226         result = false;
 227     }
 228     getResult = date.getMinutes();
 229     if (getResult != 0) {
 230         testFailed("date.getMinutes() was " + getResult + " instead of 0");
 231         result = false;
 232     }
 233     getResult = date.getHours();
 234     if (getResult != 0) {
 235         testFailed("date.getHours() was " + getResult + " instead of 0");
 236         result = false;
 237     }
 238     getResult = date.getDate();
 239     if (getResult != 1) {
 240         testFailed("date.getDate() was " + getResult + " instead of 1");
 241         result = false;
 242     }
 243     getResult = date.getMonth();
 244     if (getResult != 0) {
 245         testFailed("date.getMonth() was " + getResult + " instead of 0");
 246         result = false;
 247     }
 248     if (result)
 249         testPassed ("recover from NaN date using date.setUTCFullYear()");
 250     else
 251         testFailed ("recover from NaN date using date.setUTCFullYear()");
 252     return result && is13Compatible;
 253 }
 254
 255 function makeIEHappy(functionNameRoot, value)
 256 {
 257     var date = new Date();
 258     var setResult = date["set" + functionNameRoot](value);
 259     if (!isNaN(setResult)) {
 260         testFailed("date.set" + functionNameRoot
 261                               + "() was "
 262                               + setResult + " instead of NaN");
 263          return false;
 264     }
 265     var getResult = date["get" + functionNameRoot]();
 266     if (!isNaN(getResult)) {
 267         testFailed("date.get" + functionNameRoot + "() was "
 268                               + getResult + " instead of NaN");
 269         return false;
 270     }
 271     return true
 272 }
 273
 274 function testDateFunctionWithValueExpectingNaN1(functionNameRoot)
 275 {
 276     var result = true;
 277     for (var idx0 in testValues)
 278         if (idx0 != 0) {
 279             var date = new Date();
 280             var setResult = date["set" + functionNameRoot](testValues[idx0]);
 281             if (!isNaN(setResult)) {
 282                 testFailed("date.set" + functionNameRoot + "("
 283                                       + testValues[idx0] + ") was "
 284                                       + setResult + " instead of NaN");
 285                 result = false;
 286             }
 287             var getResult = date["get" + functionNameRoot]();
 288             if (!isNaN(getResult)) {
 289                 testFailed("date.get" + functionNameRoot + "() was "
 290                                       + getResult + " instead of NaN");
 291                 result = false;
 292             }
 293         } else if (!makeIEHappy(functionNameRoot))
 294             result = false;
 295     if (result) {
 296         testPassed("date.set" + functionNameRoot + "(arg0)");
 297         testPassed("date.set" + functionNameRoot + "()");
 298     }
 299     return result;
 300 }
 301
 302 function testDateFunctionWithValueExpectingNaN2(functionNameRoot)
 303 {
 304     var result = true;
 305     for (var idx0 in testValues)
 306         for (var idx1 in testValues)
 307             if (idx0 != 0 || idx1 != 0) {
 308                 var date = new Date();
 309                 var setResult = date["set" + functionNameRoot](testValues[idx0],
 310                                                                testValues[idx1]);
 311
 312                 if (!isNaN(setResult)) {
 313                     testFailed("date.set" + functionNameRoot + "("
 314                                           + testValues[idx0] + ", "
 315                                           + testValues[idx1] + ") was "
 316                                           + setResult + " instead of NaN");
 317                     result = false;
 318                 }
 319                 var getResult = date["get" + functionNameRoot]();
 320                 if (!isNaN(getResult)) {
 321                     testFailed("date.get" + functionNameRoot + "() was "
 322                                           + getResult + " instead of NaN");
 323                     result = false;
 324                 }
 325             }
 326
 327     if (result)
 328         testPassed("date.set" + functionNameRoot + "(arg0, arg1)");
 329     return result;
 330 }
 331
 332 function testDateFunctionWithValueExpectingNaN3(functionNameRoot)
 333 {
 334     var result = true;
 335     for (var idx0 in testValues)
 336         for (var idx1 in testValues)
 337             for (var idx2 in testValues)
 338                 if (idx0 != 0 || idx1 != 0 || idx2 != 0) {
 339                     var date = new Date();
 340                     var setResult = date["set" + functionNameRoot](testValues[idx0],
 341                                                                    testValues[idx1],
 342                                                                    testValues[idx2]);
 343                     if (!isNaN(setResult)) {
 344                         testFailed("date.set" + functionNameRoot + "("
 345                                               + testValues[idx0] + ", "
 346                                               + testValues[idx1] + ", "
 347                                               + testValues[idx2] + ") was "
 348                                               + setResult + " instead of NaN");
 349                         result = false;
 350                     }
 351                     var getResult = date["get" + functionNameRoot]();
 352                     if (!isNaN(getResult)) {
 353                         testFailed("date.get" + functionNameRoot + "() was "
 354                                               + getResult + " instead of NaN");
 355                         result = false;
 356                     }
 357                 }
 358
 359     if (result)
 360         testPassed("date.set" + functionNameRoot + "(arg0, arg1, arg2)");
 361     return result;
 362 }
 363
 364 function testDateFunctionWithValueExpectingNaN4(functionNameRoot)
 365 {
 366     var result = true;
 367     for (var idx0 in testValues)
 368         for (var idx1 in testValues)
 369             for (var idx2 in testValues)
 370                 for (var idx3 in testValues)
 371                     if (idx0 != 0 || idx1 != 0 || idx2 != 0 || idx3 != 0) {
 372                         var date = new Date();
 373                         var setResult = date["set" + functionNameRoot](testValues[idx0],
 374                                                                        testValues[idx1],
 375                                                                        testValues[idx2],
 376                                                                        testValues[idx3]);
 377                         if (!isNaN(setResult)) {
 378                             testFailed("date.set" + functionNameRoot + "("
 379                                                   + testValues[idx0] + ", "
 380                                                   + testValues[idx1] + ", "
 381                                                   + testValues[idx2] + ", "
 382                                                   + testValues[idx3] + ") was "
 383                                                   + setResult + " instead of NaN");
 384                             result = false;
 385                         }
 386                         var getResult = date["get" + functionNameRoot]();
 387                         if (!isNaN(getResult)) {
 388                             testFailed("date.get" + functionNameRoot + "() was "
 389                                                   + getResult + " instead of NaN");
 390                             result = false;
 391                         }
 392                     }
 393     if (result)
 394         testPassed("date.set" + functionNameRoot + "(arg0, arg1, arg2, arg3)");
 395     return result;
 396 }
 397
 398
 399
 400 function testDateFunction(functionNameRoot, functionParamNum)
 401 {
 402     var success = true;
 403
 404     switch (functionParamNum) {
 405     case 4:
 406         success &= testDateFunctionWithValueExpectingNaN4(functionNameRoot);
 407         if (functionNameRoot != "Time" &&
 408             functionNameRoot != "FullYear" &&
 409             functionNameRoot != "UTCFullYear" &&
 410             functionNameRoot != "Year")
 411             success &= testDateFunctionWithValueNoRecoverNaN(functionNameRoot, 4);
 412
 413     case 3:
 414         success &= testDateFunctionWithValueExpectingNaN3(functionNameRoot);
 415         if (functionNameRoot != "Time" &&
 416             functionNameRoot != "FullYear" &&
 417             functionNameRoot != "UTCFullYear" &&
 418             functionNameRoot != "Year")
 419             success &= testDateFunctionWithValueNoRecoverNaN(functionNameRoot, 3);
 420
 421     case 2:
 422         success &= testDateFunctionWithValueExpectingNaN2(functionNameRoot);
 423         if (functionNameRoot != "Time" &&
 424             functionNameRoot != "FullYear" &&
 425             functionNameRoot != "UTCFullYear" &&
 426             functionNameRoot != "Year")
 427             success &= testDateFunctionWithValueNoRecoverNaN(functionNameRoot, 2);
 428
 429     case 1:
 430         success &= testDateFunctionWithValueExpectingNaN1(functionNameRoot);
 431         if (functionNameRoot == "Time")
 432             success &= testDateFunctionWithValueRecoverTime(functionNameRoot);
 433         else if (functionNameRoot == "FullYear")
 434             success &= testDateFunctionWithValueRecoverFullYear(functionNameRoot);
 435         else if (functionNameRoot == "UTCFullYear")
 436             success &= testDateFunctionWithValueRecoverUTCFullYear(functionNameRoot);
 437         else if (functionNameRoot == "Year")
 438             success &= testDateFunctionWithValueRecoverYear(functionNameRoot);
 439         else
 440             success &= testDateFunctionWithValueNoRecoverNaN(functionNameRoot, 1);
 441     }
 442
 443     if (success)
 444         testPassed("date.set" + functionNameRoot + " passed all tests");
 445 }
 446
 447 for (var x in dateFunctionNameRoots)
 448 {
 449     testDateFunction(dateFunctionNameRoots[x], dateFunctionParameterNum[x]);
 450 }
 451
 452 var successfullyParsed = true;