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