2006-11-20 W. Andy Carrel <wac@google.com>
[WebKit-https.git] / JavaScriptCore / tests / mozilla / 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         writeLineToLog( "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         writeLineToLog( s + FONT_ + B_ + TT_ );
137
138         return passed;
139 }
140
141 function writeLineToLog( string ) {
142     print( string + BR + CR );
143 }
144 function writeHeaderToLog( string ) {
145     print( H2 + string + H2_ );
146 }
147 function stopTest()
148 {
149     var sizeTag  = "<#TEST CASES SIZE>";
150     var doneTag  = "<#TEST CASES DONE>";
151     var beginTag = "<#TEST CASE ";
152     var endTag   = ">";
153
154     print(sizeTag);
155     print(testcases.length);
156     for (tc = 0; tc < testcases.length; tc++)
157     {
158         print(beginTag + 'PASSED'      + endTag);
159         print(testcases[tc].passed);
160         print(beginTag + 'NAME'        + endTag);
161         print(testcases[tc].name);
162         print(beginTag + 'EXPECTED'    + endTag);
163         print(testcases[tc].expect);
164         print(beginTag + 'ACTUAL'      + endTag);
165         print(testcases[tc].actual);
166         print(beginTag + 'DESCRIPTION' + endTag);
167         print(testcases[tc].description);
168         print(beginTag + 'REASON'      + endTag);
169         print(( testcases[tc].passed ) ? "" : "wrong value ");
170         print(beginTag + 'BUGNUMBER'   + endTag);
171         print( BUGNUMBER );
172     }
173     print(doneTag);
174     print( HR );
175     gc();
176 }
177 function getFailedCases() {
178   for ( var i = 0; i < testcases.length; i++ ) {
179      if ( ! testcases[i].passed ) {
180         print( testcases[i].description +" = " +testcases[i].actual +" expected: "+ testcases[i].expect );
181      }
182   }
183 }
184 function err( msg, page, line ) {
185     testcases[tc].actual = "error";
186     testcases[tc].reason = msg;
187     writeTestCaseResult( testcases[tc].expect,
188                          testcases[tc].actual,
189                          testcases[tc].description +" = "+ testcases[tc].actual +
190                          ": " + testcases[tc].reason );
191     stopTest();
192     return true;
193 }
194
195 /**
196  *  Type Conversion functions used by Type Conversion
197  *
198  */
199
200
201
202  /*
203   * Date functions used by tests in Date suite
204   *
205   */
206 var msPerDay =          86400000;
207 var HoursPerDay =       24;
208 var MinutesPerHour =    60;
209 var SecondsPerMinute =  60;
210 var msPerSecond =       1000;
211 var msPerMinute =       60000;      //  msPerSecond * SecondsPerMinute
212 var msPerHour =         3600000;    //  msPerMinute * MinutesPerHour
213
214 var TIME_1970    = 0;
215 var TIME_2000    = 946684800000;
216 var TIME_1900    = -2208988800000;
217
218 function Day( t ) {
219     return ( Math.floor(t/msPerDay ) );
220 }
221 function DaysInYear( y ) {
222     if ( y % 4 != 0 ) {
223         return 365;
224     }
225     if ( (y % 4 == 0) && (y % 100 != 0) ) {
226         return 366;
227     }
228     if ( (y % 100 == 0) &&  (y % 400 != 0) ) {
229         return 365;
230     }
231     if ( (y % 400 == 0) ){
232         return 366;
233     } else {
234         return "ERROR: DaysInYear(" + y + ") case not covered";
235     }
236 }
237 function TimeInYear( y ) {
238     return ( DaysInYear(y) * msPerDay );
239 }
240 function DayNumber( t ) {
241     return ( Math.floor( t / msPerDay ) );
242 }
243 function TimeWithinDay( t ) {
244     if ( t < 0 ) {
245         return ( (t % msPerDay) + msPerDay );
246     } else {
247         return ( t % msPerDay );
248     }
249 }
250 function YearNumber( t ) {
251 }
252 function TimeFromYear( y ) {
253     return ( msPerDay * DayFromYear(y) );
254 }
255 function DayFromYear( y ) {
256     return (    365*(y-1970) +
257                 Math.floor((y-1969)/4) -
258                 Math.floor((y-1901)/100) +
259                 Math.floor((y-1601)/400) );
260 }
261 function InLeapYear( t ) {
262     if ( DaysInYear(YearFromTime(t)) == 365 ) {
263         return 0;
264     }
265     if ( DaysInYear(YearFromTime(t)) == 366 ) {
266         return 1;
267     } else {
268         return "ERROR:  InLeapYear("+t+") case not covered";
269     }
270 }
271 function YearFromTime( t ) {
272     t = Number( t );
273     var sign = ( t < 0 ) ? -1 : 1;
274     var year = ( sign < 0 ) ? 1969 : 1970;
275     for (   var timeToTimeZero = t; ;  ) {
276     //  subtract the current year's time from the time that's left.
277         timeToTimeZero -= sign * TimeInYear(year)
278
279     //  if there's less than the current year's worth of time left, then break.
280         if ( sign < 0 ) {
281             if ( sign * timeToTimeZero <= 0 ) {
282                 break;
283             } else {
284                 year += sign;
285             }
286         } else {
287             if ( sign * timeToTimeZero < 0 ) {
288                 break;
289             } else {
290                 year += sign;
291             }
292         }
293     }
294     return ( year );
295 }
296 function MonthFromTime( t ) {
297     //  i know i could use switch but i'd rather not until it's part of ECMA
298     var day = DayWithinYear( t );
299     var leap = InLeapYear(t);
300
301     if ( (0 <= day) && (day < 31) ) {
302         return 0;
303     }
304     if ( (31 <= day) && (day < (59+leap)) ) {
305         return 1;
306     }
307     if ( ((59+leap) <= day) && (day < (90+leap)) ) {
308         return 2;
309     }
310     if ( ((90+leap) <= day) && (day < (120+leap)) ) {
311         return 3;
312     }
313     if ( ((120+leap) <= day) && (day < (151+leap)) ) {
314         return 4;
315     }
316     if ( ((151+leap) <= day) && (day < (181+leap)) ) {
317         return 5;
318     }
319     if ( ((181+leap) <= day) && (day < (212+leap)) ) {
320         return 6;
321     }
322     if ( ((212+leap) <= day) && (day < (243+leap)) ) {
323         return 7;
324     }
325     if ( ((243+leap) <= day) && (day < (273+leap)) ) {
326         return 8;
327     }
328     if ( ((273+leap) <= day) && (day < (304+leap)) ) {
329         return 9;
330     }
331     if ( ((304+leap) <= day) && (day < (334+leap)) ) {
332         return 10;
333     }
334     if ( ((334+leap) <= day) && (day < (365+leap)) ) {
335         return 11;
336     } else {
337         return "ERROR:  MonthFromTime("+t+") not known";
338     }
339 }
340 function DayWithinYear( t ) {
341         return( Day(t) - DayFromYear(YearFromTime(t)));
342 }
343 function DateFromTime( t ) {
344     var day = DayWithinYear(t);
345     var month = MonthFromTime(t);
346
347     if ( month == 0 ) {
348         return ( day + 1 );
349     }
350     if ( month == 1 ) {
351         return ( day - 30 );
352     }
353     if ( month == 2 ) {
354         return ( day - 58 - InLeapYear(t) );
355     }
356     if ( month == 3 ) {
357         return ( day - 89 - InLeapYear(t));
358     }
359     if ( month == 4 ) {
360         return ( day - 119 - InLeapYear(t));
361     }
362     if ( month == 5 ) {
363         return ( day - 150- InLeapYear(t));
364     }
365     if ( month == 6 ) {
366         return ( day - 180- InLeapYear(t));
367     }
368     if ( month == 7 ) {
369         return ( day - 211- InLeapYear(t));
370     }
371     if ( month == 8 ) {
372         return ( day - 242- InLeapYear(t));
373     }
374     if ( month == 9 ) {
375         return ( day - 272- InLeapYear(t));
376     }
377     if ( month == 10 ) {
378         return ( day - 303- InLeapYear(t));
379     }
380     if ( month == 11 ) {
381         return ( day - 333- InLeapYear(t));
382     }
383
384     return ("ERROR:  DateFromTime("+t+") not known" );
385 }
386 function WeekDay( t ) {
387     var weekday = (Day(t)+4) % 7;
388     return( weekday < 0 ? 7 + weekday : weekday );
389 }
390
391 // missing daylight savins time adjustment
392
393 function HourFromTime( t ) {
394     var h = Math.floor( t / msPerHour ) % HoursPerDay;
395     return ( (h<0) ? HoursPerDay + h : h  );
396 }
397 function MinFromTime( t ) {
398     var min = Math.floor( t / msPerMinute ) % MinutesPerHour;
399     return( ( min < 0 ) ? MinutesPerHour + min : min  );
400 }
401 function SecFromTime( t ) {
402     var sec = Math.floor( t / msPerSecond ) % SecondsPerMinute;
403     return ( (sec < 0 ) ? SecondsPerMinute + sec : sec );
404 }
405 function msFromTime( t ) {
406     var ms = t % msPerSecond;
407     return ( (ms < 0 ) ? msPerSecond + ms : ms );
408 }
409 function LocalTZA() {
410     return ( TZ_DIFF * msPerHour );
411 }
412 function UTC( t ) {
413     return ( t - LocalTZA() - DaylightSavingTA(t - LocalTZA()) );
414 }
415 function DaylightSavingTA( t ) {
416     t = t - LocalTZA();
417
418     var dst_start = GetFirstSundayInApril(t) + 2*msPerHour;
419     var dst_end   = GetLastSundayInOctober(t)+ 2*msPerHour;
420
421     if ( t >= dst_start && t < dst_end ) {
422         return msPerHour;
423     } else {
424         return 0;
425     }
426
427     // Daylight Savings Time starts on the first Sunday in April at 2:00AM in
428     // PST.  Other time zones will need to override this function.
429
430     print( new Date( UTC(dst_start + LocalTZA())) );
431
432     return UTC(dst_start  + LocalTZA());
433 }
434 function GetFirstSundayInApril( t ) {
435     var year = YearFromTime(t);
436     var leap = InLeapYear(t);
437
438     var april = TimeFromYear(year) + TimeInMonth(0, leap) + TimeInMonth(1,leap) +
439     TimeInMonth(2,leap);
440
441     for ( var first_sunday = april; WeekDay(first_sunday) > 0;
442         first_sunday += msPerDay )
443     {
444         ;
445     }
446
447     return first_sunday;
448 }
449 function GetLastSundayInOctober( t ) {
450     var year = YearFromTime(t);
451     var leap = InLeapYear(t);
452
453     for ( var oct = TimeFromYear(year), m = 0; m < 9; m++ ) {
454         oct += TimeInMonth(m, leap);
455     }
456     for ( var last_sunday = oct + 30*msPerDay; WeekDay(last_sunday) > 0;
457         last_sunday -= msPerDay )
458     {
459         ;
460     }
461     return last_sunday;
462 }
463 function LocalTime( t ) {
464     return ( t + LocalTZA() + DaylightSavingTA(t) );
465 }
466 function MakeTime( hour, min, sec, ms ) {
467     if ( isNaN( hour ) || isNaN( min ) || isNaN( sec ) || isNaN( ms ) ) {
468         return Number.NaN;
469     }
470
471     hour = ToInteger(hour);
472     min  = ToInteger( min);
473     sec  = ToInteger( sec);
474     ms   = ToInteger( ms );
475
476     return( (hour*msPerHour) + (min*msPerMinute) +
477             (sec*msPerSecond) + ms );
478 }
479 function MakeDay( year, month, date ) {
480     if ( isNaN(year) || isNaN(month) || isNaN(date) ) {
481         return Number.NaN;
482     }
483     year = ToInteger(year);
484     month = ToInteger(month);
485     date = ToInteger(date );
486
487     var sign = ( year < 1970 ) ? -1 : 1;
488     var t =    ( year < 1970 ) ? 1 :  0;
489     var y =    ( year < 1970 ) ? 1969 : 1970;
490
491     var result5 = year + Math.floor( month/12 );
492     var result6 = month % 12;
493
494     if ( year < 1970 ) {
495        for ( y = 1969; y >= year; y += sign ) {
496          t += sign * TimeInYear(y);
497        }
498     } else {
499         for ( y = 1970 ; y < year; y += sign ) {
500             t += sign * TimeInYear(y);
501         }
502     }
503
504     var leap = InLeapYear( t );
505
506     for ( var m = 0; m < month; m++ ) {
507         t += TimeInMonth( m, leap );
508     }
509
510     if ( YearFromTime(t) != result5 ) {
511         return Number.NaN;
512     }
513     if ( MonthFromTime(t) != result6 ) {
514         return Number.NaN;
515     }
516     if ( DateFromTime(t) != 1 ) {
517         return Number.NaN;
518     }
519
520     return ( (Day(t)) + date - 1 );
521 }
522 function TimeInMonth( month, leap ) {
523     // september april june november
524     // jan 0  feb 1  mar 2  apr 3   may 4  june 5  jul 6
525     // aug 7  sep 8  oct 9  nov 10  dec 11
526
527     if ( month == 3 || month == 5 || month == 8 || month == 10 ) {
528         return ( 30*msPerDay );
529     }
530
531     // all the rest
532     if ( month == 0 || month == 2 || month == 4 || month == 6 ||
533          month == 7 || month == 9 || month == 11 ) {
534         return ( 31*msPerDay );
535      }
536
537     // save february
538     return ( (leap == 0) ? 28*msPerDay : 29*msPerDay );
539 }
540 function MakeDate( day, time ) {
541     if (    day == Number.POSITIVE_INFINITY ||
542             day == Number.NEGATIVE_INFINITY ||
543             day == Number.NaN ) {
544         return Number.NaN;
545     }
546     if (    time == Number.POSITIVE_INFINITY ||
547             time == Number.POSITIVE_INFINITY ||
548             day == Number.NaN) {
549         return Number.NaN;
550     }
551     return ( day * msPerDay ) + time;
552 }
553 function TimeClip( t ) {
554     if ( isNaN( t ) ) {
555         return ( Number.NaN );
556     }
557     if ( Math.abs( t ) > 8.64e15 ) {
558         return ( Number.NaN );
559     }
560
561     return ( ToInteger( t ) );
562 }
563 function ToInteger( t ) {
564     t = Number( t );
565
566     if ( isNaN( t ) ){
567         return ( Number.NaN );
568     }
569     if ( t == 0 || t == -0 ||
570          t == Number.POSITIVE_INFINITY || t == Number.NEGATIVE_INFINITY ) {
571          return 0;
572     }
573
574     var sign = ( t < 0 ) ? -1 : 1;
575
576     return ( sign * Math.floor( Math.abs( t ) ) );
577 }
578 function Enumerate ( o ) {
579     var properties = new Array();
580     for ( p in o ) {
581        properties[ properties.length ] = new Array( p, o[p] );
582     }
583     return properties;
584 }
585 function AddTestCase( description, expect, actual ) {
586     testcases[tc++] = new TestCase( SECTION, description, expect, actual );
587 }
588 function getFailedCases() {
589   for ( var i = 0; i < testcases.length; i++ ) {
590      if ( ! testcases[i].passed ) {
591         print( testcases[i].description +" = " +testcases[i].actual +" expected: "+ testcases[i].expect );
592      }
593   }
594 }