/// 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!"); | |
} | |
} |