diff options
Diffstat (limited to 'js/src/tests/test262/shell.js')
| -rw-r--r-- | js/src/tests/test262/shell.js | 940 |
1 files changed, 940 insertions, 0 deletions
diff --git a/js/src/tests/test262/shell.js b/js/src/tests/test262/shell.js new file mode 100644 index 000000000..b70bb5dbb --- /dev/null +++ b/js/src/tests/test262/shell.js @@ -0,0 +1,940 @@ +/// 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; }; +})(); |