js/src/tests/ecma_2/jsref.js

   1 var completed = false;
   2 var testcases;
   3 var tc = 0;
   4
   5 SECTION = "";
   6 VERSION = "";
   7 BUGNUMBER = "";
   8 EXCLUDE = "";
   9 BUGNUMBER = "";
  10
  11
  12 TZ_DIFF = -8;
  13
  14 var TT = "";
  15 var TT_ = "";
  16 var BR = "";
  17 var NBSP = " ";
  18 var CR = "\n";
  19 var FONT = "";
  20 var FONT_ = "";
  21 var FONT_RED = "";
  22 var FONT_GREEN = "";
  23 var B = "";
  24 var B_ = ""
  25 var H2 = "";
  26 var H2_ = "";
  27 var HR = "";
  28 var DEBUG = false;
  29
  30
  31 var PASSED = " PASSED!"
  32 var FAILED = " FAILED! expected: ";
  33 function test() {
  34     for ( tc=0; tc < testcases.length; tc++ ) {
  35         testcases[tc].passed = writeTestCaseResult(
  36                             testcases[tc].expect,
  37                             testcases[tc].actual,
  38                             testcases[tc].description +" = "+
  39                             testcases[tc].actual );
  40
  41         testcases[tc].reason += ( testcases[tc].passed ) ? "" : "wrong value ";
  42     }
  43     stopTest();
  44     return ( testcases );
  45 }
  46
  47 function TestCase( n, d, e, a ) {
  48     this.name        = n;
  49     this.description = d;
  50     this.expect      = e;
  51     this.actual      = a;
  52     this.passed      = true;
  53     this.reason      = "";
  54     this.bugnumber   = BUGNUMBER;
  55
  56     this.passed = getTestCaseResult( this.expect, this.actual );
  57     if ( DEBUG ) {
  58         print( "added " + this.description );
  59     }
  60 }
  61 function startTest() {
  62     //  JavaScript 1.3 is supposed to be compliant ecma version 1.0
  63     if ( VERSION == "ECMA_1" ) {
  64         version ( "130" );
  65     }
  66     if ( VERSION == "JS_13" ) {
  67         version ( "130" );
  68     }
  69     if ( VERSION == "JS_12" ) {
  70         version ( "120" );
  71     }
  72     if ( VERSION  == "JS_11" ) {
  73         version ( "110" );
  74     }
  75     // for ecma version 2.0, we will leave the javascript version to
  76     // the default ( for now ).
  77     writeHeaderToLog( SECTION + " "+ TITLE);
  78     testcases = new Array();
  79     tc = 0;
  80
  81 }
  82 function getTestCaseResult( expect, actual ) {
  83     //  because ( NaN == NaN ) always returns false, need to do
  84     //  a special compare to see if we got the right result.
  85         if ( actual != actual ) {
  86             if ( typeof actual == "object" ) {
  87                 actual = "NaN object";
  88             } else {
  89                 actual = "NaN number";
  90             }
  91         }
  92         if ( expect != expect ) {
  93             if ( typeof expect == "object" ) {
  94                 expect = "NaN object";
  95             } else {
  96                 expect = "NaN number";
  97             }
  98         }
  99
 100         var passed = ( expect == actual ) ? true : false;
 101
 102     //  if both objects are numbers
 103     // need to replace w/ IEEE standard for rounding
 104         if (    !passed
 105                 && typeof(actual) == "number"
 106                 && typeof(expect) == "number"
 107             ) {
 108                 if ( Math.abs(actual-expect) < 0.0000001 ) {
 109                     passed = true;
 110                 }
 111         }
 112
 113     //  verify type is the same
 114         if ( typeof(expect) != typeof(actual) ) {
 115             passed = false;
 116         }
 117
 118         return passed;
 119 }
 120 function writeTestCaseResult( expect, actual, string ) {
 121         var passed = getTestCaseResult( expect, actual );
 122         writeFormattedResult( expect, actual, string, passed );
 123         return passed;
 124 }
 125 function writeFormattedResult( expect, actual, string, passed ) {
 126         var s = TT + string ;
 127
 128         for ( k = 0;
 129               k <  (60 - string.length >= 0 ? 60 - string.length : 5) ;
 130               k++ ) {
 131         }
 132
 133         s += B ;
 134         s += ( passed ) ? FONT_GREEN + NBSP + PASSED : FONT_RED + NBSP + FAILED + expect + TT_ ;
 135
 136         print( s + FONT_ + B_ + TT_ );
 137
 138         return passed;
 139 }
 140
 141 function writeHeaderToLog( string ) {
 142     print( H2 + string + H2_ );
 143 }
 144 function stopTest()
 145 {
 146     var sizeTag  = "<#TEST CASES SIZE>";
 147     var doneTag  = "<#TEST CASES DONE>";
 148     var beginTag = "<#TEST CASE ";
 149     var endTag   = ">";
 150
 151     print(sizeTag);
 152     print(testcases.length);
 153     for (tc = 0; tc < testcases.length; tc++)
 154     {
 155         print(beginTag + 'PASSED'      + endTag);
 156         print(testcases[tc].passed);
 157         print(beginTag + 'NAME'        + endTag);
 158         print(testcases[tc].name);
 159         print(beginTag + 'EXPECTED'    + endTag);
 160         print(testcases[tc].expect);
 161         print(beginTag + 'ACTUAL'      + endTag);
 162         print(testcases[tc].actual);
 163         print(beginTag + 'DESCRIPTION' + endTag);
 164         print(testcases[tc].description);
 165         print(beginTag + 'REASON'      + endTag);
 166         print(( testcases[tc].passed ) ? "" : "wrong value ");
 167         print(beginTag + 'BUGNUMBER'   + endTag);
 168         print( BUGNUMBER );
 169     }
 170     print(doneTag);
 171     print( HR );
 172     gc();
 173 }
 174 function getFailedCases() {
 175   for ( var i = 0; i < testcases.length; i++ ) {
 176      if ( ! testcases[i].passed ) {
 177         print( testcases[i].description +" = " +testcases[i].actual +" expected: "+ testcases[i].expect );
 178      }
 179   }
 180 }
 181 function err( msg, page, line ) {
 182     testcases[tc].actual = "error";
 183     testcases[tc].reason = msg;
 184     writeTestCaseResult( testcases[tc].expect,
 185                          testcases[tc].actual,
 186                          testcases[tc].description +" = "+ testcases[tc].actual +
 187                          ": " + testcases[tc].reason );
 188     stopTest();
 189     return true;
 190 }
 191
 192 /**
 193  *  Type Conversion functions used by Type Conversion
 194  *
 195  */
 196
 197
 198
 199  /*
 200   * Date functions used by tests in Date suite
 201   *
 202   */
 203 var msPerDay =          86400000;
 204 var HoursPerDay =       24;
 205 var MinutesPerHour =    60;
 206 var SecondsPerMinute =  60;
 207 var msPerSecond =       1000;
 208 var msPerMinute =       60000;      //  msPerSecond * SecondsPerMinute
 209 var msPerHour =         3600000;    //  msPerMinute * MinutesPerHour
 210
 211 var TIME_1970    = 0;
 212 var TIME_2000    = 946684800000;
 213 var TIME_1900    = -2208988800000;
 214
 215 function Day( t ) {
 216     return ( Math.floor(t/msPerDay ) );
 217 }
 218 function DaysInYear( y ) {
 219     if ( y % 4 != 0 ) {
 220         return 365;
 221     }
 222     if ( (y % 4 == 0) && (y % 100 != 0) ) {
 223         return 366;
 224     }
 225     if ( (y % 100 == 0) &&  (y % 400 != 0) ) {
 226         return 365;
 227     }
 228     if ( (y % 400 == 0) ){
 229         return 366;
 230     } else {
 231         return "ERROR: DaysInYear(" + y + ") case not covered";
 232     }
 233 }
 234 function TimeInYear( y ) {
 235     return ( DaysInYear(y) * msPerDay );
 236 }
 237 function DayNumber( t ) {
 238     return ( Math.floor( t / msPerDay ) );
 239 }
 240 function TimeWithinDay( t ) {
 241     if ( t < 0 ) {
 242         return ( (t % msPerDay) + msPerDay );
 243     } else {
 244         return ( t % msPerDay );
 245     }
 246 }
 247 function YearNumber( t ) {
 248 }
 249 function TimeFromYear( y ) {
 250     return ( msPerDay * DayFromYear(y) );
 251 }
 252 function DayFromYear( y ) {
 253     return (    365*(y-1970) +
 254                 Math.floor((y-1969)/4) -
 255                 Math.floor((y-1901)/100) +
 256                 Math.floor((y-1601)/400) );
 257 }
 258 function InLeapYear( t ) {
 259     if ( DaysInYear(YearFromTime(t)) == 365 ) {
 260         return 0;
 261     }
 262     if ( DaysInYear(YearFromTime(t)) == 366 ) {
 263         return 1;
 264     } else {
 265         return "ERROR:  InLeapYear("+t+") case not covered";
 266     }
 267 }
 268 function YearFromTime( t ) {
 269     t = Number( t );
 270     var sign = ( t < 0 ) ? -1 : 1;
 271     var year = ( sign < 0 ) ? 1969 : 1970;
 272     for (   var timeToTimeZero = t; ;  ) {
 273     //  subtract the current year's time from the time that's left.
 274         timeToTimeZero -= sign * TimeInYear(year)
 275
 276     //  if there's less than the current year's worth of time left, then break.
 277         if ( sign < 0 ) {
 278             if ( sign * timeToTimeZero <= 0 ) {
 279                 break;
 280             } else {
 281                 year += sign;
 282             }
 283         } else {
 284             if ( sign * timeToTimeZero < 0 ) {
 285                 break;
 286             } else {
 287                 year += sign;
 288             }
 289         }
 290     }
 291     return ( year );
 292 }
 293 function MonthFromTime( t ) {
 294     //  i know i could use switch but i'd rather not until it's part of ECMA
 295     var day = DayWithinYear( t );
 296     var leap = InLeapYear(t);
 297
 298     if ( (0 <= day) && (day < 31) ) {
 299         return 0;
 300     }
 301     if ( (31 <= day) && (day < (59+leap)) ) {
 302         return 1;
 303     }
 304     if ( ((59+leap) <= day) && (day < (90+leap)) ) {
 305         return 2;
 306     }
 307     if ( ((90+leap) <= day) && (day < (120+leap)) ) {
 308         return 3;
 309     }
 310     if ( ((120+leap) <= day) && (day < (151+leap)) ) {
 311         return 4;
 312     }
 313     if ( ((151+leap) <= day) && (day < (181+leap)) ) {
 314         return 5;
 315     }
 316     if ( ((181+leap) <= day) && (day < (212+leap)) ) {
 317         return 6;
 318     }
 319     if ( ((212+leap) <= day) && (day < (243+leap)) ) {
 320         return 7;
 321     }
 322     if ( ((243+leap) <= day) && (day < (273+leap)) ) {
 323         return 8;
 324     }
 325     if ( ((273+leap) <= day) && (day < (304+leap)) ) {
 326         return 9;
 327     }
 328     if ( ((304+leap) <= day) && (day < (334+leap)) ) {
 329         return 10;
 330     }
 331     if ( ((334+leap) <= day) && (day < (365+leap)) ) {
 332         return 11;
 333     } else {
 334         return "ERROR:  MonthFromTime("+t+") not known";
 335     }
 336 }
 337 function DayWithinYear( t ) {
 338         return( Day(t) - DayFromYear(YearFromTime(t)));
 339 }
 340 function DateFromTime( t ) {
 341     var day = DayWithinYear(t);
 342     var month = MonthFromTime(t);
 343
 344     if ( month == 0 ) {
 345         return ( day + 1 );
 346     }
 347     if ( month == 1 ) {
 348         return ( day - 30 );
 349     }
 350     if ( month == 2 ) {
 351         return ( day - 58 - InLeapYear(t) );
 352     }
 353     if ( month == 3 ) {
 354         return ( day - 89 - InLeapYear(t));
 355     }
 356     if ( month == 4 ) {
 357         return ( day - 119 - InLeapYear(t));
 358     }
 359     if ( month == 5 ) {
 360         return ( day - 150- InLeapYear(t));
 361     }
 362     if ( month == 6 ) {
 363         return ( day - 180- InLeapYear(t));
 364     }
 365     if ( month == 7 ) {
 366         return ( day - 211- InLeapYear(t));
 367     }
 368     if ( month == 8 ) {
 369         return ( day - 242- InLeapYear(t));
 370     }
 371     if ( month == 9 ) {
 372         return ( day - 272- InLeapYear(t));
 373     }
 374     if ( month == 10 ) {
 375         return ( day - 303- InLeapYear(t));
 376     }
 377     if ( month == 11 ) {
 378         return ( day - 333- InLeapYear(t));
 379     }
 380
 381     return ("ERROR:  DateFromTime("+t+") not known" );
 382 }
 383 function WeekDay( t ) {
 384     var weekday = (Day(t)+4) % 7;
 385     return( weekday < 0 ? 7 + weekday : weekday );
 386 }
 387
 388 // missing daylight savins time adjustment
 389
 390 function HourFromTime( t ) {
 391     var h = Math.floor( t / msPerHour ) % HoursPerDay;
 392     return ( (h<0) ? HoursPerDay + h : h  );
 393 }
 394 function MinFromTime( t ) {
 395     var min = Math.floor( t / msPerMinute ) % MinutesPerHour;
 396     return( ( min < 0 ) ? MinutesPerHour + min : min  );
 397 }
 398 function SecFromTime( t ) {
 399     var sec = Math.floor( t / msPerSecond ) % SecondsPerMinute;
 400     return ( (sec < 0 ) ? SecondsPerMinute + sec : sec );
 401 }
 402 function msFromTime( t ) {
 403     var ms = t % msPerSecond;
 404     return ( (ms < 0 ) ? msPerSecond + ms : ms );
 405 }
 406 function LocalTZA() {
 407     return ( TZ_DIFF * msPerHour );
 408 }
 409 function UTC( t ) {
 410     return ( t - LocalTZA() - DaylightSavingTA(t - LocalTZA()) );
 411 }
 412 function DaylightSavingTA( t ) {
 413     t = t - LocalTZA();
 414
 415     var dst_start = GetFirstSundayInApril(t) + 2*msPerHour;
 416     var dst_end   = GetLastSundayInOctober(t)+ 2*msPerHour;
 417
 418     if ( t >= dst_start && t < dst_end ) {
 419         return msPerHour;
 420     } else {
 421         return 0;
 422     }
 423
 424     // Daylight Savings Time starts on the first Sunday in April at 2:00AM in
 425     // PST.  Other time zones will need to override this function.
 426
 427     print( new Date( UTC(dst_start + LocalTZA())) );
 428
 429     return UTC(dst_start  + LocalTZA());
 430 }
 431 function GetFirstSundayInApril( t ) {
 432     var year = YearFromTime(t);
 433     var leap = InLeapYear(t);
 434
 435     var april = TimeFromYear(year) + TimeInMonth(0, leap) + TimeInMonth(1,leap) +
 436     TimeInMonth(2,leap);
 437
 438     for ( var first_sunday = april; WeekDay(first_sunday) > 0;
 439         first_sunday += msPerDay )
 440     {
 441         ;
 442     }
 443
 444     return first_sunday;
 445 }
 446 function GetLastSundayInOctober( t ) {
 447     var year = YearFromTime(t);
 448     var leap = InLeapYear(t);
 449
 450     for ( var oct = TimeFromYear(year), m = 0; m < 9; m++ ) {
 451         oct += TimeInMonth(m, leap);
 452     }
 453     for ( var last_sunday = oct + 30*msPerDay; WeekDay(last_sunday) > 0;
 454         last_sunday -= msPerDay )
 455     {
 456         ;
 457     }
 458     return last_sunday;
 459 }
 460 function LocalTime( t ) {
 461     return ( t + LocalTZA() + DaylightSavingTA(t) );
 462 }
 463 function MakeTime( hour, min, sec, ms ) {
 464     if ( isNaN( hour ) || isNaN( min ) || isNaN( sec ) || isNaN( ms ) ) {
 465         return Number.NaN;
 466     }
 467
 468     hour = ToInteger(hour);
 469     min  = ToInteger( min);
 470     sec  = ToInteger( sec);
 471     ms   = ToInteger( ms );
 472
 473     return( (hour*msPerHour) + (min*msPerMinute) +
 474             (sec*msPerSecond) + ms );
 475 }
 476 function MakeDay( year, month, date ) {
 477     if ( isNaN(year) || isNaN(month) || isNaN(date) ) {
 478         return Number.NaN;
 479     }
 480     year = ToInteger(year);
 481     month = ToInteger(month);
 482     date = ToInteger(date );
 483
 484     var sign = ( year < 1970 ) ? -1 : 1;
 485     var t =    ( year < 1970 ) ? 1 :  0;
 486     var y =    ( year < 1970 ) ? 1969 : 1970;
 487
 488     var result5 = year + Math.floor( month/12 );
 489     var result6 = month % 12;
 490
 491     if ( year < 1970 ) {
 492        for ( y = 1969; y >= year; y += sign ) {
 493          t += sign * TimeInYear(y);
 494        }
 495     } else {
 496         for ( y = 1970 ; y < year; y += sign ) {
 497             t += sign * TimeInYear(y);
 498         }
 499     }
 500
 501     var leap = InLeapYear( t );
 502
 503     for ( var m = 0; m < month; m++ ) {
 504         t += TimeInMonth( m, leap );
 505     }
 506
 507     if ( YearFromTime(t) != result5 ) {
 508         return Number.NaN;
 509     }
 510     if ( MonthFromTime(t) != result6 ) {
 511         return Number.NaN;
 512     }
 513     if ( DateFromTime(t) != 1 ) {
 514         return Number.NaN;
 515     }
 516
 517     return ( (Day(t)) + date - 1 );
 518 }
 519 function TimeInMonth( month, leap ) {
 520     // september april june november
 521     // jan 0  feb 1  mar 2  apr 3   may 4  june 5  jul 6
 522     // aug 7  sep 8  oct 9  nov 10  dec 11
 523
 524     if ( month == 3 || month == 5 || month == 8 || month == 10 ) {
 525         return ( 30*msPerDay );
 526     }
 527
 528     // all the rest
 529     if ( month == 0 || month == 2 || month == 4 || month == 6 ||
 530          month == 7 || month == 9 || month == 11 ) {
 531         return ( 31*msPerDay );
 532      }
 533
 534     // save february
 535     return ( (leap == 0) ? 28*msPerDay : 29*msPerDay );
 536 }
 537 function MakeDate( day, time ) {
 538     if (    day == Number.POSITIVE_INFINITY ||
 539             day == Number.NEGATIVE_INFINITY ||
 540             day == Number.NaN ) {
 541         return Number.NaN;
 542     }
 543     if (    time == Number.POSITIVE_INFINITY ||
 544             time == Number.POSITIVE_INFINITY ||
 545             day == Number.NaN) {
 546         return Number.NaN;
 547     }
 548     return ( day * msPerDay ) + time;
 549 }
 550 function TimeClip( t ) {
 551     if ( isNaN( t ) ) {
 552         return ( Number.NaN );
 553     }
 554     if ( Math.abs( t ) > 8.64e15 ) {
 555         return ( Number.NaN );
 556     }
 557
 558     return ( ToInteger( t ) );
 559 }
 560 function ToInteger( t ) {
 561     t = Number( t );
 562
 563     if ( isNaN( t ) ){
 564         return ( Number.NaN );
 565     }
 566     if ( t == 0 || t == -0 ||
 567          t == Number.POSITIVE_INFINITY || t == Number.NEGATIVE_INFINITY ) {
 568          return 0;
 569     }
 570
 571     var sign = ( t < 0 ) ? -1 : 1;
 572
 573     return ( sign * Math.floor( Math.abs( t ) ) );
 574 }
 575 function Enumerate ( o ) {
 576     var properties = new Array();
 577     for ( p in o ) {
 578        properties[ properties.length ] = new Array( p, o[p] );
 579     }
 580     return properties;
 581 }
 582 function AddTestCase( description, expect, actual ) {
 583     testcases[tc++] = new TestCase( SECTION, description, expect, actual );
 584 }
 585 function getFailedCases() {
 586   for ( var i = 0; i < testcases.length; i++ ) {
 587      if ( ! testcases[i].passed ) {
 588         print( testcases[i].description +" = " +testcases[i].actual +" expected: "+ testcases[i].expect );
 589      }
 590   }
 591 }