The Tor Browser / file comparison

comparison: js/src/tests/ecma_2/jsref.js

js/src/tests/ecma_2/jsref.js

branch
TOR_BUG_3246
changeset 7
129ffea94266
equal deleted inserted replaced
-1:000000000000 0:8b9f96ec8db5
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 }

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial