time-zones-historic.js

// |reftest| skip-if(winWidget||!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);

Source code

Revision control

Copy as Markdown

Other Tools