| /// Copyright (c) 2012 Ecma International. All rights reserved. |
| /// Ecma International makes this code available under the terms and conditions set |
| /// forth on http://hg.ecmascript.org/tests/test262/raw-file/tip/LICENSE (the |
| /// "Use Terms"). Any redistribution of this code must retain the above |
| /// copyright and this notice and otherwise comply with the Use Terms. |
| |
| //----------------------------------------------------------------------------- |
| function compareArray(aExpected, aActual) { |
| if (aActual.length != aExpected.length) { |
| return false; |
| } |
| |
| aExpected.sort(); |
| aActual.sort(); |
| |
| var s; |
| for (var i = 0; i < aExpected.length; i++) { |
| if (aActual[i] !== aExpected[i]) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| //----------------------------------------------------------------------------- |
| function arrayContains(arr, expected) { |
| var found; |
| for (var i = 0; i < expected.length; i++) { |
| found = false; |
| for (var j = 0; j < arr.length; j++) { |
| if (expected[i] === arr[j]) { |
| found = true; |
| break; |
| } |
| } |
| if (!found) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| //----------------------------------------------------------------------------- |
| var supportsArrayIndexGettersOnArrays = undefined; |
| function fnSupportsArrayIndexGettersOnArrays() { |
| if (typeof supportsArrayIndexGettersOnArrays !== "undefined") { |
| return supportsArrayIndexGettersOnArrays; |
| } |
| |
| supportsArrayIndexGettersOnArrays = false; |
| |
| if (fnExists(Object.defineProperty)) { |
| var arr = []; |
| Object.defineProperty(arr, "0", { |
| get: function() { |
| supportsArrayIndexGettersOnArrays = true; |
| return 0; |
| } |
| }); |
| var res = arr[0]; |
| } |
| |
| return supportsArrayIndexGettersOnArrays; |
| } |
| |
| //----------------------------------------------------------------------------- |
| var supportsArrayIndexGettersOnObjects = undefined; |
| function fnSupportsArrayIndexGettersOnObjects() { |
| if (typeof supportsArrayIndexGettersOnObjects !== "undefined") |
| return supportsArrayIndexGettersOnObjects; |
| |
| supportsArrayIndexGettersOnObjects = false; |
| |
| if (fnExists(Object.defineProperty)) { |
| var obj = {}; |
| Object.defineProperty(obj, "0", { |
| get: function() { |
| supportsArrayIndexGettersOnObjects = true; |
| return 0; |
| } |
| }); |
| var res = obj[0]; |
| } |
| |
| return supportsArrayIndexGettersOnObjects; |
| } |
| |
| //----------------------------------------------------------------------------- |
| function ConvertToFileUrl(pathStr) { |
| return "file:" + pathStr.replace(/\\/g, "/"); |
| } |
| |
| //----------------------------------------------------------------------------- |
| function fnExists(/*arguments*/) { |
| for (var i = 0; i < arguments.length; i++) { |
| if (typeof (arguments[i]) !== "function") return false; |
| } |
| return true; |
| } |
| |
| //----------------------------------------------------------------------------- |
| var __globalObject = Function("return this;")(); |
| function fnGlobalObject() { |
| return __globalObject; |
| } |
| |
| //----------------------------------------------------------------------------- |
| function fnSupportsStrict() { |
| "use strict"; |
| try { |
| eval('with ({}) {}'); |
| return false; |
| } catch (e) { |
| return true; |
| } |
| } |
| |
| //----------------------------------------------------------------------------- |
| //Verify all attributes specified data property of given object: |
| //value, writable, enumerable, configurable |
| //If all attribute values are expected, return true, otherwise, return false |
| function dataPropertyAttributesAreCorrect(obj, |
| name, |
| value, |
| writable, |
| enumerable, |
| configurable) { |
| var attributesCorrect = true; |
| |
| if (obj[name] !== value) { |
| if (typeof obj[name] === "number" && |
| isNaN(obj[name]) && |
| typeof value === "number" && |
| isNaN(value)) { |
| // keep empty |
| } else { |
| attributesCorrect = false; |
| } |
| } |
| |
| try { |
| if (obj[name] === "oldValue") { |
| obj[name] = "newValue"; |
| } else { |
| obj[name] = "OldValue"; |
| } |
| } catch (we) { |
| } |
| |
| var overwrited = false; |
| if (obj[name] !== value) { |
| if (typeof obj[name] === "number" && |
| isNaN(obj[name]) && |
| typeof value === "number" && |
| isNaN(value)) { |
| // keep empty |
| } else { |
| overwrited = true; |
| } |
| } |
| if (overwrited !== writable) { |
| attributesCorrect = false; |
| } |
| |
| var enumerated = false; |
| for (var prop in obj) { |
| if (obj.hasOwnProperty(prop) && prop === name) { |
| enumerated = true; |
| } |
| } |
| |
| if (enumerated !== enumerable) { |
| attributesCorrect = false; |
| } |
| |
| |
| var deleted = false; |
| |
| try { |
| delete obj[name]; |
| } catch (de) { |
| } |
| if (!obj.hasOwnProperty(name)) { |
| deleted = true; |
| } |
| if (deleted !== configurable) { |
| attributesCorrect = false; |
| } |
| |
| return attributesCorrect; |
| } |
| |
| //----------------------------------------------------------------------------- |
| //Verify all attributes specified accessor property of given object: |
| //get, set, enumerable, configurable |
| //If all attribute values are expected, return true, otherwise, return false |
| function accessorPropertyAttributesAreCorrect(obj, |
| name, |
| get, |
| set, |
| setVerifyHelpProp, |
| enumerable, |
| configurable) { |
| var attributesCorrect = true; |
| |
| if (get !== undefined) { |
| if (obj[name] !== get()) { |
| if (typeof obj[name] === "number" && |
| isNaN(obj[name]) && |
| typeof get() === "number" && |
| isNaN(get())) { |
| // keep empty |
| } else { |
| attributesCorrect = false; |
| } |
| } |
| } else { |
| if (obj[name] !== undefined) { |
| attributesCorrect = false; |
| } |
| } |
| |
| try { |
| var desc = Object.getOwnPropertyDescriptor(obj, name); |
| if (typeof desc.set === "undefined") { |
| if (typeof set !== "undefined") { |
| attributesCorrect = false; |
| } |
| } else { |
| obj[name] = "toBeSetValue"; |
| if (obj[setVerifyHelpProp] !== "toBeSetValue") { |
| attributesCorrect = false; |
| } |
| } |
| } catch (se) { |
| throw se; |
| } |
| |
| |
| var enumerated = false; |
| for (var prop in obj) { |
| if (obj.hasOwnProperty(prop) && prop === name) { |
| enumerated = true; |
| } |
| } |
| |
| if (enumerated !== enumerable) { |
| attributesCorrect = false; |
| } |
| |
| |
| var deleted = false; |
| try { |
| delete obj[name]; |
| } catch (de) { |
| throw de; |
| } |
| if (!obj.hasOwnProperty(name)) { |
| deleted = true; |
| } |
| if (deleted !== configurable) { |
| attributesCorrect = false; |
| } |
| |
| return attributesCorrect; |
| } |
| |
| //----------------------------------------------------------------------------- |
| var NotEarlyErrorString = "NotEarlyError"; |
| var EarlyErrorRePat = "^((?!" + NotEarlyErrorString + ").)*$"; |
| var NotEarlyError = new Error(NotEarlyErrorString); |
| |
| //----------------------------------------------------------------------------- |
| // Copyright 2009 the Sputnik authors. All rights reserved. |
| // This code is governed by the BSD license found in the LICENSE file. |
| |
| function Test262Error(message) { |
| if (message) this.message = message; |
| } |
| |
| Test262Error.prototype.toString = function () { |
| return "Test262 Error: " + this.message; |
| }; |
| |
| function testFailed(message) { |
| throw new Test262Error(message); |
| } |
| |
| |
| function testPrint(message) { |
| |
| } |
| |
| |
| //adaptors for Test262 framework |
| function $PRINT(message) { |
| |
| } |
| |
| function $INCLUDE(message) { } |
| function $ERROR(message) { |
| testFailed(message); |
| } |
| |
| function $FAIL(message) { |
| testFailed(message); |
| } |
| |
| |
| |
| //Sputnik library definitions |
| //Ultimately these should be namespaced some how and only made |
| //available to tests that explicitly include them. |
| //For now, we just define the globally |
| |
| //math_precision.js |
| // Copyright 2009 the Sputnik authors. All rights reserved. |
| // This code is governed by the BSD license found in the LICENSE file. |
| |
| function getPrecision(num) { |
| //TODO: Create a table of prec's, |
| // because using Math for testing Math isn't that correct. |
| |
| var log2num = Math.log(Math.abs(num)) / Math.LN2; |
| var pernum = Math.ceil(log2num); |
| return (2 * Math.pow(2, -52 + pernum)); |
| //return(0); |
| } |
| |
| |
| //math_isequal.js |
| // Copyright 2009 the Sputnik authors. All rights reserved. |
| // This code is governed by the BSD license found in the LICENSE file. |
| |
| var prec; |
| function isEqual(num1, num2) { |
| if ((num1 === Infinity) && (num2 === Infinity)) { |
| return (true); |
| } |
| if ((num1 === -Infinity) && (num2 === -Infinity)) { |
| return (true); |
| } |
| prec = getPrecision(Math.min(Math.abs(num1), Math.abs(num2))); |
| return (Math.abs(num1 - num2) <= prec); |
| //return(num1 === num2); |
| } |
| |
| //numeric_conversion.js |
| // Copyright 2009 the Sputnik authors. All rights reserved. |
| // This code is governed by the BSD license found in the LICENSE file. |
| |
| function ToInteger(p) { |
| var x = Number(p); |
| |
| if (isNaN(x)) { |
| return +0; |
| } |
| |
| if ((x === +0) |
| || (x === -0) |
| || (x === Number.POSITIVE_INFINITY) |
| || (x === Number.NEGATIVE_INFINITY)) { |
| return x; |
| } |
| |
| var sign = (x < 0) ? -1 : 1; |
| |
| return (sign * Math.floor(Math.abs(x))); |
| } |
| |
| //Date_constants.js |
| // Copyright 2009 the Sputnik authors. All rights reserved. |
| // This code is governed by the BSD license found in the LICENSE file. |
| |
| var HoursPerDay = 24; |
| var MinutesPerHour = 60; |
| var SecondsPerMinute = 60; |
| |
| var msPerDay = 86400000; |
| var msPerSecond = 1000; |
| var msPerMinute = 60000; |
| var msPerHour = 3600000; |
| |
| var date_1899_end = -2208988800001; |
| var date_1900_start = -2208988800000; |
| var date_1969_end = -1; |
| var date_1970_start = 0; |
| var date_1999_end = 946684799999; |
| var date_2000_start = 946684800000; |
| var date_2099_end = 4102444799999; |
| var date_2100_start = 4102444800000; |
| |
| // Copyright 2009 the Sputnik authors. All rights reserved. |
| // This code is governed by the BSD license found in the LICENSE file. |
| |
| //the following values are normally generated by the sputnik.py driver |
| var $LocalTZ, |
| $DST_start_month, |
| $DST_start_sunday, |
| $DST_start_hour, |
| $DST_start_minutes, |
| $DST_end_month, |
| $DST_end_sunday, |
| $DST_end_hour, |
| $DST_end_minutes; |
| |
| (function () { |
| /** |
| * Finds the first date, starting from |start|, where |predicate| |
| * holds. |
| */ |
| var findNearestDateBefore = function(start, predicate) { |
| var current = start; |
| var month = 1000 * 60 * 60 * 24 * 30; |
| for (var step = month; step > 0; step = Math.floor(step / 3)) { |
| if (!predicate(current)) { |
| while (!predicate(current)) |
| current = new Date(current.getTime() + step); |
| current = new Date(current.getTime() - step); |
| } |
| } |
| while (!predicate(current)) { |
| current = new Date(current.getTime() + 1); |
| } |
| return current; |
| }; |
| |
| var juneDate = new Date(2000, 5, 20, 0, 0, 0, 0); |
| var decemberDate = new Date(2000, 11, 20, 0, 0, 0, 0); |
| var juneOffset = juneDate.getTimezoneOffset(); |
| var decemberOffset = decemberDate.getTimezoneOffset(); |
| var isSouthernHemisphere = (juneOffset > decemberOffset); |
| var winterTime = isSouthernHemisphere ? juneDate : decemberDate; |
| var summerTime = isSouthernHemisphere ? decemberDate : juneDate; |
| |
| var dstStart = findNearestDateBefore(winterTime, function (date) { |
| return date.getTimezoneOffset() == summerTime.getTimezoneOffset(); |
| }); |
| $DST_start_month = dstStart.getMonth(); |
| $DST_start_sunday = dstStart.getDate() > 15 ? '"last"' : '"first"'; |
| $DST_start_hour = dstStart.getHours(); |
| $DST_start_minutes = dstStart.getMinutes(); |
| |
| var dstEnd = findNearestDateBefore(summerTime, function (date) { |
| return date.getTimezoneOffset() == winterTime.getTimezoneOffset(); |
| }); |
| $DST_end_month = dstEnd.getMonth(); |
| $DST_end_sunday = dstEnd.getDate() > 15 ? '"last"' : '"first"'; |
| $DST_end_hour = dstEnd.getHours(); |
| $DST_end_minutes = dstEnd.getMinutes(); |
| |
| return; |
| })(); |
| |
| |
| //Date.library.js |
| // Copyright 2009 the Sputnik authors. All rights reserved. |
| // This code is governed by the BSD license found in the LICENSE file. |
| |
| //15.9.1.2 Day Number and Time within Day |
| function Day(t) { |
| return Math.floor(t/msPerDay); |
| } |
| |
| function TimeWithinDay(t) { |
| return t%msPerDay; |
| } |
| |
| //15.9.1.3 Year Number |
| function DaysInYear(y){ |
| if(y%4 != 0) return 365; |
| if(y%4 == 0 && y%100 != 0) return 366; |
| if(y%100 == 0 && y%400 != 0) return 365; |
| if(y%400 == 0) return 366; |
| } |
| |
| function DayFromYear(y) { |
| return (365*(y-1970) |
| + Math.floor((y-1969)/4) |
| - Math.floor((y-1901)/100) |
| + Math.floor((y-1601)/400)); |
| } |
| |
| function TimeFromYear(y){ |
| return msPerDay*DayFromYear(y); |
| } |
| |
| function YearFromTime(t) { |
| t = Number(t); |
| var sign = ( t < 0 ) ? -1 : 1; |
| var year = ( sign < 0 ) ? 1969 : 1970; |
| |
| for(var time = 0;;year += sign){ |
| time = TimeFromYear(year); |
| |
| if(sign > 0 && time > t){ |
| year -= sign; |
| break; |
| } |
| else if(sign < 0 && time <= t){ |
| break; |
| } |
| }; |
| return year; |
| } |
| |
| function InLeapYear(t){ |
| if(DaysInYear(YearFromTime(t)) == 365) |
| return 0; |
| |
| if(DaysInYear(YearFromTime(t)) == 366) |
| return 1; |
| } |
| |
| function DayWithinYear(t) { |
| return Day(t)-DayFromYear(YearFromTime(t)); |
| } |
| |
| //15.9.1.4 Month Number |
| function MonthFromTime(t){ |
| var day = DayWithinYear(t); |
| var leap = InLeapYear(t); |
| |
| if((0 <= day) && (day < 31)) return 0; |
| if((31 <= day) && (day < (59+leap))) return 1; |
| if(((59+leap) <= day) && (day < (90+leap))) return 2; |
| if(((90+leap) <= day) && (day < (120+leap))) return 3; |
| if(((120+leap) <= day) && (day < (151+leap))) return 4; |
| if(((151+leap) <= day) && (day < (181+leap))) return 5; |
| if(((181+leap) <= day) && (day < (212+leap))) return 6; |
| if(((212+leap) <= day) && (day < (243+leap))) return 7; |
| if(((243+leap) <= day) && (day < (273+leap))) return 8; |
| if(((273+leap) <= day) && (day < (304+leap))) return 9; |
| if(((304+leap) <= day) && (day < (334+leap))) return 10; |
| if(((334+leap) <= day) && (day < (365+leap))) return 11; |
| } |
| |
| //15.9.1.5 Date Number |
| function DateFromTime(t) { |
| var day = DayWithinYear(t); |
| var month = MonthFromTime(t); |
| var leap = InLeapYear(t); |
| |
| if(month == 0) return day+1; |
| if(month == 1) return day-30; |
| if(month == 2) return day-58-leap; |
| if(month == 3) return day-89-leap; |
| if(month == 4) return day-119-leap; |
| if(month == 5) return day-150-leap; |
| if(month == 6) return day-180-leap; |
| if(month == 7) return day-211-leap; |
| if(month == 8) return day-242-leap; |
| if(month == 9) return day-272-leap; |
| if(month == 10) return day-303-leap; |
| if(month == 11) return day-333-leap; |
| } |
| |
| //15.9.1.6 Week Day |
| function WeekDay(t) { |
| var weekday = (Day(t)+4)%7; |
| return (weekday < 0 ? 7+weekday : weekday); |
| } |
| |
| //15.9.1.9 Daylight Saving Time Adjustment |
| $LocalTZ = (new Date()).getTimezoneOffset() / -60; |
| if (DaylightSavingTA((new Date()).valueOf()) !== 0) { |
| $LocalTZ -= 1; |
| } |
| var LocalTZA = $LocalTZ*msPerHour; |
| |
| function DaysInMonth(m, leap) { |
| m = m%12; |
| |
| //April, June, Sept, Nov |
| if(m == 3 || m == 5 || m == 8 || m == 10 ) { |
| return 30; |
| } |
| |
| //Jan, March, May, July, Aug, Oct, Dec |
| if(m == 0 || m == 2 || m == 4 || m == 6 || m == 7 || m == 9 || m == 11){ |
| return 31; |
| } |
| |
| //Feb |
| return 28+leap; |
| } |
| |
| function GetSundayInMonth(t, m, count){ |
| var year = YearFromTime(t); |
| var tempDate; |
| |
| if (count==='"first"') { |
| for (var d=1; d <= DaysInMonth(m, InLeapYear(t)); d++) { |
| tempDate = new Date(year, m, d); |
| if (tempDate.getDay()===0) { |
| return tempDate.valueOf(); |
| } |
| } |
| } else if(count==='"last"') { |
| for (var d=DaysInMonth(m, InLeapYear(t)); d>0; d--) { |
| tempDate = new Date(year, m, d); |
| if (tempDate.getDay()===0) { |
| return tempDate.valueOf(); |
| } |
| } |
| } |
| throw new Error("Unsupported 'count' arg:" + count); |
| } |
| /* |
| function GetSundayInMonth(t, m, count){ |
| var year = YearFromTime(t); |
| var leap = InLeapYear(t); |
| var day = 0; |
| |
| if(m >= 1) day += DaysInMonth(0, leap); |
| if(m >= 2) day += DaysInMonth(1, leap); |
| if(m >= 3) day += DaysInMonth(2, leap); |
| if(m >= 4) day += DaysInMonth(3, leap); |
| if(m >= 5) day += DaysInMonth(4, leap); |
| if(m >= 6) day += DaysInMonth(5, leap); |
| if(m >= 7) day += DaysInMonth(6, leap); |
| if(m >= 8) day += DaysInMonth(7, leap); |
| if(m >= 9) day += DaysInMonth(8, leap); |
| if(m >= 10) day += DaysInMonth(9, leap); |
| if(m >= 11) day += DaysInMonth(10, leap); |
| |
| var month_start = TimeFromYear(year)+day*msPerDay; |
| var sunday = 0; |
| |
| if(count === "last"){ |
| for(var last_sunday = month_start+DaysInMonth(m, leap)*msPerDay; |
| WeekDay(last_sunday)>0; |
| last_sunday -= msPerDay |
| ){}; |
| sunday = last_sunday; |
| } |
| else { |
| for(var first_sunday = month_start; |
| WeekDay(first_sunday)>0; |
| first_sunday += msPerDay |
| ){}; |
| sunday = first_sunday+7*msPerDay*(count-1); |
| } |
| |
| return sunday; |
| }*/ |
| |
| function DaylightSavingTA(t) { |
| // t = t-LocalTZA; |
| |
| var DST_start = GetSundayInMonth(t, $DST_start_month, $DST_start_sunday) + |
| $DST_start_hour*msPerHour + |
| $DST_start_minutes*msPerMinute; |
| |
| var k = new Date(DST_start); |
| |
| var DST_end = GetSundayInMonth(t, $DST_end_month, $DST_end_sunday) + |
| $DST_end_hour*msPerHour + |
| $DST_end_minutes*msPerMinute; |
| |
| if ( t >= DST_start && t < DST_end ) { |
| return msPerHour; |
| } else { |
| return 0; |
| } |
| } |
| |
| //15.9.1.9 Local Time |
| function LocalTime(t){ |
| return t+LocalTZA+DaylightSavingTA(t); |
| } |
| |
| function UTC(t) { |
| return t-LocalTZA-DaylightSavingTA(t-LocalTZA); |
| } |
| |
| //15.9.1.10 Hours, Minutes, Second, and Milliseconds |
| function HourFromTime(t){ |
| return Math.floor(t/msPerHour)%HoursPerDay; |
| } |
| |
| function MinFromTime(t){ |
| return Math.floor(t/msPerMinute)%MinutesPerHour; |
| } |
| |
| function SecFromTime(t){ |
| return Math.floor(t/msPerSecond)%SecondsPerMinute; |
| } |
| |
| function msFromTime(t){ |
| return t%msPerSecond; |
| } |
| |
| //15.9.1.11 MakeTime (hour, min, sec, ms) |
| function MakeTime(hour, min, sec, ms){ |
| if ( !isFinite(hour) || !isFinite(min) || !isFinite(sec) || !isFinite(ms)) { |
| return Number.NaN; |
| } |
| |
| hour = ToInteger(hour); |
| min = ToInteger(min); |
| sec = ToInteger(sec); |
| ms = ToInteger(ms); |
| |
| return ((hour*msPerHour) + (min*msPerMinute) + (sec*msPerSecond) + ms); |
| } |
| |
| //15.9.1.12 MakeDay (year, month, date) |
| function MakeDay(year, month, date) { |
| if ( !isFinite(year) || !isFinite(month) || !isFinite(date)) { |
| return Number.NaN; |
| } |
| |
| year = ToInteger(year); |
| month = ToInteger(month); |
| date = ToInteger(date ); |
| |
| var result5 = year + Math.floor(month/12); |
| var result6 = month%12; |
| |
| var sign = ( year < 1970 ) ? -1 : 1; |
| var t = ( year < 1970 ) ? 1 : 0; |
| var y = ( year < 1970 ) ? 1969 : 1970; |
| |
| if( sign == -1 ){ |
| for ( y = 1969; y >= year; y += sign ) { |
| t += sign * DaysInYear(y)*msPerDay; |
| } |
| } else { |
| for ( y = 1970 ; y < year; y += sign ) { |
| t += sign * DaysInYear(y)*msPerDay; |
| } |
| } |
| |
| var leap = 0; |
| for ( var m = 0; m < month; m++ ) { |
| //if year is changed, than we need to recalculate leep |
| leap = InLeapYear(t); |
| t += DaysInMonth(m, leap)*msPerDay; |
| } |
| |
| if ( YearFromTime(t) != result5 ) { |
| return Number.NaN; |
| } |
| if ( MonthFromTime(t) != result6 ) { |
| return Number.NaN; |
| } |
| if ( DateFromTime(t) != 1 ) { |
| return Number.NaN; |
| } |
| |
| return Day(t)+date-1; |
| } |
| |
| //15.9.1.13 MakeDate (day, time) |
| function MakeDate( day, time ) { |
| if(!isFinite(day) || !isFinite(time)) { |
| return Number.NaN; |
| } |
| |
| return day*msPerDay+time; |
| } |
| |
| //15.9.1.14 TimeClip (time) |
| function TimeClip(time) { |
| if(!isFinite(time) || Math.abs(time) > 8.64e15){ |
| return Number.NaN; |
| } |
| |
| return ToInteger(time); |
| } |
| |
| //Test Functions |
| //ConstructDate is considered deprecated, and should not be used directly from |
| //test262 tests as it's incredibly sensitive to DST start/end dates that |
| //vary with geographic location. |
| function ConstructDate(year, month, date, hours, minutes, seconds, ms){ |
| /* |
| * 1. Call ToNumber(year) |
| * 2. Call ToNumber(month) |
| * 3. If date is supplied use ToNumber(date); else use 1 |
| * 4. If hours is supplied use ToNumber(hours); else use 0 |
| * 5. If minutes is supplied use ToNumber(minutes); else use 0 |
| * 6. If seconds is supplied use ToNumber(seconds); else use 0 |
| * 7. If ms is supplied use ToNumber(ms); else use 0 |
| * 8. If Result(1) is not NaN and 0 <= ToInteger(Result(1)) <= 99, Result(8) is |
| * 1900+ToInteger(Result(1)); otherwise, Result(8) is Result(1) |
| * 9. Compute MakeDay(Result(8), Result(2), Result(3)) |
| * 10. Compute MakeTime(Result(4), Result(5), Result(6), Result(7)) |
| * 11. Compute MakeDate(Result(9), Result(10)) |
| * 12. Set the [[Value]] property of the newly constructed object to TimeClip(UTC(Result(11))) |
| */ |
| var r1 = Number(year); |
| var r2 = Number(month); |
| var r3 = ((date && arguments.length > 2) ? Number(date) : 1); |
| var r4 = ((hours && arguments.length > 3) ? Number(hours) : 0); |
| var r5 = ((minutes && arguments.length > 4) ? Number(minutes) : 0); |
| var r6 = ((seconds && arguments.length > 5) ? Number(seconds) : 0); |
| var r7 = ((ms && arguments.length > 6) ? Number(ms) : 0); |
| |
| var r8 = r1; |
| |
| if(!isNaN(r1) && (0 <= ToInteger(r1)) && (ToInteger(r1) <= 99)) |
| r8 = 1900+r1; |
| |
| var r9 = MakeDay(r8, r2, r3); |
| var r10 = MakeTime(r4, r5, r6, r7); |
| var r11 = MakeDate(r9, r10); |
| |
| var retVal = TimeClip(UTC(r11)); |
| return retVal; |
| } |
| |
| |
| |
| /**** Python code for initialize the above constants |
| // We may want to replicate the following in JavaScript. |
| // However, using JS date operations to generate parameters that are then used to |
| // test those some date operations seems unsound. However, it isn't clear if there |
| //is a good interoperable alternative. |
| |
| # Copyright 2009 the Sputnik authors. All rights reserved. |
| # This code is governed by the BSD license found in the LICENSE file. |
| |
| def GetDaylightSavingsTimes(): |
| # Is the given floating-point time in DST? |
| def IsDst(t): |
| return time.localtime(t)[-1] |
| # Binary search to find an interval between the two times no greater than |
| # delta where DST switches, returning the midpoint. |
| def FindBetween(start, end, delta): |
| while end - start > delta: |
| middle = (end + start) / 2 |
| if IsDst(middle) == IsDst(start): |
| start = middle |
| else: |
| end = middle |
| return (start + end) / 2 |
| now = time.time() |
| one_month = (30 * 24 * 60 * 60) |
| # First find a date with different daylight savings. To avoid corner cases |
| # we try four months before and after today. |
| after = now + 4 * one_month |
| before = now - 4 * one_month |
| if IsDst(now) == IsDst(before) and IsDst(now) == IsDst(after): |
| logger.warning("Was unable to determine DST info.") |
| return None |
| # Determine when the change occurs between now and the date we just found |
| # in a different DST. |
| if IsDst(now) != IsDst(before): |
| first = FindBetween(before, now, 1) |
| else: |
| first = FindBetween(now, after, 1) |
| # Determine when the change occurs between three and nine months from the |
| # first. |
| second = FindBetween(first + 3 * one_month, first + 9 * one_month, 1) |
| # Find out which switch is into and which if out of DST |
| if IsDst(first - 1) and not IsDst(first + 1): |
| start = second |
| end = first |
| else: |
| start = first |
| end = second |
| return (start, end) |
| |
| |
| def GetDaylightSavingsAttribs(): |
| times = GetDaylightSavingsTimes() |
| if not times: |
| return None |
| (start, end) = times |
| def DstMonth(t): |
| return time.localtime(t)[1] - 1 |
| def DstHour(t): |
| return time.localtime(t - 1)[3] + 1 |
| def DstSunday(t): |
| if time.localtime(t)[2] > 15: |
| return "'last'" |
| else: |
| return "'first'" |
| def DstMinutes(t): |
| return (time.localtime(t - 1)[4] + 1) % 60 |
| attribs = { } |
| attribs['start_month'] = DstMonth(start) |
| attribs['end_month'] = DstMonth(end) |
| attribs['start_sunday'] = DstSunday(start) |
| attribs['end_sunday'] = DstSunday(end) |
| attribs['start_hour'] = DstHour(start) |
| attribs['end_hour'] = DstHour(end) |
| attribs['start_minutes'] = DstMinutes(start) |
| attribs['end_minutes'] = DstMinutes(end) |
| return attribs |
| |
| *********/ |
| |
| //--Test case registration----------------------------------------------------- |
| function runTestCase(testcase) { |
| if (testcase() !== true) { |
| $ERROR("Test case returned non-true value!"); |
| } |
| } |
| /* This Source Code Form is subject to the terms of the Mozilla Public |
| * License, v. 2.0. If a copy of the MPL was not distributed with this |
| * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ |
| |
| /* |
| * The current crop of Test262 test cases that we run are expected to pass |
| * unless they crash or throw. (This isn't true for all Test262 test cases -- |
| * for the ones marked @negative the logic is inverted. We'll have to deal with |
| * that concern eventually, but for now we're punting so we can run subsets of |
| * Test262 tests.) |
| */ |
| testPassesUnlessItThrows(); |
| |
| /* |
| * Test262 function $ERROR throws an error with the message provided. Test262 |
| * test cases call it to indicate failure. |
| */ |
| function $ERROR(msg) |
| { |
| throw new Error("Test262 error: " + msg); |
| } |
| |
| /* |
| * Test262 function $INCLUDE loads a file with support functions for the tests. |
| * This function is replaced in browser.js. |
| */ |
| function $INCLUDE(file) |
| { |
| load("supporting/" + file); |
| } |
| |
| /* |
| * Test262 function fnGlobalObject returns the global object. |
| */ |
| var fnGlobalObject = (function() |
| { |
| var global = Function("return this")(); |
| return function fnGlobalObject() { return global; }; |
| })(); |