The Tor Browser / file comparison
comparison: js/src/tests/ecma/jsref.js
js/src/tests/ecma/jsref.js
- changeset 0
- 6474c204b198
equal
deleted
inserted
replaced
| -1:000000000000 | 0:e78609f86010 |
|---|---|
| 1 var completed = false; | |
| 2 var testcases; | |
| 3 var tc = 0; | |
| 4 | |
| 5 SECTION = ""; | |
| 6 VERSION = ""; | |
| 7 BUGNUMBER = ""; | |
| 8 TITLE = ""; | |
| 9 | |
| 10 /* | |
| 11 * constant strings | |
| 12 */ | |
| 13 var GLOBAL = "[object global]"; | |
| 14 var PASSED = " PASSED!" | |
| 15 var FAILED = " FAILED! expected: "; | |
| 16 var DEBUG = false; | |
| 17 | |
| 18 TZ_DIFF = -8; | |
| 19 | |
| 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; | |
| 35 | |
| 36 var PASSED = " PASSED!" | |
| 37 var FAILED = " FAILED! expected: "; | |
| 38 | |
| 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 ); | |
| 46 | |
| 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 */ | |
| 55 | |
| 56 function AddTestCase( description, expect, actual ) { | |
| 57 testcases[tc++] = new TestCase( SECTION, description, expect, actual ); | |
| 58 } | |
| 59 | |
| 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; | |
| 68 | |
| 69 this.passed = getTestCaseResult( this.expect, this.actual ); | |
| 70 if ( DEBUG ) { | |
| 71 print( "added " + this.description ); | |
| 72 } | |
| 73 } | |
| 74 | |
| 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 } | |
| 97 | |
| 98 // print out bugnumber | |
| 99 | |
| 100 if ( BUGNUMBER ) { | |
| 101 print ("BUGNUMBER: " + BUGNUMBER ); | |
| 102 } | |
| 103 | |
| 104 testcases = new Array(); | |
| 105 tc = 0; | |
| 106 } | |
| 107 | |
| 108 | |
| 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 } | |
| 120 | |
| 121 | |
| 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 } | |
| 139 | |
| 140 var passed = ( expect == actual ) ? true : false; | |
| 141 | |
| 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 } | |
| 152 | |
| 153 // verify type is the same | |
| 154 if ( typeof(expect) != typeof(actual) ) { | |
| 155 passed = false; | |
| 156 } | |
| 157 | |
| 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 ; | |
| 167 | |
| 168 for ( k = 0; | |
| 169 k < (60 - string.length >= 0 ? 60 - string.length : 5) ; | |
| 170 k++ ) { | |
| 171 } | |
| 172 | |
| 173 s += B ; | |
| 174 s += ( passed ) ? FONT_GREEN + NBSP + PASSED : FONT_RED + NBSP + FAILED + expect + TT_ ; | |
| 175 | |
| 176 print( s + FONT_ + B_ + TT_ ); | |
| 177 | |
| 178 return passed; | |
| 179 } | |
| 180 | |
| 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 = ">"; | |
| 190 | |
| 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 } | |
| 231 | |
| 232 /** | |
| 233 * Type Conversion functions used by Type Conversion | |
| 234 * | |
| 235 */ | |
| 236 | |
| 237 | |
| 238 | |
| 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 | |
| 250 | |
| 251 var TIME_1970 = 0; | |
| 252 var TIME_2000 = 946684800000; | |
| 253 var TIME_1900 = -2208988800000; | |
| 254 | |
| 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) | |
| 315 | |
| 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); | |
| 337 | |
| 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); | |
| 383 | |
| 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 } | |
| 420 | |
| 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 } | |
| 427 | |
| 428 // missing daylight savins time adjustment | |
| 429 | |
| 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(); | |
| 454 | |
| 455 var dst_start = GetFirstSundayInApril(t) + 2*msPerHour; | |
| 456 var dst_end = GetLastSundayInOctober(t)+ 2*msPerHour; | |
| 457 | |
| 458 if ( t >= dst_start && t < dst_end ) { | |
| 459 return msPerHour; | |
| 460 } else { | |
| 461 return 0; | |
| 462 } | |
| 463 | |
| 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. | |
| 466 | |
| 467 print( new Date( UTC(dst_start + LocalTZA())) ); | |
| 468 | |
| 469 return UTC(dst_start + LocalTZA()); | |
| 470 } | |
| 471 function GetFirstSundayInApril( t ) { | |
| 472 var year = YearFromTime(t); | |
| 473 var leap = InLeapYear(t); | |
| 474 | |
| 475 var april = TimeFromYear(year) + TimeInMonth(0, leap) + TimeInMonth(1,leap) + | |
| 476 TimeInMonth(2,leap); | |
| 477 | |
| 478 for ( var first_sunday = april; WeekDay(first_sunday) > 0; | |
| 479 first_sunday += msPerDay ) | |
| 480 { | |
| 481 ; | |
| 482 } | |
| 483 | |
| 484 return first_sunday; | |
| 485 } | |
| 486 function GetLastSundayInOctober( t ) { | |
| 487 var year = YearFromTime(t); | |
| 488 var leap = InLeapYear(t); | |
| 489 | |
| 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 } | |
| 507 | |
| 508 hour = ToInteger(hour); | |
| 509 min = ToInteger( min); | |
| 510 sec = ToInteger( sec); | |
| 511 ms = ToInteger( ms ); | |
| 512 | |
| 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 ); | |
| 523 | |
| 524 var sign = ( year < 1970 ) ? -1 : 1; | |
| 525 var t = ( year < 1970 ) ? 1 : 0; | |
| 526 var y = ( year < 1970 ) ? 1969 : 1970; | |
| 527 | |
| 528 var result5 = year + Math.floor( month/12 ); | |
| 529 var result6 = month % 12; | |
| 530 | |
| 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 } | |
| 540 | |
| 541 var leap = InLeapYear( t ); | |
| 542 | |
| 543 for ( var m = 0; m < month; m++ ) { | |
| 544 t += TimeInMonth( m, leap ); | |
| 545 } | |
| 546 | |
| 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 } | |
| 556 | |
| 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 | |
| 563 | |
| 564 if ( month == 3 || month == 5 || month == 8 || month == 10 ) { | |
| 565 return ( 30*msPerDay ); | |
| 566 } | |
| 567 | |
| 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 } | |
| 573 | |
| 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 } | |
| 597 | |
| 598 return ( ToInteger( t ) ); | |
| 599 } | |
| 600 function ToInteger( t ) { | |
| 601 t = Number( t ); | |
| 602 | |
| 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 } | |
| 610 | |
| 611 var sign = ( t < 0 ) ? -1 : 1; | |
| 612 | |
| 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 } | |
| 625 | |
| 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 } |
