diff options
Diffstat (limited to 'js/src/tests/non262/Date')
55 files changed, 4938 insertions, 0 deletions
diff --git a/js/src/tests/non262/Date/15.9.4.2.js b/js/src/tests/non262/Date/15.9.4.2.js new file mode 100644 index 0000000000..684f7638fd --- /dev/null +++ b/js/src/tests/non262/Date/15.9.4.2.js @@ -0,0 +1,134 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ + +//----------------------------------------------------------------------------- +var BUGNUMBER = 430930; + + +//----------------------------------------------------------------------------- +test(); +//----------------------------------------------------------------------------- + +function iso(d) +{ + return new Date(d).toISOString(); +} + +function check(s, millis){ + description = "Date.parse('"+s+"') == '"+iso(millis)+"'"; + expected = millis; + actual = Date.parse(s); + reportCompare(expected, actual, description); +} + +function checkInvalid(s) +{ + description = "Date.parse('"+s+"') produces invalid date"; + expected = NaN; + actual = Date.parse(s); + reportCompare(expected, actual, description); +} + +function dd(year, month, day, hour, minute, second, millis){ + return Date.UTC(year, month-1, day, hour, minute, second, millis); +} + +function TZAtDate(d){ + return d.getTimezoneOffset() * 60000; +} + +function TZInMonth(month, year){ + return TZAtDate(new Date(dd(year,month,1,0,0,0,0))); +} + +function test() +{ + printBugNumber(BUGNUMBER); + + Jan1970TZ = TZInMonth(1, 1970); + Jan2009TZ = TZInMonth(1, 2009); + Jul2009TZ = TZInMonth(7, 2009); + CurrTZ = TZAtDate(new Date()); + + // formats with explicit timezone + check("2009-07-23T19:53:21.001+12:00", dd(2009,7,23,7,53,21,1)); + check("2009-07-23T19:53:21+12:00", dd(2009,7,23,7,53,21,0)); + check("2009-07-23T19:53+12:00", dd(2009,7,23,7,53,0,0)); + + check("2009-07T19:53:21.001+12:00", dd(2009,7,1,7,53,21,1)); + check("2009-07T19:53:21+12:00", dd(2009,7,1,7,53,21,0)); + check("2009-07T19:53+12:00", dd(2009,7,1,7,53,0,0)); + + check("2009T19:53:21.001+12:00", dd(2009,1,1,7,53,21,1)); + check("2009T19:53:21+12:00", dd(2009,1,1,7,53,21,0)); + check("2009T19:53+12:00", dd(2009,1,1,7,53,0,0)); + + checkInvalid("T19:53:21.001+12:00"); + checkInvalid("T19:53:21+12:00"); + checkInvalid("T19:53+12:00"); + + // formats without timezone uses the timezone as at that date + check("2009-07-23T19:53:21.001", dd(2009,7,23,19,53,21,1)+Jul2009TZ); + check("2009-07-23T19:53:21", dd(2009,7,23,19,53,21,0)+Jul2009TZ); + check("2009-07-23T19:53", dd(2009,7,23,19,53,0,0)+Jul2009TZ); + + check("2009-07T19:53:21.001", dd(2009,7,1,19,53,21,1)+Jul2009TZ); + check("2009-07T19:53:21", dd(2009,7,1,19,53,21,0)+Jul2009TZ); + check("2009-07T19:53", dd(2009,7,1,19,53,0,0)+Jul2009TZ); + + check("2009T19:53:21.001", dd(2009,1,1,19,53,21,1)+Jan2009TZ); + check("2009T19:53:21", dd(2009,1,1,19,53,21,0)+Jan2009TZ); + check("2009T19:53", dd(2009,1,1,19,53,0,0)+Jan2009TZ); + + checkInvalid("T19:53:21.001"); + checkInvalid("T19:53:21"); + checkInvalid("T19:53"); + + // with no time at all assume UTC + check("2009-07-23", dd(2009,7,23,0,0,0,0)); + check("2009-07", dd(2009,7,1,0,0,0,0)); + check("2009", dd(2009,1,1,0,0,0,0)); + + // one field too big + checkInvalid("2009-13-23T19:53:21.001+12:00"); + checkInvalid("2009-07-32T19:53:21.001+12:00"); + checkInvalid("2009-07-23T25:53:21.001+12:00"); + checkInvalid("2009-07-23T19:60:21.001+12:00"); + checkInvalid("2009-07-23T19:53:60.001+12:00"); + checkInvalid("2009-07-23T19:53:21.001+24:00"); + checkInvalid("2009-07-23T19:53:21.001+12:60"); + + // other month ends + check("2009-06-30T19:53:21.001+12:00", dd(2009,6,30,7,53,21,1)); + checkInvalid("2009-06-31T19:53:21.001+12:00"); + check("2009-02-28T19:53:21.001+12:00", dd(2009,2,28,7,53,21,1)); + checkInvalid("2009-02-29T19:53:21.001+12:00"); + check("2008-02-29T19:53:21.001+12:00", dd(2008,2,29,7,53,21,1)); + checkInvalid("2008-02-30T19:53:21.001+12:00"); + + // limits of representation + checkInvalid("-271821-04-19T23:59:59.999Z"); + check("-271821-04-20", -8.64e15); + check("+275760-09-13", 8.64e15); + checkInvalid("+275760-09-13T00:00:00.001Z"); + + check("-269845-07-23T19:53:21.001+12:00", dd(-269845,7,23,7,53,21,1)); + check("+273785-07-23T19:53:21.001+12:00", dd(273785,7,23,7,53,21,1)); + + // explicit UTC + check("2009-07-23T19:53:21.001Z", dd(2009,7,23,19,53,21,1)); + check("+002009-07-23T19:53:21.001Z", dd(2009,7,23,19,53,21,1)); + + // different timezones + check("2009-07-23T19:53:21.001+12:00", dd(2009,7,23,7,53,21,1)); + check("2009-07-23T00:53:21.001-07:00", dd(2009,7,23,7,53,21,1)); + + // 00:00 and 24:00 + check("2009-07-23T00:00:00.000-07:00", dd(2009,7,23,7,0,0,0)); + check("2009-07-23T24:00:00.000-07:00", dd(2009,7,24,7,0,0,0)); + + // Bug 730838 - non-zero fraction part for midnight should produce NaN + checkInvalid("1970-01-01T24:00:00.500Z"); +} diff --git a/js/src/tests/non262/Date/15.9.5.5-02.js b/js/src/tests/non262/Date/15.9.5.5-02.js new file mode 100644 index 0000000000..07623e675c --- /dev/null +++ b/js/src/tests/non262/Date/15.9.5.5-02.js @@ -0,0 +1,63 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ + +//----------------------------------------------------------------------------- +var BUGNUMBER = 398485; +var summary = 'Date.prototype.toLocaleString should not clamp year'; +var actual = ''; +var expect = ''; + + +//----------------------------------------------------------------------------- +test(); +//----------------------------------------------------------------------------- + +function test() +{ + printBugNumber(BUGNUMBER); + printStatus (summary); + + var d; + var y; + var l; + var maxms = 8640000000000000; + + d = new Date(-maxms ); + y = d.getFullYear(); + + actual = y; + expect = -271821; + reportCompare(expect, actual, summary + ': check year'); + + l = d.toLocaleString(); + print(l); + if (this.hasOwnProperty("Intl")) { + // ECMA-402 specifies that toLocaleString uses a proleptic Gregorian + // calender without year 0. + // Also, localized strings usually use era indicators such as "BC" + // instead of minus signs. + expect = Math.abs(y - 1) + ''; + } else { + // ECMA-262 up to edition 5.1 didn't specify toLocaleString; + // the previous implementation assumed a calendar with year 0 and used + // minus sign. + expect = y + ''; + } + actual = l.match(/-?[0-9]{3,}/) + ''; + reportCompare(expect, actual, summary + ': check toLocaleString'); + + d = new Date(maxms ); + y = d.getFullYear(); + l = d.toLocaleString(); + print(l); + + actual = y; + expect = 275760; + reportCompare(expect, actual, summary + ': check year'); + + actual = l.match(new RegExp(y)) + ''; + expect = y + ''; + reportCompare(expect, actual, summary + ': check toLocaleString'); +} diff --git a/js/src/tests/non262/Date/15.9.5.5.js b/js/src/tests/non262/Date/15.9.5.5.js new file mode 100644 index 0000000000..1a21b33a63 --- /dev/null +++ b/js/src/tests/non262/Date/15.9.5.5.js @@ -0,0 +1,111 @@ +// |reftest| random-if(xulRuntime.OS=="Linux") +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* 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/. */ + + +/** + File Name: 15.9.5.5.js + ECMA Section: 15.9.5.5 Date.prototype.toLocaleString() + Description: + This function returns a string value. The contents of the string are + implementation dependent, but are intended to represent the "date" + portion of the Date in the current time zone in a convenient, + human-readable form. We can't test the content of the string, + but can verify that the string is parsable by Date.parse + + The toLocaleString function is not generic; it generates a runtime error + if its 'this' value is not a Date object. Therefore it cannot be transferred + to other kinds of objects for use as a method. + + Note: This test isn't supposed to work with a non-English locale per spec. + + Author: pschwartau@netscape.com + Date: 14 november 2000 +*/ + +var SECTION = "15.9.5.5"; +var TITLE = "Date.prototype.toLocaleString()"; + +var status = ''; +var actual = ''; +var expect = ''; + + +writeHeaderToLog( SECTION + " "+ TITLE); + +var now = new Date(); + +// first, some generic tests - + +status = "typeof (now.toLocaleString())"; +actual = typeof (now.toLocaleString()); +expect = "string"; +addTestCase(); + +status = "Date.prototype.toLocaleString.length"; +actual = Date.prototype.toLocaleString.length; +expect = 0; +addTestCase(); + +// Date.parse is accurate to the second; valueOf() to the millisecond - +status = "Math.abs(Date.parse(now.toLocaleString('en-US')) - now.valueOf()) < 1000"; +actual = Math.abs(Date.parse(now.toLocaleString('en-US')) - now.valueOf()) < 1000; +expect = true; +addTestCase(); + + + +// 1970 +addDateTestCase(0); +addDateTestCase(TZ_ADJUST); + + +// 1900 +addDateTestCase(UTC_01_JAN_1900); +addDateTestCase(UTC_01_JAN_1900 -TZ_ADJUST); + + +// 2000 +addDateTestCase(UTC_01_JAN_2000); +addDateTestCase(UTC_01_JAN_2000 -TZ_ADJUST); + + +// 29 Feb 2000 +addDateTestCase(UTC_29_FEB_2000); +addDateTestCase(UTC_29_FEB_2000 - 1000); +addDateTestCase(UTC_29_FEB_2000 - TZ_ADJUST); + + +// 2005 +addDateTestCase(UTC_01_JAN_2005); +addDateTestCase(UTC_01_JAN_2005 - 1000); +addDateTestCase(UTC_01_JAN_2005-TZ_ADJUST); + + + +//----------------------------------------------------------------------------------------------------- +test(); +//----------------------------------------------------------------------------------------------------- + + +function addTestCase() +{ + AddTestCase( + status, + expect, + actual); +} + + +function addDateTestCase(date_given_in_milliseconds) +{ + var givenDate = new Date(date_given_in_milliseconds); + + status = 'Date.parse(' + givenDate + ').toLocaleString("en-US"))'; + actual = Date.parse(givenDate.toLocaleString("en-US")); + expect = date_given_in_milliseconds; + addTestCase(); +} + diff --git a/js/src/tests/non262/Date/15.9.5.6.js b/js/src/tests/non262/Date/15.9.5.6.js new file mode 100644 index 0000000000..67e67630ec --- /dev/null +++ b/js/src/tests/non262/Date/15.9.5.6.js @@ -0,0 +1,118 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ + + +/** + File Name: 15.9.5.6.js + ECMA Section: 15.9.5.6 Date.prototype.toLocaleDateString() + Description: + This function returns a string value. The contents of the string are + implementation dependent, but are intended to represent the "date" + portion of the Date in the current time zone in a convenient, + human-readable form. We can't test the content of the string, + but can verify that the string is parsable by Date.parse + + The toLocaleDateString function is not generic; it generates a runtime error + if its 'this' value is not a Date object. Therefore it cannot be transferred + to other kinds of objects for use as a method. + + Note: This test isn't supposed to work with a non-English locale per spec. + + Author: pschwartau@netscape.com + Date: 14 november 2000 +*/ + +var SECTION = "15.9.5.6"; +var TITLE = "Date.prototype.toLocaleDateString()"; + +var status = ''; +var actual = ''; +var expect = ''; + + +writeHeaderToLog( SECTION + " "+ TITLE); + +var now = new Date(); + +// first, some generic tests - + +status = "typeof (now.toLocaleDateString())"; +actual = typeof (now.toLocaleDateString()); +expect = "string"; +addTestCase(); + +status = "Date.prototype.toLocaleDateString.length"; +actual = Date.prototype.toLocaleDateString.length; +expect = 0; +addTestCase(); + +/* Date.parse is accurate to the second; valueOf() to the millisecond. + Here we expect them to coincide, as we expect a time of exactly midnight - */ +status = "(Date.parse(now.toLocaleDateString('en-US')) - (midnight(now)).valueOf()) == 0"; +actual = (Date.parse(now.toLocaleDateString('en-US')) - (midnight(now)).valueOf()) == 0; +expect = true; +addTestCase(); + + + +// 1970 +addDateTestCase(0); +addDateTestCase(TZ_ADJUST); + + +// 1900 +addDateTestCase(UTC_01_JAN_1900); +addDateTestCase(UTC_01_JAN_1900 - TZ_ADJUST); + + +// 2000 +addDateTestCase(UTC_01_JAN_2000); +addDateTestCase(UTC_01_JAN_2000 - TZ_ADJUST); + + +// 29 Feb 2000 +addDateTestCase(UTC_29_FEB_2000); +addDateTestCase(UTC_29_FEB_2000 - 1000); +addDateTestCase(UTC_29_FEB_2000 - TZ_ADJUST); + + +// 2005 +addDateTestCase(UTC_01_JAN_2005); +addDateTestCase(UTC_01_JAN_2005 - 1000); +addDateTestCase(UTC_01_JAN_2005 - TZ_ADJUST); + + + +//----------------------------------------------------------------------------------------------------- +test(); +//----------------------------------------------------------------------------------------------------- + + +function addTestCase() +{ + new TestCase( + status, + expect, + actual); +} + + +function addDateTestCase(date_given_in_milliseconds) +{ + var givenDate = new Date(date_given_in_milliseconds); + + status = 'Date.parse(' + givenDate + ').toLocaleDateString("en-US"))'; + actual = Date.parse(givenDate.toLocaleDateString("en-US")); + expect = Date.parse(midnight(givenDate)); + addTestCase(); +} + + +function midnight(givenDate) +{ + // midnight on the given date - + return new Date(givenDate.getFullYear(), givenDate.getMonth(), givenDate.getDate()); +} + diff --git a/js/src/tests/non262/Date/15.9.5.7.js b/js/src/tests/non262/Date/15.9.5.7.js new file mode 100644 index 0000000000..61ebf72fee --- /dev/null +++ b/js/src/tests/non262/Date/15.9.5.7.js @@ -0,0 +1,111 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ + +/** + File Name: 15.9.5.7.js + ECMA Section: 15.9.5.7 Date.prototype.toLocaleTimeString() + Description: + This function returns a string value. The contents of the string are + implementation dependent, but are intended to represent the "time" + portion of the Date in the current time zone in a convenient, + human-readable form. We test the content of the string by checking + that + + new Date(d.toDateString() + " " + d.toLocaleTimeString()) == d + + Author: pschwartau@netscape.com + Date: 14 november 2000 + Revised: 07 january 2002 because of a change in JS Date format: + Revised: 21 November 2005 since the string comparison stuff is horked. + bclary + + See http://bugzilla.mozilla.org/show_bug.cgi?id=118266 (SpiderMonkey) + See http://bugzilla.mozilla.org/show_bug.cgi?id=118636 (Rhino) +*/ +//----------------------------------------------------------------------------- +var SECTION = "15.9.5.7"; +var TITLE = "Date.prototype.toLocaleTimeString()"; + +var status = ''; +var actual = ''; +var expect = ''; +var givenDate; +var year = ''; +var regexp = ''; +var TimeString = ''; +var reducedDateString = ''; +var hopeThisIsLocaleTimeString = ''; +var cnERR ='OOPS! FATAL ERROR: no regexp match in extractLocaleTimeString()'; + +writeHeaderToLog( SECTION + " "+ TITLE); + +var now = new Date(); + +// valueOf() is to accurate to the millisecond, +// Date.parse() is accurate only to the second +var TIME_NOW = now.valueOf(); + +// first, a couple generic tests - + +status = "typeof (now.toLocaleTimeString())"; +actual = typeof (now.toLocaleTimeString()); +expect = "string"; +addTestCase(); + +status = "Date.prototype.toLocaleTimeString.length"; +actual = Date.prototype.toLocaleTimeString.length; +expect = 0; +addTestCase(); + +// 1970 +addDateTestCase(0); +addDateTestCase(TZ_ADJUST); + +// 1900 +addDateTestCase(UTC_01_JAN_1900); +addDateTestCase(UTC_01_JAN_1900 - TZ_ADJUST); + +// 2000 +addDateTestCase(UTC_01_JAN_2000); +addDateTestCase(UTC_01_JAN_2000 - TZ_ADJUST); + +// 29 Feb 2000 +addDateTestCase(UTC_29_FEB_2000); +addDateTestCase(UTC_29_FEB_2000 - 1000); +addDateTestCase(UTC_29_FEB_2000 - TZ_ADJUST); + +// Now +addDateTestCase( TIME_NOW); +addDateTestCase( TIME_NOW - TZ_ADJUST); + +// 2005 +addDateTestCase(UTC_01_JAN_2005); +addDateTestCase(UTC_01_JAN_2005 - 1000); +addDateTestCase(UTC_01_JAN_2005 - TZ_ADJUST); + +test(); + +function addTestCase() +{ + new TestCase( + status, + expect, + actual); +} + + +function addDateTestCase(date_given_in_milliseconds) +{ + var s = 'new Date(' + date_given_in_milliseconds + ')'; + givenDate = new Date(date_given_in_milliseconds); + + status = 'd = ' + s + + '; d == new Date(d.toDateString() + " " + d.toLocaleTimeString())'; + expect = givenDate.toString(); + actual = new Date(givenDate.toDateString() + + ' ' + givenDate.toLocaleTimeString()).toString(); + addTestCase(); +} + diff --git a/js/src/tests/non262/Date/UTC-convert-all-arguments.js b/js/src/tests/non262/Date/UTC-convert-all-arguments.js new file mode 100644 index 0000000000..2fee8b951d --- /dev/null +++ b/js/src/tests/non262/Date/UTC-convert-all-arguments.js @@ -0,0 +1,70 @@ +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommonn.org/licenses/publicdomain/ + */ + +var BUGNUMBER = 1160356; +var summary = + "Date.UTC must convert *all* arguments to number, not return NaN early if " + + "a non-finite argument is encountered"; + +print(BUGNUMBER + ": " + summary); + +/************** + * BEGIN TEST * + **************/ + +function expectThrowTypeError(f, i) +{ + try + { + f(); + throw new Error("didn't throw"); + } + catch (e) + { + assertEq(e, 42, "index " + i + ": expected 42, got " + e); + } +} + +var bad = + { toString: function() { throw 17; }, valueOf: function() { throw 42; } }; + +var args = + [ + [bad], + + [NaN, bad], + [Infinity, bad], + [1970, bad], + + [1970, NaN, bad], + [1970, Infinity, bad], + [1970, 4, bad], + + [1970, 4, NaN, bad], + [1970, 4, Infinity, bad], + [1970, 4, 17, bad], + + [1970, 4, 17, NaN, bad], + [1970, 4, 17, Infinity, bad], + [1970, 4, 17, 13, bad], + + [1970, 4, 17, 13, NaN, bad], + [1970, 4, 17, 13, Infinity, bad], + [1970, 4, 17, 13, 37, bad], + + [1970, 4, 17, 13, 37, NaN, bad], + [1970, 4, 17, 13, 37, Infinity, bad], + [1970, 4, 17, 13, 37, 23, bad], + ]; + +for (var i = 0, len = args.length; i < len; i++) + expectThrowTypeError(function() { Date.UTC.apply(null, args[i]); }, i); + +/******************************************************************************/ + +if (typeof reportCompare === "function") + reportCompare(true, true); + +print("Tests complete"); diff --git a/js/src/tests/non262/Date/browser.js b/js/src/tests/non262/Date/browser.js new file mode 100644 index 0000000000..e2c7f6d317 --- /dev/null +++ b/js/src/tests/non262/Date/browser.js @@ -0,0 +1,12 @@ +if (typeof getDefaultLocale === "undefined") { + var getDefaultLocale = SpecialPowers.Cu.getJSTestingFunctions().getDefaultLocale; +} +if (typeof setDefaultLocale === "undefined") { + var setDefaultLocale = SpecialPowers.Cu.getJSTestingFunctions().setDefaultLocale; +} +if (typeof getTimeZone === "undefined") { + var getTimeZone = SpecialPowers.Cu.getJSTestingFunctions().getTimeZone; +} +if (typeof setTimeZone === "undefined") { + var setTimeZone = SpecialPowers.Cu.getJSTestingFunctions().setTimeZone; +} diff --git a/js/src/tests/non262/Date/constructor-convert-all-arguments.js b/js/src/tests/non262/Date/constructor-convert-all-arguments.js new file mode 100644 index 0000000000..3a281cae22 --- /dev/null +++ b/js/src/tests/non262/Date/constructor-convert-all-arguments.js @@ -0,0 +1,70 @@ +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommonn.org/licenses/publicdomain/ + */ + +var BUGNUMBER = 1160356; +var summary = + "new Date(...) must convert *all* arguments to number, not return NaN " + + "early if a non-finite argument is encountered"; + +print(BUGNUMBER + ": " + summary); + +/************** + * BEGIN TEST * + **************/ + +function expectThrowTypeError(f, i) +{ + try + { + f(); + throw new Error("didn't throw"); + } + catch (e) + { + assertEq(e, 42, "index " + i + ": expected 42, got " + e); + } +} + +var bad = + { toString: function() { throw 17; }, valueOf: function() { throw 42; } }; + +var funcs = + [ + function() { new Date(bad); }, + + function() { new Date(NaN, bad); }, + function() { new Date(Infinity, bad); }, + function() { new Date(1970, bad); }, + + function() { new Date(1970, NaN, bad); }, + function() { new Date(1970, Infinity, bad); }, + function() { new Date(1970, 4, bad); }, + + function() { new Date(1970, 4, NaN, bad); }, + function() { new Date(1970, 4, Infinity, bad); }, + function() { new Date(1970, 4, 17, bad); }, + + function() { new Date(1970, 4, 17, NaN, bad); }, + function() { new Date(1970, 4, 17, Infinity, bad); }, + function() { new Date(1970, 4, 17, 13, bad); }, + + function() { new Date(1970, 4, 17, 13, NaN, bad); }, + function() { new Date(1970, 4, 17, 13, Infinity, bad); }, + function() { new Date(1970, 4, 17, 13, 37, bad); }, + + function() { new Date(1970, 4, 17, 13, 37, NaN, bad); }, + function() { new Date(1970, 4, 17, 13, 37, Infinity, bad); }, + function() { new Date(1970, 4, 17, 13, 37, 23, bad); }, + ]; + +for (var i = 0, len = funcs.length; i < len; i++) + expectThrowTypeError(funcs[i]); + +/******************************************************************************/ + +if (typeof reportCompare === "function") + reportCompare(true, true); + +print("Tests complete"); diff --git a/js/src/tests/non262/Date/constructor-one-Date-argument.js b/js/src/tests/non262/Date/constructor-one-Date-argument.js new file mode 100644 index 0000000000..718c413731 --- /dev/null +++ b/js/src/tests/non262/Date/constructor-one-Date-argument.js @@ -0,0 +1,40 @@ +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommonn.org/licenses/publicdomain/ + */ + +var BUGNUMBER = 1187233; +var summary = + "Passing a Date object to |new Date()| should copy it, not convert it to " + + "a primitive and create it from that."; + +print(BUGNUMBER + ": " + summary); + +/************** + * BEGIN TEST * + **************/ + +Date.prototype.toString = Date.prototype.valueOf = null; +var d = new Date(new Date(8675309)); +assertEq(d.getTime(), 8675309); + +Date.prototype.valueOf = () => 42; +d = new Date(new Date(8675309)); +assertEq(d.getTime(), 8675309); + +var D = newGlobal().Date; + +D.prototype.toString = D.prototype.valueOf = null; +var d = new Date(new D(3141592654)); +assertEq(d.getTime(), 3141592654); + +D.prototype.valueOf = () => 525600; +d = new Date(new D(3141592654)); +assertEq(d.getTime(), 3141592654); + +/******************************************************************************/ + +if (typeof reportCompare === "function") + reportCompare(true, true); + +print("Tests complete"); diff --git a/js/src/tests/non262/Date/constructor-one-argument.js b/js/src/tests/non262/Date/constructor-one-argument.js new file mode 100644 index 0000000000..d7acd33aad --- /dev/null +++ b/js/src/tests/non262/Date/constructor-one-argument.js @@ -0,0 +1,26 @@ +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommonn.org/licenses/publicdomain/ + */ + +var BUGNUMBER = 738511; +var summary = + "new Date(value) should call ToPrimitive on value before testing for " + + "string-ness"; + +print(BUGNUMBER + ": " + summary); + +/************** + * BEGIN TEST * + **************/ + +assertEq(new Date(new String("2012-01-31T00:00:00.000Z")).valueOf(), + 1327968000000, + "Date constructor passed a String object should parse it"); + +/******************************************************************************/ + +if (typeof reportCompare === "function") + reportCompare(true, true); + +print("Tests complete"); diff --git a/js/src/tests/non262/Date/dashed-date.js b/js/src/tests/non262/Date/dashed-date.js new file mode 100644 index 0000000000..a1babf991e --- /dev/null +++ b/js/src/tests/non262/Date/dashed-date.js @@ -0,0 +1,118 @@ +const tests = [ + // ==== Date only ==== + + // dd-MMM-yyyy + ["24-Apr-2023", "2023-04-24T00:00:00"], + ["24-apr-2023", "2023-04-24T00:00:00"], + ["24-April-2023", "2023-04-24T00:00:00"], + ["24-APRIL-2023", "2023-04-24T00:00:00"], + ["24-Apr-2033", "2033-04-24T00:00:00"], + + ["24-Apr-0023", "0023-04-24T00:00:00"], + + // dd-MMM-yy + ["24-Apr-23", "2023-04-24T00:00:00"], + ["24-Apr-33", "2033-04-24T00:00:00"], + + // dd-MMM-yyy + ["24-Apr-023", "2023-04-24T00:00:00"], + + // yyyy-MM-dd + ["2023-Apr-24", "2023-04-24T00:00:00"], + ["2033-Apr-24", "2033-04-24T00:00:00"], + + // yy-MM-dd + ["33-Apr-24", "2033-04-24T00:00:00"], + + // yyy-MM-dd + ["033-Apr-24", "2033-04-24T00:00:00"], + + // ==== Date followed by hour and TZ ==== + + ["24-Apr-2023 12:34:56", "2023-04-24T12:34:56"], + ["24-Apr-2023 Mon 12:34:56", "2023-04-24T12:34:56"], + ["24-Apr-2023 (Mon) 12:34:56", "2023-04-24T12:34:56"], + ["24-Apr-2023(Mon)12:34:56", "2023-04-24T12:34:56"], + + ["24-Apr-2023,12:34:56", "2023-04-24T12:34:56"], + ["24-Apr-2023,Mon 12:34:56", "2023-04-24T12:34:56"], + + ["24-Apr-2023 12:34:56 GMT", "2023-04-24T12:34:56Z"], + ["24-Apr-2023 12:34:56 +04", "2023-04-24T12:34:56+04:00"], + ["24-Apr-2023 12:34:56 +04:30", "2023-04-24T12:34:56+04:30"], + ["24-Apr-2023 12:34:56 -04", "2023-04-24T12:34:56-04:00"], + ["24-Apr-2023 12:34:56 -04:30", "2023-04-24T12:34:56-04:30"], + + ["24-Apr-2023 GMT", "2023-04-24T00:00:00Z"], + ["24-Apr-2023 +04", "2023-04-24T00:00:00+04:00"], + ["24-Apr-2023 +04:30", "2023-04-24T00:00:00+04:30"], + ["24-Apr-2023 -04", "2023-04-24T00:00:00-04:00"], + ["24-Apr-2023 -04:30", "2023-04-24T00:00:00-04:30"], + + ["24-Apr-2023GMT", "2023-04-24T00:00:00Z"], + ["24-Apr-2023+04", "2023-04-24T00:00:00+04:00"], + ["24-Apr-2023+04:30", "2023-04-24T00:00:00+04:30"], + ["24-Apr-2023-04", "2023-04-24T00:00:00-04:00"], + ["24-Apr-2023-04:30", "2023-04-24T00:00:00-04:30"], + + ["24-Apr-2023,GMT", "2023-04-24T00:00:00Z"], + ["24-Apr-2023,+04", "2023-04-24T00:00:00+04:00"], + ["24-Apr-2023,+04:30", "2023-04-24T00:00:00+04:30"], + ["24-Apr-2023,-04", "2023-04-24T00:00:00-04:00"], + ["24-Apr-2023,-04:30", "2023-04-24T00:00:00-04:30"], + + ["24-Apr-2023/12:34:56", "2023-04-24T12:34:56"], + ["24-Apr-2023/GMT", "2023-04-24T00:00:00Z"], + + // ==== non dd-MMM-yyyy. Uses fallback path ==== + + // Missing space. + ["24-Apr-202312:13:14", "-202312-04-24T13:14:00"], + + // Extra delimiter. + ["24-Apr- 2023", "2023-04-24T00:00:00"], + ["24-Apr -2023", "-002023-04-24T00:00:00"], + ["24- Apr-2023", "-002023-04-24T00:00:00"], + ["24 -Apr-2023", "-002023-04-24T00:00:00"], + + ["24-Apr-/2023", "2023-04-24T00:00:00"], + ["24-Apr/-2023", "-002023-04-24T00:00:00"], + ["24-/Apr-2023", "-002023-04-24T00:00:00"], + ["24/-Apr-2023", "-002023-04-24T00:00:00"], + + ["24-Apr-()2023", "2023-04-24T00:00:00"], + ["24-Apr()-2023", "-002023-04-24T00:00:00"], + ["24-()Apr-2023", "-002023-04-24T00:00:00"], + ["24()-Apr-2023", "-002023-04-24T00:00:00"], + + // mday being 3+ digits + ["024-Apr-2023", "-002023-04-24T00:00:00"], + ["0024-Apr-2023", "-002023-04-24T00:00:00"], +]; + +for (const [testString, isoString] of tests) { + const testDate = new Date(testString); + const isoDate = new Date(isoString); + + assertEq(testDate.getTime(), isoDate.getTime(), + testString); +} + +const invalidTests = [ + // mday being out of range. + "32-01-32", + + // mday being 3+ digits, while year being 2-3 digits. + "024-Apr-22", + "024-Apr-023", + + // Duplicate date. + "2012-Apr-08 12/12/12", +]; + +for (const testString of invalidTests) { + assertEq(Number.isNaN(new Date(testString).getTime()), true, testString); +} + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/non262/Date/defaultvalue.js b/js/src/tests/non262/Date/defaultvalue.js new file mode 100644 index 0000000000..2fc5887d18 --- /dev/null +++ b/js/src/tests/non262/Date/defaultvalue.js @@ -0,0 +1,190 @@ +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommonn.org/licenses/publicdomain/ + */ + +var BUGNUMBER = 645464; +var summary = + "[[DefaultValue]] behavior wrong for Date with overridden valueOf/toString"; + +print(BUGNUMBER + ": " + summary); + +/************** + * BEGIN TEST * + **************/ + +function allTests() +{ + var DS = new Date(2010, 1, 1).toString(); + + // equality + + var d = new Date(2010, 1, 1); + assertEq(d == DS, true); + + var d2 = new Date(2010, 1, 1); + d2.valueOf = function() { assertEq(arguments.length, 0); return 17; }; + assertEq(d2 == DS, true); + + var d3 = new Date(2010, 1, 1); + d3.toString = function() { return 42; }; + assertEq(d3 == 42, true); + + function testEquality() + { + var d = new Date(2010, 1, 1); + assertEq(d == DS, true); + + var d2 = new Date(2010, 1, 1); + d2.valueOf = function() { assertEq(arguments.length, 0); return 17; }; + assertEq(d2 == DS, true); + + var d3 = new Date(2010, 1, 1); + d3.toString = function() { return 42; }; + assertEq(d3 == 42, true); + } + testEquality(); + + + // addition of Date to number + + var d = new Date(2010, 1, 1); + assertEq(d + 5, DS + "5"); + + var d2 = new Date(2010, 1, 1); + d2.toString = function() { return 9; }; + assertEq(d2 + 3, 9 + 3); + + var d3 = new Date(2010, 1, 1); + d3.valueOf = function() { assertEq(arguments.length, 0); return 17; }; + assertEq(d3 + 5, DS + "5"); + + function testDateNumberAddition() + { + var d = new Date(2010, 1, 1); + assertEq(d + 5, DS + "5"); + + var d2 = new Date(2010, 1, 1); + d2.toString = function() { return 9; }; + assertEq(d2 + 3, 9 + 3); + + var d3 = new Date(2010, 1, 1); + d3.valueOf = function() { assertEq(arguments.length, 0); return 17; }; + assertEq(d3 + 5, DS + "5"); + } + testDateNumberAddition(); + + + // addition of Date to Date + + var d = new Date(2010, 1, 1); + assertEq(d + d, DS + DS); + + var d2 = new Date(2010, 1, 1); + d2.toString = function() { return 5; }; + assertEq(d2 + d2, 10); + + var d3 = new Date(2010, 1, 1); + d3.valueOf = function() { assertEq(arguments.length, 0); return 8.5; }; + assertEq(d3 + d3, DS + DS); + + function testDateDateAddition() + { + var d = new Date(2010, 1, 1); + assertEq(d + d, DS + DS); + + var d2 = new Date(2010, 1, 1); + d2.toString = function() { return 5; }; + assertEq(d2 + d2, 10); + + var d3 = new Date(2010, 1, 1); + d3.valueOf = function() { assertEq(arguments.length, 0); return 8.5; }; + assertEq(d3 + d3, DS + DS); + } + testDateDateAddition(); + + + // Date as bracketed property name + + var obj = { 8: 42, 9: 73 }; + obj[DS] = 17; + + var d = new Date(2010, 1, 1); + assertEq(obj[d], 17); + + var d2 = new Date(2010, 1, 1); + d2.valueOf = function() { assertEq(arguments.length, 0); return 8; } + assertEq(obj[d2], 17); + + var d3 = new Date(2010, 1, 1); + d3.toString = function() { return 9; }; + assertEq(obj[d3], 73); + + function testPropertyName() + { + var obj = { 8: 42, 9: 73 }; + obj[DS] = 17; + + var d = new Date(2010, 1, 1); + assertEq(obj[d], 17); + + var d2 = new Date(2010, 1, 1); + d2.valueOf = function() { assertEq(arguments.length, 0); return 8; } + assertEq(obj[d2], 17); + + var d3 = new Date(2010, 1, 1); + d3.toString = function() { return 9; }; + assertEq(obj[d3], 73); + } + testPropertyName(); + + + // Date as property name with |in| operator + + var obj = {}; + obj[DS] = 5; + + var d = new Date(2010, 1, 1); + assertEq(d in obj, true); + + var d2 = new Date(2010, 1, 1); + d2.toString = function() { return "baz"; }; + assertEq(d2 in { baz: 42 }, true); + + var d3 = new Date(2010, 1, 1); + d3.valueOf = function() { assertEq(arguments.length, 0); return "quux"; }; + assertEq(d3 in obj, true); + + function testInOperatorName() + { + var obj = {}; + obj[DS] = 5; + + var d = new Date(2010, 1, 1); + assertEq(d in obj, true); + + var d2 = new Date(2010, 1, 1); + d2.toString = function() { return "baz"; }; + assertEq(d2 in { baz: 42 }, true); + + var d3 = new Date(2010, 1, 1); + d3.valueOf = function() { assertEq(arguments.length, 0); return "quux"; }; + assertEq(d3 in obj, true); + } + testInOperatorName(); +} + +allTests(); + +if (typeof newGlobal === "function") +{ + Date = newGlobal().Date; + allTests(); +} + +/******************************************************************************/ + +if (typeof reportCompare === "function") + reportCompare(true, true); + +print("All tests passed!"); diff --git a/js/src/tests/non262/Date/dst-offset-caching-1-of-8.js b/js/src/tests/non262/Date/dst-offset-caching-1-of-8.js new file mode 100644 index 0000000000..95a88e9a92 --- /dev/null +++ b/js/src/tests/non262/Date/dst-offset-caching-1-of-8.js @@ -0,0 +1,6 @@ +// |reftest| slow +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + */ +runDSTOffsetCachingTestsFraction(1, 8); diff --git a/js/src/tests/non262/Date/dst-offset-caching-2-of-8.js b/js/src/tests/non262/Date/dst-offset-caching-2-of-8.js new file mode 100644 index 0000000000..0810f91176 --- /dev/null +++ b/js/src/tests/non262/Date/dst-offset-caching-2-of-8.js @@ -0,0 +1,6 @@ +// |reftest| slow +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + */ +runDSTOffsetCachingTestsFraction(2, 8); diff --git a/js/src/tests/non262/Date/dst-offset-caching-3-of-8.js b/js/src/tests/non262/Date/dst-offset-caching-3-of-8.js new file mode 100644 index 0000000000..a70559afa3 --- /dev/null +++ b/js/src/tests/non262/Date/dst-offset-caching-3-of-8.js @@ -0,0 +1,6 @@ +// |reftest| slow +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + */ +runDSTOffsetCachingTestsFraction(3, 8); diff --git a/js/src/tests/non262/Date/dst-offset-caching-4-of-8.js b/js/src/tests/non262/Date/dst-offset-caching-4-of-8.js new file mode 100644 index 0000000000..3bda28d617 --- /dev/null +++ b/js/src/tests/non262/Date/dst-offset-caching-4-of-8.js @@ -0,0 +1,6 @@ +// |reftest| slow +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + */ +runDSTOffsetCachingTestsFraction(4, 8); diff --git a/js/src/tests/non262/Date/dst-offset-caching-5-of-8.js b/js/src/tests/non262/Date/dst-offset-caching-5-of-8.js new file mode 100644 index 0000000000..a15692ff0d --- /dev/null +++ b/js/src/tests/non262/Date/dst-offset-caching-5-of-8.js @@ -0,0 +1,6 @@ +// |reftest| slow +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + */ +runDSTOffsetCachingTestsFraction(5, 8); diff --git a/js/src/tests/non262/Date/dst-offset-caching-6-of-8.js b/js/src/tests/non262/Date/dst-offset-caching-6-of-8.js new file mode 100644 index 0000000000..d2ce8e90c8 --- /dev/null +++ b/js/src/tests/non262/Date/dst-offset-caching-6-of-8.js @@ -0,0 +1,6 @@ +// |reftest| slow +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + */ +runDSTOffsetCachingTestsFraction(6, 8); diff --git a/js/src/tests/non262/Date/dst-offset-caching-7-of-8.js b/js/src/tests/non262/Date/dst-offset-caching-7-of-8.js new file mode 100644 index 0000000000..aaa560c202 --- /dev/null +++ b/js/src/tests/non262/Date/dst-offset-caching-7-of-8.js @@ -0,0 +1,6 @@ +// |reftest| slow +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + */ +runDSTOffsetCachingTestsFraction(7, 8); diff --git a/js/src/tests/non262/Date/dst-offset-caching-8-of-8.js b/js/src/tests/non262/Date/dst-offset-caching-8-of-8.js new file mode 100644 index 0000000000..30a6f781b8 --- /dev/null +++ b/js/src/tests/non262/Date/dst-offset-caching-8-of-8.js @@ -0,0 +1,6 @@ +// |reftest| slow +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + */ +runDSTOffsetCachingTestsFraction(8, 8); diff --git a/js/src/tests/non262/Date/equality-to-boolean.js b/js/src/tests/non262/Date/equality-to-boolean.js new file mode 100644 index 0000000000..c60319b9d9 --- /dev/null +++ b/js/src/tests/non262/Date/equality-to-boolean.js @@ -0,0 +1,39 @@ +// Any copyright is dedicated to the Public Domain. +// http://creativecommons.org/licenses/publicdomain/ + +//----------------------------------------------------------------------------- +print("Test for correct implementation of |Date == boolean| and vice versa"); + +/************** + * BEGIN TEST * + **************/ + +Date.prototype.toString = function() { return 1; }; +Date.prototype.valueOf = function() { return 0; }; + +/* + * ES5 11.9.3 doesn't directly handle obj == boolean. Instead it translates it + * as follows: + * + * obj == boolean + * ↳ obj == ToNumber(boolean), per step 7 + * ↳ ToPrimitive(obj) == ToNumber(boolean), per step 9 + * + * ToPrimitive calls [[DefaultValue]] with no hint. For Date objects this is + * treated as if it were instead called with hint String. That calls toString, + * which returns 1, so Date objects here should compare equal to true and + * unequal to false. + */ +assertEq(new Date == true, true); +assertEq(new Date == false, false); + +/* == is symmetric. */ +assertEq(true == new Date, true); +assertEq(false == new Date, false); + +/******************************************************************************/ + +if (typeof reportCompare === "function") + reportCompare(true, true); + +print("Tests complete"); diff --git a/js/src/tests/non262/Date/fractions.js b/js/src/tests/non262/Date/fractions.js new file mode 100644 index 0000000000..30dd663ddd --- /dev/null +++ b/js/src/tests/non262/Date/fractions.js @@ -0,0 +1,24 @@ +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommonn.org/licenses/publicdomain/ + */ + +var BUGNUMBER = 771946; +var summary = "Fractional days, months, years shouldn't trigger asserts"; + +print(BUGNUMBER + ": " + summary); + +/************** + * BEGIN TEST * + **************/ + +new Date(0).setFullYear(1.5); +new Date(0).setUTCDate(1.5); +new Date(0).setMonth(1.5); + +/******************************************************************************/ + +if (typeof reportCompare === "function") + reportCompare(true, true); + +print("Tests complete"); diff --git a/js/src/tests/non262/Date/non-iso.js b/js/src/tests/non262/Date/non-iso.js new file mode 100644 index 0000000000..9bd97dc288 --- /dev/null +++ b/js/src/tests/non262/Date/non-iso.js @@ -0,0 +1,81 @@ +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommonn.org/licenses/publicdomain/ + */ + +/* + * For the sake of cross compatibility with other implementations we + * follow the W3C "NOTE-datetime" specification when parsing dates of + * the form YYYY-MM-DDTHH:MM:SS save for a few exceptions: months, days, hours + * minutes, and seconds may be either one _or_ two digits long, and the 'T' + * preceding the time part may be replaced with a space. So, a string like + * "1997-3-8 1:1:1" will parse successfully. See bug: 1203298 + */ + +/************** + * BEGIN TEST * + **************/ + +assertEq(new Date("1997-03-08 1:1:1.01").getTime(), + new Date("1997-03-08T01:01:01.01").getTime()); +assertEq(new Date("1997-03-08 11:19:20").getTime(), + new Date("1997-03-08T11:19:20").getTime()); +assertEq(new Date("1997-3-08 11:19:20").getTime(), + new Date("1997-03-08T11:19:20").getTime()); +assertEq(new Date("1997-3-8 11:19:20").getTime(), + new Date("1997-03-08T11:19:20").getTime()); +assertEq(new Date("+001997-3-8 11:19:20").getTime(), + new Date("1997-03-08T11:19:20").getTime()); +assertEq(new Date("+001997-03-8 11:19:20").getTime(), + new Date("1997-03-08T11:19:20").getTime()); +assertEq(new Date("1997-03-08 11:19").getTime(), + new Date("1997-03-08T11:19").getTime()); +assertEq(new Date("1997-03-08 1:19").getTime(), + new Date("1997-03-08T01:19").getTime()); +assertEq(new Date("1997-03-08 1:1").getTime(), + new Date("1997-03-08T01:01").getTime()); +assertEq(new Date("1997-03-08 1:1:01").getTime(), + new Date("1997-03-08T01:01:01").getTime()); +assertEq(new Date("1997-03-08 1:1:1").getTime(), + new Date("1997-03-08T01:01:01").getTime()); +assertEq(new Date("1997-03-08 11").getTime(), + new Date("1997-03-08T11").getTime()); // Date(NaN) +assertEq(new Date("1997-03-08").getTime(), + new Date("1997-03-08").getTime()); +assertEq(new Date("1997-03-8").getTime(), + new Date("1997-03-08").getTime()); +assertEq(new Date("1997-3-8").getTime(), + new Date("1997-03-08").getTime()); +assertEq(new Date("1997-03-08 11:19:10-07").getTime(), + new Date("1997-03-08 11:19:10-0700").getTime()); +assertEq(new Date("1997-03-08T11:19:10-07").getTime(), + new Date(NaN).getTime()); +assertEq(new Date("1997-3-8 ").getTime(), + new Date("1997-03-08T").getTime()); // Date(NaN) +assertEq(new Date("1997-3-8T11:19:20").getTime(), + new Date(NaN).getTime()); +assertEq(new Date("1997-03-8T11:19:20").getTime(), + new Date(NaN).getTime()); +assertEq(new Date("+001997-3-8T11:19:20").getTime(), + new Date(NaN).getTime()); +assertEq(new Date("+001997-3-08T11:19:20").getTime(), + new Date(NaN).getTime()); +assertEq(new Date("1997-3-8 :00:01").getTime(), + new Date(NaN).getTime()); +assertEq(new Date("1997-3-8 01::01").getTime(), + new Date(NaN).getTime()); +assertEq(new Date("1997-03-08T1:19").getTime(), + new Date(NaN).getTime()); +assertEq(new Date("1997-03-08T1:1").getTime(), + new Date(NaN).getTime()); +assertEq(new Date("1997-03-08T1:1:01").getTime(), + new Date(NaN).getTime()); +assertEq(new Date("1997-03-08T1:1:1").getTime(), + new Date(NaN).getTime()); + +/******************************************************************************/ + +if (typeof reportCompare === "function") + reportCompare(true, true); + +print("Tests complete"); diff --git a/js/src/tests/non262/Date/parse-from-tostring-methods.js b/js/src/tests/non262/Date/parse-from-tostring-methods.js new file mode 100644 index 0000000000..b6bf577bb0 --- /dev/null +++ b/js/src/tests/non262/Date/parse-from-tostring-methods.js @@ -0,0 +1,31 @@ +let dates = [ + "0041-09-23", "+000041-09-23", "-000041-09-23", + "0091-09-23", "+000091-09-23", "-000091-09-23", + "0217-09-23", "+000217-09-23", "-000217-09-23", + "2017-09-23", "+002017-09-23", "-002017-09-23", + "+022017-09-23", "-022017-09-23", + "+202017-09-23", "-202017-09-23", +]; + +for (let date of dates) { + let d = new Date(date); + let timeValue = d.valueOf(); + + assertEq(Number.isNaN(timeValue), false, `Cannot parse "${date}" as ISO date-only form`); + + // Ensure parsing the results of toString(), toUTCString(), and toISOString() + // gives the same time value as required by 20.3.3.2 Date.parse. + // + // Additional requirement not present in ES2019 draft rev 7acacc524213058a2368b5fa751fac7ea08ba230: + // The time zone offset must not contain seconds (or milliseconds) for |Date.parse(x.toString())| + // to be equal to |x.valueOf()|. + let tz = d.getTimezoneOffset(); + if (Math.trunc(tz) === tz) { + assertEq(Date.parse(d.toString()), timeValue, `Cannot parse from toString() of "${date}"`); + } + assertEq(Date.parse(d.toUTCString()), timeValue, `Cannot parse from toUTCString() of "${date}"`); + assertEq(Date.parse(d.toISOString()), timeValue, `Cannot parse from toISOString() of "${date}"`); +} + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/non262/Date/parse-time-zone.js b/js/src/tests/non262/Date/parse-time-zone.js new file mode 100644 index 0000000000..c239822b04 --- /dev/null +++ b/js/src/tests/non262/Date/parse-time-zone.js @@ -0,0 +1,10 @@ +// |reftest| skip-if(xulRuntime.OS=="WINNT") -- Windows doesn't accept IANA names for the TZ env variable + +// bug 1676708 +inTimeZone("Europe/London", () => { + let dt = new Date("Wed Nov 11 2020 19:18:50 GMT+0010"); + assertEq(dt.getTime(), new Date(2020, Month.November, 11, 19, 08, 50).getTime()); +}); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/non262/Date/prototype-is-not-a-date.js b/js/src/tests/non262/Date/prototype-is-not-a-date.js new file mode 100644 index 0000000000..26f0c3e859 --- /dev/null +++ b/js/src/tests/non262/Date/prototype-is-not-a-date.js @@ -0,0 +1,15 @@ +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + */ + +var BUGNUMBER = 861219; +var summary = "Date.prototype isn't an instance of Date"; + +print(BUGNUMBER + ": " + summary); + +assertEq(Date.prototype instanceof Date, false); +assertEq(Date.prototype.__proto__, Object.prototype); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/non262/Date/regress-188211.js b/js/src/tests/non262/Date/regress-188211.js new file mode 100644 index 0000000000..663611b81b --- /dev/null +++ b/js/src/tests/non262/Date/regress-188211.js @@ -0,0 +1,27 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ + +//----------------------------------------------------------------------------- +var BUGNUMBER = 188211; +var summary = 'Date.prototype.toLocaleString() error on future dates'; +var actual = ''; +var expect = ''; + +printBugNumber(BUGNUMBER); +printStatus (summary); + +var dt; + +dt = new Date(208e10); +printStatus(dt+''); +expect = true; +actual = dt.toLocaleString().indexOf('2035') >= 0; +reportCompare(expect, actual, summary + ': new Date(208e10)'); + +dt = new Date(209e10); +printStatus(dt+''); +expect = true; +actual = dt.toLocaleString().indexOf('2036') >= 0; +reportCompare(expect, actual, summary + ': new Date(209e10)'); diff --git a/js/src/tests/non262/Date/regress-301738-01.js b/js/src/tests/non262/Date/regress-301738-01.js new file mode 100644 index 0000000000..8f5ae7d304 --- /dev/null +++ b/js/src/tests/non262/Date/regress-301738-01.js @@ -0,0 +1,97 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ + +//----------------------------------------------------------------------------- +var BUGNUMBER = 301738; +var summary = 'Date parse compatibilty with MSIE'; +var actual = ''; +var expect = ''; + +printBugNumber(BUGNUMBER); +printStatus (summary); + +/* + Case 1. The input string contains an English month name. + The form of the string can be month f l, or f month l, or + f l month which each evaluate to the same date. + If f and l are both greater than or equal to 70, or + both less than 70, the date is invalid. + The year is taken to be the greater of the values f, l. + If the year is greater than or equal to 70 and less than 100, + it is considered to be the number of years after 1900. +*/ + +var month = 'January'; +var f; +var l; + +f = l = 0; +expect = true; + +actual = isNaN(new Date(month + ' ' + f + ' ' + l)); +reportCompare(expect, actual, 'January 0 0 is invalid'); + +actual = isNaN(new Date(f + ' ' + l + ' ' + month)); +reportCompare(expect, actual, '0 0 January is invalid'); + +actual = isNaN(new Date(f + ' ' + month + ' ' + l)); +reportCompare(expect, actual, '0 January 0 is invalid'); + +f = l = 70; + +actual = isNaN(new Date(month + ' ' + f + ' ' + l)); +reportCompare(expect, actual, 'January 70 70 is invalid'); + +actual = isNaN(new Date(f + ' ' + l + ' ' + month)); +reportCompare(expect, actual, '70 70 January is invalid'); + +actual = isNaN(new Date(f + ' ' + month + ' ' + l)); +reportCompare(expect, actual, '70 January 70 is invalid'); + +f = 100; +l = 15; + +// year, month, day +expect = new Date(f, 0, l).toString(); + +actual = new Date(month + ' ' + f + ' ' + l).toString(); +reportCompare(expect, actual, 'month f l'); + +actual = new Date(f + ' ' + l + ' ' + month).toString(); +reportCompare(expect, actual, 'f l month'); + +actual = new Date(f + ' ' + month + ' ' + l).toString(); +reportCompare(expect, actual, 'f month l'); + +f = 80; +l = 15; + +// year, month, day +expect = (new Date(f, 0, l)).toString(); + +actual = (new Date(month + ' ' + f + ' ' + l)).toString(); +reportCompare(expect, actual, 'month f l'); + +actual = (new Date(f + ' ' + l + ' ' + month)).toString(); +reportCompare(expect, actual, 'f l month'); + +actual = (new Date(f + ' ' + month + ' ' + l)).toString(); +reportCompare(expect, actual, 'f month l'); + +f = 2040; +l = 15; + +// year, month, day +expect = (new Date(f, 0, l)).toString(); + +actual = (new Date(month + ' ' + f + ' ' + l)).toString(); +reportCompare(expect, actual, 'month f l'); + +actual = (new Date(f + ' ' + l + ' ' + month)).toString(); +reportCompare(expect, actual, 'f l month'); + +actual = (new Date(f + ' ' + month + ' ' + l)).toString(); +reportCompare(expect, actual, 'f month l'); + diff --git a/js/src/tests/non262/Date/regress-309925-01.js b/js/src/tests/non262/Date/regress-309925-01.js new file mode 100644 index 0000000000..ee6daaffc4 --- /dev/null +++ b/js/src/tests/non262/Date/regress-309925-01.js @@ -0,0 +1,15 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ + +//----------------------------------------------------------------------------- +var BUGNUMBER = 309925; +var summary = 'Correctly parse Date strings with HH:MM'; +var actual = new Date('Sep 24, 11:58 105') + ''; +var expect = new Date('Sep 24, 11:58:00 105') + ''; + +printBugNumber(BUGNUMBER); +printStatus (summary); + +reportCompare(expect, actual, summary); diff --git a/js/src/tests/non262/Date/regress-309925-02.js b/js/src/tests/non262/Date/regress-309925-02.js new file mode 100644 index 0000000000..60bbfc33b0 --- /dev/null +++ b/js/src/tests/non262/Date/regress-309925-02.js @@ -0,0 +1,15 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ + +//----------------------------------------------------------------------------- +var BUGNUMBER = 309925; +var summary = 'Correctly parse Date strings with HH:MM(comment)'; +var actual = new Date('Sep 24, 11:58(comment) 105') + ''; +var expect = new Date('Sep 24, 11:58:00 (comment) 105') + ''; + +printBugNumber(BUGNUMBER); +printStatus (summary); + +reportCompare(expect, actual, summary); diff --git a/js/src/tests/non262/Date/regress-346027.js b/js/src/tests/non262/Date/regress-346027.js new file mode 100644 index 0000000000..ad1dc9e55f --- /dev/null +++ b/js/src/tests/non262/Date/regress-346027.js @@ -0,0 +1,27 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ + +//----------------------------------------------------------------------------- +var BUGNUMBER = 346027; +var summary = 'Date.prototype.setFullYear()'; +var actual = ''; +var expect = true; + + +//----------------------------------------------------------------------------- +test(); +//----------------------------------------------------------------------------- + +function test() +{ + printBugNumber(BUGNUMBER); + printStatus (summary); + + var d = new Date(); + d.setFullYear(); + actual = isNaN(d.getFullYear()); + + reportCompare(expect, actual, summary); +} diff --git a/js/src/tests/non262/Date/regress-346363.js b/js/src/tests/non262/Date/regress-346363.js new file mode 100644 index 0000000000..6381899fbc --- /dev/null +++ b/js/src/tests/non262/Date/regress-346363.js @@ -0,0 +1,28 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ + +//----------------------------------------------------------------------------- +var BUGNUMBER = 346363; +var summary = 'Date.prototype.setFullYear()'; +var actual = ''; +var expect = true; + + +//----------------------------------------------------------------------------- +test(); +//----------------------------------------------------------------------------- + +function test() +{ + printBugNumber(BUGNUMBER); + printStatus (summary); + + var d = new Date(); + d.setFullYear(); + d.setFullYear(2006); + actual = d.getFullYear() == 2006; + + reportCompare(expect, actual, summary); +} diff --git a/js/src/tests/non262/Date/regress-452786.js b/js/src/tests/non262/Date/regress-452786.js new file mode 100644 index 0000000000..c8943b1f99 --- /dev/null +++ b/js/src/tests/non262/Date/regress-452786.js @@ -0,0 +1,30 @@ +/* -*- indent-tabs-mode: nil; js-indent-level: 2 -*- */ +/* 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/. */ + +//----------------------------------------------------------------------------- +var BUGNUMBER = 452786; +var summary = 'Do not crash with (new Date()).getMonth.call(new Function())'; +var actual = ''; +var expect = ''; + + +//----------------------------------------------------------------------------- +test(); +//----------------------------------------------------------------------------- + +function test() +{ + printBugNumber(BUGNUMBER); + printStatus (summary); + + try + { + (new Date()).getMonth.call(new Function()); + } + catch(ex) + { + } + reportCompare(expect, actual, summary); +} diff --git a/js/src/tests/non262/Date/reset-time-zone-cache-same-offset.js b/js/src/tests/non262/Date/reset-time-zone-cache-same-offset.js new file mode 100644 index 0000000000..56c9fc262c --- /dev/null +++ b/js/src/tests/non262/Date/reset-time-zone-cache-same-offset.js @@ -0,0 +1,30 @@ +// |reftest| skip-if(xulRuntime.OS=="WINNT") -- Windows doesn't accept IANA names for the TZ env variable + +const testCases = [ + { + timeZone: "Europe/London", + string: "Tue Aug 14 2018 00:00:00 GMT+0100 (BST)", + alternativeTimeZones: ["British Summer Time"], + localeString: "8/14/2018, 12:00:00 AM GMT+1", + }, + { + timeZone: "UTC", + string: "Tue Aug 14 2018 00:00:00 GMT+0000 (UTC)", + alternativeTimeZones: ["Coordinated Universal Time"], + localeString: "8/14/2018, 12:00:00 AM UTC", + }, +]; + +// Repeat twice to test both transitions (Europe/London -> UTC and UTC -> Europe/London). +for (let i = 0; i < 2; ++i) { + for (let {timeZone, string, localeString, alternativeTimeZones} of testCases) { + setTimeZone(timeZone); + + let dt = new Date(2018, 8 - 1, 14); + assertDateTime(dt, string, ...alternativeTimeZones); + assertEq(dt.toLocaleString("en-US", {timeZoneName: "short"}), localeString); + } +} + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/non262/Date/setTime-argument-shortcircuiting.js b/js/src/tests/non262/Date/setTime-argument-shortcircuiting.js new file mode 100644 index 0000000000..7e67d03742 --- /dev/null +++ b/js/src/tests/non262/Date/setTime-argument-shortcircuiting.js @@ -0,0 +1,147 @@ +// Any copyright is dedicated to the Public Domain. +// http://creativecommons.org/licenses/publicdomain/ + +//----------------------------------------------------------------------------- +print("Test for correct short-circuiting implementation of Date.set methods"); + +/************** + * BEGIN TEST * + **************/ +var global = 0; +var date; + +/* Test that methods don't short circuit argument evaluation. */ +date = new Date(0).setSeconds(NaN, {valueOf:function(){global = 3}}); +assertEq(global, 3); + +date = new Date(0).setUTCSeconds(NaN, {valueOf:function(){global = 4}}); +assertEq(global, 4); + +date = new Date(0).setMinutes(NaN, {valueOf:function(){global = 5}}); +assertEq(global, 5); + +date = new Date(0).setUTCMinutes(NaN, {valueOf:function(){global = 6}}); +assertEq(global, 6); + +date = new Date(0).setHours(NaN, {valueOf:function(){global = 7}}); +assertEq(global, 7); + +date = new Date(0).setUTCHours(NaN, {valueOf:function(){global = 8}}); +assertEq(global, 8); + +date = new Date(0).setMonth(NaN, {valueOf:function(){global = 11}}); +assertEq(global, 11); + +date = new Date(0).setUTCMonth(NaN, {valueOf:function(){global = 12}}); +assertEq(global, 12); + +date = new Date(0).setFullYear(NaN, {valueOf:function(){global = 13}}); +assertEq(global, 13); + +date = new Date(0).setUTCFullYear(NaN, {valueOf:function(){global = 14}}); +assertEq(global, 14); + + + +/* Test that argument evaluation is not short circuited if Date == NaN */ +date = new Date(NaN).setMilliseconds({valueOf:function(){global = 15}}); +assertEq(global, 15); + +date = new Date(NaN).setUTCMilliseconds({valueOf:function(){global = 16}}); +assertEq(global, 16); + +date = new Date(NaN).setSeconds({valueOf:function(){global = 17}}); +assertEq(global, 17); + +date = new Date(NaN).setUTCSeconds({valueOf:function(){global = 18}}); +assertEq(global, 18); + +date = new Date(NaN).setMinutes({valueOf:function(){global = 19}}); +assertEq(global, 19); + +date = new Date(NaN).setUTCMinutes({valueOf:function(){global = 20}}); +assertEq(global, 20); + +date = new Date(NaN).setHours({valueOf:function(){global = 21}}); +assertEq(global, 21); + +date = new Date(NaN).setUTCHours({valueOf:function(){global = 22}}); +assertEq(global, 22); + +date = new Date(NaN).setDate({valueOf:function(){global = 23}}); +assertEq(global, 23); + +date = new Date(NaN).setUTCDate({valueOf:function(){global = 24}}); +assertEq(global, 24); + +date = new Date(NaN).setMonth({valueOf:function(){global = 25}}); +assertEq(global, 25); + +date = new Date(NaN).setUTCMonth({valueOf:function(){global = 26}}); +assertEq(global, 26); + +date = new Date(NaN).setFullYear({valueOf:function(){global = 27}}); +assertEq(global, 27); + +date = new Date(NaN).setUTCFullYear({valueOf:function(){global = 28}}); +assertEq(global, 28); + + +/* Test the combination of the above two. */ +date = new Date(NaN).setSeconds(NaN, {valueOf:function(){global = 31}}); +assertEq(global, 31); + +date = new Date(NaN).setUTCSeconds(NaN, {valueOf:function(){global = 32}}); +assertEq(global, 32); + +date = new Date(NaN).setMinutes(NaN, {valueOf:function(){global = 33}}); +assertEq(global, 33); + +date = new Date(NaN).setUTCMinutes(NaN, {valueOf:function(){global = 34}}); +assertEq(global, 34); + +date = new Date(NaN).setHours(NaN, {valueOf:function(){global = 35}}); +assertEq(global, 35); + +date = new Date(NaN).setUTCHours(NaN, {valueOf:function(){global = 36}}); +assertEq(global, 36); + +date = new Date(NaN).setMonth(NaN, {valueOf:function(){global = 39}}); +assertEq(global, 39); + +date = new Date(NaN).setUTCMonth(NaN, {valueOf:function(){global = 40}}); +assertEq(global, 40); + +date = new Date(NaN).setFullYear(NaN, {valueOf:function(){global = 41}}); +assertEq(global, 41); + +date = new Date(NaN).setUTCFullYear(NaN, {valueOf:function(){global = 42}}); +assertEq(global, 42); + + +/*Test two methods evaluation*/ +var secondGlobal = 0; + +date = new Date(NaN).setFullYear({valueOf:function(){global = 43}}, {valueOf:function(){secondGlobal = 1}}); +assertEq(global, 43); +assertEq(secondGlobal, 1); + +date = new Date(0).setFullYear(NaN, {valueOf:function(){global = 44}}, {valueOf:function(){secondGlobal = 2}}); +assertEq(global, 44); +assertEq(secondGlobal, 2); + + +/* Test year methods*/ +date = new Date(0).setYear({valueOf:function(){global = 45}}); +assertEq(global, 45); + +date = new Date(NaN).setYear({valueOf:function(){global = 46}}); +assertEq(global, 46); + + +/******************************************************************************/ + +if (typeof reportCompare === "function") + reportCompare(true, true); + +print("Tests complete"); diff --git a/js/src/tests/non262/Date/shell.js b/js/src/tests/non262/Date/shell.js new file mode 100644 index 0000000000..9246c1eaaa --- /dev/null +++ b/js/src/tests/non262/Date/shell.js @@ -0,0 +1,311 @@ +/** + * Date functions used by tests in Date suite + */ +(function(global) { + const msPerDay = 1000 * 60 * 60 * 24; + const msPerHour = 1000 * 60 * 60; + global.msPerHour = msPerHour; + + // Offset of tester's time zone from UTC. + const TZ_DIFF = GetRawTimezoneOffset(); + global.TZ_ADJUST = TZ_DIFF * msPerHour; + + const UTC_01_JAN_1900 = -2208988800000; + const UTC_01_JAN_2000 = 946684800000; + const UTC_29_FEB_2000 = UTC_01_JAN_2000 + 31 * msPerDay + 28 * msPerDay; + const UTC_01_JAN_2005 = UTC_01_JAN_2000 + TimeInYear(2000) + TimeInYear(2001) + + TimeInYear(2002) + TimeInYear(2003) + TimeInYear(2004); + global.UTC_01_JAN_1900 = UTC_01_JAN_1900; + global.UTC_01_JAN_2000 = UTC_01_JAN_2000; + global.UTC_29_FEB_2000 = UTC_29_FEB_2000; + global.UTC_01_JAN_2005 = UTC_01_JAN_2005; + + /* + * Originally, the test suite used a hard-coded value TZ_DIFF = -8. + * But that was only valid for testers in the Pacific Standard Time Zone! + * We calculate the proper number dynamically for any tester. We just + * have to be careful not to use a date subject to Daylight Savings Time... + */ + function GetRawTimezoneOffset() { + let t1 = new Date(2000, 1, 1).getTimezoneOffset(); + let t2 = new Date(2000, 1 + 6, 1).getTimezoneOffset(); + + // 1) Time zone without daylight saving time. + // 2) Northern hemisphere with daylight saving time. + if ((t1 - t2) >= 0) + return -t1 / 60; + + // 3) Southern hemisphere with daylight saving time. + return -t2 / 60; + } + + function DaysInYear(y) { + return y % 4 === 0 && (y % 100 !== 0 || y % 400 === 0) ? 366 : 365; + } + + function TimeInYear(y) { + return DaysInYear(y) * msPerDay; + } + + function getDefaultTimeZone() { + var tz = getTimeZone(); + switch (tz) { + case "EST": + case "EDT": + return "EST5EDT"; + + case "CST": + case "CDT": + return "CST6CDT"; + + case "MST": + case "MDT": + return "MST7MDT"; + + case "PST": + case "PDT": + return "PST8PDT"; + + default: + // Other time zones abbrevations are not supported. + return tz; + } + } + + function getDefaultLocale() { + // If the default locale looks like a BCP-47 language tag, return it. + var locale = global.getDefaultLocale(); + if (locale.match(/^[a-z][a-z0-9\-]+$/i)) + return locale; + + // Otherwise use undefined to reset to the default locale. + return undefined; + } + + let defaultTimeZone = null; + let defaultLocale = null; + + // Run the given test in the requested time zone. + function inTimeZone(tzname, fn) { + if (defaultTimeZone === null) + defaultTimeZone = getDefaultTimeZone(); + + setTimeZone(tzname); + try { + fn(); + } finally { + setTimeZone(defaultTimeZone); + } + } + global.inTimeZone = inTimeZone; + + // Run the given test with the requested locale. + function withLocale(locale, fn) { + if (defaultLocale === null) + defaultLocale = getDefaultLocale(); + + setDefaultLocale(locale); + try { + fn(); + } finally { + setDefaultLocale(defaultLocale); + } + } + global.withLocale = withLocale; + + const Month = { + January: 0, + February: 1, + March: 2, + April: 3, + May: 4, + June: 5, + July: 6, + August: 7, + September: 8, + October: 9, + November: 10, + December: 11, + }; + global.Month = Month; + + const weekdays = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"].join("|"); + const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"].join("|"); + const datePart = String.raw `(?:${weekdays}) (?:${months}) \d{2}`; + const timePart = String.raw `\d{4,6} \d{2}:\d{2}:\d{2} GMT[+-]\d{4}`; + const dateTimeRE = new RegExp(String.raw `^(${datePart} ${timePart})(?: \((.+)\))?$`); + + function assertDateTime(date, expected, ...alternativeTimeZones) { + let actual = date.toString(); + assertEq(dateTimeRE.test(expected), true, `${expected}`); + assertEq(dateTimeRE.test(actual), true, `${actual}`); + + let [, expectedDateTime, expectedTimeZone] = dateTimeRE.exec(expected); + let [, actualDateTime, actualTimeZone] = dateTimeRE.exec(actual); + + assertEq(actualDateTime, expectedDateTime); + + // The time zone identifier is optional, so only compare its value if + // it's present in |actual| and |expected|. + if (expectedTimeZone !== undefined && actualTimeZone !== undefined) { + // Test against the alternative time zone identifiers if necessary. + if (actualTimeZone !== expectedTimeZone) { + for (let alternativeTimeZone of alternativeTimeZones) { + if (actualTimeZone === alternativeTimeZone) { + expectedTimeZone = alternativeTimeZone; + break; + } + } + } + assertEq(actualTimeZone, expectedTimeZone); + } + } + global.assertDateTime = assertDateTime; +})(this); + + +function runDSTOffsetCachingTestsFraction(part, parts) +{ + var BUGNUMBER = 563938; + var summary = 'Cache DST offsets to improve SunSpider score'; + + print(BUGNUMBER + ": " + summary); + + var MAX_UNIX_TIMET = 2145859200; // "2037-12-31T08:00:00.000Z" (PST8PDT based!) + var RANGE_EXPANSION_AMOUNT = 30 * 24 * 60 * 60; + + /** + * Computes the time zone offset in minutes at the given timestamp. + */ + function tzOffsetFromUnixTimestamp(timestamp) + { + var d = new Date(NaN); + d.setTime(timestamp); // local slot = NaN, UTC slot = timestamp + return d.getTimezoneOffset(); // get UTC, calculate local => diff in minutes + } + + /** + * Clear the DST offset cache, leaving it initialized to include a timestamp + * completely unlike the provided one (i.e. one very, very far away in time + * from it). Thus an immediately following lookup for the provided timestamp + * will cache-miss and compute a clean value. + */ + function clearDSTOffsetCache(undesiredTimestamp) + { + var opposite = (undesiredTimestamp + MAX_UNIX_TIMET / 2) % MAX_UNIX_TIMET; + + // Generic purge to known, but not necessarily desired, state + tzOffsetFromUnixTimestamp(0); + tzOffsetFromUnixTimestamp(MAX_UNIX_TIMET); + + // Purge to desired state. Cycle 2x in case opposite or undesiredTimestamp + // is close to 0 or MAX_UNIX_TIMET. + tzOffsetFromUnixTimestamp(opposite); + tzOffsetFromUnixTimestamp(undesiredTimestamp); + tzOffsetFromUnixTimestamp(opposite); + tzOffsetFromUnixTimestamp(undesiredTimestamp); + } + + function computeCanonicalTZOffset(timestamp) + { + clearDSTOffsetCache(timestamp); + return tzOffsetFromUnixTimestamp(timestamp); + } + + var TEST_TIMESTAMPS_SECONDS = + [ + // Special-ish timestamps + 0, + RANGE_EXPANSION_AMOUNT, + MAX_UNIX_TIMET, + ]; + + var ONE_DAY = 24 * 60 * 60; + var EIGHTY_THREE_HOURS = 83 * 60 * 60; + var NINETY_EIGHT_HOURS = 98 * 60 * 60; + function nextIncrement(i) + { + return i === EIGHTY_THREE_HOURS ? NINETY_EIGHT_HOURS : EIGHTY_THREE_HOURS; + } + + // Now add a long sequence of non-special timestamps, from a fixed range, that + // overlaps a DST change by "a bit" on each side. 67 days should be enough + // displacement that we can occasionally exercise the implementation's + // thirty-day expansion and the DST-offset-change logic. Use two different + // increments just to be safe and catch something a single increment might not. + var DST_CHANGE_DATE = 1268553600; // March 14, 2010 + for (var t = DST_CHANGE_DATE - 67 * ONE_DAY, + i = nextIncrement(NINETY_EIGHT_HOURS), + end = DST_CHANGE_DATE + 67 * ONE_DAY; + t < end; + i = nextIncrement(i), t += i) + { + TEST_TIMESTAMPS_SECONDS.push(t); + } + + var TEST_TIMESTAMPS = + TEST_TIMESTAMPS_SECONDS.map(function(v) { return v * 1000; }); + + /************** + * BEGIN TEST * + **************/ + + // Compute the correct time zone offsets for all timestamps to be tested. + var CORRECT_TZOFFSETS = TEST_TIMESTAMPS.map(computeCanonicalTZOffset); + + // Intentionally and knowingly invoking every single logic path in the cache + // isn't easy for a human to get right (and know he's gotten it right), so + // let's do it the easy way: exhaustively try all possible four-date sequences + // selecting from our array of possible timestamps. + + var sz = TEST_TIMESTAMPS.length; + var start = Math.floor((part - 1) / parts * sz); + var end = Math.floor(part / parts * sz); + + print("Exhaustively testing timestamps " + + "[" + start + ", " + end + ") of " + sz + "..."); + + try + { + for (var i = start; i < end; i++) + { + print("Testing timestamp " + i + "..."); + + var t1 = TEST_TIMESTAMPS[i]; + for (var j = 0; j < sz; j++) + { + var t2 = TEST_TIMESTAMPS[j]; + for (var k = 0; k < sz; k++) + { + var t3 = TEST_TIMESTAMPS[k]; + for (var w = 0; w < sz; w++) + { + var t4 = TEST_TIMESTAMPS[w]; + + clearDSTOffsetCache(t1); + + var tzo1 = tzOffsetFromUnixTimestamp(t1); + var tzo2 = tzOffsetFromUnixTimestamp(t2); + var tzo3 = tzOffsetFromUnixTimestamp(t3); + var tzo4 = tzOffsetFromUnixTimestamp(t4); + + assertEq(tzo1, CORRECT_TZOFFSETS[i]); + assertEq(tzo2, CORRECT_TZOFFSETS[j]); + assertEq(tzo3, CORRECT_TZOFFSETS[k]); + assertEq(tzo4, CORRECT_TZOFFSETS[w]); + } + } + } + } + } + catch (e) + { + assertEq(true, false, + "Error when testing with timestamps " + + i + ", " + j + ", " + k + ", " + w + + " (" + t1 + ", " + t2 + ", " + t3 + ", " + t4 + ")!"); + } + + reportCompare(true, true); + print("All tests passed!"); +} diff --git a/js/src/tests/non262/Date/time-components-negative-zero.js b/js/src/tests/non262/Date/time-components-negative-zero.js new file mode 100644 index 0000000000..511dcc9fe4 --- /dev/null +++ b/js/src/tests/non262/Date/time-components-negative-zero.js @@ -0,0 +1,18 @@ +// Don't return negative zero for get[Hours,Minutes,Seconds,Milliseconds] for dates before 1970. + +let date = new Date(1955, 0, 1); +assertEq(date.getTime() < 0, true); +assertEq(date.getHours(), +0); +assertEq(date.getMinutes(), +0); +assertEq(date.getSeconds(), +0); +assertEq(date.getMilliseconds(), +0); + +let utc = new Date(Date.UTC(1955, 0, 1)); +assertEq(utc.getTime() < 0, true); +assertEq(utc.getUTCHours(), +0); +assertEq(utc.getUTCMinutes(), +0); +assertEq(utc.getUTCSeconds(), +0); +assertEq(utc.getUTCMilliseconds(), +0); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/non262/Date/time-zone-2038-pst.js b/js/src/tests/non262/Date/time-zone-2038-pst.js new file mode 100644 index 0000000000..2abad4dbfd --- /dev/null +++ b/js/src/tests/non262/Date/time-zone-2038-pst.js @@ -0,0 +1,43 @@ +// |reftest| skip-if(!xulRuntime.shell) + +assertEq(/^(PST|PDT)$/.test(getTimeZone()), true, + "The default time zone is set to PST8PDT for all jstests (when run in the shell)"); + +// U.S. daylight saving rules changed in 2007, excerpt from tzdata's +// northamerica file: +// NAME FROM TO IN ON AT SAVE LETTER/S +// US 1967 2006 Oct lastSun 2:00 0 S +// US 1967 1973 Apr lastSun 2:00 1:00 D +// US 1974 only Jan 6 2:00 1:00 D +// US 1975 only Feb 23 2:00 1:00 D +// US 1976 1986 Apr lastSun 2:00 1:00 D +// US 1987 2006 Apr Sun>=1 2:00 1:00 D +// US 2007 max Mar Sun>=8 2:00 1:00 D +// US 2007 max Nov Sun>=1 2:00 0 S + + +// When 2040 is mapped to 1984, the old U.S. rules are applied, i.e. DST isn't +// yet observed on March 31. If mapped to 2012, the new U.S. rules are applied +// and DST is already observed, which is the expected behaviour. +// A similar effect is visible in November. +// NOTE: This test expects that 2012 and 2040 use the same DST rules. If this +// ever changes, the test needs to be updated accordingly. +{ + let dt1 = new Date(2040, Month.March, 31); + assertDateTime(dt1, "Sat Mar 31 2040 00:00:00 GMT-0700 (PDT)", "Pacific Daylight Time"); + + let dt2 = new Date(2040, Month.November, 1); + assertDateTime(dt2, "Thu Nov 01 2040 00:00:00 GMT-0700 (PDT)", "Pacific Daylight Time"); +} + +// 2038 is mapped to 2027 instead of 1971. +{ + let dt1 = new Date(2038, Month.March, 31); + assertDateTime(dt1, "Wed Mar 31 2038 00:00:00 GMT-0700 (PDT)", "Pacific Daylight Time"); + + let dt2 = new Date(2038, Month.November, 1); + assertDateTime(dt2, "Mon Nov 01 2038 00:00:00 GMT-0700 (PDT)", "Pacific Daylight Time"); +} + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/non262/Date/time-zone-etc_localetime.js b/js/src/tests/non262/Date/time-zone-etc_localetime.js new file mode 100644 index 0000000000..eaf8f7d940 --- /dev/null +++ b/js/src/tests/non262/Date/time-zone-etc_localetime.js @@ -0,0 +1,29 @@ +// |reftest| skip-if(xulRuntime.OS=="WINNT"||!xulRuntime.shell) + +assertEq(/^(PST|PDT)$/.test(getTimeZone()), true, + "The default time zone is set to PST8PDT for all jstests (when run in the shell)"); + +function timeZoneName() { + var dtf = new Intl.DateTimeFormat("en-US", {timeZoneName: "long"}); + return dtf.formatToParts().filter(x => x.type === "timeZoneName")[0].value; +} + +// Calling setTimeZone() with an undefined argument clears the TZ environment +// variable and by that reveal the actual system time zone. +setTimeZone(undefined); +var systemTimeZone = getTimeZone(); +var systemTimeZoneName = timeZoneName(); + +// Set to an unlikely system time zone, so that the next call to setTimeZone() +// will lead to a time zone change. +setTimeZone("Antarctica/Troll"); + +// Now call with the file path ":/etc/localtime" which is special-cased in +// DateTimeInfo to read the system time zone. +setTimeZone(":/etc/localtime"); + +assertEq(getTimeZone(), systemTimeZone); +assertEq(timeZoneName(), systemTimeZoneName); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/non262/Date/time-zone-path.js b/js/src/tests/non262/Date/time-zone-path.js new file mode 100644 index 0000000000..3422022e2b --- /dev/null +++ b/js/src/tests/non262/Date/time-zone-path.js @@ -0,0 +1,30 @@ +// |reftest| skip-if(xulRuntime.OS=="WINNT"||!xulRuntime.shell) + +assertEq(/^(PST|PDT)$/.test(getTimeZone()), true, + "The default time zone is set to PST8PDT for all jstests (when run in the shell)"); + +function timeZoneName() { + var dtf = new Intl.DateTimeFormat("en-US", {timeZoneName: "long"}); + return dtf.formatToParts(Date.UTC(2017, 2, 31, 12, 0, 0)).filter(x => x.type === "timeZoneName")[0].value; +} + +setTimeZone("Europe/Paris"); +assertEq(timeZoneName(), "Central European Summer Time"); + +setTimeZone(":Europe/Helsinki"); +assertEq(timeZoneName(), "Eastern European Summer Time"); + +setTimeZone("::Europe/London"); // two colons, invalid +assertEq(timeZoneName(), "Coordinated Universal Time"); + +setTimeZone("/this-part-is-ignored/zoneinfo/America/Chicago"); +assertEq(timeZoneName(), "Central Daylight Time"); + +setTimeZone(":/this-part-is-ignored/zoneinfo/America/Phoenix"); +assertEq(timeZoneName(), "Mountain Standard Time"); + +setTimeZone("::/this-part-is-ignored/zoneinfo/America/Los_Angeles"); // two colons, invalid +assertEq(timeZoneName(), "Coordinated Universal Time"); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/non262/Date/time-zone-pst.js b/js/src/tests/non262/Date/time-zone-pst.js new file mode 100644 index 0000000000..341d3c8236 --- /dev/null +++ b/js/src/tests/non262/Date/time-zone-pst.js @@ -0,0 +1,120 @@ +// |reftest| skip-if(!xulRuntime.shell) + +assertEq(/^(PST|PDT)$/.test(getTimeZone()), true, + "The default time zone is set to PST8PDT for all jstests (when run in the shell)"); + +const msPerMinute = 60 * 1000; + +function shortTimeZone(str) { + return str.replace("(Pacific Standard Time)", "(PST)") + .replace("(Pacific Daylight Time)", "(PDT)"); +} + +function assertEqDate(dt, date, time) { + assertEq(shortTimeZone(dt.toString()), `${date} ${time}`); + assertEq(dt.toDateString(), date); + assertEq(shortTimeZone(dt.toTimeString()), time); +} + +// PDT -> PST, using milliseconds from epoch. +{ + let midnight = new Date(2016, Month.November, 6, 0, 0, 0, 0); + let midnightUTC = Date.UTC(2016, Month.November, 6, 0, 0, 0, 0); + + // Ensure midnight time is correct. + assertEq(midnightUTC - midnight.getTime(), -7 * msPerHour); + + let tests = [ + { offset: 0 * 60, date: "Sun Nov 06 2016", time: "00:00:00 GMT-0700 (PDT)" }, + { offset: 0 * 60 + 30, date: "Sun Nov 06 2016", time: "00:30:00 GMT-0700 (PDT)" }, + { offset: 1 * 60, date: "Sun Nov 06 2016", time: "01:00:00 GMT-0700 (PDT)" }, + { offset: 1 * 60 + 30, date: "Sun Nov 06 2016", time: "01:30:00 GMT-0700 (PDT)" }, + { offset: 2 * 60, date: "Sun Nov 06 2016", time: "01:00:00 GMT-0800 (PST)" }, + { offset: 2 * 60 + 30, date: "Sun Nov 06 2016", time: "01:30:00 GMT-0800 (PST)" }, + { offset: 3 * 60, date: "Sun Nov 06 2016", time: "02:00:00 GMT-0800 (PST)" }, + { offset: 3 * 60 + 30, date: "Sun Nov 06 2016", time: "02:30:00 GMT-0800 (PST)" }, + { offset: 4 * 60, date: "Sun Nov 06 2016", time: "03:00:00 GMT-0800 (PST)" }, + { offset: 4 * 60 + 30, date: "Sun Nov 06 2016", time: "03:30:00 GMT-0800 (PST)" }, + ]; + + for (let {offset, date, time} of tests) { + let dt = new Date(midnight.getTime() + offset * msPerMinute); + assertEqDate(dt, date, time); + } +} + + +// PDT -> PST, using local date-time. +{ + let tests = [ + { offset: 0 * 60, date: "Sun Nov 06 2016", time: "00:00:00 GMT-0700 (PDT)" }, + { offset: 0 * 60 + 30, date: "Sun Nov 06 2016", time: "00:30:00 GMT-0700 (PDT)" }, + { offset: 1 * 60, date: "Sun Nov 06 2016", time: "01:00:00 GMT-0700 (PDT)" }, + { offset: 1 * 60 + 30, date: "Sun Nov 06 2016", time: "01:30:00 GMT-0700 (PDT)" }, + { offset: 2 * 60, date: "Sun Nov 06 2016", time: "02:00:00 GMT-0800 (PST)" }, + { offset: 2 * 60 + 30, date: "Sun Nov 06 2016", time: "02:30:00 GMT-0800 (PST)" }, + { offset: 3 * 60, date: "Sun Nov 06 2016", time: "03:00:00 GMT-0800 (PST)" }, + { offset: 3 * 60 + 30, date: "Sun Nov 06 2016", time: "03:30:00 GMT-0800 (PST)" }, + { offset: 4 * 60, date: "Sun Nov 06 2016", time: "04:00:00 GMT-0800 (PST)" }, + { offset: 4 * 60 + 30, date: "Sun Nov 06 2016", time: "04:30:00 GMT-0800 (PST)" }, + ]; + + for (let {offset, date, time} of tests) { + let dt = new Date(2016, Month.November, 6, (offset / 60)|0, (offset % 60), 0, 0); + assertEqDate(dt, date, time); + } +} + + +// PST -> PDT, using milliseconds from epoch. +{ + let midnight = new Date(2016, Month.March, 13, 0, 0, 0, 0); + let midnightUTC = Date.UTC(2016, Month.March, 13, 0, 0, 0, 0); + + // Ensure midnight time is correct. + assertEq(midnightUTC - midnight.getTime(), -8 * msPerHour); + + let tests = [ + { offset: 0 * 60, date: "Sun Mar 13 2016", time: "00:00:00 GMT-0800 (PST)" }, + { offset: 0 * 60 + 30, date: "Sun Mar 13 2016", time: "00:30:00 GMT-0800 (PST)" }, + { offset: 1 * 60, date: "Sun Mar 13 2016", time: "01:00:00 GMT-0800 (PST)" }, + { offset: 1 * 60 + 30, date: "Sun Mar 13 2016", time: "01:30:00 GMT-0800 (PST)" }, + { offset: 2 * 60, date: "Sun Mar 13 2016", time: "03:00:00 GMT-0700 (PDT)" }, + { offset: 2 * 60 + 30, date: "Sun Mar 13 2016", time: "03:30:00 GMT-0700 (PDT)" }, + { offset: 3 * 60, date: "Sun Mar 13 2016", time: "04:00:00 GMT-0700 (PDT)" }, + { offset: 3 * 60 + 30, date: "Sun Mar 13 2016", time: "04:30:00 GMT-0700 (PDT)" }, + { offset: 4 * 60, date: "Sun Mar 13 2016", time: "05:00:00 GMT-0700 (PDT)" }, + { offset: 4 * 60 + 30, date: "Sun Mar 13 2016", time: "05:30:00 GMT-0700 (PDT)" }, + ]; + + for (let {offset, date, time} of tests) { + let dt = new Date(midnight.getTime() + offset * msPerMinute); + assertEqDate(dt, date, time); + } +} + + +// PST -> PDT, using local date-time. +{ + let tests = [ + { offset: 0 * 60, date: "Sun Mar 13 2016", time: "00:00:00 GMT-0800 (PST)" }, + { offset: 0 * 60 + 30, date: "Sun Mar 13 2016", time: "00:30:00 GMT-0800 (PST)" }, + { offset: 1 * 60, date: "Sun Mar 13 2016", time: "01:00:00 GMT-0800 (PST)" }, + { offset: 1 * 60 + 30, date: "Sun Mar 13 2016", time: "01:30:00 GMT-0800 (PST)" }, + { offset: 2 * 60, date: "Sun Mar 13 2016", time: "03:00:00 GMT-0700 (PDT)" }, + { offset: 2 * 60 + 30, date: "Sun Mar 13 2016", time: "03:30:00 GMT-0700 (PDT)" }, + { offset: 3 * 60, date: "Sun Mar 13 2016", time: "03:00:00 GMT-0700 (PDT)" }, + { offset: 3 * 60 + 30, date: "Sun Mar 13 2016", time: "03:30:00 GMT-0700 (PDT)" }, + { offset: 4 * 60, date: "Sun Mar 13 2016", time: "04:00:00 GMT-0700 (PDT)" }, + { offset: 4 * 60 + 30, date: "Sun Mar 13 2016", time: "04:30:00 GMT-0700 (PDT)" }, + ]; + + for (let {offset, date, time} of tests) { + let dt = new Date(2016, Month.March, 13, (offset / 60)|0, (offset % 60), 0, 0); + assertEqDate(dt, date, time); + } +} + + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/non262/Date/time-zones-historic.js b/js/src/tests/non262/Date/time-zones-historic.js new file mode 100644 index 0000000000..3117870687 --- /dev/null +++ b/js/src/tests/non262/Date/time-zones-historic.js @@ -0,0 +1,538 @@ +// |reftest| skip-if(xulRuntime.OS=="WINNT"||!this.hasOwnProperty("Intl")) -- Windows doesn't accept IANA names for the TZ env variable; Requires ICU time zone support + +// bug 487897 +inTimeZone("Europe/London", () => { + let dt1 = new Date(1970, Month.January, 1, 0, 0, 0, 0); + assertDateTime(dt1, "Thu Jan 01 1970 00:00:00 GMT+0100 (Greenwich Mean Time)"); + assertEq(dt1.getHours(), 0); + + let dt2 = new Date(1915, Month.January, 1); + assertDateTime(dt2, "Fri Jan 01 1915 00:00:00 GMT+0000 (Greenwich Mean Time)"); + + let dt3 = new Date(1970, Month.January, 1); + assertDateTime(dt3, "Thu Jan 01 1970 00:00:00 GMT+0100 (Greenwich Mean Time)"); +}); + +// bug 637244 +inTimeZone("Asia/Novosibirsk", () => { + let dt1 = new Date("1942-03-01T00:00:00"); + assertDateTime(dt1, "Sun Mar 01 1942 00:00:00 GMT+0700 (Novosibirsk Standard Time)"); + dt1.setMonth(Month.April); + assertDateTime(dt1, "Wed Apr 01 1942 00:00:00 GMT+0700 (Novosibirsk Standard Time)"); + + let dt2 = new Date(2010, Month.October, 31); + assertDateTime(dt2, "Sun Oct 31 2010 00:00:00 GMT+0700 (Novosibirsk Summer Time)"); + dt2.setMonth(Month.November); + assertDateTime(dt2, "Wed Dec 01 2010 00:00:00 GMT+0600 (Novosibirsk Standard Time)"); + + let dt3 = new Date(1942, Month.April, 1); + assertDateTime(dt3, "Wed Apr 01 1942 00:00:00 GMT+0700 (Novosibirsk Standard Time)"); + + function getNumberOfDaysInMonth(year, month) { + switch (month) { + case Month.January: + case Month.March: + case Month.May: + case Month.July: + case Month.August: + case Month.October: + case Month.December: + return 31; + case Month.April: + case Month.June: + case Month.September: + case Month.November: + return 30; + case Month.February: + if (year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0)) + return 29; + return 28; + } + throw new Error(`Illegal month value: ${month}`); + } + + for (let year = 1900; year <= 2142; ++year) { + for (let month = Month.January; month <= Month.December; ++month) { + const numDays = getNumberOfDaysInMonth(year, month); + for (let day = 1; day <= numDays; ++day) { + let date = new Date(year, month, day); + assertEq(date.getMonth(), month); + } + } + } + + let dt4 = new Date(1984, Month.April, 1); + assertDateTime(dt4, "Sun Apr 01 1984 01:00:00 GMT+0800 (Novosibirsk Summer Time)"); + + let dt5 = new Date(1984, Month.March, 1); + assertDateTime(dt5, "Thu Mar 01 1984 00:00:00 GMT+0700 (Novosibirsk Standard Time)"); + + let dt6 = new Date(1984, Month.April, 1); + assertEq(dt6.toUTCString(), "Sat, 31 Mar 1984 17:00:00 GMT"); + assertEq(dt6.getTime(), 449600400000); +}); +inTimeZone("Europe/Tallinn", () => { + let dt = new Date(2040, Month.March, 31, 20); + + for (let {datetime, date, hours} of [ + {datetime: "Sat Mar 31 2040 20:00:00", date: 31, hours: 20}, + {datetime: "Sat Mar 31 2040 22:00:00", date: 31, hours: 22}, + {datetime: "Sun Apr 01 2040 00:00:00", date: 1, hours: 0}, + {datetime: "Sun Apr 01 2040 02:00:00", date: 1, hours: 2}, + {datetime: "Sun Apr 01 2040 04:00:00", date: 1, hours: 4}, + {datetime: "Sun Apr 01 2040 06:00:00", date: 1, hours: 6}, + {datetime: "Sun Apr 01 2040 08:00:00", date: 1, hours: 8}, + ]) { + assertDateTime(dt, `${datetime} GMT+0300 (Eastern European Summer Time)`); + assertEq(dt.getDate(), date); + assertEq(dt.getHours(), hours); + assertEq(dt.getTimezoneOffset(), -180); + + dt.setHours(dt.getHours() + 2); + } +}); +inTimeZone("Europe/Riga", () => { + let dt1 = new Date(2016, Month.March, 27, 2, 59); + assertDateTime(dt1, "Sun Mar 27 2016 02:59:00 GMT+0200 (Eastern European Standard Time)"); + + let dt2 = new Date(2016, Month.March, 27, 3, 0); + assertDateTime(dt2, "Sun Mar 27 2016 04:00:00 GMT+0300 (Eastern European Summer Time)"); +}); + +// bug 704486 +inTimeZone("Europe/Zagreb", () => { + let dt = new Date(Date.UTC(1942, Month.June, 11, 22, 0, 0, 0)); + assertDateTime(dt, "Fri Jun 12 1942 00:00:00 GMT+0200 (Central European Summer Time)"); + assertEq(dt.getFullYear(), 1942); + assertEq(dt.getMonth(), Month.June); + assertEq(dt.getDate(), 12); + assertEq(dt.getHours(), 0); + assertEq(dt.getMinutes(), 0); + assertEq(dt.getSeconds(), 0); + assertEq(dt.getMilliseconds(), 0); + assertEq(dt.getTimezoneOffset(), -120); +}); + +// bug 935909 +inTimeZone("Europe/London", () => { + let dt1 = new Date(1954, Month.January, 1); + assertDateTime(dt1, "Fri Jan 01 1954 00:00:00 GMT+0000 (Greenwich Mean Time)"); + + let dt2 = new Date(1965, Month.January, 1); + assertDateTime(dt2, "Fri Jan 01 1965 00:00:00 GMT+0000 (Greenwich Mean Time)"); + + let dt3 = new Date(1970, Month.January, 1); + assertDateTime(dt3, "Thu Jan 01 1970 00:00:00 GMT+0100 (Greenwich Mean Time)"); + + let dt4 = new Date(-504921600000); + assertDateTime(dt4, "Fri Jan 01 1954 00:00:00 GMT+0000 (Greenwich Mean Time)"); + + let dt5 = new Date(1974, Month.January, 1); + assertDateTime(dt5, "Tue Jan 01 1974 00:00:00 GMT+0000 (Greenwich Mean Time)"); +}); +inTimeZone("Europe/Dublin", () => { + let dt = new Date(0, Month.January, 1, 0, 0, 0, 0); + dt.setFullYear(1970); + assertEq(dt.getFullYear(), 1970); +}); + +// bug 937261 +inTimeZone("Europe/Lisbon", () => { + let dt = new Date(0, Month.January, 1, 0, 0, 0, 0); + assertDateTime(dt, "Mon Jan 01 1900 00:00:00 GMT-0036 (Western European Standard Time)"); + + dt.setFullYear(2015); + assertDateTime(dt, "Thu Jan 01 2015 00:00:00 GMT+0000 (Western European Standard Time)"); + + dt.setMonth(Month.November); + assertDateTime(dt, "Sun Nov 01 2015 00:00:00 GMT+0000 (Western European Standard Time)"); +}); +inTimeZone("Europe/London", () => { + let dt = new Date(0, Month.January, 1, 0, 0, 0, 0); + assertDateTime(dt, "Mon Jan 01 1900 00:00:00 GMT+0000 (Greenwich Mean Time)"); + + dt.setFullYear(2015); + assertDateTime(dt, "Thu Jan 01 2015 00:00:00 GMT+0000 (Greenwich Mean Time)"); + + dt.setMonth(Month.November); + assertDateTime(dt, "Sun Nov 01 2015 00:00:00 GMT+0000 (Greenwich Mean Time)"); +}); + +// bug 1079720 +inTimeZone("Europe/Moscow", () => { + let dt1 = new Date(2014, Month.January, 1); + assertDateTime(dt1, "Wed Jan 01 2014 00:00:00 GMT+0400 (Moscow Standard Time)"); + assertEq(dt1.toISOString(), "2013-12-31T20:00:00.000Z"); + assertEq(dt1.getHours(), 0); + + let dt2 = new Date(2013, Month.January, 1); + assertDateTime(dt2, "Tue Jan 01 2013 00:00:00 GMT+0400 (Moscow Standard Time)"); + + let dt3 = new Date(new Date(2014, Month.December, 1).setMonth(Month.January)); + assertDateTime(dt3, "Wed Jan 01 2014 00:00:00 GMT+0400 (Moscow Standard Time)"); + assertEq(dt3.getFullYear(), 2014); + + let dt4 = new Date(2040, Month.April, 1); + assertDateTime(dt4, "Sun Apr 01 2040 00:00:00 GMT+0300 (Moscow Standard Time)"); + + let dt5 = new Date(2043, Month.April, 1); + assertDateTime(dt5, "Wed Apr 01 2043 00:00:00 GMT+0300 (Moscow Standard Time)"); + + let dt6 = new Date(2054, Month.April, 1); + assertDateTime(dt6, "Wed Apr 01 2054 00:00:00 GMT+0300 (Moscow Standard Time)"); + + let dt7 = new Date(2065, Month.April, 1); + assertDateTime(dt7, "Wed Apr 01 2065 00:00:00 GMT+0300 (Moscow Standard Time)"); + + let dt8 = new Date(2068, Month.April, 1); + assertDateTime(dt8, "Sun Apr 01 2068 00:00:00 GMT+0300 (Moscow Standard Time)"); + + let dt9 = new Date(2071, Month.April, 1); + assertDateTime(dt9, "Wed Apr 01 2071 00:00:00 GMT+0300 (Moscow Standard Time)"); + + let dt10 = new Date(2082, Month.April, 1); + assertDateTime(dt10, "Wed Apr 01 2082 00:00:00 GMT+0300 (Moscow Standard Time)"); + + let dt11 = new Date(2093, Month.April, 1); + assertDateTime(dt11, "Wed Apr 01 2093 00:00:00 GMT+0300 (Moscow Standard Time)"); + + let dt12 = new Date(2096, Month.April, 1); + assertDateTime(dt12, "Sun Apr 01 2096 00:00:00 GMT+0300 (Moscow Standard Time)"); + + let dt13 = new Date(2099, Month.April, 1); + assertDateTime(dt13, "Wed Apr 01 2099 00:00:00 GMT+0300 (Moscow Standard Time)"); +}); + +// bug 1107837 +inTimeZone("Europe/Moscow", () => { + let dt1 = new Date(2015, Month.January, 4); + assertDateTime(dt1, "Sun Jan 04 2015 00:00:00 GMT+0300 (Moscow Standard Time)"); + + let dt2 = new Date(2015, Month.January, 5); + assertDateTime(dt2, "Mon Jan 05 2015 00:00:00 GMT+0300 (Moscow Standard Time)"); + + let dt3 = new Date(2015, Month.January, 6); + assertDateTime(dt3, "Tue Jan 06 2015 00:00:00 GMT+0300 (Moscow Standard Time)"); + + let dt4 = new Date(2015, Month.January, 7); + assertDateTime(dt4, "Wed Jan 07 2015 00:00:00 GMT+0300 (Moscow Standard Time)"); + + let dt5 = new Date(2015, Month.January, 8); + assertDateTime(dt5, "Thu Jan 08 2015 00:00:00 GMT+0300 (Moscow Standard Time)"); + + let dt6 = new Date(2015, Month.January, 9); + assertDateTime(dt6, "Fri Jan 09 2015 00:00:00 GMT+0300 (Moscow Standard Time)"); +}); + +// bug 1122571 +inTimeZone("Europe/Berlin", () => { + const locale = "en-001"; + const opts = {timeZoneName: "long", hour12: false}; + + let dt1 = new Date(1950, Month.March, 28); + assertDateTime(dt1, "Tue Mar 28 1950 00:00:00 GMT+0100 (Central European Standard Time)"); + assertEq(dt1.toLocaleString(locale, opts), "28/03/1950, 00:00:00 GMT+01:00"); + + let dt2 = new Date(1950, Month.July, 1); + assertDateTime(dt2, "Sat Jul 01 1950 00:00:00 GMT+0100 (Central European Standard Time)"); + assertEq(dt2.toLocaleString(locale, opts), "01/07/1950, 00:00:00 GMT+01:00"); + + let dt3 = new Date(1960, Month.March, 27); + assertDateTime(dt3, "Sun Mar 27 1960 00:00:00 GMT+0100 (Central European Standard Time)"); + assertEq(dt3.toLocaleString(locale, opts), "27/03/1960, 00:00:00 GMT+01:00"); + + let dt4 = new Date(1960, Month.March, 28); + assertDateTime(dt4, "Mon Mar 28 1960 00:00:00 GMT+0100 (Central European Standard Time)"); + assertEq(dt4.toLocaleString(locale, opts), "28/03/1960, 00:00:00 GMT+01:00"); + + let dt5 = new Date(1960, Month.March, 29); + assertDateTime(dt5, "Tue Mar 29 1960 00:00:00 GMT+0100 (Central European Standard Time)"); + assertEq(dt5.toLocaleString(locale, opts), "29/03/1960, 00:00:00 GMT+01:00"); + + let dt6 = new Date(1960, Month.July, 1); + assertDateTime(dt6, "Fri Jul 01 1960 00:00:00 GMT+0100 (Central European Standard Time)"); + assertEq(dt6.toLocaleString(locale, opts), "01/07/1960, 00:00:00 GMT+01:00"); + + let dt7 = new Date(1961, Month.July, 1); + assertDateTime(dt7, "Sat Jul 01 1961 00:00:00 GMT+0100 (Central European Standard Time)"); + assertEq(dt7.toLocaleString(locale, opts), "01/07/1961, 00:00:00 GMT+01:00"); + + let dt8 = new Date(1970, Month.March, 1); + assertDateTime(dt8, "Sun Mar 01 1970 00:00:00 GMT+0100 (Central European Standard Time)"); + assertEq(dt8.toLocaleString(locale, opts), "01/03/1970, 00:00:00 Central European Standard Time"); + + let dt9 = new Date(1970, Month.March, 27); + assertDateTime(dt9, "Fri Mar 27 1970 00:00:00 GMT+0100 (Central European Standard Time)"); + assertEq(dt9.toLocaleString(locale, opts), "27/03/1970, 00:00:00 Central European Standard Time"); + + let dt10 = new Date(1970, Month.March, 28); + assertDateTime(dt10, "Sat Mar 28 1970 00:00:00 GMT+0100 (Central European Standard Time)"); + assertEq(dt10.toLocaleString(locale, opts), "28/03/1970, 00:00:00 Central European Standard Time"); + + let dt11 = new Date(1970, Month.July, 1); + assertDateTime(dt11, "Wed Jul 01 1970 00:00:00 GMT+0100 (Central European Standard Time)"); + assertEq(dt11.toLocaleString(locale, opts), "01/07/1970, 00:00:00 Central European Standard Time"); +}); + +// bug 1143398 +inTimeZone("Australia/Adelaide", () => { + let dt = new Date(621000); + assertDateTime(dt, "Thu Jan 01 1970 09:40:21 GMT+0930 (Australian Central Standard Time)"); + assertEq(dt.getUTCFullYear(), 1970); + + dt.setMilliseconds(dt.getMilliseconds()); + dt.setSeconds(dt.getSeconds()); + + assertDateTime(dt, "Thu Jan 01 1970 09:40:21 GMT+0930 (Australian Central Standard Time)"); + assertEq(dt.getUTCFullYear(), 1970); +}); +inTimeZone("America/Denver", () => { + let dt = new Date(1446361200000); + assertDateTime(dt, "Sun Nov 01 2015 01:00:00 GMT-0600 (Mountain Daylight Time)"); + + assertEq(dt.getTime(), 1446361200000); + dt.setMilliseconds(0); + assertEq(dt.getTime(), 1446361200000); +}); + +// bug 1233809 +inTimeZone("America/New_York", () => { + let dt = new Date(1980, Month.March, 10); + assertDateTime(dt, "Mon Mar 10 1980 00:00:00 GMT-0500 (Eastern Standard Time)"); +}); + +// bug 1254041 +inTimeZone("Asia/Ho_Chi_Minh", () => { + let dt1 = new Date(Date.UTC(1969, Month.December, 31, 23, 0)); + assertDateTime(dt1, "Thu Jan 01 1970 07:00:00 GMT+0800 (Indochina Time)"); + assertEq(dt1.getTime(), -3600000); + + dt1.setMinutes(dt1.getMinutes() + 30); + assertDateTime(dt1, "Thu Jan 01 1970 07:30:00 GMT+0800 (Indochina Time)"); + assertEq(dt1.getTime(), -1800000); + + dt1.setMinutes(dt1.getMinutes() + 30); + assertDateTime(dt1, "Thu Jan 01 1970 08:00:00 GMT+0800 (Indochina Time)"); + assertEq(dt1.getTime(), 0); + + dt1.setMinutes(dt1.getMinutes() + 30); + assertDateTime(dt1, "Thu Jan 01 1970 08:30:00 GMT+0800 (Indochina Time)"); + assertEq(dt1.getTime(), 1800000); + + dt1.setMinutes(dt1.getMinutes() + 30); + assertDateTime(dt1, "Thu Jan 01 1970 09:00:00 GMT+0800 (Indochina Time)"); + assertEq(dt1.getTime(), 3600000); + + let dt2 = new Date(-1); + assertEq(dt2.getTime(), -1); + + dt2.setMilliseconds(dt2.getMilliseconds() + 1); + assertEq(dt2.getTime(), 0); + + dt2.setTime(1); + assertEq(dt2.getTime(), 1); + + dt2.setMilliseconds(dt2.getMilliseconds() - 1); + assertEq(dt2.getTime(), 0); + + dt2.setMilliseconds(dt2.getMilliseconds() - 1); + assertEq(dt2.getTime(), -1); + + dt2.setMilliseconds(dt2.getMilliseconds() + 1); + assertEq(dt2.getTime(), 0); + + dt2.setMilliseconds(dt2.getMilliseconds() + 3600000); + assertEq(dt2.getTime(), 3600000); + + dt2.setMilliseconds(dt2.getMilliseconds() + (3600000 * 2 - 1)); + assertEq(dt2.getTime(), 3600000 * 3 - 1); + + dt2.setMilliseconds(dt2.getMilliseconds() + 1); + assertEq(dt2.getTime(), 3600000 * 3); + + dt2.setMilliseconds(dt2.getMilliseconds() + (3600000 * 2)); + assertEq(dt2.getTime(), 3600000 * 5); + + let dt3 = new Date(0); + assertDateTime(dt3, "Thu Jan 01 1970 08:00:00 GMT+0800 (Indochina Time)"); + + let dt4 = new Date(-1); + assertDateTime(dt4, "Thu Jan 01 1970 07:59:59 GMT+0800 (Indochina Time)"); +}); + +// bug 1300197 +inTimeZone("Europe/Dublin", () => { + let dt = new Date(1910, Month.January, 1); + assertDateTime(dt, "Sat Jan 01 1910 00:00:00 GMT-0025 (Greenwich Mean Time)"); +}); + +// bug 1304774 +inTimeZone("Europe/Zurich", () => { + let dt = new Date(1986, Month.April, 4, 0, 0, 0, 0); + assertDateTime(dt, "Fri Apr 04 1986 00:00:00 GMT+0200 (Central European Summer Time)"); + assertEq(dt.getTimezoneOffset(), -120); +}); + +// bug 1330307 +inTimeZone("Europe/Moscow", () => { + let dt = new Date(2012, Month.May, 14, 12, 13, 14); + assertDateTime(dt, "Mon May 14 2012 12:13:14 GMT+0400 (Moscow Standard Time)"); + + let dtf = new Intl.DateTimeFormat("en-US", {hour: "numeric", minute: "numeric"}); + assertEq(dtf.format(dt), "12:13 PM"); +}); +inTimeZone("Asia/Baku", () => { + let dt = new Date(2012, Month.May, 14, 12, 13, 14); + assertDateTime(dt, "Mon May 14 2012 12:13:14 GMT+0500 (Azerbaijan Summer Time)"); + + let dtf = new Intl.DateTimeFormat("en-US", {hour: "numeric", minute: "numeric"}); + assertEq(dtf.format(dt), "12:13 PM"); +}); +inTimeZone("Asia/Tbilisi", () => { + let dt = new Date(2012, Month.May, 14, 12, 13, 14); + assertDateTime(dt, "Mon May 14 2012 12:13:14 GMT+0400 (Georgia Standard Time)"); + + let dtf = new Intl.DateTimeFormat("en-US", {hour: "numeric", minute: "numeric"}); + assertEq(dtf.format(dt), "12:13 PM"); +}); + +// bug 1335818 +inTimeZone("Asia/Jerusalem", () => { + let dt1 = new Date(2013, Month.March, 22, 1, 0, 0, 0); + assertDateTime(dt1, "Fri Mar 22 2013 01:00:00 GMT+0200 (Israel Standard Time)"); + + let dt2 = new Date(2013, Month.March, 22, 2, 0, 0, 0); + assertDateTime(dt2, "Fri Mar 22 2013 02:00:00 GMT+0200 (Israel Standard Time)"); + + let dt3 = new Date(2013, Month.March, 22, 3, 0, 0, 0); + assertDateTime(dt3, "Fri Mar 22 2013 03:00:00 GMT+0200 (Israel Standard Time)"); + + let dt4 = new Date(2013, Month.March, 29, 1, 0, 0, 0); + assertDateTime(dt4, "Fri Mar 29 2013 01:00:00 GMT+0200 (Israel Standard Time)"); + + let dt5 = new Date(2013, Month.March, 29, 2, 0, 0, 0); + assertDateTime(dt5, "Fri Mar 29 2013 03:00:00 GMT+0300 (Israel Daylight Time)"); + + let dt6 = new Date(2013, Month.March, 29, 3, 0, 0, 0); + assertDateTime(dt6, "Fri Mar 29 2013 03:00:00 GMT+0300 (Israel Daylight Time)"); +}); + +// bug 1342853 +inTimeZone("America/Sao_Paulo", () => { + let dt1 = new Date(2017, Month.October, 14, 12, 0, 0); + assertDateTime(dt1, "Sat Oct 14 2017 12:00:00 GMT-0300 (Brasilia Standard Time)"); + assertEq(dt1.getTimezoneOffset(), 180); + + let dt2 = new Date(2017, Month.October, 15, 12, 0, 0); + assertDateTime(dt2, "Sun Oct 15 2017 12:00:00 GMT-0200 (Brasilia Summer Time)"); + assertEq(dt2.getTimezoneOffset(), 120); + + let dt3 = new Date(2018, Month.February, 17, 12, 0, 0); + assertDateTime(dt3, "Sat Feb 17 2018 12:00:00 GMT-0200 (Brasilia Summer Time)"); + assertEq(dt3.getTimezoneOffset(), 120); + + let dt4 = new Date(2018, Month.February, 18, 12, 0, 0); + assertDateTime(dt4, "Sun Feb 18 2018 12:00:00 GMT-0300 (Brasilia Standard Time)"); + assertEq(dt4.getTimezoneOffset(), 180); + + let dt5 = new Date(2018, Month.November, 3, 12, 0, 0); + assertDateTime(dt5, "Sat Nov 03 2018 12:00:00 GMT-0300 (Brasilia Standard Time)"); + assertEq(dt5.getTimezoneOffset(), 180); + + let dt6 = new Date(2018, Month.November, 4, 12, 0, 0); + assertDateTime(dt6, "Sun Nov 04 2018 12:00:00 GMT-0200 (Brasilia Summer Time)"); + assertEq(dt6.getTimezoneOffset(), 120); + + let dt7 = new Date(2019, Month.February, 16, 12, 0, 0); + assertDateTime(dt7, "Sat Feb 16 2019 12:00:00 GMT-0200 (Brasilia Summer Time)"); + assertEq(dt7.getTimezoneOffset(), 120); + + let dt8 = new Date(2019, Month.February, 17, 12, 0, 0); + assertDateTime(dt8, "Sun Feb 17 2019 12:00:00 GMT-0300 (Brasilia Standard Time)"); + assertEq(dt8.getTimezoneOffset(), 180); +}); + +// bug 1365192 +inTimeZone("America/Asuncion", () => { + let dt = new Date(2018, Month.March, 31); + assertDateTime(dt, "Sat Mar 31 2018 00:00:00 GMT-0400 (Paraguay Standard Time)"); + assertEq(dt.getTimezoneOffset(), 240); +}); + +// bug 1385643 +inTimeZone("Europe/Warsaw", () => { + let shortMonths = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]; + let dtf = new Intl.DateTimeFormat("en-US", {month: "short"}); + + for (let year = 1900; year <= 2100; ++year) { + for (let month = Month.January; month <= Month.December; ++month) { + let date = new Date(year, month, 1); + assertEq(dtf.format(date), shortMonths[month]); + } + } +}); + +// bug 1401696 +inTimeZone("Europe/Berlin", () => { + let dt = new Date(1970, Month.January, 1, 0, 0, 0); + assertDateTime(dt, "Thu Jan 01 1970 00:00:00 GMT+0100 (Central European Standard Time)"); +}); + +// bug 1459842 +inTimeZone("Europe/Moscow", () => { + let dt1 = new Date(1004, Month.April, 1, 2, 0, 0); + assertDateTime(dt1, "Sun Apr 01 1004 02:00:00 GMT+0230 (Moscow Standard Time)"); + assertEq(dt1.getHours(), 2); + + let dt2 = new Date(1004, Month.April, 1, 1, 0, 0); + assertDateTime(dt2, "Sun Apr 01 1004 01:00:00 GMT+0230 (Moscow Standard Time)"); + assertEq(dt2.getHours(), 1); + + let dt3 = new Date(1004, Month.April, 1, 0, 0, 0); + assertDateTime(dt3, "Sun Apr 01 1004 00:00:00 GMT+0230 (Moscow Standard Time)"); + assertEq(dt3.getHours(), 0); + + let dt4 = new Date(1004, Month.March, 1, 2, 0, 0); + assertDateTime(dt4, "Thu Mar 01 1004 02:00:00 GMT+0230 (Moscow Standard Time)"); + assertEq(dt4.getHours(), 2); + + let dt5 = new Date(1004, Month.March, 1, 1, 0, 0); + assertDateTime(dt5, "Thu Mar 01 1004 01:00:00 GMT+0230 (Moscow Standard Time)"); + assertEq(dt5.getHours(), 1); + + let dt6 = new Date(1004, Month.March, 1, 0, 0, 0); + assertDateTime(dt6, "Thu Mar 01 1004 00:00:00 GMT+0230 (Moscow Standard Time)"); + assertEq(dt6.getHours(), 0); + +}); + +// bug 1799638 +inTimeZone("Asia/Tokyo", () => { + let dt1 = new Date(1948, Month.May, 1, 23, 59, 59); + assertDateTime(dt1, "Sat May 01 1948 23:59:59 GMT+0900 (Japan Standard Time)"); + assertEq(dt1.getTimezoneOffset(), -540); + + let dt2 = new Date(1948, Month.May, 1, 24, 0, 0); + assertDateTime(dt2, "Sun May 02 1948 01:00:00 GMT+1000 (Japan Daylight Time)"); + assertEq(dt2.getTimezoneOffset(), -600); + + let dt3 = new Date(1948, Month.May, 1, 23, 59, 59, 1); + assertDateTime(dt3, "Sat May 01 1948 23:59:59 GMT+0900 (Japan Standard Time)"); + assertEq(dt3.getTimezoneOffset(), -540); +}); +inTimeZone("America/New_York", () => { + let dt1 = new Date(1966, Month.April, 24, 1, 59, 59); + assertDateTime(dt1, "Sun Apr 24 1966 01:59:59 GMT-0500 (Eastern Standard Time)"); + assertEq(dt1.getTimezoneOffset(), 300); + + let dt2 = new Date(1966, Month.April, 24, 2, 0, 0); + assertDateTime(dt2, "Sun Apr 24 1966 03:00:00 GMT-0400 (Eastern Daylight Time)"); + assertEq(dt2.getTimezoneOffset(), 240); + + let dt3 = new Date(1966, Month.April, 24, 1, 59, 59, 1); + assertDateTime(dt3, "Sun Apr 24 1966 01:59:59 GMT-0500 (Eastern Standard Time)"); + assertEq(dt3.getTimezoneOffset(), 300); +}); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/non262/Date/time-zones-imported.js b/js/src/tests/non262/Date/time-zones-imported.js new file mode 100644 index 0000000000..8a13e34981 --- /dev/null +++ b/js/src/tests/non262/Date/time-zones-imported.js @@ -0,0 +1,1020 @@ +// |reftest| skip-if(xulRuntime.OS=="WINNT"||!this.hasOwnProperty("Intl")) -- Windows doesn't accept IANA names for the TZ env variable; Requires ICU time zone support + +// Imported tests from es6draft and then adapted to use ICU/CLDR time zone display names. + +function assertSame(expected, actual, message = undefined) { + if (message !== undefined) + assertEq(actual, expected, String(message)); + else + assertEq(actual, expected); +} + +function assertTrue(actual, message = undefined) { + assertSame(true, actual, message); +} + +// File: lib/datetime.jsm +const { + DayOfWeek, + Month, + DateTime, + TimeZone, + Format, +} = (function() { + +// 5.2 Algorithm Conventions +function modulo(dividend, divisor) { + assertTrue(typeof dividend === "number"); + assertTrue(typeof divisor === "number"); + assertTrue(divisor !== 0 && Number.isFinite(divisor)); + let remainder = dividend % divisor; + // NB: add +0 to convert -0 to +0 + return (remainder >= 0 ? remainder + 0 : remainder + divisor); +} + +// 7.1.4 ToInteger ( argument ) +function ToInteger(number) { + /* steps 1-2 */ + assertTrue(typeof number === "number"); + /* step 3 */ + if (Number.isNaN(number)) + return +0.0; + /* step 4 */ + if (number == 0.0 || !Number.isFinite(number)) + return number; + /* step 5 */ + return Math.sign(number) * Math.floor(Math.abs(number)); +} + +// 20.3.1.2 Day Number and Time within Day +const msPerDay = 86400000; + +// 20.3.1.2 Day Number and Time within Day +function Day(t) { + assertTrue(typeof t === "number"); + return Math.floor(t / msPerDay); +} + +// 20.3.1.2 Day Number and Time within Day +function TimeWithinDay(t) { + assertTrue(typeof t === "number"); + return modulo(t, msPerDay); +} + +// 20.3.1.3 Year Number +function DaysInYear(y) { + assertTrue(typeof y === "number"); + if (y % 4 !== 0) { + return 365; + } + if (y % 100 !== 0) { + return 366; + } + if (y % 400 !== 0) { + return 365; + } + return 366; +} + +// 20.3.1.3 Year Number +function DayFromYear(y) { + assertTrue(typeof y === "number"); + return 365 * (y - 1970) + Math.floor((y - 1969) / 4) - Math.floor((y - 1901) / 100) + Math.floor((y - 1601) / 400); +} + +// 20.3.1.3 Year Number +function TimeFromYear(y) { + assertTrue(typeof y === "number"); + return msPerDay * DayFromYear(y); +} + +// TODO: fill in rest + +// 20.3.1.10 Hours, Minutes, Second, and Milliseconds +const HoursPerDay = 24; +const MinutesPerHour = 60; +const SecondsPerMinute = 60; +const msPerSecond = 1000; +const msPerMinute = msPerSecond * SecondsPerMinute; +const msPerHour = msPerMinute * MinutesPerHour; + +// 20.3.1.10 Hours, Minutes, Second, and Milliseconds +function HourFromTime(t) { + assertTrue(typeof t === "number"); + return modulo(Math.floor(t / msPerHour), HoursPerDay); +} + +// 20.3.1.10 Hours, Minutes, Second, and Milliseconds +function MinFromTime(t) { + assertTrue(typeof t === "number"); + return modulo(Math.floor(t / msPerMinute), MinutesPerHour); +} + +// 20.3.1.10 Hours, Minutes, Second, and Milliseconds +function SecFromTime(t) { + assertTrue(typeof t === "number"); + return modulo(Math.floor(t / msPerSecond), SecondsPerMinute); +} + +// 20.3.1.10 Hours, Minutes, Second, and Milliseconds +function msFromTime(t) { + assertTrue(typeof t === "number"); + return modulo(t, msPerSecond); +} + +// 20.3.1.11 MakeTime (hour, min, sec, ms) +function MakeTime(hour, min, sec, ms) { + assertTrue(typeof hour === "number"); + assertTrue(typeof min === "number"); + assertTrue(typeof sec === "number"); + assertTrue(typeof ms === "number"); + if (!Number.isFinite(hour) || !Number.isFinite(min) || !Number.isFinite(sec) || !Number.isFinite(ms)) { + return Number.NaN; + } + let h = ToInteger(hour); + let m = ToInteger(min); + let s = ToInteger(sec); + let milli = ToInteger(ms); + let t = h * msPerHour + m * msPerMinute + s * msPerSecond + milli; + return t; +} + +// 20.3.1.12 MakeDay (year, month, date) +function MakeDay(year, month, date) { + assertTrue(typeof year === "number"); + assertTrue(typeof month === "number"); + assertTrue(typeof date === "number"); + if (!Number.isFinite(year) || !Number.isFinite(month) || !Number.isFinite(date)) { + return Number.NaN; + } + let y = ToInteger(year); + let m = ToInteger(month); + let dt = ToInteger(date); + let ym = y + Math.floor(m / 12); + let mn = modulo(m, 12); + + const monthStart = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334]; + let day = Math.floor(TimeFromYear(ym) / msPerDay) + monthStart[mn]; + if (mn >= 2 && DaysInYear(ym) == 366) { + day += 1; + } + + return day + dt - 1; +} + +// 20.3.1.13 MakeDate (day, time) +function MakeDate(day, time) { + assertTrue(typeof day === "number"); + assertTrue(typeof time === "number"); + if (!Number.isFinite(day) || !Number.isFinite(time)) { + return Number.NaN; + } + return day * msPerDay + time; +} + +// 20.3.1.14 TimeClip (time) +function TimeClip(time) { + assertTrue(typeof time === "number"); + if (!Number.isFinite(time)) { + return Number.NaN; + } + if (Math.abs(time) > 8.64e15) { + return Number.NaN; + } + return ToInteger(time) + (+0); +} + +const DayOfWeek = { + Sunday: 0, + Monday: 1, + Tuesday: 2, + Wednesday: 3, + Thursday: 4, + Friday: 5, + Saturday: 6, +}; + +const Month = { + January: 0, + February: 1, + March: 2, + April: 3, + May: 4, + June: 5, + July: 6, + August: 7, + September: 8, + October: 9, + November: 10, + December: 11, +}; + +const DateTime = { + Local: class { + constructor(year, month, day, weekday, hour = 0, minute = 0, second = 0, ms = 0) { + Object.assign(this, {year, month, day, weekday, hour, minute, second, ms}); + } + + toDate() { + return new Date(this.year, this.month, this.day, this.hour, this.minute, this.second, this.ms); + } + }, + UTC: class { + constructor(year, month, day, weekday, hour = 0, minute = 0, second = 0, ms = 0) { + Object.assign(this, {year, month, day, weekday, hour, minute, second, ms}); + } + + toInstant() { + return MakeDate(MakeDay(this.year, this.month, this.day), MakeTime(this.hour, this.minute, this.second, this.ms)); + } + }, +}; + +function TimeZone(hour, minute = 0, second = 0) { + return new class TimeZone { + constructor(hour, minute, second) { + Object.assign(this, {hour, minute, second}); + } + + toOffset() { + let offset = TimeZoneOffset(this.hour, this.minute, this.second); + return offset !== 0 ? -offset : 0; + } + }(hour, minute, second); + + function TimeZoneOffset(hour, minute = 0, second = 0) { + assertTrue(typeof hour === "number"); + assertTrue(typeof minute === "number"); + assertTrue(typeof second === "number"); + assertTrue(minute >= 0); + assertTrue(second >= 0); + if (hour < 0 || Object.is(-0, hour)) { + return hour * MinutesPerHour - minute - (second / 60); + } + return hour * MinutesPerHour + minute + (second / 60); + } +} + +const Format = { + Locale: "en-US", + DateTime: { + localeMatcher: "lookup", + timeZone: void 0, + weekday: "short", + era: void 0, + year: "numeric", + month: "2-digit", + day: "2-digit", + hour: "2-digit", + minute: "2-digit", + second: "2-digit", + timeZoneName: "short", + formatMatcher: "best fit", + hour12: void 0, + }, + Date: { + localeMatcher: "lookup", + timeZone: void 0, + weekday: "short", + era: void 0, + year: "numeric", + month: "2-digit", + day: "2-digit", + hour: void 0, + minute: void 0, + second: void 0, + timeZoneName: void 0, + formatMatcher: "best fit", + hour12: void 0, + }, + Time: { + localeMatcher: "lookup", + timeZone: void 0, + weekday: void 0, + era: void 0, + year: void 0, + month: void 0, + day: void 0, + hour: "2-digit", + minute: "2-digit", + second: "2-digit", + timeZoneName: "short", + formatMatcher: "best fit", + hour12: void 0, + }, +}; + +return { + DayOfWeek, + Month, + DateTime, + TimeZone, + Format, +}; +})(); + + +// File: lib/assert-datetime.js + +function assertDate(local, utc, timeZone, options, formatArgs) { + let d = local.toDate(); + assertDateValue(d, utc.toInstant(), timeZone.toOffset()); + assertLocalDate(d, local); + assertUTCDate(d, utc); + assertDateString(d, options, formatArgs); +} + +function assertDateValue(actual, dateValue, timeZoneOffset) { + assertSame(dateValue, actual.valueOf(), `valueOf()[${dateValue - actual.valueOf()}]`); + assertSame(dateValue, actual.getTime(), `valueOf()[${dateValue - actual.getTime()}]`); + assertSame(timeZoneOffset, actual.getTimezoneOffset(), "getTimezoneOffset()"); +} + +function assertLocalDate(actual, {year, month, day, weekday, hour = 0, minute = 0, second = 0, ms = 0}) { + assertSame(year, actual.getFullYear(), "getFullYear()"); + assertSame(month, actual.getMonth(), "getMonth()"); + assertSame(day, actual.getDate(), "getDate()"); + assertSame(weekday, actual.getDay(), "getDay()"); + assertSame(hour, actual.getHours(), "getHours()"); + assertSame(minute, actual.getMinutes(), "getMinutes()"); + assertSame(second, actual.getSeconds(), "getSeconds()"); + assertSame(ms, actual.getMilliseconds(), "getMilliseconds()"); +} + +function assertUTCDate(actual, {year, month, day, weekday, hour = 0, minute = 0, second = 0, ms = 0}) { + assertSame(year, actual.getUTCFullYear(), "getUTCFullYear()"); + assertSame(month, actual.getUTCMonth(), "getUTCMonth()"); + assertSame(day, actual.getUTCDate(), "getUTCDate()"); + assertSame(weekday, actual.getUTCDay(), "getUTCDay()"); + assertSame(hour, actual.getUTCHours(), "getUTCHours()"); + assertSame(minute, actual.getUTCMinutes(), "getUTCMinutes()"); + assertSame(second, actual.getUTCSeconds(), "getUTCSeconds()"); + assertSame(ms, actual.getUTCMilliseconds(), "getUTCMilliseconds()"); +} + +function assertDateString(actual, options, formatArgs = { + LocaleString: [Format.Locale, Format.DateTime], + LocaleDateString: [Format.Locale, Format.Date], + LocaleTimeString: [Format.Locale, Format.Time], +}) { + for (var key of Object.keys(options)) { + var args = formatArgs[key] || []; + assertSame(options[key], actual[`to${key}`](...args), `to${key}()`); + } +} + + +// File: Date/Africa_Monrovia.js +// Liberia was the last country to switch to UTC based offsets (1972 May). + +inTimeZone("Africa/Monrovia", () => { +{ + let local = new DateTime.Local(1972, Month.January, 6, DayOfWeek.Thursday, 0, 0, 0); + let utc = new DateTime.UTC(1972, Month.January, 6, DayOfWeek.Thursday, 0, 44, 30); + + assertDate(local, utc, TimeZone(-0,44,30), { + String: "Thu Jan 06 1972 00:00:00 GMT-0044 (Greenwich Mean Time)", + UTCString: "Thu, 06 Jan 1972 00:44:30 GMT", + }); +} + +{ + let local = new DateTime.Local(1972, Month.January, 6, DayOfWeek.Thursday, 23, 59, 0); + let utc = new DateTime.UTC(1972, Month.January, 7, DayOfWeek.Friday, 0, 43, 30); + + assertDate(local, utc, TimeZone(-0,44,30), { + String: "Thu Jan 06 1972 23:59:00 GMT-0044 (Greenwich Mean Time)", + UTCString: "Fri, 07 Jan 1972 00:43:30 GMT", + }); +} + +{ + let local = new DateTime.Local(1972, Month.January, 7, DayOfWeek.Friday, 0, 0, 0); + let utc = new DateTime.UTC(1972, Month.January, 7, DayOfWeek.Friday, 0, 44, 30); + + assertDateValue(local.toDate(), utc.toInstant(), TimeZone(+0).toOffset()); + + assertDateString(local.toDate(), { + String: "Fri Jan 07 1972 00:44:30 GMT+0000 (Greenwich Mean Time)", + UTCString: "Fri, 07 Jan 1972 00:44:30 GMT", + }); +} + +{ + let local = new DateTime.Local(1972, Month.January, 7, DayOfWeek.Friday, 0, 44, 30); + let utc = new DateTime.UTC(1972, Month.January, 7, DayOfWeek.Friday, 0, 44, 30); + + assertDate(local, utc, TimeZone(+0), { + String: "Fri Jan 07 1972 00:44:30 GMT+0000 (Greenwich Mean Time)", + UTCString: "Fri, 07 Jan 1972 00:44:30 GMT", + }); +} + +{ + let local = new DateTime.Local(1972, Month.January, 7, DayOfWeek.Friday, 0, 45, 0); + let utc = new DateTime.UTC(1972, Month.January, 7, DayOfWeek.Friday, 0, 45, 0); + + assertDate(local, utc, TimeZone(+0), { + String: "Fri Jan 07 1972 00:45:00 GMT+0000 (Greenwich Mean Time)", + UTCString: "Fri, 07 Jan 1972 00:45:00 GMT", + }); +} + +{ + let local = new DateTime.Local(1972, Month.January, 8, DayOfWeek.Saturday, 0, 0, 0); + let utc = new DateTime.UTC(1972, Month.January, 8, DayOfWeek.Saturday, 0, 0, 0); + + assertDate(local, utc, TimeZone(+0), { + String: "Sat Jan 08 1972 00:00:00 GMT+0000 (Greenwich Mean Time)", + UTCString: "Sat, 08 Jan 1972 00:00:00 GMT", + }); +} +}); + + +// File: Date/Africa_Monrovia.js +// Africa/Tripoli switched from +02:00 to +01:00 and back. + +inTimeZone("Africa/Tripoli", () => { +{ + // +02:00 (standard time) + let local = new DateTime.Local(2012, Month.November, 1, DayOfWeek.Thursday, 0, 0, 0); + let utc = new DateTime.UTC(2012, Month.October, 31, DayOfWeek.Wednesday, 22, 0, 0); + + assertDate(local, utc, TimeZone(+2), { + String: "Thu Nov 01 2012 00:00:00 GMT+0200 (Eastern European Standard Time)", + UTCString: "Wed, 31 Oct 2012 22:00:00 GMT", + }); +} + +{ + // +01:00 (standard time) + let local = new DateTime.Local(2012, Month.December, 1, DayOfWeek.Saturday, 0, 0, 0); + let utc = new DateTime.UTC(2012, Month.November, 30, DayOfWeek.Friday, 23, 0, 0); + + assertDate(local, utc, TimeZone(+1), { + String: "Sat Dec 01 2012 00:00:00 GMT+0100 (Eastern European Standard Time)", + UTCString: "Fri, 30 Nov 2012 23:00:00 GMT", + }); +} + +{ + // +01:00 (daylight savings) + let local = new DateTime.Local(2013, Month.October, 1, DayOfWeek.Tuesday, 0, 0, 0); + let utc = new DateTime.UTC(2013, Month.September, 30, DayOfWeek.Monday, 22, 0, 0); + + assertDate(local, utc, TimeZone(+2), { + String: "Tue Oct 01 2013 00:00:00 GMT+0200 (Eastern European Summer Time)", + UTCString: "Mon, 30 Sep 2013 22:00:00 GMT", + }); +} + +{ + // +02:00 (standard time) + let local = new DateTime.Local(2013, Month.November, 1, DayOfWeek.Friday, 0, 0, 0); + let utc = new DateTime.UTC(2013, Month.October, 31, DayOfWeek.Thursday, 22, 0, 0); + + assertDate(local, utc, TimeZone(+2), { + String: "Fri Nov 01 2013 00:00:00 GMT+0200 (Eastern European Standard Time)", + UTCString: "Thu, 31 Oct 2013 22:00:00 GMT", + }); +} +}); + + +// File: Date/America_Caracas.js +// America/Caracas switched from -04:00 to -04:30 on 2007 Dec 9. + +inTimeZone("America/Caracas", () => { +{ + // -04:00 (standard time) + let local = new DateTime.Local(2007, Month.December, 5, DayOfWeek.Wednesday, 0, 0, 0); + let utc = new DateTime.UTC(2007, Month.December, 5, DayOfWeek.Wednesday, 4, 0, 0); + + assertDate(local, utc, TimeZone(-4), { + String: "Wed Dec 05 2007 00:00:00 GMT-0400 (Venezuela Time)", + DateString: "Wed Dec 05 2007", + TimeString: "00:00:00 GMT-0400 (Venezuela Time)", + UTCString: "Wed, 05 Dec 2007 04:00:00 GMT", + ISOString: "2007-12-05T04:00:00.000Z", + LocaleString: "Wed, 12/05/2007, 12:00:00 AM GMT-4", + LocaleDateString: "Wed, 12/05/2007", + LocaleTimeString: "12:00:00 AM GMT-4", + }); +} + +{ + // -04:30 (standard time) + let local = new DateTime.Local(2007, Month.December, 12, DayOfWeek.Wednesday, 0, 0, 0); + let utc = new DateTime.UTC(2007, Month.December, 12, DayOfWeek.Wednesday, 4, 30, 0); + + assertDate(local, utc, TimeZone(-4, 30), { + String: "Wed Dec 12 2007 00:00:00 GMT-0430 (Venezuela Time)", + DateString: "Wed Dec 12 2007", + TimeString: "00:00:00 GMT-0430 (Venezuela Time)", + UTCString: "Wed, 12 Dec 2007 04:30:00 GMT", + ISOString: "2007-12-12T04:30:00.000Z", + LocaleString: "Wed, 12/12/2007, 12:00:00 AM GMT-4:30", + LocaleDateString: "Wed, 12/12/2007", + LocaleTimeString: "12:00:00 AM GMT-4:30", + }); +} +}); + + +// File: Date/Australia_Lord_Howe.js +// Australia/Lord_Howe time zone offset is +10:30 and daylight savings amount is 00:30. + +inTimeZone("Australia/Lord_Howe", () => { +{ + // +10:30 (standard time) + let local = new DateTime.Local(2010, Month.August, 1, DayOfWeek.Sunday, 0, 0, 0); + let utc = new DateTime.UTC(2010, Month.July, 31, DayOfWeek.Saturday, 13, 30, 0); + + assertDate(local, utc, TimeZone(+10,30), { + String: "Sun Aug 01 2010 00:00:00 GMT+1030 (Lord Howe Standard Time)", + DateString: "Sun Aug 01 2010", + TimeString: "00:00:00 GMT+1030 (Lord Howe Standard Time)", + UTCString: "Sat, 31 Jul 2010 13:30:00 GMT", + ISOString: "2010-07-31T13:30:00.000Z", + LocaleString: "Sun, 08/01/2010, 12:00:00 AM GMT+10:30", + LocaleDateString: "Sun, 08/01/2010", + LocaleTimeString: "12:00:00 AM GMT+10:30", + }); +} + +{ + // +10:30 (daylight savings) + let local = new DateTime.Local(2010, Month.January, 3, DayOfWeek.Sunday, 0, 0, 0); + let utc = new DateTime.UTC(2010, Month.January, 2, DayOfWeek.Saturday, 13, 0, 0); + + assertDate(local, utc, TimeZone(+11), { + String: "Sun Jan 03 2010 00:00:00 GMT+1100 (Lord Howe Daylight Time)", + DateString: "Sun Jan 03 2010", + TimeString: "00:00:00 GMT+1100 (Lord Howe Daylight Time)", + UTCString: "Sat, 02 Jan 2010 13:00:00 GMT", + ISOString: "2010-01-02T13:00:00.000Z", + LocaleString: "Sun, 01/03/2010, 12:00:00 AM GMT+11", + LocaleDateString: "Sun, 01/03/2010", + LocaleTimeString: "12:00:00 AM GMT+11", + }); +} +}); + + +// File: Date/Europe_Amsterdam.js +// Europe/Amsterdam as an example for mean time like timezones after LMT (AMT, NST). +// +// tzdata2022b changed Europe/Amsterdam into a link to Europe/Brussels. + +inTimeZone("Europe/Amsterdam", () => { +{ + let local = new DateTime.Local(1935, Month.January, 1, DayOfWeek.Tuesday, 0, 0, 0); + let utc = new DateTime.UTC(1935, Month.January, 1, DayOfWeek.Tuesday, 0, 0, 0); + + assertDate(local, utc, TimeZone(+0,0,0), { + String: "Tue Jan 01 1935 00:00:00 GMT+0000 (Central European Standard Time)", + UTCString: "Tue, 01 Jan 1935 00:00:00 GMT", + }); +} + +{ + let local = new DateTime.Local(1935, Month.July, 1, DayOfWeek.Monday, 0, 0, 0); + let utc = new DateTime.UTC(1935, Month.June, 30, DayOfWeek.Sunday, 23, 0, 0); + + assertDate(local, utc, TimeZone(+1,0,0), { + String: "Mon Jul 01 1935 00:00:00 GMT+0100 (Central European Summer Time)", + UTCString: "Sun, 30 Jun 1935 23:00:00 GMT", + }); +} +}); + +// Use America/St_Johns as a replacement for the Europe/Amsterdam test case. +// +// Zone America/St_Johns as an example for mean time like timezones after LMT (NST, NDT). + +inTimeZone("America/St_Johns", () => { +{ + let local = new DateTime.Local(1917, Month.January, 1, DayOfWeek.Monday, 0, 0, 0); + let utc = new DateTime.UTC(1917, Month.January, 1, DayOfWeek.Monday, 3, 30, 52); + + assertDate(local, utc, TimeZone(-3,30,52), { + String: "Mon Jan 01 1917 00:00:00 GMT-0330 (Newfoundland Standard Time)", + UTCString: "Mon, 01 Jan 1917 03:30:52 GMT", + }); +} + +{ + let local = new DateTime.Local(1917, Month.July, 1, DayOfWeek.Sunday, 0, 0, 0); + let utc = new DateTime.UTC(1917, Month.July, 1, DayOfWeek.Sunday, 2, 30, 52); + + assertDate(local, utc, TimeZone(-2,30,52), { + String: "Sun Jul 01 1917 00:00:00 GMT-0230 (Newfoundland Daylight Time)", + UTCString: "Sun, 01 Jul 1917 02:30:52 GMT", + }); +} +}); + + +// File: Date/Europe_London.js + +inTimeZone("Europe/London", () => { +{ + // +01:00 (standard time) + let local = new DateTime.Local(1970, Month.January, 1, DayOfWeek.Thursday, 0, 0, 0); + let utc = new DateTime.UTC(1969, Month.December, 31, DayOfWeek.Wednesday, 23, 0, 0); + + assertDate(local, utc, TimeZone(+1), { + String: "Thu Jan 01 1970 00:00:00 GMT+0100 (Greenwich Mean Time)", + DateString: "Thu Jan 01 1970", + TimeString: "00:00:00 GMT+0100 (Greenwich Mean Time)", + UTCString: "Wed, 31 Dec 1969 23:00:00 GMT", + ISOString: "1969-12-31T23:00:00.000Z", + LocaleString: "Thu, 01/01/1970, 12:00:00 AM GMT+1", + LocaleDateString: "Thu, 01/01/1970", + LocaleTimeString: "12:00:00 AM GMT+1", + }); +} +}); + + +// File: Date/Europe_Moscow.js + +inTimeZone("Europe/Moscow", () => { +{ + let local = new DateTime.Local(1970, Month.January, 1, DayOfWeek.Thursday, 0, 0, 0); + let utc = new DateTime.UTC(1969, Month.December, 31, DayOfWeek.Wednesday, 21, 0, 0); + + assertDate(local, utc, TimeZone(+3), { + String: "Thu Jan 01 1970 00:00:00 GMT+0300 (Moscow Standard Time)", + DateString: "Thu Jan 01 1970", + TimeString: "00:00:00 GMT+0300 (Moscow Standard Time)", + UTCString: "Wed, 31 Dec 1969 21:00:00 GMT", + ISOString: "1969-12-31T21:00:00.000Z", + LocaleString: "Thu, 01/01/1970, 12:00:00 AM GMT+3", + LocaleDateString: "Thu, 01/01/1970", + LocaleTimeString: "12:00:00 AM GMT+3", + }); +} + +// Russia was in +02:00 starting on 1991-03-31 until 1992-01-19, +// while still observing DST (transitions 1991-03-31 and 1991-09-29). + +{ + // +03:00 (daylight savings) + let local = new DateTime.Local(1990, Month.September, 1, DayOfWeek.Saturday, 0, 0, 0); + let utc = new DateTime.UTC(1990, Month.August, 31, DayOfWeek.Friday, 20, 0, 0); + + assertDate(local, utc, TimeZone(+4), { + String: "Sat Sep 01 1990 00:00:00 GMT+0400 (Moscow Summer Time)", + DateString: "Sat Sep 01 1990", + TimeString: "00:00:00 GMT+0400 (Moscow Summer Time)", + UTCString: "Fri, 31 Aug 1990 20:00:00 GMT", + ISOString: "1990-08-31T20:00:00.000Z", + LocaleString: "Sat, 09/01/1990, 12:00:00 AM GMT+4", + LocaleDateString: "Sat, 09/01/1990", + LocaleTimeString: "12:00:00 AM GMT+4", + }); +} + +{ + // +03:00 (standard time) + let local = new DateTime.Local(1991, Month.March, 25, DayOfWeek.Monday, 0, 0, 0); + let utc = new DateTime.UTC(1991, Month.March, 24, DayOfWeek.Sunday, 21, 0, 0); + + assertDate(local, utc, TimeZone(+3), { + String: "Mon Mar 25 1991 00:00:00 GMT+0300 (Moscow Standard Time)", + DateString: "Mon Mar 25 1991", + TimeString: "00:00:00 GMT+0300 (Moscow Standard Time)", + UTCString: "Sun, 24 Mar 1991 21:00:00 GMT", + ISOString: "1991-03-24T21:00:00.000Z", + LocaleString: "Mon, 03/25/1991, 12:00:00 AM GMT+3", + LocaleDateString: "Mon, 03/25/1991", + LocaleTimeString: "12:00:00 AM GMT+3", + }); +} + +{ + // +02:00 (daylight savings) + let local = new DateTime.Local(1991, Month.March, 31, DayOfWeek.Sunday, 12, 0, 0); + let utc = new DateTime.UTC(1991, Month.March, 31, DayOfWeek.Sunday, 9, 0, 0); + + assertDate(local, utc, TimeZone(+3), { + String: "Sun Mar 31 1991 12:00:00 GMT+0300 (Moscow Summer Time)", + DateString: "Sun Mar 31 1991", + TimeString: "12:00:00 GMT+0300 (Moscow Summer Time)", + UTCString: "Sun, 31 Mar 1991 09:00:00 GMT", + ISOString: "1991-03-31T09:00:00.000Z", + LocaleString: "Sun, 03/31/1991, 12:00:00 PM GMT+3", + LocaleDateString: "Sun, 03/31/1991", + LocaleTimeString: "12:00:00 PM GMT+3", + }); +} + +{ + // +02:00 (daylight savings) + let local = new DateTime.Local(1991, Month.September, 28, DayOfWeek.Saturday, 0, 0, 0); + let utc = new DateTime.UTC(1991, Month.September, 27, DayOfWeek.Friday, 21, 0, 0); + + assertDate(local, utc, TimeZone(+3), { + String: "Sat Sep 28 1991 00:00:00 GMT+0300 (Moscow Summer Time)", + DateString: "Sat Sep 28 1991", + TimeString: "00:00:00 GMT+0300 (Moscow Summer Time)", + UTCString: "Fri, 27 Sep 1991 21:00:00 GMT", + ISOString: "1991-09-27T21:00:00.000Z", + LocaleString: "Sat, 09/28/1991, 12:00:00 AM GMT+3", + LocaleDateString: "Sat, 09/28/1991", + LocaleTimeString: "12:00:00 AM GMT+3", + }); +} + +{ + // +02:00 (standard time) + let local = new DateTime.Local(1991, Month.September, 30, DayOfWeek.Monday, 0, 0, 0); + let utc = new DateTime.UTC(1991, Month.September, 29, DayOfWeek.Sunday, 22, 0, 0); + + assertDate(local, utc, TimeZone(+2), { + String: "Mon Sep 30 1991 00:00:00 GMT+0200 (Moscow Standard Time)", + DateString: "Mon Sep 30 1991", + TimeString: "00:00:00 GMT+0200 (Moscow Standard Time)", + UTCString: "Sun, 29 Sep 1991 22:00:00 GMT", + ISOString: "1991-09-29T22:00:00.000Z", + LocaleString: "Mon, 09/30/1991, 12:00:00 AM GMT+2", + LocaleDateString: "Mon, 09/30/1991", + LocaleTimeString: "12:00:00 AM GMT+2", + }); +} + +// Russia stopped observing DST in Oct. 2010 (last transition on 2010-10-31), +// and changed timezone from +03:00 to +04:00 on 2011-03-27. + +{ + // +03:00 (daylight savings) + let local = new DateTime.Local(2010, Month.October, 30, DayOfWeek.Saturday, 0, 0, 0); + let utc = new DateTime.UTC(2010, Month.October, 29, DayOfWeek.Friday, 20, 0, 0); + + assertDate(local, utc, TimeZone(+4), { + String: "Sat Oct 30 2010 00:00:00 GMT+0400 (Moscow Summer Time)", + DateString: "Sat Oct 30 2010", + TimeString: "00:00:00 GMT+0400 (Moscow Summer Time)", + UTCString: "Fri, 29 Oct 2010 20:00:00 GMT", + ISOString: "2010-10-29T20:00:00.000Z", + LocaleString: "Sat, 10/30/2010, 12:00:00 AM GMT+4", + LocaleDateString: "Sat, 10/30/2010", + LocaleTimeString: "12:00:00 AM GMT+4", + }); +} + +{ + // +03:00 (standard time) + let local = new DateTime.Local(2010, Month.November, 1, DayOfWeek.Monday, 0, 0, 0); + let utc = new DateTime.UTC(2010, Month.October, 31, DayOfWeek.Sunday, 21, 0, 0); + + assertDate(local, utc, TimeZone(+3), { + String: "Mon Nov 01 2010 00:00:00 GMT+0300 (Moscow Standard Time)", + DateString: "Mon Nov 01 2010", + TimeString: "00:00:00 GMT+0300 (Moscow Standard Time)", + UTCString: "Sun, 31 Oct 2010 21:00:00 GMT", + ISOString: "2010-10-31T21:00:00.000Z", + LocaleString: "Mon, 11/01/2010, 12:00:00 AM GMT+3", + LocaleDateString: "Mon, 11/01/2010", + LocaleTimeString: "12:00:00 AM GMT+3", + }); +} + +{ + // +04:00 (standard time) + let local = new DateTime.Local(2011, Month.October, 30, DayOfWeek.Sunday, 0, 0, 0); + let utc = new DateTime.UTC(2011, Month.October, 29, DayOfWeek.Saturday, 20, 0, 0); + + assertDate(local, utc, TimeZone(+4), { + String: "Sun Oct 30 2011 00:00:00 GMT+0400 (Moscow Standard Time)", + DateString: "Sun Oct 30 2011", + TimeString: "00:00:00 GMT+0400 (Moscow Standard Time)", + UTCString: "Sat, 29 Oct 2011 20:00:00 GMT", + ISOString: "2011-10-29T20:00:00.000Z", + LocaleString: "Sun, 10/30/2011, 12:00:00 AM GMT+4", + LocaleDateString: "Sun, 10/30/2011", + LocaleTimeString: "12:00:00 AM GMT+4", + }); +} + +{ + // +04:00 (standard time) + let local = new DateTime.Local(2011, Month.November, 1, DayOfWeek.Tuesday, 0, 0, 0); + let utc = new DateTime.UTC(2011, Month.October, 31, DayOfWeek.Monday, 20, 0, 0); + + assertDate(local, utc, TimeZone(+4), { + String: "Tue Nov 01 2011 00:00:00 GMT+0400 (Moscow Standard Time)", + DateString: "Tue Nov 01 2011", + TimeString: "00:00:00 GMT+0400 (Moscow Standard Time)", + UTCString: "Mon, 31 Oct 2011 20:00:00 GMT", + ISOString: "2011-10-31T20:00:00.000Z", + LocaleString: "Tue, 11/01/2011, 12:00:00 AM GMT+4", + LocaleDateString: "Tue, 11/01/2011", + LocaleTimeString: "12:00:00 AM GMT+4", + }); +} + +// Russia changed timezone from +04:00 to +03:00 on 2014-10-26. + +{ + // +04:00 (standard time) + let local = new DateTime.Local(2014, Month.October, 26, DayOfWeek.Sunday, 0, 0, 0); + let utc = new DateTime.UTC(2014, Month.October, 25, DayOfWeek.Saturday, 20, 0, 0); + + assertDate(local, utc, TimeZone(+4), { + String: "Sun Oct 26 2014 00:00:00 GMT+0400 (Moscow Standard Time)", + DateString: "Sun Oct 26 2014", + TimeString: "00:00:00 GMT+0400 (Moscow Standard Time)", + UTCString: "Sat, 25 Oct 2014 20:00:00 GMT", + ISOString: "2014-10-25T20:00:00.000Z", + LocaleString: "Sun, 10/26/2014, 12:00:00 AM GMT+4", + LocaleDateString: "Sun, 10/26/2014", + LocaleTimeString: "12:00:00 AM GMT+4", + }); +} + +{ + // +03:00 (standard time) + let local = new DateTime.Local(2014, Month.October, 27, DayOfWeek.Monday, 0, 0, 0); + let utc = new DateTime.UTC(2014, Month.October, 26, DayOfWeek.Sunday, 21, 0, 0); + + assertDate(local, utc, TimeZone(+3), { + String: "Mon Oct 27 2014 00:00:00 GMT+0300 (Moscow Standard Time)", + DateString: "Mon Oct 27 2014", + TimeString: "00:00:00 GMT+0300 (Moscow Standard Time)", + UTCString: "Sun, 26 Oct 2014 21:00:00 GMT", + ISOString: "2014-10-26T21:00:00.000Z", + LocaleString: "Mon, 10/27/2014, 12:00:00 AM GMT+3", + LocaleDateString: "Mon, 10/27/2014", + LocaleTimeString: "12:00:00 AM GMT+3", + }); +} +}); + + +// File: Date/Pacific_Apia.js +// Pacific/Apia switched from -11:00 to +13:00 on 2011 Dec 29 24:00. + +inTimeZone("Pacific/Apia", () => { +{ + // -11:00 (daylight savings) + let local = new DateTime.Local(2011, Month.December, 29, DayOfWeek.Thursday, 0, 0, 0); + let utc = new DateTime.UTC(2011, Month.December, 29, DayOfWeek.Thursday, 10, 0, 0); + + assertDate(local, utc, TimeZone(-10), { + String: "Thu Dec 29 2011 00:00:00 GMT-1000 (Apia Daylight Time)", + DateString: "Thu Dec 29 2011", + TimeString: "00:00:00 GMT-1000 (Apia Daylight Time)", + UTCString: "Thu, 29 Dec 2011 10:00:00 GMT", + ISOString: "2011-12-29T10:00:00.000Z", + LocaleString: "Thu, 12/29/2011, 12:00:00 AM GMT-10", + LocaleDateString: "Thu, 12/29/2011", + LocaleTimeString: "12:00:00 AM GMT-10", + }); +} + +{ + // +13:00 (daylight savings) + let local = new DateTime.Local(2011, Month.December, 31, DayOfWeek.Saturday, 0, 0, 0); + let utc = new DateTime.UTC(2011, Month.December, 30, DayOfWeek.Friday, 10, 0, 0); + + assertDate(local, utc, TimeZone(+14), { + String: "Sat Dec 31 2011 00:00:00 GMT+1400 (Apia Daylight Time)", + DateString: "Sat Dec 31 2011", + TimeString: "00:00:00 GMT+1400 (Apia Daylight Time)", + UTCString: "Fri, 30 Dec 2011 10:00:00 GMT", + ISOString: "2011-12-30T10:00:00.000Z", + LocaleString: "Sat, 12/31/2011, 12:00:00 AM GMT+14", + LocaleDateString: "Sat, 12/31/2011", + LocaleTimeString: "12:00:00 AM GMT+14", + }); +} + +{ + // +13:00 (standard time) + let local = new DateTime.Local(2012, Month.April, 2, DayOfWeek.Monday, 0, 0, 0); + let utc = new DateTime.UTC(2012, Month.April, 1, DayOfWeek.Sunday, 11, 0, 0); + + assertDate(local, utc, TimeZone(+13), { + String: "Mon Apr 02 2012 00:00:00 GMT+1300 (Apia Standard Time)", + DateString: "Mon Apr 02 2012", + TimeString: "00:00:00 GMT+1300 (Apia Standard Time)", + UTCString: "Sun, 01 Apr 2012 11:00:00 GMT", + ISOString: "2012-04-01T11:00:00.000Z", + LocaleString: "Mon, 04/02/2012, 12:00:00 AM GMT+13", + LocaleDateString: "Mon, 04/02/2012", + LocaleTimeString: "12:00:00 AM GMT+13", + }); +} +}); + + +// File: Date/Pacific_Chatham.js +// Pacific/Chatham time zone offset is 12:45. + +inTimeZone("Pacific/Chatham", () => { +{ + // +12:45 (standard time) + let local = new DateTime.Local(2010, Month.August, 1, DayOfWeek.Sunday, 0, 0, 0); + let utc = new DateTime.UTC(2010, Month.July, 31, DayOfWeek.Saturday, 11, 15, 0); + + assertDate(local, utc, TimeZone(+12,45), { + String: "Sun Aug 01 2010 00:00:00 GMT+1245 (Chatham Standard Time)", + DateString: "Sun Aug 01 2010", + TimeString: "00:00:00 GMT+1245 (Chatham Standard Time)", + UTCString: "Sat, 31 Jul 2010 11:15:00 GMT", + ISOString: "2010-07-31T11:15:00.000Z", + LocaleString: "Sun, 08/01/2010, 12:00:00 AM GMT+12:45", + LocaleDateString: "Sun, 08/01/2010", + LocaleTimeString: "12:00:00 AM GMT+12:45", + }); +} + +{ + // +12:45 (daylight savings) + let local = new DateTime.Local(2010, Month.January, 3, DayOfWeek.Sunday, 0, 0, 0); + let utc = new DateTime.UTC(2010, Month.January, 2, DayOfWeek.Saturday, 10, 15, 0); + + assertDate(local, utc, TimeZone(+13,45), { + String: "Sun Jan 03 2010 00:00:00 GMT+1345 (Chatham Daylight Time)", + DateString: "Sun Jan 03 2010", + TimeString: "00:00:00 GMT+1345 (Chatham Daylight Time)", + UTCString: "Sat, 02 Jan 2010 10:15:00 GMT", + ISOString: "2010-01-02T10:15:00.000Z", + LocaleString: "Sun, 01/03/2010, 12:00:00 AM GMT+13:45", + LocaleDateString: "Sun, 01/03/2010", + LocaleTimeString: "12:00:00 AM GMT+13:45", + }); +} +}); + + +// File: Date/Pacific_Kiritimati.js +// Pacific/Kiritimati time zone offset is +14:00. + +inTimeZone("Pacific/Kiritimati", () => { +{ + // +14:00 (standard time) + let local = new DateTime.Local(2010, Month.August, 1, DayOfWeek.Sunday, 0, 0, 0); + let utc = new DateTime.UTC(2010, Month.July, 31, DayOfWeek.Saturday, 10, 0, 0); + + assertDate(local, utc, TimeZone(+14), { + String: "Sun Aug 01 2010 00:00:00 GMT+1400 (Line Islands Time)", + DateString: "Sun Aug 01 2010", + TimeString: "00:00:00 GMT+1400 (Line Islands Time)", + UTCString: "Sat, 31 Jul 2010 10:00:00 GMT", + ISOString: "2010-07-31T10:00:00.000Z", + LocaleString: "Sun, 08/01/2010, 12:00:00 AM GMT+14", + LocaleDateString: "Sun, 08/01/2010", + LocaleTimeString: "12:00:00 AM GMT+14", + }); +} + +// Pacific/Kiritimati time zone offset was -10:40 until Oct. 1979. + +{ + // -10:40 (standard time) + let local = new DateTime.Local(1975, Month.January, 1, DayOfWeek.Wednesday, 0, 0, 0); + let utc = new DateTime.UTC(1975, Month.January, 1, DayOfWeek.Wednesday, 10, 40, 0); + + assertDate(local, utc, TimeZone(-10,40), { + String: "Wed Jan 01 1975 00:00:00 GMT-1040 (Line Islands Time)", + DateString: "Wed Jan 01 1975", + TimeString: "00:00:00 GMT-1040 (Line Islands Time)", + UTCString: "Wed, 01 Jan 1975 10:40:00 GMT", + ISOString: "1975-01-01T10:40:00.000Z", + LocaleString: "Wed, 01/01/1975, 12:00:00 AM GMT-10:40", + LocaleDateString: "Wed, 01/01/1975", + LocaleTimeString: "12:00:00 AM GMT-10:40", + }); +} +}); + + +// File: Date/Pacifi_Niue.js +// Pacific/Niue time zone offset was -11:20 from 1952 through 1964. + +inTimeZone("Pacific/Niue", () => { +{ + // -11:20 (standard time) + let local = new DateTime.Local(1956, Month.January, 1, DayOfWeek.Sunday, 0, 0, 0); + let utc = new DateTime.UTC(1956, Month.January, 1, DayOfWeek.Sunday, 11, 20, 0); + + assertDate(local, utc, TimeZone(-11,20), { + String: "Sun Jan 01 1956 00:00:00 GMT-1120 (Niue Time)", + DateString: "Sun Jan 01 1956", + TimeString: "00:00:00 GMT-1120 (Niue Time)", + UTCString: "Sun, 01 Jan 1956 11:20:00 GMT", + ISOString: "1956-01-01T11:20:00.000Z", + LocaleString: "Sun, 01/01/1956, 12:00:00 AM GMT-11:20", + LocaleDateString: "Sun, 01/01/1956", + LocaleTimeString: "12:00:00 AM GMT-11:20", + }); +} +}); + + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/non262/Date/time-zones-pedantic.js b/js/src/tests/non262/Date/time-zones-pedantic.js new file mode 100644 index 0000000000..c3445ed5fd --- /dev/null +++ b/js/src/tests/non262/Date/time-zones-pedantic.js @@ -0,0 +1,15 @@ +// |reftest| skip-if(xulRuntime.OS=="WINNT"||xulRuntime.OS=="Darwin") -- Skip on OS X in addition to Windows + +// Contains the tests from "time-zones.js" which fail on OS X. + +// bug 637244 +inTimeZone("Asia/Novosibirsk", () => { + let dt1 = new Date(1984, Month.April, 1, -1); + assertDateTime(dt1, "Sat Mar 31 1984 23:00:00 GMT+0700 (NOVT)", "+07", "Novosibirsk Standard Time"); + + let dt2 = new Date(1984, Month.April, 1); + assertDateTime(dt2, "Sun Apr 01 1984 01:00:00 GMT+0800 (NOVST)", "+08", "Novosibirsk Summer Time"); +}); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/non262/Date/time-zones-posix.js b/js/src/tests/non262/Date/time-zones-posix.js new file mode 100644 index 0000000000..c2d7cc20c9 --- /dev/null +++ b/js/src/tests/non262/Date/time-zones-posix.js @@ -0,0 +1,160 @@ +// |reftest| skip-if(xulRuntime.OS=="WINNT"&&!xulRuntime.shell) -- Windows browser in automation doesn't pick up new time zones correctly + +// Repeats the test from "time-zones.js", but uses POSIX instead of IANA names +// for the time zones. This allows to run these tests on Windows, too. + +// From bug 1330149: +// +// Windows only supports a very limited set of IANA time zone names for the TZ +// environment variable. +// +// TZ format supported by Windows: "TZ=tzn[+|-]hh[:mm[:ss]][dzn]". +// +// Complete list of all IANA time zone ids matching that format. +// +// From tzdata's "northamerica" file: +// EST5EDT +// CST6CDT +// MST7MDT +// PST8PDT +// +// From tzdata's "backward" file: +// GMT+0 +// GMT-0 +// GMT0 +// +// Also supported on Windows even though they don't match the format listed +// above. +// +// From tzdata's "backward" file: +// UCT +// UTC +// +// From tzdata's "etcetera" file: +// GMT + + +// Perform the following replacements: +// America/New_York -> EST5EDT +// America/Chicago -> CST6CDT +// America/Denver -> MST7MDT +// America/Los_Angeles -> PST8PDT +// +// And remove any tests not matching one of the four time zones from above. + +// bug 294908 +inTimeZone("EST5EDT", () => { + let dt = new Date(2003, Month.April, 6, 2, 30, 00); + assertDateTime(dt, "Sun Apr 06 2003 03:30:00 GMT-0400 (EDT)", "Eastern Daylight Time"); +}); + +// bug 610183 +inTimeZone("PST8PDT", () => { + let dt = new Date(2014, Month.November, 2, 1, 47, 42); + assertDateTime(dt, "Sun Nov 02 2014 01:47:42 GMT-0700 (PDT)", "Pacific Daylight Time"); +}); + +// bug 629465 +inTimeZone("MST7MDT", () => { + let dt1 = new Date(Date.UTC(2015, Month.November, 1, 0, 0, 0) + 6 * msPerHour); + assertDateTime(dt1, "Sun Nov 01 2015 00:00:00 GMT-0600 (MDT)", "Mountain Daylight Time"); + + let dt2 = new Date(Date.UTC(2015, Month.November, 1, 1, 0, 0) + 6 * msPerHour); + assertDateTime(dt2, "Sun Nov 01 2015 01:00:00 GMT-0600 (MDT)", "Mountain Daylight Time"); + + let dt3 = new Date(Date.UTC(2015, Month.November, 1, 1, 0, 0) + 7 * msPerHour); + assertDateTime(dt3, "Sun Nov 01 2015 01:00:00 GMT-0700 (MST)", "Mountain Standard Time"); +}); + +// bug 742427 +inTimeZone("EST5EDT", () => { + let dt = new Date(2009, Month.March, 8, 1, 0, 0); + assertDateTime(dt, "Sun Mar 08 2009 01:00:00 GMT-0500 (EST)", "Eastern Standard Time"); + dt.setHours(dt.getHours() + 1); + assertDateTime(dt, "Sun Mar 08 2009 03:00:00 GMT-0400 (EDT)", "Eastern Daylight Time"); +}); +inTimeZone("MST7MDT", () => { + let dt = new Date(2009, Month.March, 8, 1, 0, 0); + assertDateTime(dt, "Sun Mar 08 2009 01:00:00 GMT-0700 (MST)", "Mountain Standard Time"); + dt.setHours(dt.getHours() + 1); + assertDateTime(dt, "Sun Mar 08 2009 03:00:00 GMT-0600 (MDT)", "Mountain Daylight Time"); +}); +inTimeZone("EST5EDT", () => { + let dt1 = new Date(Date.UTC(2008, Month.March, 9, 0, 0, 0) + 5 * msPerHour); + assertDateTime(dt1, "Sun Mar 09 2008 00:00:00 GMT-0500 (EST)", "Eastern Standard Time"); + + let dt2 = new Date(Date.UTC(2008, Month.March, 9, 1, 0, 0) + 5 * msPerHour); + assertDateTime(dt2, "Sun Mar 09 2008 01:00:00 GMT-0500 (EST)", "Eastern Standard Time"); + + let dt3 = new Date(Date.UTC(2008, Month.March, 9, 4, 0, 0) + 4 * msPerHour); + assertDateTime(dt3, "Sun Mar 09 2008 04:00:00 GMT-0400 (EDT)", "Eastern Daylight Time"); +}); + +// bug 802627 +inTimeZone("EST5EDT", () => { + let dt = new Date(0); + assertDateTime(dt, "Wed Dec 31 1969 19:00:00 GMT-0500 (EST)", "Eastern Standard Time"); +}); + +// bug 879261 +inTimeZone("EST5EDT", () => { + let dt1 = new Date(1362891600000); + assertDateTime(dt1, "Sun Mar 10 2013 00:00:00 GMT-0500 (EST)", "Eastern Standard Time"); + + let dt2 = new Date(dt1.setHours(dt1.getHours() + 24)); + assertDateTime(dt2, "Mon Mar 11 2013 00:00:00 GMT-0400 (EDT)", "Eastern Daylight Time"); +}); +inTimeZone("PST8PDT", () => { + let dt1 = new Date(2014, Month.January, 1); + assertDateTime(dt1, "Wed Jan 01 2014 00:00:00 GMT-0800 (PST)", "Pacific Standard Time"); + + let dt2 = new Date(2014, Month.August, 1); + assertDateTime(dt2, "Fri Aug 01 2014 00:00:00 GMT-0700 (PDT)", "Pacific Daylight Time"); +}); +inTimeZone("EST5EDT", () => { + let dt1 = new Date(2016, Month.October, 14, 3, 5, 9); + assertDateTime(dt1, "Fri Oct 14 2016 03:05:09 GMT-0400 (EDT)", "Eastern Daylight Time"); + + let dt2 = new Date(2016, Month.January, 9, 23, 26, 40); + assertDateTime(dt2, "Sat Jan 09 2016 23:26:40 GMT-0500 (EST)", "Eastern Standard Time"); +}); + +// bug 1084547 +inTimeZone("EST5EDT", () => { + let dt = new Date(Date.parse("2014-11-02T02:00:00-04:00")); + assertDateTime(dt, "Sun Nov 02 2014 01:00:00 GMT-0500 (EST)", "Eastern Standard Time"); + + dt.setMilliseconds(0); + assertDateTime(dt, "Sun Nov 02 2014 01:00:00 GMT-0400 (EDT)", "Eastern Daylight Time"); +}); + +// bug 1303306 +inTimeZone("EST5EDT", () => { + let dt = new Date(2016, Month.September, 15, 16, 14, 48); + assertDateTime(dt, "Thu Sep 15 2016 16:14:48 GMT-0400 (EDT)", "Eastern Daylight Time"); +}); + +// bug 1317364 +inTimeZone("PST8PDT", () => { + let dt = new Date(2016, Month.March, 13, 2, 30, 0, 0); + assertDateTime(dt, "Sun Mar 13 2016 03:30:00 GMT-0700 (PDT)", "Pacific Daylight Time"); + + let dt2 = new Date(2016, Month.January, 5, 0, 30, 30, 500); + assertDateTime(dt2, "Tue Jan 05 2016 00:30:30 GMT-0800 (PST)", "Pacific Standard Time"); + + let dt3 = new Date(dt2.getTime()); + dt3.setMonth(dt2.getMonth() + 2); + dt3.setDate(dt2.getDate() + 7 + 1); + dt3.setHours(dt2.getHours() + 2); + + assertEq(dt3.getHours(), 3); +}); + +// bug 1355272 +inTimeZone("PST8PDT", () => { + let dt = new Date(2017, Month.April, 10, 17, 25, 07); + assertDateTime(dt, "Mon Apr 10 2017 17:25:07 GMT-0700 (PDT)", "Pacific Daylight Time"); +}); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/non262/Date/time-zones.js b/js/src/tests/non262/Date/time-zones.js new file mode 100644 index 0000000000..da2b328be7 --- /dev/null +++ b/js/src/tests/non262/Date/time-zones.js @@ -0,0 +1,261 @@ +// |reftest| skip-if(xulRuntime.OS=="WINNT") -- Windows doesn't accept IANA names for the TZ env variable + +// bug 158328 +inTimeZone("Europe/London", () => { + let dt1 = new Date(2002, Month.July, 19, 16, 10, 55); + assertDateTime(dt1, "Fri Jul 19 2002 16:10:55 GMT+0100 (BST)", "British Summer Time"); + + let dt2 = new Date(2009, Month.December, 24, 13, 44, 52); + assertDateTime(dt2, "Thu Dec 24 2009 13:44:52 GMT+0000 (GMT)", "Greenwich Mean Time"); +}); + +// bug 294908 +inTimeZone("America/New_York", () => { + let dt = new Date(2003, Month.April, 6, 2, 30, 00); + assertDateTime(dt, "Sun Apr 06 2003 03:30:00 GMT-0400 (EDT)", "Eastern Daylight Time"); +}); + +// bug 610183 +inTimeZone("America/Los_Angeles", () => { + let dt = new Date(2014, Month.November, 2, 1, 47, 42); + assertDateTime(dt, "Sun Nov 02 2014 01:47:42 GMT-0700 (PDT)", "Pacific Daylight Time"); +}); + +// bug 629465 +inTimeZone("America/Denver", () => { + let dt1 = new Date(Date.UTC(2015, Month.November, 1, 0, 0, 0) + 6 * msPerHour); + assertDateTime(dt1, "Sun Nov 01 2015 00:00:00 GMT-0600 (MDT)", "Mountain Daylight Time"); + + let dt2 = new Date(Date.UTC(2015, Month.November, 1, 1, 0, 0) + 6 * msPerHour); + assertDateTime(dt2, "Sun Nov 01 2015 01:00:00 GMT-0600 (MDT)", "Mountain Daylight Time"); + + let dt3 = new Date(Date.UTC(2015, Month.November, 1, 1, 0, 0) + 7 * msPerHour); + assertDateTime(dt3, "Sun Nov 01 2015 01:00:00 GMT-0700 (MST)", "Mountain Standard Time"); +}); + +// bug 637244 +inTimeZone("Europe/Helsinki", () => { + let dt1 = new Date(2016, Month.March, 27, 2, 59); + assertDateTime(dt1, "Sun Mar 27 2016 02:59:00 GMT+0200 (EET)", "Eastern European Standard Time"); + + let dt2 = new Date(2016, Month.March, 27, 3, 0); + assertDateTime(dt2, "Sun Mar 27 2016 04:00:00 GMT+0300 (EEST)", "Eastern European Summer Time"); +}); + +// bug 718175 +inTimeZone("Europe/London", () => { + let dt = new Date(0); + assertEq(dt.getHours(), 1); +}); + +// bug 719274 +inTimeZone("Pacific/Auckland", () => { + let dt = new Date(2012, Month.January, 19, 12, 54, 27); + assertDateTime(dt, "Thu Jan 19 2012 12:54:27 GMT+1300 (NZDT)", "New Zealand Daylight Time"); +}); + +// bug 742427 +inTimeZone("Europe/Paris", () => { + let dt1 = new Date(2009, Month.March, 29, 1, 0, 0); + assertDateTime(dt1, "Sun Mar 29 2009 01:00:00 GMT+0100 (CET)", "Central European Standard Time"); + dt1.setHours(dt1.getHours() + 1); + assertDateTime(dt1, "Sun Mar 29 2009 03:00:00 GMT+0200 (CEST)", "Central European Summer Time"); + + let dt2 = new Date(2010, Month.March, 29, 1, 0, 0); + assertDateTime(dt2, "Mon Mar 29 2010 01:00:00 GMT+0200 (CEST)", "Central European Summer Time"); + dt2.setHours(dt2.getHours() + 1); + assertDateTime(dt2, "Mon Mar 29 2010 02:00:00 GMT+0200 (CEST)", "Central European Summer Time"); +}); +inTimeZone("America/New_York", () => { + let dt = new Date(2009, Month.March, 8, 1, 0, 0); + assertDateTime(dt, "Sun Mar 08 2009 01:00:00 GMT-0500 (EST)", "Eastern Standard Time"); + dt.setHours(dt.getHours() + 1); + assertDateTime(dt, "Sun Mar 08 2009 03:00:00 GMT-0400 (EDT)", "Eastern Daylight Time"); +}); +inTimeZone("America/Denver", () => { + let dt = new Date(2009, Month.March, 8, 1, 0, 0); + assertDateTime(dt, "Sun Mar 08 2009 01:00:00 GMT-0700 (MST)", "Mountain Standard Time"); + dt.setHours(dt.getHours() + 1); + assertDateTime(dt, "Sun Mar 08 2009 03:00:00 GMT-0600 (MDT)", "Mountain Daylight Time"); +}); +inTimeZone("America/New_York", () => { + let dt1 = new Date(Date.UTC(2008, Month.March, 9, 0, 0, 0) + 5 * msPerHour); + assertDateTime(dt1, "Sun Mar 09 2008 00:00:00 GMT-0500 (EST)", "Eastern Standard Time"); + + let dt2 = new Date(Date.UTC(2008, Month.March, 9, 1, 0, 0) + 5 * msPerHour); + assertDateTime(dt2, "Sun Mar 09 2008 01:00:00 GMT-0500 (EST)", "Eastern Standard Time"); + + let dt3 = new Date(Date.UTC(2008, Month.March, 9, 4, 0, 0) + 4 * msPerHour); + assertDateTime(dt3, "Sun Mar 09 2008 04:00:00 GMT-0400 (EDT)", "Eastern Daylight Time"); +}); +inTimeZone("Europe/Paris", () => { + let dt1 = new Date(Date.UTC(2008, Month.March, 30, 0, 0, 0) - 1 * msPerHour); + assertDateTime(dt1, "Sun Mar 30 2008 00:00:00 GMT+0100 (CET)", "Central European Standard Time"); + + let dt2 = new Date(Date.UTC(2008, Month.March, 30, 1, 0, 0) - 1 * msPerHour); + assertDateTime(dt2, "Sun Mar 30 2008 01:00:00 GMT+0100 (CET)", "Central European Standard Time"); + + let dt3 = new Date(Date.UTC(2008, Month.March, 30, 3, 0, 0) - 2 * msPerHour); + assertDateTime(dt3, "Sun Mar 30 2008 03:00:00 GMT+0200 (CEST)", "Central European Summer Time"); + + let dt4 = new Date(Date.UTC(2008, Month.March, 30, 4, 0, 0) - 2 * msPerHour); + assertDateTime(dt4, "Sun Mar 30 2008 04:00:00 GMT+0200 (CEST)", "Central European Summer Time"); +}); + +// bug 802627 +inTimeZone("America/New_York", () => { + let dt = new Date(0); + assertDateTime(dt, "Wed Dec 31 1969 19:00:00 GMT-0500 (EST)", "Eastern Standard Time"); +}); + +// bug 819820 +inTimeZone("Europe/London", () => { + let dt1 = new Date(Date.UTC(2012, Month.October, 28, 0, 59, 59)); + assertDateTime(dt1, "Sun Oct 28 2012 01:59:59 GMT+0100 (BST)", "British Summer Time"); + + let dt2 = new Date(Date.UTC(2012, Month.October, 28, 1, 0, 0)); + assertDateTime(dt2, "Sun Oct 28 2012 01:00:00 GMT+0000 (GMT)", "Greenwich Mean Time"); + + let dt3 = new Date(Date.UTC(2012, Month.October, 28, 1, 59, 59)); + assertDateTime(dt3, "Sun Oct 28 2012 01:59:59 GMT+0000 (GMT)", "Greenwich Mean Time"); + + let dt4 = new Date(Date.UTC(2012, Month.October, 28, 2, 0, 0)); + assertDateTime(dt4, "Sun Oct 28 2012 02:00:00 GMT+0000 (GMT)", "Greenwich Mean Time"); +}); + +// bug 879261 +inTimeZone("America/New_York", () => { + let dt1 = new Date(1362891600000); + assertDateTime(dt1, "Sun Mar 10 2013 00:00:00 GMT-0500 (EST)", "Eastern Standard Time"); + + let dt2 = new Date(dt1.setHours(dt1.getHours() + 24)); + assertDateTime(dt2, "Mon Mar 11 2013 00:00:00 GMT-0400 (EDT)", "Eastern Daylight Time"); +}); +inTimeZone("America/Los_Angeles", () => { + let dt1 = new Date(2014, Month.January, 1); + assertDateTime(dt1, "Wed Jan 01 2014 00:00:00 GMT-0800 (PST)", "Pacific Standard Time"); + + let dt2 = new Date(2014, Month.August, 1); + assertDateTime(dt2, "Fri Aug 01 2014 00:00:00 GMT-0700 (PDT)", "Pacific Daylight Time"); +}); +inTimeZone("America/New_York", () => { + let dt1 = new Date(2016, Month.October, 14, 3, 5, 9); + assertDateTime(dt1, "Fri Oct 14 2016 03:05:09 GMT-0400 (EDT)", "Eastern Daylight Time"); + + let dt2 = new Date(2016, Month.January, 9, 23, 26, 40); + assertDateTime(dt2, "Sat Jan 09 2016 23:26:40 GMT-0500 (EST)", "Eastern Standard Time"); +}); + +// bug 994086 +inTimeZone("Europe/Vienna", () => { + let dt1 = new Date(2014, Month.March, 30, 2, 0); + assertDateTime(dt1, "Sun Mar 30 2014 03:00:00 GMT+0200 (CEST)", "Central European Summer Time"); + + let dt2 = new Date(2014, Month.March, 30, 3, 0); + assertDateTime(dt2, "Sun Mar 30 2014 03:00:00 GMT+0200 (CEST)", "Central European Summer Time"); + + let dt3 = new Date(2014, Month.March, 30, 4, 0); + assertDateTime(dt3, "Sun Mar 30 2014 04:00:00 GMT+0200 (CEST)", "Central European Summer Time"); +}); + +// bug 1084434 +inTimeZone("America/Sao_Paulo", () => { + let dt = new Date(2014, Month.October, 19); + assertEq(dt.getDate(), 19); + assertEq(dt.getHours(), 1); + assertDateTime(dt, "Sun Oct 19 2014 01:00:00 GMT-0200 (BRST)", "-02", "Brasilia Summer Time"); +}); + +// bug 1084547 +inTimeZone("America/New_York", () => { + let dt = new Date(Date.parse("2014-11-02T02:00:00-04:00")); + assertDateTime(dt, "Sun Nov 02 2014 01:00:00 GMT-0500 (EST)", "Eastern Standard Time"); + + dt.setMilliseconds(0); + assertDateTime(dt, "Sun Nov 02 2014 01:00:00 GMT-0400 (EDT)", "Eastern Daylight Time"); +}); + +// bug 1118690 +inTimeZone("Europe/London", () => { + let dt = new Date(1965, Month.January, 1); + assertEq(dt.getFullYear(), 1965); +}); + +// bug 1155096 +inTimeZone("Europe/Moscow", () => { + let dt1 = new Date(1981, Month.March, 32); + assertEq(dt1.getDate(), 1); + + let dt2 = new Date(1982, Month.March, 32); + assertEq(dt2.getDate(), 1); + + let dt3 = new Date(1983, Month.March, 32); + assertEq(dt3.getDate(), 1); + + let dt4 = new Date(1984, Month.March, 32); + assertEq(dt4.getDate(), 1); +}); + +// bug 1284507 +inTimeZone("Atlantic/Azores", () => { + let dt1 = new Date(2017, Month.March, 25, 0, 0, 0); + assertDateTime(dt1, "Sat Mar 25 2017 00:00:00 GMT-0100 (AZOT)", "-01", "Azores Standard Time"); + + let dt2 = new Date(2016, Month.October, 30, 0, 0, 0); + assertDateTime(dt2, "Sun Oct 30 2016 00:00:00 GMT+0000 (AZOST)", "+00", "Azores Summer Time"); + + let dt3 = new Date(2016, Month.October, 30, 23, 0, 0); + assertDateTime(dt3, "Sun Oct 30 2016 23:00:00 GMT-0100 (AZOT)", "-01", "Azores Standard Time"); +}); + +// bug 1303306 +inTimeZone("America/New_York", () => { + let dt = new Date(2016, Month.September, 15, 16, 14, 48); + assertDateTime(dt, "Thu Sep 15 2016 16:14:48 GMT-0400 (EDT)", "Eastern Daylight Time"); +}); + +// bug 1317364 +inTimeZone("America/Los_Angeles", () => { + let dt = new Date(2016, Month.March, 13, 2, 30, 0, 0); + assertDateTime(dt, "Sun Mar 13 2016 03:30:00 GMT-0700 (PDT)", "Pacific Daylight Time"); + + let dt2 = new Date(2016, Month.January, 5, 0, 30, 30, 500); + assertDateTime(dt2, "Tue Jan 05 2016 00:30:30 GMT-0800 (PST)", "Pacific Standard Time"); + + let dt3 = new Date(dt2.getTime()); + dt3.setMonth(dt2.getMonth() + 2); + dt3.setDate(dt2.getDate() + 7 + 1); + dt3.setHours(dt2.getHours() + 2); + + assertEq(dt3.getHours(), 3); +}); + +// bug 1335818 +inTimeZone("Asia/Jerusalem", () => { + let dt1 = new Date(2013, Month.March, 22, 1, 0, 0, 0); + assertDateTime(dt1, "Fri Mar 22 2013 01:00:00 GMT+0200 (IST)", "Israel Standard Time"); + + let dt2 = new Date(2013, Month.March, 22, 2, 0, 0, 0); + assertDateTime(dt2, "Fri Mar 22 2013 02:00:00 GMT+0200 (IST)", "Israel Standard Time"); + + let dt3 = new Date(2013, Month.March, 22, 3, 0, 0, 0); + assertDateTime(dt3, "Fri Mar 22 2013 03:00:00 GMT+0200 (IST)", "Israel Standard Time"); + + let dt4 = new Date(2013, Month.March, 29, 1, 0, 0, 0); + assertDateTime(dt4, "Fri Mar 29 2013 01:00:00 GMT+0200 (IST)", "Israel Standard Time"); + + let dt5 = new Date(2013, Month.March, 29, 2, 0, 0, 0); + assertDateTime(dt5, "Fri Mar 29 2013 03:00:00 GMT+0300 (IDT)", "Israel Daylight Time"); + + let dt6 = new Date(2013, Month.March, 29, 3, 0, 0, 0); + assertDateTime(dt6, "Fri Mar 29 2013 03:00:00 GMT+0300 (IDT)", "Israel Daylight Time"); +}); + +// bug 1355272 +inTimeZone("America/Los_Angeles", () => { + let dt = new Date(2017, Month.April, 10, 17, 25, 07); + assertDateTime(dt, "Mon Apr 10 2017 17:25:07 GMT-0700 (PDT)", "Pacific Daylight Time"); +}); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/non262/Date/timeclip.js b/js/src/tests/non262/Date/timeclip.js new file mode 100644 index 0000000000..50bde39e77 --- /dev/null +++ b/js/src/tests/non262/Date/timeclip.js @@ -0,0 +1,42 @@ +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommonn.org/licenses/publicdomain/ + */ + +var BUGNUMBER = 747197; +var summary = "TimeClip behavior for very large numbers"; + +print(BUGNUMBER + ": " + summary); + +/************** + * BEGIN TEST * + **************/ + +function addToLimit(n) { return 8.64e15 + n; } + +assertEq(8.64e15 === addToLimit(0.0), true); +assertEq(8.64e15 === addToLimit(0.5), true); +assertEq(8.64e15 === addToLimit(0.5000000000000001), false); + +var times = + [Number.MAX_VALUE, + -Number.MAX_VALUE, + Infinity, + -Infinity, + addToLimit(0.5000000000000001), + -addToLimit(0.5000000000000001)]; + +for (var i = 0, len = times.length; i < len; i++) +{ + var d = new Date(); + assertEq(d.setTime(times[i]), NaN, "times[" + i + "]"); + assertEq(d.getTime(), NaN); + assertEq(d.valueOf(), NaN); +} + +/******************************************************************************/ + +if (typeof reportCompare === "function") + reportCompare(true, true); + +print("Tests complete"); diff --git a/js/src/tests/non262/Date/toISOString-01.js b/js/src/tests/non262/Date/toISOString-01.js new file mode 100644 index 0000000000..cc300a6604 --- /dev/null +++ b/js/src/tests/non262/Date/toISOString-01.js @@ -0,0 +1,53 @@ +/* Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/publicdomain/zero/1.0/ */ + +//----------------------------------------------------------------------------- +var BUGNUMBER = 730831; +var summary = 'Date.prototype.toISOString returns an invalid ISO-8601 string'; + +print(BUGNUMBER + ": " + summary); + +function iso(t) { + return new Date(t).toISOString(); +} + +function utc(year, month, day, hour, minute, second, millis) { + var date = new Date(0); + date.setUTCFullYear(year, month - 1, day); + date.setUTCHours(hour, minute, second, millis); + return date.getTime(); +} + + +// Values around maximum date for simple iso format. +var maxDateSimple = utc(9999, 12, 31, 23, 59, 59, 999); +assertEq(iso(maxDateSimple - 1), "9999-12-31T23:59:59.998Z"); +assertEq(iso(maxDateSimple ), "9999-12-31T23:59:59.999Z"); +assertEq(iso(maxDateSimple + 1), "+010000-01-01T00:00:00.000Z"); + + +// Values around minimum date for simple iso format. +var minDateSimple = utc(0, 1, 1, 0, 0, 0, 0); +assertEq(iso(minDateSimple - 1), "-000001-12-31T23:59:59.999Z"); +assertEq(iso(minDateSimple ), "0000-01-01T00:00:00.000Z"); +assertEq(iso(minDateSimple + 1), "0000-01-01T00:00:00.001Z"); + + +// Values around maximum date for extended iso format. +var maxDateExtended = utc(+275760, 9, 13, 0, 0, 0, 0); +assertEq(maxDateExtended, +8.64e15); +assertEq(iso(maxDateExtended - 1), "+275760-09-12T23:59:59.999Z"); +assertEq(iso(maxDateExtended ), "+275760-09-13T00:00:00.000Z"); +assertThrowsInstanceOf(() => iso(maxDateExtended + 1), RangeError); + + +// Values around minimum date for extended iso format. +var minDateExtended = utc(-271821, 4, 20, 0, 0, 0, 0); +assertEq(minDateExtended, -8.64e15); +assertThrowsInstanceOf(() => iso(minDateExtended - 1), RangeError); +assertEq(iso(minDateExtended ), "-271821-04-20T00:00:00.000Z"); +assertEq(iso(minDateExtended + 1), "-271821-04-20T00:00:00.001Z"); + + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/non262/Date/toISOString.js b/js/src/tests/non262/Date/toISOString.js new file mode 100644 index 0000000000..9eb4129345 --- /dev/null +++ b/js/src/tests/non262/Date/toISOString.js @@ -0,0 +1,24 @@ +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommons.org/licenses/publicdomain/ + */ + +function throwsRangeError(t) { + try { + var date = new Date(); + date.setTime(t); + var r = date.toISOString(); + throw new Error("toISOString didn't throw, instead returned " + r); + } catch (err) { + assertEq(err instanceof RangeError, true, 'wrong error: ' + err); + return; + } + assertEq(0, 1, 'not good, nyan, nyan'); +} + +throwsRangeError(Infinity); +throwsRangeError(-Infinity); +throwsRangeError(NaN); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/non262/Date/toJSON-01.js b/js/src/tests/non262/Date/toJSON-01.js new file mode 100644 index 0000000000..4a756aab54 --- /dev/null +++ b/js/src/tests/non262/Date/toJSON-01.js @@ -0,0 +1,238 @@ +// Any copyright is dedicated to the Public Domain. +// http://creativecommons.org/licenses/publicdomain/ + +var gTestfile = 'toJSON-01.js'; +//----------------------------------------------------------------------------- +var BUGNUMBER = 584811; +var summary = "Date.prototype.toJSON isn't to spec"; + +print(BUGNUMBER + ": " + summary); + +/************** + * BEGIN TEST * + **************/ + +var called; + +var dateToJSON = Date.prototype.toJSON; +assertEq(Date.prototype.hasOwnProperty("toJSON"), true); +assertEq(typeof dateToJSON, "function"); + +// brief test to exercise this outside of isolation, just for sanity +var invalidDate = new Date(); +invalidDate.setTime(NaN); +assertEq(JSON.stringify({ p: invalidDate }), '{"p":null}'); + + +/* 15.9.5.44 Date.prototype.toJSON ( key ) */ +assertEq(dateToJSON.length, 1); + +/* + * 1. Let O be the result of calling ToObject, giving it the this value as its + * argument. + */ +try +{ + dateToJSON.call(null); + throw new Error("should have thrown a TypeError"); +} +catch (e) +{ + assertEq(e instanceof TypeError, true, + "ToObject throws TypeError for null/undefined"); +} + +try +{ + dateToJSON.call(undefined); + throw new Error("should have thrown a TypeError"); +} +catch (e) +{ + assertEq(e instanceof TypeError, true, + "ToObject throws TypeError for null/undefined"); +} + + +/* + * 2. Let tv be ToPrimitive(O, hint Number). + * ...expands to: + * 1. Let valueOf be the result of calling the [[Get]] internal method of object O with argument "valueOf". + * 2. If IsCallable(valueOf) is true then, + * a. Let val be the result of calling the [[Call]] internal method of valueOf, with O as the this value and + * an empty argument list. + * b. If val is a primitive value, return val. + * 3. Let toString be the result of calling the [[Get]] internal method of object O with argument "toString". + * 4. If IsCallable(toString) is true then, + * a. Let str be the result of calling the [[Call]] internal method of toString, with O as the this value and + * an empty argument list. + * b. If str is a primitive value, return str. + * 5. Throw a TypeError exception. + */ +try +{ + var r = dateToJSON.call({ get valueOf() { throw 17; } }); + throw new Error("didn't throw, returned: " + r); +} +catch (e) +{ + assertEq(e, 17, "bad exception: " + e); +} + +called = false; +assertEq(dateToJSON.call({ valueOf: null, + toString: function() { called = true; return 12; }, + toISOString: function() { return "ohai"; } }), + "ohai"); +assertEq(called, true); + +called = false; +assertEq(dateToJSON.call({ valueOf: function() { called = true; return 42; }, + toISOString: function() { return null; } }), + null); +assertEq(called, true); + +try +{ + called = false; + dateToJSON.call({ valueOf: function() { called = true; return {}; }, + get toString() { throw 42; } }); +} +catch (e) +{ + assertEq(called, true); + assertEq(e, 42, "bad exception: " + e); +} + +called = false; +assertEq(dateToJSON.call({ valueOf: function() { called = true; return {}; }, + get toString() { return function() { return 8675309; }; }, + toISOString: function() { return true; } }), + true); +assertEq(called, true); + +var asserted = false; +called = false; +assertEq(dateToJSON.call({ valueOf: function() { called = true; return {}; }, + get toString() + { + assertEq(called, true); + asserted = true; + return function() { return 8675309; }; + }, + toISOString: function() { return NaN; } }), + NaN); +assertEq(asserted, true); + +try +{ + var r = dateToJSON.call({ valueOf: null, toString: null, + get toISOString() + { + throw new Error("shouldn't have been gotten"); + } }); + throw new Error("didn't throw, returned: " + r); +} +catch (e) +{ + assertEq(e instanceof TypeError, true, "bad exception: " + e); +} + + +/* 3. If tv is a Number and is not finite, return null. */ +assertEq(dateToJSON.call({ valueOf: function() { return Infinity; } }), null); +assertEq(dateToJSON.call({ valueOf: function() { return -Infinity; } }), null); +assertEq(dateToJSON.call({ valueOf: function() { return NaN; } }), null); + +assertEq(dateToJSON.call({ valueOf: function() { return Infinity; }, + toISOString: function() { return {}; } }), null); +assertEq(dateToJSON.call({ valueOf: function() { return -Infinity; }, + toISOString: function() { return []; } }), null); +assertEq(dateToJSON.call({ valueOf: function() { return NaN; }, + toISOString: function() { return undefined; } }), null); + + +/* + * 4. Let toISO be the result of calling the [[Get]] internal method of O with + * argument "toISOString". + */ +try +{ + var r = dateToJSON.call({ get toISOString() { throw 42; } }); + throw new Error("didn't throw, returned: " + r); +} +catch (e) +{ + assertEq(e, 42, "bad exception: " + e); +} + + +/* 5. If IsCallable(toISO) is false, throw a TypeError exception. */ +try +{ + var r = dateToJSON.call({ toISOString: null }); + throw new Error("didn't throw, returned: " + r); +} +catch (e) +{ + assertEq(e instanceof TypeError, true, "bad exception: " + e); +} + +try +{ + var r = dateToJSON.call({ toISOString: undefined }); + throw new Error("didn't throw, returned: " + r); +} +catch (e) +{ + assertEq(e instanceof TypeError, true, "bad exception: " + e); +} + +try +{ + var r = dateToJSON.call({ toISOString: "oogabooga" }); + throw new Error("didn't throw, returned: " + r); +} +catch (e) +{ + assertEq(e instanceof TypeError, true, "bad exception: " + e); +} + +try +{ + var r = dateToJSON.call({ toISOString: Math.PI }); + throw new Error("didn't throw, returned: " + r); +} +catch (e) +{ + assertEq(e instanceof TypeError, true, "bad exception: " + e); +} + + +/* + * 6. Return the result of calling the [[Call]] internal method of toISO with O + * as the this value and an empty argument list. + */ +var o = + { + toISOString: function(a) + { + called = true; + assertEq(this, o); + assertEq(a, undefined); + assertEq(arguments.length, 0); + return obj; + } + }; +var obj = {}; +called = false; +assertEq(dateToJSON.call(o), obj, "should have gotten obj back"); +assertEq(called, true); + + +/******************************************************************************/ + +if (typeof reportCompare === "function") + reportCompare(true, true); + +print("All tests passed!"); diff --git a/js/src/tests/non262/Date/toPrimitive.js b/js/src/tests/non262/Date/toPrimitive.js new file mode 100644 index 0000000000..11346b1ae8 --- /dev/null +++ b/js/src/tests/non262/Date/toPrimitive.js @@ -0,0 +1,62 @@ +// ES6 20.3.4.45 Date.prototype[@@toPrimitive](hint) + +// The toPrimitive method throws if the this value isn't an object. +var toPrimitive = Date.prototype[Symbol.toPrimitive]; +assertThrowsInstanceOf(() => toPrimitive.call(undefined, "default"), TypeError); +assertThrowsInstanceOf(() => toPrimitive.call(3, "default"), TypeError); + +// It doesn't have to be a Date object, though. +var obj = { + toString() { return "str"; }, + valueOf() { return "val"; } +}; +assertEq(toPrimitive.call(obj, "number"), "val"); +assertEq(toPrimitive.call(obj, "string"), "str"); +assertEq(toPrimitive.call(obj, "default"), "str"); + +// It throws if the hint argument is missing or not one of the three allowed values. +assertThrowsInstanceOf(() => toPrimitive.call(obj), TypeError); +assertThrowsInstanceOf(() => toPrimitive.call(obj, undefined), TypeError); +assertThrowsInstanceOf(() => toPrimitive.call(obj, "boolean"), TypeError); +assertThrowsInstanceOf(() => toPrimitive.call(obj, ["number"]), TypeError); +assertThrowsInstanceOf(() => toPrimitive.call(obj, {toString() { throw "FAIL"; }}), TypeError); + +// The next few tests cover the OrdinaryToPrimitive algorithm, specified in +// ES6 7.1.1 ToPrimitive(input [, PreferredType]). + +// Date.prototype.toString or .valueOf can be overridden. +var dateobj = new Date(); +Date.prototype.toString = function () { + assertEq(this, dateobj); + return 14; +}; +Date.prototype.valueOf = function () { + return "92"; +}; +assertEq(dateobj[Symbol.toPrimitive]("number"), "92"); +assertEq(dateobj[Symbol.toPrimitive]("string"), 14); +assertEq(dateobj[Symbol.toPrimitive]("default"), 14); +assertEq(dateobj == 14, true); // equality comparison: passes "default" + +// If this.toString is a non-callable value, this.valueOf is called instead. +Date.prototype.toString = {}; +assertEq(dateobj[Symbol.toPrimitive]("string"), "92"); +assertEq(dateobj[Symbol.toPrimitive]("default"), "92"); + +// And vice versa. +Date.prototype.toString = function () { return 15; }; +Date.prototype.valueOf = "ponies"; +assertEq(dateobj[Symbol.toPrimitive]("number"), 15); + +// If neither is callable, it throws a TypeError. +Date.prototype.toString = "ponies"; +assertThrowsInstanceOf(() => dateobj[Symbol.toPrimitive]("default"), TypeError); + +// Surface features. +assertEq(toPrimitive.name, "[Symbol.toPrimitive]"); +var desc = Object.getOwnPropertyDescriptor(Date.prototype, Symbol.toPrimitive); +assertEq(desc.configurable, true); +assertEq(desc.enumerable, false); +assertEq(desc.writable, false); + +reportCompare(0, 0); diff --git a/js/src/tests/non262/Date/toString-generic.js b/js/src/tests/non262/Date/toString-generic.js new file mode 100644 index 0000000000..1e1c1fee93 --- /dev/null +++ b/js/src/tests/non262/Date/toString-generic.js @@ -0,0 +1,15 @@ +var BUGNUMBER = 861219; +var summary = 'Date.prototype.toString is a generic function'; + +// Revised in ECMA 2018, Date.prototype.toString is no longer generic (bug 1381433). + +print(BUGNUMBER + ": " + summary); + +for (var thisValue of [{}, [], /foo/, Date.prototype, new Proxy(new Date(), {})]) + assertThrowsInstanceOf(() => Date.prototype.toString.call(thisValue), TypeError); + +for (var prim of [null, undefined, 0, 1.2, true, false, "foo", Symbol.iterator]) + assertThrowsInstanceOf(() => Date.prototype.toString.call(prim), TypeError); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/non262/Date/toString-localized-posix.js b/js/src/tests/non262/Date/toString-localized-posix.js new file mode 100644 index 0000000000..b2314f60a5 --- /dev/null +++ b/js/src/tests/non262/Date/toString-localized-posix.js @@ -0,0 +1,71 @@ +// |reftest| skip-if(!this.hasOwnProperty("Intl")) -- Requires ICU time zone support + +// Date.prototype.toString includes a localized time zone name comment. + +// Repeats the test from "toString-localized.js", but uses POSIX instead of IANA +// names for the time zones. This allows to run these tests on Windows, too. + +inTimeZone("PST8PDT", () => { + let dt = new Date(2018, Month.July, 14); + + withLocale("en", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT-0700 (Pacific Daylight Time)"); + }); + withLocale("fr", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT-0700 (heure d’été du Pacifique nord-américain)"); + }); + withLocale("de", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT-0700 (Nordamerikanische Westküsten-Sommerzeit)"); + }); + withLocale("ar", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT-0700 (توقيت المحيط الهادي الصيفي)"); + }); + withLocale("zh", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT-0700 (北美太平洋夏令时间)"); + }); +}); + +for (let tz of ["UTC", "UCT"]) { + inTimeZone(tz, () => { + let dt = new Date(2018, Month.July, 14); + + withLocale("en", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT+0000 (Coordinated Universal Time)"); + }); + withLocale("fr", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT+0000 (temps universel coordonné)"); + }); + withLocale("de", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT+0000 (Koordinierte Weltzeit)"); + }); + withLocale("ar", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT+0000 (التوقيت العالمي المنسق)"); + }); + withLocale("zh", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT+0000 (协调世界时)"); + }); + }); +} + +inTimeZone("GMT", () => { + let dt = new Date(2018, Month.July, 14); + + withLocale("en", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT+0000 (Greenwich Mean Time)"); + }); + withLocale("fr", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT+0000 (heure moyenne de Greenwich)"); + }); + withLocale("de", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT+0000 (Mittlere Greenwich-Zeit)"); + }); + withLocale("ar", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT+0000 (توقيت غرينتش)"); + }); + withLocale("zh", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT+0000 (格林尼治标准时间)"); + }); +}); + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/non262/Date/toString-localized.js b/js/src/tests/non262/Date/toString-localized.js new file mode 100644 index 0000000000..6baa535e5e --- /dev/null +++ b/js/src/tests/non262/Date/toString-localized.js @@ -0,0 +1,90 @@ +// |reftest| skip-if(xulRuntime.OS=="WINNT"||!this.hasOwnProperty("Intl")) -- Windows doesn't accept IANA names for the TZ env variable; Requires ICU time zone support + +// Date.prototype.toString includes a localized time zone name comment. + +inTimeZone("Europe/Paris", () => { + let dt = new Date(2018, Month.July, 14); + + withLocale("en", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT+0200 (Central European Summer Time)"); + }); + withLocale("fr", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT+0200 (heure d’été d’Europe centrale)"); + }); + withLocale("de", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT+0200 (Mitteleuropäische Sommerzeit)"); + }); + withLocale("ar", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT+0200 (توقيت وسط أوروبا الصيفي)"); + }); + withLocale("zh", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT+0200 (中欧夏令时间)"); + }); +}); + +inTimeZone("America/Los_Angeles", () => { + let dt = new Date(2018, Month.July, 14); + + withLocale("en", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT-0700 (Pacific Daylight Time)"); + }); + withLocale("fr", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT-0700 (heure d’été du Pacifique nord-américain)"); + }); + withLocale("de", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT-0700 (Nordamerikanische Westküsten-Sommerzeit)"); + }); + withLocale("ar", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT-0700 (توقيت المحيط الهادي الصيفي)"); + }); + withLocale("zh", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT-0700 (北美太平洋夏令时间)"); + }); +}); + +for (let tz of ["UTC", "UCT", "Zulu", "Universal", "Etc/UTC", "Etc/UCT", "Etc/Zulu", "Etc/Universal"]) { + inTimeZone(tz, () => { + let dt = new Date(2018, Month.July, 14); + + withLocale("en", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT+0000 (Coordinated Universal Time)"); + }); + withLocale("fr", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT+0000 (temps universel coordonné)"); + }); + withLocale("de", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT+0000 (Koordinierte Weltzeit)"); + }); + withLocale("ar", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT+0000 (التوقيت العالمي المنسق)"); + }); + withLocale("zh", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT+0000 (协调世界时)"); + }); + }); +} + +for (let tz of ["GMT", "Etc/GMT"]) { + inTimeZone(tz, () => { + let dt = new Date(2018, Month.July, 14); + + withLocale("en", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT+0000 (Greenwich Mean Time)"); + }); + withLocale("fr", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT+0000 (heure moyenne de Greenwich)"); + }); + withLocale("de", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT+0000 (Mittlere Greenwich-Zeit)"); + }); + withLocale("ar", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT+0000 (توقيت غرينتش)"); + }); + withLocale("zh", () => { + assertDateTime(dt, "Sat Jul 14 2018 00:00:00 GMT+0000 (格林尼治标准时间)"); + }); + }); +} + +if (typeof reportCompare === "function") + reportCompare(true, true); diff --git a/js/src/tests/non262/Date/two-digit-years.js b/js/src/tests/non262/Date/two-digit-years.js new file mode 100644 index 0000000000..80cbc2ecef --- /dev/null +++ b/js/src/tests/non262/Date/two-digit-years.js @@ -0,0 +1,71 @@ +/* + * Any copyright is dedicated to the Public Domain. + * http://creativecommonn.org/licenses/publicdomain/ + */ + +/* + * For the sake of cross compatibility with other implementations we + * implement date parsing heuristics which support single and double + * digit years. See bug: 1265136 + */ + +/************** + * BEGIN TEST * + **************/ + +for (let year of Array(100).keys()) { + for (let month of Array(12).keys()) { + for (let day of Array(31).keys()) { + let fullYear = year >= 50 ? year + 1900 : year + 2000; + let fullDate = new Date(`${month + 1}/${day + 1}/${fullYear}`); + + // mm/dd/yy + let d1 = new Date(`${month + 1}/${day + 1}/${year}`); + assertEq(d1.getTime(), fullDate.getTime()) + + // yy/mm/dd + let d2 = new Date(`${year}/${month + 1}/${day + 1}`); + if (year > 31) { + assertEq(d2.getTime(), fullDate.getTime()) + } else if (year > 12) { + assertEq(d2.getTime(), new Date(NaN).getTime()) + } + } + } +} + +assertEq(new Date("99/1/99").getTime(), new Date(NaN).getTime()); +assertEq(new Date("13/13/13").getTime(), new Date(NaN).getTime()); +assertEq(new Date("0/10/0").getTime(), new Date(NaN).getTime()); + +// Written months. +for (let year of Array(1000).keys()) { + let fullDate = new Date(`5/1/${year}`); + let d1 = new Date(`may 1 ${year}`); + let d2 = new Date(`1 may ${year}`); + let d3 = new Date(`1 ${year} may`); + + assertEq(d1.getTime(), fullDate.getTime()) + assertEq(d2.getTime(), fullDate.getTime()) + assertEq(d3.getTime(), fullDate.getTime()) + + if (year > 31) { + let d4 = new Date(`may ${year} 1`); + let d5 = new Date(`${year} may 1`); + let d6 = new Date(`${year} 1 may`); + + assertEq(d4.getTime(), fullDate.getTime()) + assertEq(d5.getTime(), fullDate.getTime()) + assertEq(d6.getTime(), fullDate.getTime()) + } +} + +assertEq(new Date("may 1999 1999").getTime(), new Date(NaN).getTime()); +assertEq(new Date("may 0 0").getTime(), new Date(NaN).getTime()); + +/******************************************************************************/ + +if (typeof reportCompare === "function") + reportCompare(true, true); + +print("Tests complete"); |