Upload Kmake

deps/v8/test/intl/date-format/UnwrapDateTimeFormatUseOrdinaryHasInstance.js

@@ -0,0 +1,15 @@
+// Copyright 2020 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Verify ECMA402 PR 500 Use OrdinaryHasInstance in normative optional steps
+// https://github.com/tc39/ecma402/pull/500
+
+Object.defineProperty(Intl.DateTimeFormat, Symbol.hasInstance, {
+    get() { throw new Error("Intl.DateTimeFormat[@@hasInstance] lookup"); }
+});
+
+var dtf;
+assertDoesNotThrow(() => dtf = new Intl.DateTimeFormat());
+assertDoesNotThrow(() => dtf.format(new Date()));
+assertDoesNotThrow(() => dtf.resolvedOptions());

deps/v8/test/intl/date-format/calendar-with-multiple-type-subtags.js

@@ -0,0 +1,39 @@
+// Copyright 2016 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+var options = Intl.DateTimeFormat("ar-u-ca-islamic-civil").resolvedOptions();
+assertEquals(options.calendar, "islamic-civil");
+
+options = Intl.DateTimeFormat("ar-u-ca-islamic-umalqura").resolvedOptions();
+assertEquals(options.calendar, "islamic-umalqura");
+
+var options = Intl.DateTimeFormat("ar-u-ca-islamic-civil").resolvedOptions();
+assertEquals(options.calendar, "islamic-civil");
+
+options =
+    Intl.DateTimeFormat("ar-u-ca-islamic-civil-nu-arab").resolvedOptions();
+assertEquals(options.calendar, "islamic-civil");
+assertEquals(options.numberingSystem, "arab");
+
+// The default numberingSystem is 'arab' for 'ar' locale. Set it to 'latn'
+// to check that 'nu-latn' keyword is parsed correctly.
+options =
+    Intl.DateTimeFormat("ar-u-ca-islamic-civil-nu-latn").resolvedOptions();
+assertEquals(options.calendar, "islamic-civil");
+assertEquals(options.numberingSystem, "latn");
+
+// ethioaa is the canonical LDML/BCP 47 name.
+options = Intl.DateTimeFormat("am-u-ca-ethiopic-amete-alem").resolvedOptions();
+assertEquals(options.calendar, "ethioaa");
+
+// Invalid calendar type "foo-bar". Fall back to the default.
+options = Intl.DateTimeFormat("ar-u-ca-foo-bar").resolvedOptions();
+assertEquals(options.calendar, "gregory");
+
+// No type subtag for ca. Fall back to the default.
+options = Intl.DateTimeFormat("ar-u-ca-nu-arab").resolvedOptions();
+assertEquals(options.calendar, "gregory");
+
+// Too long a type subtag for ca.
+assertThrows(() => Intl.DateTimeFormat("ar-u-ca-foobarbaz"), RangeError);

deps/v8/test/intl/date-format/check-ca-option.js

@@ -0,0 +1,51 @@
+// Copyright 2018 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+
+let invalid_ca = [
+  "invalid",
+  "abce",
+];
+
+// https://www.unicode.org/repos/cldr/tags/latest/common/bcp47/calendar.xml
+let valid_ca= [
+  "buddhist",
+  "chinese",
+  "coptic",
+  "dangi",
+  "ethioaa",
+  "ethiopic",
+  "gregory",
+  "hebrew",
+  "indian",
+  "islamic",
+  "islamic-umalqura",
+  "islamic-tbla",
+  "islamic-civil",
+  "islamic-rgsa",
+  "iso8601",
+  "japanese",
+  "persian",
+  "roc",
+];
+
+let locales = [
+  "en",
+  "ar",
+];
+
+invalid_ca.forEach(function(ca) {
+  let df = new Intl.DateTimeFormat(["en-u-ca-" + ca + "-fo-obar"]);
+  assertEquals("en", df.resolvedOptions().locale);
+}
+);
+
+valid_ca.forEach(function(ca) {
+  locales.forEach(function(base) {
+    let l = base + "-u-ca-" + ca;
+    let df = new Intl.DateTimeFormat([l + "-fo-obar"]);
+    assertEquals(l, df.resolvedOptions().locale);
+  });
+}
+);

deps/v8/test/intl/date-format/check-calendar.js

@@ -0,0 +1,76 @@
+// Copyright 2019 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+let invalidCalendar = [
+  "invalid",
+  "abce",
+  "abc-defghi",
+];
+
+let illFormedCalendar = [
+  "",
+  "i",
+  "ij",
+  "abcdefghi",
+  "abc-ab",
+];
+
+// https://www.unicode.org/repos/cldr/tags/latest/common/bcp47/calendar.xml
+let validCalendar= [
+  "buddhist",
+  "chinese",
+  "coptic",
+  "dangi",
+  "ethioaa",
+  "ethiopic",
+  "gregory",
+  "hebrew",
+  "indian",
+  "islamic",
+  "islamic-umalqura",
+  "islamic-tbla",
+  "islamic-civil",
+  "islamic-rgsa",
+  "iso8601",
+  "japanese",
+  "persian",
+  "roc",
+];
+
+let locales = [
+  "en",
+  "ar",
+];
+
+invalidCalendar.forEach(function(calendar) {
+  locales.forEach(function(base) {
+     var df;
+     assertDoesNotThrow(() => df = new Intl.DateTimeFormat([base], {calendar}));
+     assertEquals(
+         (new Intl.DateTimeFormat([base])).resolvedOptions().calendar,
+         df.resolvedOptions().calendar);
+  });
+});
+
+illFormedCalendar.forEach(function(calendar) {
+  assertThrows(
+      () => new Intl.DateTimeFormat(["en"], {calendar}),
+      RangeError);
+}
+);
+
+let value = new Date();
+validCalendar.forEach(function(calendar) {
+  locales.forEach(function(base) {
+    let l = base + "-u-ca-" + calendar;
+    let dtf = new Intl.DateTimeFormat([base], {calendar});
+    assertEquals(base, dtf.resolvedOptions().locale);
+
+    // Test the formatting result is the same as passing in via u-ca-
+    // in the locale.
+    let dtf2 = new Intl.DateTimeFormat([l]);
+    assertEquals(dtf2.format(value), dtf.format(value));
+  });
+}
+);

deps/v8/test/intl/date-format/check-hc-option.js

@@ -0,0 +1,43 @@
+// Copyright 2018 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+
+let invalid_hc = [
+  "invalid",
+  "abce",
+  "h10",
+  "h13",
+  "h22",
+  "h25",
+];
+
+// https://www.unicode.org/repos/cldr/tags/latest/common/bcp47/calendar.xml
+let valid_hc= [
+  "h11",
+  "h12",
+  "h23",
+  "h24",
+];
+
+let locales = [
+  "en",
+  "ar",
+];
+
+invalid_hc.forEach(function(hc) {
+  let df = new Intl.DateTimeFormat(
+      ["en-u-hc-" + hc + "-fo-obar"], {hour: "2-digit"});
+  assertEquals("en", df.resolvedOptions().locale);
+}
+);
+
+valid_hc.forEach(function(hc) {
+  locales.forEach(function(base) {
+    let l = base + "-u-hc-" + hc;
+    let df = new Intl.DateTimeFormat(
+        [l + "-fo-obar"], {hour: "2-digit"});
+    assertEquals(l, df.resolvedOptions().locale);
+  });
+}
+);

deps/v8/test/intl/date-format/check-nu-option.js

@@ -0,0 +1,59 @@
+// Copyright 2018 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+
+let invalid_nu = [
+  "invalid",
+  "abce",
+  "finance",
+  "native",
+  "traditio",
+];
+
+// https://tc39.github.io/ecma402/#table-numbering-system-digits
+let valid_nu= [
+  "arab",
+  "arabext",
+  "bali",
+  "beng",
+  "deva",
+  "fullwide",
+  "gujr",
+  "guru",
+  "hanidec",
+  "khmr",
+  "knda",
+  "laoo",
+  "latn",
+  "limb",
+  "mlym",
+  "mong",
+  "mymr",
+  "orya",
+  "tamldec",
+  "telu",
+  "thai",
+  "tibt",
+];
+
+let locales = [
+  "en",
+  "ar",
+];
+
+
+invalid_nu.forEach(function(nu) {
+  let df = new Intl.DateTimeFormat(["en-u-nu-" + nu + "-fo-obar"]);
+  assertEquals("en", df.resolvedOptions().locale);
+}
+);
+
+valid_nu.forEach(function(nu) {
+  locales.forEach(function(base) {
+    let l = base + "-u-nu-" + nu;
+    let df = new Intl.DateTimeFormat([l + "-fo-obar"]);
+    assertEquals(l, df.resolvedOptions().locale);
+  });
+}
+);

deps/v8/test/intl/date-format/check-numbering-system.js

@@ -0,0 +1,84 @@
+// Copyright 2019 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+let invalidNumberingSystem = [
+  "invalid",
+  "abce",
+  "finance",
+  "native",
+  "traditio",
+  "abc-defghi",
+];
+
+let illFormedNumberingSystem = [
+  "",
+  "i",
+  "ij",
+  "abcdefghi",
+  "abc-ab",
+];
+
+// https://tc39.github.io/ecma402/#table-numbering-system-digits
+let validNumberingSystem= [
+  "arab",
+  "arabext",
+  "bali",
+  "beng",
+  "deva",
+  "fullwide",
+  "gujr",
+  "guru",
+  "hanidec",
+  "khmr",
+  "knda",
+  "laoo",
+  "latn",
+  "limb",
+  "mlym",
+  "mong",
+  "mymr",
+  "orya",
+  "tamldec",
+  "telu",
+  "thai",
+  "tibt",
+];
+
+let locales = [
+  "en",
+  "ar",
+];
+
+invalidNumberingSystem.forEach(function(numberingSystem) {
+  locales.forEach(function(base) {
+     var df;
+     assertDoesNotThrow(
+         () => df = new Intl.DateTimeFormat([base], {numberingSystem}));
+     assertEquals(
+         (new Intl.DateTimeFormat([base])).resolvedOptions().numberingSystem,
+         df.resolvedOptions().numberingSystem);
+  });
+});
+
+illFormedNumberingSystem.forEach(function(numberingSystem) {
+  assertThrows(
+      () => new Intl.DateTimeFormat(["en"], {numberingSystem}),
+      RangeError);
+});
+
+let value = new Date();
+validNumberingSystem.forEach(function(numberingSystem) {
+  locales.forEach(function(base) {
+    let l = base + "-u-nu-" + numberingSystem;
+    let dtf = new Intl.DateTimeFormat([base], {numberingSystem});
+    assertEquals(base, dtf.resolvedOptions().locale);
+    assertEquals(numberingSystem, dtf.resolvedOptions().numberingSystem);
+
+    // Test the formatting result is the same as passing in via u-nu-
+    // in the locale.
+    let dtf2 = new Intl.DateTimeFormat([l]);
+    assertEquals(dtf2.format(value), dtf.format(value));
+  });
+}
+);

deps/v8/test/intl/date-format/constructor-calendar-numberingSytem-order.js

@@ -0,0 +1,34 @@
+// Copyright 2019 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+const actual = [];
+
+const options = {
+  get localeMatcher() {
+    actual.push("localeMatcher");
+    return undefined;
+  },
+  get calendar() {
+    actual.push("calendar");
+    return undefined;
+  },
+  get numberingSystem() {
+    actual.push("numberingSystem");
+    return undefined;
+  },
+  get hour12() {
+    actual.push("hour12");
+    return undefined;
+  },
+};
+
+const expected = [
+    "localeMatcher",
+    "calendar",
+    "numberingSystem",
+    "hour12"
+];
+
+let df = new Intl.DateTimeFormat(undefined, options);
+assertEquals(actual.join(":"), expected.join(":"));

deps/v8/test/intl/date-format/constructor-date-style-order.js

@@ -0,0 +1,125 @@
+// Copyright 2019 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Throws only once during construction.
+// Check for all getters to prevent regression.
+// Preserve the order of getter initialization.
+let getCount = 0;
+let weekday = new Array();
+let year = new Array();
+let month = new Array();
+let day = new Array();
+let dayPeriod = new Array();
+let hour = new Array();
+let minute = new Array();
+let second = new Array();
+let localeMatcher = new Array();
+let hour12 = new Array();
+let hourCycle = new Array();
+let dateStyle = new Array();
+let timeStyle = new Array();
+let timeZone = new Array();
+let era = new Array();
+let fractionalSecondDigits = new Array();
+let timeZoneName = new Array();
+let formatMatcher = new Array();
+
+new Intl.DateTimeFormat(['en-US'], {
+  get weekday() {
+    weekday.push(++getCount);
+  },
+  get year() {
+    year.push(++getCount);
+  },
+  get month() {
+    month.push(++getCount);
+  },
+  get day() {
+    day.push(++getCount);
+  },
+  get dayPeriod() {
+    dayPeriod.push(++getCount);
+  },
+  get hour() {
+    hour.push(++getCount);
+  },
+  get minute() {
+    minute.push(++getCount);
+  },
+  get second() {
+    second.push(++getCount);
+  },
+  get localeMatcher() {
+    localeMatcher.push(++getCount);
+  },
+  get hour12() {
+    hour12.push(++getCount);
+  },
+  get hourCycle() {
+    hourCycle.push(++getCount);
+  },
+  get timeZone() {
+    timeZone.push(++getCount);
+  },
+  get dateStyle() {
+    dateStyle.push(++getCount);
+    return "full";
+  },
+  get timeStyle() {
+    timeStyle.push(++getCount);
+  },
+  get era() {
+    era.push(++getCount);
+  },
+  get timeZoneName() {
+    timeZoneName.push(++getCount);
+  },
+  get fractionalSecondDigits() {
+    fractionalSecondDigits.push(++getCount);
+  },
+  get formatMatcher() {
+    formatMatcher.push(++getCount);
+  }
+});
+
+assertEquals(1, weekday.length);
+assertEquals(1, hour.length);
+assertEquals(1, minute.length);
+assertEquals(1, second.length);
+assertEquals(1, year.length);
+assertEquals(1, month.length);
+assertEquals(1, day.length);
+assertEquals(1, era.length);
+assertEquals(1, timeZoneName.length);
+assertEquals(1, dateStyle.length);
+assertEquals(1, timeStyle.length);
+assertEquals(1, localeMatcher.length);
+assertEquals(1, hour12.length);
+assertEquals(1, hourCycle.length);
+assertEquals(1, timeZone.length);
+assertEquals(1, formatMatcher.length);
+
+// InitializeDateTimeFormat
+assertEquals(1, localeMatcher[0]);
+assertEquals(2, hour12[0]);
+assertEquals(3, hourCycle[0]);
+assertEquals(4, timeZone[0]);
+
+assertEquals(5, weekday[0]);
+assertEquals(6, era[0]);
+assertEquals(7, year[0]);
+assertEquals(8, month[0]);
+assertEquals(9, day[0]);
+assertEquals(10, dayPeriod[0]);
+assertEquals(11, hour[0]);
+assertEquals(12, minute[0]);
+assertEquals(13, second[0]);
+assertEquals(14, fractionalSecondDigits[0]);
+assertEquals(15, timeZoneName[0]);
+
+assertEquals(16, formatMatcher[0]);
+assertEquals(17, dateStyle[0]);
+assertEquals(18, timeStyle[0]);
+
+assertEquals(18, getCount);

deps/v8/test/intl/date-format/constructor-date-time-style-order.js

@@ -0,0 +1,126 @@
+// Copyright 2019 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Throws only once during construction.
+// Check for all getters to prevent regression.
+// Preserve the order of getter initialization.
+let getCount = 0;
+let weekday = new Array();
+let year = new Array();
+let month = new Array();
+let day = new Array();
+let dayPeriod = new Array();
+let hour = new Array();
+let minute = new Array();
+let second = new Array();
+let localeMatcher = new Array();
+let hour12 = new Array();
+let hourCycle = new Array();
+let dateStyle = new Array();
+let timeStyle = new Array();
+let timeZone = new Array();
+let era = new Array();
+let fractionalSecondDigits = new Array();
+let timeZoneName = new Array();
+let formatMatcher = new Array();
+
+new Intl.DateTimeFormat(['en-US'], {
+  get weekday() {
+    weekday.push(++getCount);
+  },
+  get year() {
+    year.push(++getCount);
+  },
+  get month() {
+    month.push(++getCount);
+  },
+  get day() {
+    day.push(++getCount);
+  },
+  get dayPeriod() {
+    dayPeriod.push(++getCount);
+  },
+  get hour() {
+    hour.push(++getCount);
+  },
+  get minute() {
+    minute.push(++getCount);
+  },
+  get second() {
+    second.push(++getCount);
+  },
+  get localeMatcher() {
+    localeMatcher.push(++getCount);
+  },
+  get hour12() {
+    hour12.push(++getCount);
+  },
+  get hourCycle() {
+    hourCycle.push(++getCount);
+  },
+  get timeZone() {
+    timeZone.push(++getCount);
+  },
+  get dateStyle() {
+    dateStyle.push(++getCount);
+    return "full";
+  },
+  get timeStyle() {
+    timeStyle.push(++getCount);
+    return "full";
+  },
+  get era() {
+    era.push(++getCount);
+  },
+  get timeZoneName() {
+    timeZoneName.push(++getCount);
+  },
+  get fractionalSecondDigits() {
+    fractionalSecondDigits.push(++getCount);
+  },
+  get formatMatcher() {
+    formatMatcher.push(++getCount);
+  }
+});
+
+assertEquals(1, weekday.length);
+assertEquals(1, hour.length);
+assertEquals(1, minute.length);
+assertEquals(1, second.length);
+assertEquals(1, year.length);
+assertEquals(1, month.length);
+assertEquals(1, day.length);
+assertEquals(1, era.length);
+assertEquals(1, timeZoneName.length);
+assertEquals(1, dateStyle.length);
+assertEquals(1, timeStyle.length);
+assertEquals(1, localeMatcher.length);
+assertEquals(1, hour12.length);
+assertEquals(1, hourCycle.length);
+assertEquals(1, timeZone.length);
+assertEquals(1, formatMatcher.length);
+
+// InitializeDateTimeFormat
+assertEquals(1, localeMatcher[0]);
+assertEquals(2, hour12[0]);
+assertEquals(3, hourCycle[0]);
+assertEquals(4, timeZone[0]);
+
+assertEquals(5, weekday[0]);
+assertEquals(6, era[0]);
+assertEquals(7, year[0]);
+assertEquals(8, month[0]);
+assertEquals(9, day[0]);
+assertEquals(10, dayPeriod[0]);
+assertEquals(11, hour[0]);
+assertEquals(12, minute[0]);
+assertEquals(13, second[0]);
+assertEquals(14, fractionalSecondDigits[0]);
+assertEquals(15, timeZoneName[0]);
+
+assertEquals(16, formatMatcher[0]);
+assertEquals(17, dateStyle[0]);
+assertEquals(18, timeStyle[0]);
+
+assertEquals(18, getCount);

deps/v8/test/intl/date-format/constructor-date-time-style.js

@@ -0,0 +1,31 @@
+// Copyright 2019 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+var validStyle = ["full", "long", "medium", "short", undefined];
+var invalidStyle = ["narrow", "numeric"];
+
+validStyle.forEach(function(dateStyle) {
+  validStyle.forEach(function(timeStyle) {
+    assertDoesNotThrow(() =>
+        new Intl.DateTimeFormat("en", {dateStyle, timeStyle}));
+  });
+
+  invalidStyle.forEach(function(timeStyle) {
+    assertThrows(() =>
+        new Intl.DateTimeFormat("en", {dateStyle, timeStyle}), RangeError);
+  });
+}
+);
+
+invalidStyle.forEach(function(dateStyle) {
+  validStyle.forEach(function(timeStyle) {
+    assertThrows(() =>
+        new Intl.DateTimeFormat("en", {dateStyle, timeStyle}), RangeError);
+  });
+  invalidStyle.forEach(function(timeStyle) {
+    assertThrows(() =>
+        new Intl.DateTimeFormat("en", {dateStyle, timeStyle}), RangeError);
+  });
+}
+);

deps/v8/test/intl/date-format/constructor-no-style-order.js

@@ -0,0 +1,124 @@
+// Copyright 2019 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Throws only once during construction.
+// Check for all getters to prevent regression.
+// Preserve the order of getter initialization.
+let getCount = 0;
+let weekday = new Array();
+let year = new Array();
+let month = new Array();
+let day = new Array();
+let dayPeriod = new Array();
+let hour = new Array();
+let minute = new Array();
+let second = new Array();
+let localeMatcher = new Array();
+let hour12 = new Array();
+let hourCycle = new Array();
+let dateStyle = new Array();
+let timeStyle = new Array();
+let timeZone = new Array();
+let era = new Array();
+let timeZoneName = new Array();
+let formatMatcher = new Array();
+let fractionalSecondDigits = new Array();
+
+new Intl.DateTimeFormat(['en-US'], {
+  get weekday() {
+    weekday.push(++getCount);
+  },
+  get year() {
+    year.push(++getCount);
+  },
+  get month() {
+    month.push(++getCount);
+  },
+  get day() {
+    day.push(++getCount);
+  },
+  get dayPeriod() {
+    dayPeriod.push(++getCount);
+  },
+  get hour() {
+    hour.push(++getCount);
+  },
+  get minute() {
+    minute.push(++getCount);
+  },
+  get second() {
+    second.push(++getCount);
+  },
+  get localeMatcher() {
+    localeMatcher.push(++getCount);
+  },
+  get hour12() {
+    hour12.push(++getCount);
+  },
+  get hourCycle() {
+    hourCycle.push(++getCount);
+  },
+  get timeZone() {
+    timeZone.push(++getCount);
+  },
+  get dateStyle() {
+    dateStyle.push(++getCount);
+  },
+  get timeStyle() {
+    timeStyle.push(++getCount);
+  },
+  get era() {
+    era.push(++getCount);
+  },
+  get timeZoneName() {
+    timeZoneName.push(++getCount);
+  },
+  get formatMatcher() {
+    formatMatcher.push(++getCount);
+  },
+  get fractionalSecondDigits() {
+    fractionalSecondDigits.push(++getCount);
+  }
+});
+
+assertEquals(1, weekday.length);
+assertEquals(1, hour.length);
+assertEquals(1, minute.length);
+assertEquals(1, second.length);
+assertEquals(1, year.length);
+assertEquals(1, month.length);
+assertEquals(1, day.length);
+assertEquals(1, era.length);
+assertEquals(1, timeZoneName.length);
+assertEquals(1, dateStyle.length);
+assertEquals(1, timeStyle.length);
+assertEquals(1, localeMatcher.length);
+assertEquals(1, hour12.length);
+assertEquals(1, hourCycle.length);
+assertEquals(1, timeZone.length);
+assertEquals(1, formatMatcher.length);
+
+// InitializeDateTimeFormat
+assertEquals(1, localeMatcher[0]);
+assertEquals(2, hour12[0]);
+assertEquals(3, hourCycle[0]);
+assertEquals(4, timeZone[0]);
+
+assertEquals(5, weekday[0]);
+assertEquals(6, era[0]);
+assertEquals(7, year[0]);
+assertEquals(8, month[0]);
+assertEquals(9, day[0]);
+assertEquals(10, dayPeriod[0]);
+assertEquals(11, hour[0]);
+assertEquals(12, minute[0]);
+assertEquals(13, second[0]);
+assertEquals(14, fractionalSecondDigits[0]);
+assertEquals(15, timeZoneName[0]);
+
+assertEquals(16, formatMatcher[0]);
+assertEquals(17, dateStyle[0]);
+assertEquals(18, timeStyle[0]);
+
+assertEquals(18, getCount);

deps/v8/test/intl/date-format/constructor-time-style-order.js

@@ -0,0 +1,125 @@
+// Copyright 2019 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Throws only once during construction.
+// Check for all getters to prevent regression.
+// Preserve the order of getter initialization.
+let getCount = 0;
+let weekday = new Array();
+let year = new Array();
+let month = new Array();
+let day = new Array();
+let dayPeriod = new Array();
+let hour = new Array();
+let minute = new Array();
+let second = new Array();
+let localeMatcher = new Array();
+let hour12 = new Array();
+let hourCycle = new Array();
+let dateStyle = new Array();
+let timeStyle = new Array();
+let timeZone = new Array();
+let era = new Array();
+let timeZoneName = new Array();
+let formatMatcher = new Array();
+let fractionalSecondDigits = new Array();
+
+new Intl.DateTimeFormat(['en-US'], {
+  get weekday() {
+    weekday.push(++getCount);
+  },
+  get year() {
+    year.push(++getCount);
+  },
+  get month() {
+    month.push(++getCount);
+  },
+  get day() {
+    day.push(++getCount);
+  },
+  get dayPeriod() {
+    dayPeriod.push(++getCount);
+  },
+  get hour() {
+    hour.push(++getCount);
+  },
+  get minute() {
+    minute.push(++getCount);
+  },
+  get second() {
+    second.push(++getCount);
+  },
+  get localeMatcher() {
+    localeMatcher.push(++getCount);
+  },
+  get hour12() {
+    hour12.push(++getCount);
+  },
+  get hourCycle() {
+    hourCycle.push(++getCount);
+  },
+  get timeZone() {
+    timeZone.push(++getCount);
+  },
+  get dateStyle() {
+    dateStyle.push(++getCount);
+  },
+  get timeStyle() {
+    timeStyle.push(++getCount);
+    return "full";
+  },
+  get era() {
+    era.push(++getCount);
+  },
+  get timeZoneName() {
+    timeZoneName.push(++getCount);
+  },
+  get formatMatcher() {
+    formatMatcher.push(++getCount);
+  },
+  get fractionalSecondDigits() {
+    fractionalSecondDigits.push(++getCount);
+  }
+});
+
+assertEquals(1, weekday.length);
+assertEquals(1, hour.length);
+assertEquals(1, minute.length);
+assertEquals(1, second.length);
+assertEquals(1, year.length);
+assertEquals(1, month.length);
+assertEquals(1, day.length);
+assertEquals(1, era.length);
+assertEquals(1, timeZoneName.length);
+assertEquals(1, dateStyle.length);
+assertEquals(1, timeStyle.length);
+assertEquals(1, localeMatcher.length);
+assertEquals(1, hour12.length);
+assertEquals(1, hourCycle.length);
+assertEquals(1, timeZone.length);
+assertEquals(1, formatMatcher.length);
+
+// InitializeDateTimeFormat
+assertEquals(1, localeMatcher[0]);
+assertEquals(2, hour12[0]);
+assertEquals(3, hourCycle[0]);
+assertEquals(4, timeZone[0]);
+
+assertEquals(5, weekday[0]);
+assertEquals(6, era[0]);
+assertEquals(7, year[0]);
+assertEquals(8, month[0]);
+assertEquals(9, day[0]);
+assertEquals(10, dayPeriod[0]);
+assertEquals(11, hour[0]);
+assertEquals(12, minute[0]);
+assertEquals(13, second[0]);
+assertEquals(14, fractionalSecondDigits[0]);
+assertEquals(15, timeZoneName[0]);
+
+assertEquals(16, formatMatcher[0]);
+assertEquals(17, dateStyle[0]);
+assertEquals(18, timeStyle[0]);
+
+assertEquals(18, getCount);

deps/v8/test/intl/date-format/date-format-to-parts.js

@@ -0,0 +1,20 @@
+// Copyright 2016 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+var d = new Date(2016, 11, 15, 14, 10, 34);
+var df = Intl.DateTimeFormat("ja",
+    {hour: 'numeric', minute: 'numeric', second: 'numeric', year: 'numeric',
+     month: 'numeric', day: 'numeric', timeZoneName: 'short', era: 'short',
+     hour12: true});
+
+var formattedParts = df.formatToParts(d);
+
+var formattedReconstructedFromParts = formattedParts.map((part) => part.value)
+    .reduce((accumulated, part) => accumulated + part);
+assertEquals(df.format(d), formattedReconstructedFromParts);
+// 西暦2016年11月15日 午後02:10:34 GMT-7
+assertEquals(["era", "year", "literal", "month", "literal", "day", "literal",
+              "dayPeriod", "hour", "literal", "minute", "literal", "second",
+              "literal", "timeZoneName"
+             ], formattedParts.map((part) => part.type));

deps/v8/test/intl/date-format/date_style_time_style_hour_cycle.js

@@ -0,0 +1,54 @@
+// Copyright 2019 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+let midnight = new Date(2019, 3, 4, 0);
+let noon = new Date(2019, 3, 4, 12);
+
+let df_11_dt = new Intl.DateTimeFormat(
+    "en", {timeStyle: "short", dateStyle: "short", hourCycle: "h11"})
+assertEquals("h11", df_11_dt.resolvedOptions().hourCycle);
+assertEquals("4/4/19, 0:00 AM", df_11_dt.format(midnight));
+assertEquals("4/4/19, 0:00 PM", df_11_dt.format(noon));
+
+let df_12_dt = new Intl.DateTimeFormat(
+    "en", {timeStyle: "short", dateStyle: "short", hourCycle: "h12"})
+assertEquals("h12", df_12_dt.resolvedOptions().hourCycle);
+assertEquals("4/4/19, 12:00 AM", df_12_dt.format(midnight));
+assertEquals("4/4/19, 12:00 PM", df_12_dt.format(noon));
+
+let df_23_dt = new Intl.DateTimeFormat(
+    "en", {timeStyle: "short", dateStyle: "short", hourCycle: "h23"})
+assertEquals("h23", df_23_dt.resolvedOptions().hourCycle);
+assertEquals("4/4/19, 00:00", df_23_dt.format(midnight));
+assertEquals("4/4/19, 12:00" ,df_23_dt.format(noon));
+
+let df_24_dt = new Intl.DateTimeFormat(
+    "en", {timeStyle: "short", dateStyle: "short", hourCycle: "h24"})
+assertEquals("h24", df_24_dt.resolvedOptions().hourCycle);
+assertEquals("4/4/19, 24:00", df_24_dt.format(midnight));
+assertEquals("4/4/19, 12:00", df_24_dt.format(noon));
+
+let df_11_ja_dt = new Intl.DateTimeFormat(
+    "ja-JP", {timeStyle: "short", dateStyle: "short", hourCycle: "h11"})
+assertEquals("h11", df_11_ja_dt.resolvedOptions().hourCycle);
+assertEquals("2019/04/04 午前0:00", df_11_ja_dt.format(midnight));
+assertEquals("2019/04/04 午後0:00", df_11_ja_dt.format(noon));
+
+let df_12_ja_dt = new Intl.DateTimeFormat(
+    "ja-JP", {timeStyle: "short", dateStyle: "short", hourCycle: "h12"})
+assertEquals("h12", df_12_ja_dt.resolvedOptions().hourCycle);
+assertEquals("2019/04/04 午前12:00", df_12_ja_dt.format(midnight));
+assertEquals("2019/04/04 午後12:00", df_12_ja_dt.format(noon));
+
+let df_23_ja_dt = new Intl.DateTimeFormat(
+    "ja-JP", {timeStyle: "short", dateStyle: "short", hourCycle: "h23"})
+assertEquals("h23", df_23_ja_dt.resolvedOptions().hourCycle);
+assertEquals("2019/04/04 0:00", df_23_ja_dt.format(midnight));
+assertEquals("2019/04/04 12:00", df_23_ja_dt.format(noon));
+
+let df_24_ja_dt = new Intl.DateTimeFormat(
+    "ja-JP", {timeStyle: "short", dateStyle: "short", hourCycle: "h24"})
+assertEquals("h24", df_24_ja_dt.resolvedOptions().hourCycle);
+assertEquals("2019/04/04 24:00", df_24_ja_dt.format(midnight));
+assertEquals("2019/04/04 12:00", df_24_ja_dt.format(noon));

deps/v8/test/intl/date-format/default-locale.js

@@ -0,0 +1,41 @@
+// Copyright 2013 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Constructing DateTimeFormat with no locale arguments or with []
+// creates one with default locale.
+
+var dtf = new Intl.DateTimeFormat([]);
+
+var options = dtf.resolvedOptions();
+
+// Check it's none of these first.
+assertFalse(options.locale === 'und');
+assertFalse(options.locale === '');
+assertFalse(options.locale === undefined);
+
+var dtfNone = new Intl.DateTimeFormat();
+assertEquals(options.locale, dtfNone.resolvedOptions().locale);

deps/v8/test/intl/date-format/en-format-range-to-parts.js

@@ -0,0 +1,47 @@
+// Copyright 2019 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+const date1 = new Date("2019-01-03T03:20");
+const date2 = new Date("2019-01-05T19:33");
+const date3 = new Date("2019-01-05T22:57");
+
+// value:  "Jan 3 – 5, 2019"
+// source:  hhhhShhhEhhhhhh
+// type:    mmmldllldllyyyy
+// h: Shared, S: startRange, E: endRange
+// m: month, l: literal, d: day, y: year
+const expected1 = [
+  {type: "month", value: "Jan", source: "shared"},
+  {type: "literal", value: " ", source: "shared"},
+  {type: "day", value: "3", source: "startRange"},
+  {type: "literal", value: "\u2009–\u2009", source: "shared"},
+  {type: "day", value: "5", source: "endRange"},
+  {type: "literal", value: ", ", source: "shared"},
+  {type: "year", value: "2019", source: "shared"}
+];
+
+var dtf = new Intl.DateTimeFormat(["en"], {year: "numeric", month: "short", day: "numeric"});
+const ret1 = dtf.formatRangeToParts(date1, date2);
+assertEquals(expected1, ret1);
+
+// value:  "Jan 5, 7 – 10 PM"
+// source:  hhhhhhhShhhEEhhh
+// type:    mmmldlldlllhhlpp
+// h: Shared, S: startRange, E: endRange
+// m: month, l: literal, d: day, h: hour, p: dayPeriod
+
+const expected2 = [
+  {type: "month", value: "Jan", source: "shared"},
+  {type: "literal", value: " ", source: "shared"},
+  {type: "day", value: "5", source: "shared"},
+  {type: "literal", value: ", ", source: "shared"},
+  {type: "hour", value: "7", source: "startRange"},
+  {type: "literal", value: "\u2009–\u2009", source: "shared"},
+  {type: "hour", value: "10", source: "endRange"},
+  {type: "literal", value: "\u202f", source: "shared"},
+  {type: "dayPeriod", value: "PM", source: "shared"}
+];
+dtf = new Intl.DateTimeFormat(["en"], {month: "short", day: "numeric", hour: "numeric"});
+const ret2 = dtf.formatRangeToParts(date2, date3);
+assertEquals(expected2, ret2);

deps/v8/test/intl/date-format/format-is-bound.js

@@ -0,0 +1,46 @@
+// Copyright 2013 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Create default DateTimeFormat.
+var dtf = new Intl.DateTimeFormat();
+
+// Array we want to iterate, actual dates are not important.
+var dateArray = [Date.now(), Date.now(), Date.now()];
+
+// It shouldn't throw.
+// The format() method should be properly bound to the dtf object.
+dateArray.forEach(dtf.format);
+
+// Formatting a date should work in a direct call.
+dtf.format();
+
+// format should be bound properly even if created from a non-instance
+var legacy = Intl.DateTimeFormat.call(
+    Object.create(Intl.DateTimeFormat));
+var boundFormat = legacy.format;
+assertEquals(dtf.format(12345), legacy.format(12345));
+assertEquals(dtf.format(54321), boundFormat(54321));

deps/v8/test/intl/date-format/format-range-to-parts.js

@@ -0,0 +1,81 @@
+// Copyright 2019 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+let descriptor = Object.getOwnPropertyDescriptor(
+      Intl.DateTimeFormat.prototype, "formatRangeToParts");
+assertTrue(descriptor.writable);
+assertFalse(descriptor.enumerable);
+assertTrue(descriptor.configurable);
+
+const date1 = new Date("2019-1-3");
+const date2 = new Date("2019-1-5");
+const date3 = new Date("2019-3-4");
+const date4 = new Date("2020-3-4");
+let dtf = new Intl.DateTimeFormat();
+assertThrows(() => dtf.formatRangeToParts(), TypeError);
+assertThrows(() => dtf.formatRangeToParts(date1), TypeError);
+assertThrows(() => dtf.formatRangeToParts(undefined, date2), TypeError);
+assertThrows(() => dtf.formatRangeToParts(date1, undefined), TypeError);
+assertThrows(() => dtf.formatRangeToParts("2019-1-3", date2), RangeError);
+assertThrows(() => dtf.formatRangeToParts(date1, "2019-5-4"), RangeError);
+
+assertDoesNotThrow(() =>dtf.formatRangeToParts(date2, date1));
+assertDoesNotThrow(() =>dtf.formatRangeToParts(date1, date2));
+
+function partsToString(parts) {
+  return parts.map(x => x.value).join("");
+}
+
+const validSources = ["startRange", "endRange", "shared"];
+const validTypes = ["literal", "year", "month", "day", "hour", "minute", "second",
+                    "weekday", "dayPeriod", "timeZoneName", "era"];
+
+function assertParts(parts) {
+  const str = partsToString(parts);
+  parts.forEach(function(part) {
+    // Check the range of part.source
+    assertTrue(validSources.includes(part.source),
+        "Invalid source '" + part.source + "' in '" + str + "' for '" + part.value + "'");
+    // Check the range of part.type
+    assertTrue(validTypes.includes(part.type),
+        "Invalid type '" + part.type + "' in '" + str + "' for '" + part.value + "'");
+    // Check the part.value is a string
+    assertEquals("string", typeof part.value, "Invalid value for '" + str + "'");
+  });
+}
+
+function verifyFormatRangeToParts(a, b, dtf) {
+  var parts = dtf.formatRangeToParts(a, b);
+  // Check each parts fulfill basic property of the parts.
+  assertParts(parts);
+  // ensure the 'value' in the parts is the same as the output of
+  // the formatRange.
+  assertEquals(dtf.formatRange(a, b), partsToString(parts));
+}
+
+verifyFormatRangeToParts(date1, date2, dtf);
+verifyFormatRangeToParts(date1, date3, dtf);
+verifyFormatRangeToParts(date1, date4, dtf);
+verifyFormatRangeToParts(date2, date3, dtf);
+verifyFormatRangeToParts(date2, date4, dtf);
+verifyFormatRangeToParts(date3, date4, dtf);
+
+dtf = new Intl.DateTimeFormat(["en"], {year: "numeric", month: "short", day: "numeric"});
+
+verifyFormatRangeToParts(date1, date2, dtf);
+verifyFormatRangeToParts(date1, date3, dtf);
+verifyFormatRangeToParts(date1, date4, dtf);
+verifyFormatRangeToParts(date2, date3, dtf);
+verifyFormatRangeToParts(date2, date4, dtf);
+verifyFormatRangeToParts(date3, date4, dtf);
+
+// Test the sequence of ToNumber and TimeClip
+var secondDateAccessed = false;
+assertThrows(
+    () =>
+    dtf.formatRangeToParts(
+        new Date(864000000*10000000 + 1), // a date will cause TimeClip return NaN
+        { get [Symbol.toPrimitive]() { secondDateAccessed = true; return {}} }),
+    TypeError);
+assertTrue(secondDateAccessed);

deps/v8/test/intl/date-format/format-range.js

@@ -0,0 +1,49 @@
+// Copyright 2019 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+let descriptor = Object.getOwnPropertyDescriptor(
+      Intl.DateTimeFormat.prototype, "formatRange");
+assertTrue(descriptor.writable);
+assertFalse(descriptor.enumerable);
+assertTrue(descriptor.configurable);
+
+const date1 = new Date("2019-1-3");
+const date2 = new Date("2019-1-5");
+const date3 = new Date("2019-3-4");
+const date4 = new Date("2020-3-4");
+var dtf = new Intl.DateTimeFormat(["en"]);
+assertThrows(() => dtf.formatRange(), TypeError);
+assertThrows(() => dtf.formatRange(date1), TypeError);
+assertThrows(() => dtf.formatRange(undefined, date2), TypeError);
+assertThrows(() => dtf.formatRange(date1, undefined), TypeError);
+assertThrows(() => dtf.formatRange("2019-1-3", date2), RangeError);
+assertThrows(() => dtf.formatRange(date1, "2019-5-4"), RangeError);
+
+assertDoesNotThrow(() =>dtf.formatRange(date2, date1));
+assertDoesNotThrow(() =>dtf.formatRange(date1, date2));
+
+assertEquals("1/3/2019\u2009–\u20091/5/2019", dtf.formatRange(date1, date2));
+assertEquals("1/3/2019\u2009–\u20093/4/2019", dtf.formatRange(date1, date3));
+assertEquals("1/3/2019\u2009–\u20093/4/2020", dtf.formatRange(date1, date4));
+assertEquals("1/5/2019\u2009–\u20093/4/2019", dtf.formatRange(date2, date3));
+assertEquals("1/5/2019\u2009–\u20093/4/2020", dtf.formatRange(date2, date4));
+assertEquals("3/4/2019\u2009–\u20093/4/2020", dtf.formatRange(date3, date4));
+
+dtf = new Intl.DateTimeFormat(["en"], {year: "numeric", month: "short", day: "numeric"});
+assertEquals("Jan 3\u2009–\u20095, 2019", dtf.formatRange(date1, date2));
+assertEquals("Jan 3\u2009–\u2009Mar 4, 2019", dtf.formatRange(date1, date3));
+assertEquals("Jan 3, 2019\u2009–\u2009Mar 4, 2020", dtf.formatRange(date1, date4));
+assertEquals("Jan 5\u2009–\u2009Mar 4, 2019", dtf.formatRange(date2, date3));
+assertEquals("Jan 5, 2019\u2009–\u2009Mar 4, 2020", dtf.formatRange(date2, date4));
+assertEquals("Mar 4, 2019\u2009–\u2009Mar 4, 2020", dtf.formatRange(date3, date4));
+
+// Test the sequence of ToNumber and TimeClip
+var secondDateAccessed = false;
+assertThrows(
+    () =>
+    dtf.formatRange(
+        new Date(864000000*10000000 + 1), // a date will cause TimeClip return NaN
+        { get [Symbol.toPrimitive]() { secondDateAccessed = true; return {}} }),
+    TypeError);
+assertTrue(secondDateAccessed);

deps/v8/test/intl/date-format/format-test.js

@@ -0,0 +1,50 @@
+// Copyright 2013 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Test formatting method with specified date, invalid input.
+
+var dtf = new Intl.DateTimeFormat('en-US', {timeZone: 'UTC'});
+
+var someDate = dtf.format(144313200000);
+assertEquals('7/29/1974', someDate);
+
+var invalidValues = [NaN, Infinity, -Infinity];
+invalidValues.forEach(function(value) {
+  var error;
+  try {
+    dtf.format(value);
+  } catch (e) {
+    error = e;
+  }
+
+  assertTrue(error !== undefined);
+  assertEquals('RangeError', error.name);
+});
+
+// https://code.google.com/p/chromium/issues/detail?id=537382
+
+assertEquals('11/11/1500', dtf.format(new Date(Date.UTC(1500,10,11,12,0,0))));

deps/v8/test/intl/date-format/format-with-extensions.js

@@ -0,0 +1,49 @@
+// Copyright 2018 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+const d = new Date(2018, 5, 21); // 2018-06-21
+
+function checkFormat(locale, options, expected) {
+  let df = new Intl.DateTimeFormat(locale, options);
+  let resolvedOptions = df.resolvedOptions();
+  assertEquals(expected.cal, resolvedOptions.calendar);
+  assertEquals(expected.numSys, resolvedOptions.numberingSystem);
+
+  let formattedParts = df.formatToParts(d);
+  let formattedReconstructedFromParts = formattedParts.map((part) => part.value)
+      .reduce((accumulated, part) => accumulated + part);
+  let formatted = df.format(d);
+
+  assertEquals(formatted, formattedReconstructedFromParts);
+  assertEquals(expected.types, formattedParts.map((part) => part.type));
+  assertEquals(expected.formatted, formatted);
+}
+
+[
+    ["en", "gregory", "latn", "2018"],
+    ["en-GB", "gregory", "latn", "2018"],
+].forEach(function(entry) {
+  checkFormat(entry[0], {year: 'numeric'},
+      { cal: entry[1],
+        numSys: entry[2],
+        formatted: entry[3],
+        types: ["year"],
+      });
+});
+
+const enUSTypes = ["month", "literal", "day", "literal", "year"];
+const enGBTypes = ["day", "literal", "month", "literal", "year"];
+
+[
+    ["en", "gregory", "latn", "6/21/2018", enUSTypes],
+    ["en-GB", "gregory", "latn", "21/06/2018", enGBTypes],
+    ["en-u-nu-deva", "gregory", "deva", "६/२१/२०१८", enUSTypes],
+].forEach(function(entry) {
+  checkFormat(entry[0], {},
+      { cal: entry[1],
+        numSys: entry[2],
+        formatted: entry[3],
+        types: entry[4],
+      });
+});

deps/v8/test/intl/date-format/format_range_hour_cycle.js

@@ -0,0 +1,149 @@
+// Copyright 2019 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+let midnight = new Date(2019, 3, 4, 0);
+let noon = new Date(2019, 3, 4, 12);
+let df_11 = new Intl.DateTimeFormat(
+    "en", {hour: "numeric", minute: "numeric", hourCycle: "h11"})
+assertEquals("h11", df_11.resolvedOptions().hourCycle);
+assertEquals("0:00 AM", df_11.formatRange(midnight, midnight));
+assertEquals("0:00 PM", df_11.formatRange(noon, noon));
+
+let df_11_t = new Intl.DateTimeFormat(
+    "en", {timeStyle: "short", hourCycle: "h11"})
+assertEquals("h11", df_11_t.resolvedOptions().hourCycle);
+assertEquals("0:00 AM", df_11_t.formatRange(midnight, midnight));
+assertEquals("0:00 PM", df_11_t.formatRange(noon, noon));
+
+let df_11_dt = new Intl.DateTimeFormat(
+    "en", {timeStyle: "short", dateStyle: "short", hourCycle: "h11"})
+assertEquals("h11", df_11_dt.resolvedOptions().hourCycle);
+assertEquals("4/4/19, 0:00 AM", df_11_dt.formatRange(midnight, midnight));
+assertEquals("4/4/19, 0:00 PM", df_11_dt.formatRange(noon, noon));
+
+let df_12 = new Intl.DateTimeFormat(
+    "en", {hour: "numeric", minute: "numeric", hourCycle: "h12"})
+assertEquals("h12", df_12.resolvedOptions().hourCycle);
+assertEquals("12:00 AM", df_12.formatRange(midnight, midnight));
+assertEquals("12:00 PM", df_12.formatRange(noon, noon));
+
+let df_12_t = new Intl.DateTimeFormat(
+    "en", {timeStyle: "short", hourCycle: "h12"})
+assertEquals("h12", df_12_t.resolvedOptions().hourCycle);
+assertEquals("12:00 AM", df_12_t.formatRange(midnight, midnight));
+assertEquals("12:00 PM", df_12_t.formatRange(noon, noon));
+
+let df_12_dt = new Intl.DateTimeFormat(
+    "en", {timeStyle: "short", dateStyle: "short", hourCycle: "h12"})
+assertEquals("h12", df_12_dt.resolvedOptions().hourCycle);
+assertEquals("4/4/19, 12:00 AM", df_12_dt.formatRange(midnight, midnight));
+assertEquals("4/4/19, 12:00 PM", df_12_dt.formatRange(noon, noon));
+
+let df_23 = new Intl.DateTimeFormat(
+    "en", {hour: "numeric", minute: "numeric", hourCycle: "h23"})
+assertEquals("h23", df_23.resolvedOptions().hourCycle);
+assertEquals("00:00", df_23.formatRange(midnight, midnight));
+assertEquals("12:00" ,df_23.formatRange(noon, noon));
+
+let df_23_t = new Intl.DateTimeFormat(
+    "en", {timeStyle: "short", hourCycle: "h23"})
+assertEquals("h23", df_23_t.resolvedOptions().hourCycle);
+assertEquals("00:00", df_23_t.formatRange(midnight, midnight));
+assertEquals("12:00" ,df_23_t.formatRange(noon, noon));
+
+let df_23_dt = new Intl.DateTimeFormat(
+    "en", {timeStyle: "short", dateStyle: "short", hourCycle: "h23"})
+assertEquals("h23", df_23_dt.resolvedOptions().hourCycle);
+assertEquals("4/4/19, 00:00", df_23_dt.formatRange(midnight, midnight));
+assertEquals("4/4/19, 12:00" ,df_23_dt.formatRange(noon, noon));
+
+let df_24 = new Intl.DateTimeFormat(
+    "en", {hour: "numeric", minute: "numeric", hourCycle: "h24"})
+assertEquals("h24", df_24.resolvedOptions().hourCycle);
+assertEquals("24:00", df_24.formatRange(midnight, midnight));
+assertEquals("12:00", df_24.formatRange(noon, noon));
+
+let df_24_t = new Intl.DateTimeFormat(
+    "en", {timeStyle: "short", hourCycle: "h24"})
+assertEquals("h24", df_24_t.resolvedOptions().hourCycle);
+assertEquals("24:00", df_24_t.formatRange(midnight, midnight));
+assertEquals("12:00", df_24_t.formatRange(noon, noon));
+
+let df_24_dt = new Intl.DateTimeFormat(
+    "en", {timeStyle: "short", dateStyle: "short", hourCycle: "h24"})
+assertEquals("h24", df_24_dt.resolvedOptions().hourCycle);
+assertEquals("4/4/19, 24:00", df_24_dt.formatRange(midnight, midnight));
+assertEquals("4/4/19, 12:00", df_24_dt.formatRange(noon, noon));
+
+let df_11_ja = new Intl.DateTimeFormat(
+    "ja-JP", {hour: "numeric", minute: "numeric", hourCycle: "h11"})
+assertEquals("h11", df_11_ja.resolvedOptions().hourCycle);
+assertEquals("午前0:00", df_11_ja.formatRange(midnight, midnight));
+assertEquals("午後0:00", df_11_ja.formatRange(noon, noon));
+
+let df_11_ja_t = new Intl.DateTimeFormat(
+    "ja-JP", {timeStyle: "short", hourCycle: "h11"})
+assertEquals("h11", df_11_ja_t.resolvedOptions().hourCycle);
+assertEquals("午前0:00", df_11_ja_t.formatRange(midnight, midnight));
+assertEquals("午後0:00", df_11_ja_t.formatRange(noon, noon));
+
+let df_11_ja_dt = new Intl.DateTimeFormat(
+    "ja-JP", {timeStyle: "short", dateStyle: "short", hourCycle: "h11"})
+assertEquals("h11", df_11_ja_dt.resolvedOptions().hourCycle);
+assertEquals("2019/04/04 午前0:00", df_11_ja_dt.formatRange(midnight, midnight));
+assertEquals("2019/04/04 午後0:00", df_11_ja_dt.formatRange(noon, noon));
+
+let df_12_ja = new Intl.DateTimeFormat(
+    "ja-JP", {hour: "numeric", minute: "numeric", hourCycle: "h12"})
+assertEquals("h12", df_12_ja.resolvedOptions().hourCycle);
+assertEquals("午前12:00", df_12_ja.formatRange(midnight, midnight));
+assertEquals("午後12:00", df_12_ja.formatRange(noon, noon));
+
+let df_12_ja_t = new Intl.DateTimeFormat(
+    "ja-JP", {timeStyle: "short", hourCycle: "h12"})
+assertEquals("h12", df_12_ja_t.resolvedOptions().hourCycle);
+assertEquals("午前12:00", df_12_ja_t.formatRange(midnight, midnight));
+assertEquals("午後12:00", df_12_ja_t.formatRange(noon, noon));
+
+let df_12_ja_dt = new Intl.DateTimeFormat(
+    "ja-JP", {timeStyle: "short", dateStyle: "short", hourCycle: "h12"})
+assertEquals("h12", df_12_ja_dt.resolvedOptions().hourCycle);
+assertEquals("2019/04/04 午前12:00", df_12_ja_dt.formatRange(midnight, midnight));
+assertEquals("2019/04/04 午後12:00", df_12_ja_dt.formatRange(noon, noon));
+
+let df_23_ja = new Intl.DateTimeFormat(
+    "ja-JP", {hour: "numeric", minute: "numeric", hourCycle: "h23"})
+assertEquals("h23", df_23_ja.resolvedOptions().hourCycle);
+assertEquals("0:00", df_23_ja.formatRange(midnight, midnight));
+assertEquals("12:00", df_23_ja.formatRange(noon, noon));
+
+let df_23_ja_t = new Intl.DateTimeFormat(
+    "ja-JP", {timeStyle: "short", hourCycle: "h23"})
+assertEquals("h23", df_23_ja_t.resolvedOptions().hourCycle);
+assertEquals("0:00", df_23_ja_t.formatRange(midnight, midnight));
+assertEquals("12:00", df_23_ja_t.formatRange(noon, noon));
+
+let df_23_ja_dt = new Intl.DateTimeFormat(
+    "ja-JP", {timeStyle: "short", dateStyle: "short", hourCycle: "h23"})
+assertEquals("h23", df_23_ja_dt.resolvedOptions().hourCycle);
+assertEquals("2019/04/04 0:00", df_23_ja_dt.formatRange(midnight, midnight));
+assertEquals("2019/04/04 12:00", df_23_ja_dt.formatRange(noon, noon));
+
+let df_24_ja = new Intl.DateTimeFormat(
+    "ja-JP", {hour: "numeric", minute: "numeric", hourCycle: "h24"})
+assertEquals("h24", df_24_ja.resolvedOptions().hourCycle);
+assertEquals("24:00", df_24_ja.formatRange(midnight, midnight));
+assertEquals("12:00", df_24_ja.formatRange(noon, noon));
+
+let df_24_ja_t = new Intl.DateTimeFormat(
+    "ja-JP", {timeStyle: "short", hourCycle: "h24"})
+assertEquals("h24", df_24_ja_t.resolvedOptions().hourCycle);
+assertEquals("24:00", df_24_ja_t.formatRange(midnight, midnight));
+assertEquals("12:00", df_24_ja_t.formatRange(noon, noon));
+
+let df_24_ja_dt = new Intl.DateTimeFormat(
+    "ja-JP", {timeStyle: "short", dateStyle: "short", hourCycle: "h24"})
+assertEquals("h24", df_24_ja_dt.resolvedOptions().hourCycle);
+assertEquals("2019/04/04 24:00", df_24_ja_dt.formatRange(midnight, midnight));
+assertEquals("2019/04/04 12:00", df_24_ja_dt.formatRange(noon, noon));

deps/v8/test/intl/date-format/hour_cycle.js

@@ -0,0 +1,53 @@
+// Copyright 2019 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+let midnight = new Date(2019, 3, 4, 0);
+let noon = new Date(2019, 3, 4, 12);
+let df_11 = new Intl.DateTimeFormat(
+    "en", {hour: "numeric", minute: "numeric", hourCycle: "h11"})
+assertEquals("h11", df_11.resolvedOptions().hourCycle);
+assertEquals("0:00 AM", df_11.format(midnight));
+assertEquals("0:00 PM", df_11.format(noon));
+
+let df_12 = new Intl.DateTimeFormat(
+    "en", {hour: "numeric", minute: "numeric", hourCycle: "h12"})
+assertEquals("h12", df_12.resolvedOptions().hourCycle);
+assertEquals("12:00 AM", df_12.format(midnight));
+assertEquals("12:00 PM", df_12.format(noon));
+
+let df_23 = new Intl.DateTimeFormat(
+    "en", {hour: "numeric", minute: "numeric", hourCycle: "h23"})
+assertEquals("h23", df_23.resolvedOptions().hourCycle);
+assertEquals("00:00", df_23.format(midnight));
+assertEquals("12:00" ,df_23.format(noon));
+
+let df_24 = new Intl.DateTimeFormat(
+    "en", {hour: "numeric", minute: "numeric", hourCycle: "h24"})
+assertEquals("h24", df_24.resolvedOptions().hourCycle);
+assertEquals("24:00", df_24.format(midnight));
+assertEquals("12:00", df_24.format(noon));
+
+let df_11_ja = new Intl.DateTimeFormat(
+    "ja-JP", {hour: "numeric", minute: "numeric", hourCycle: "h11"})
+assertEquals("h11", df_11_ja.resolvedOptions().hourCycle);
+assertEquals("午前0:00", df_11_ja.format(midnight));
+assertEquals("午後0:00", df_11_ja.format(noon));
+
+let df_12_ja = new Intl.DateTimeFormat(
+    "ja-JP", {hour: "numeric", minute: "numeric", hourCycle: "h12"})
+assertEquals("h12", df_12_ja.resolvedOptions().hourCycle);
+assertEquals("午前12:00", df_12_ja.format(midnight));
+assertEquals("午後12:00", df_12_ja.format(noon));
+
+let df_23_ja = new Intl.DateTimeFormat(
+    "ja-JP", {hour: "numeric", minute: "numeric", hourCycle: "h23"})
+assertEquals("h23", df_23_ja.resolvedOptions().hourCycle);
+assertEquals("0:00", df_23_ja.format(midnight));
+assertEquals("12:00", df_23_ja.format(noon));
+
+let df_24_ja = new Intl.DateTimeFormat(
+    "ja-JP", {hour: "numeric", minute: "numeric", hourCycle: "h24"})
+assertEquals("h24", df_24_ja.resolvedOptions().hourCycle);
+assertEquals("24:00", df_24_ja.format(midnight));
+assertEquals("12:00", df_24_ja.format(noon));

deps/v8/test/intl/date-format/invalid-time.js

@@ -0,0 +1,20 @@
+// Copyright 2017 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+var df = new Intl.DateTimeFormat();
+
+assertThrows("df.format(Infinity)", RangeError);
+assertThrows("df.formatToParts(Infinity)", RangeError);
+assertThrows("df.format(-Infinity)", RangeError);
+assertThrows("df.formatToParts(-Infinity)", RangeError);
+assertThrows("df.format(NaN)", RangeError);
+assertThrows("df.formatToParts(NaN)", RangeError);
+
+// https://crbug.com/774833
+var df2 = new Intl.DateTimeFormat('en', {'hour': 'numeric'});
+Date.prototype.valueOf = "ponies";
+assertEquals(df.format(Date.now()), df.format());
+assertEquals(df2.format(Date.now()), df2.format());
+assertEquals(df.formatToParts(Date.now()), df.formatToParts());
+assertEquals(df2.formatToParts(Date.now()), df2.formatToParts());

deps/v8/test/intl/date-format/month-far-future.js

@@ -0,0 +1,32 @@
+// Copyright 2018 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Test for crbug.com/801602 .
+
+var locales = [
+    "en-u-ca-gregori",
+    "fa-u-ca-persian",
+    "ar-u-ca-islamic-civil",
+    "ar-u-ca-islamic-umalqura",
+    "ar-u-ca-islamic-tbla",
+    "ar-u-ca-islamic-rgsa",
+    "he-u-ca-hebrew",
+    "zh-u-ca-chinese",
+    "ko-u-ca-dangi",
+    "ja-u-ca-japanese",
+    "am-u-ca-ethiopic",
+    "am-u-ca-ethioaa",
+    "hi-u-ca-indian",
+    "th-u-ca-buddhist",
+];
+
+// Used to test with 1.7976931348623157e+308, but it does not work
+// any more with TimeClip. Instead, try the largest time value.
+var end_of_time =  8.64e15;
+
+locales.forEach(function(loc) {
+  var df = new Intl.DateTimeFormat(loc, {month: "long"});
+  assertFalse(df.format(end_of_time) == '');
+}
+);

deps/v8/test/intl/date-format/property-override-date-style.js

@@ -0,0 +1,46 @@
+// Copyright 2019 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Checks for security holes introduced by Object.property overrides.
+// For example:
+// Object.defineProperty(Array.prototype, 'locale', {
+//   set: function(value) {
+//     throw new Error('blah');
+//   },
+//   configurable: true,
+//   enumerable: false
+// });
+//
+// would throw in case of (JS) x.locale = 'us' or (C++) x->Set('locale', 'us').
+//
+// First get supported properties.
+// Some of the properties are optional, so we request them.
+var properties = [];
+var options = Intl.DateTimeFormat(
+  'en-US', {dateStyle: 'full'}).resolvedOptions();
+for (var prop in options) {
+  if (options.hasOwnProperty(prop)) {
+    properties.push(prop);
+  }
+}
+
+// In the order of Table 6 of
+// ecma402 #sec-intl.datetimeformat.prototype.resolvedoptions
+var expectedProperties = [
+  'locale',
+  'calendar',
+  'numberingSystem',
+  'timeZone',
+  'dateStyle',
+];
+
+assertEquals(expectedProperties.length, properties.length);
+
+properties.forEach(function(prop) {
+  assertFalse(expectedProperties.indexOf(prop) === -1);
+});
+
+taintProperties(properties);
+
+var locale = Intl.DateTimeFormat().resolvedOptions().locale;

deps/v8/test/intl/date-format/property-override-date-time-style.js

@@ -0,0 +1,49 @@
+// Copyright 2019 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Checks for security holes introduced by Object.property overrides.
+// For example:
+// Object.defineProperty(Array.prototype, 'locale', {
+//   set: function(value) {
+//     throw new Error('blah');
+//   },
+//   configurable: true,
+//   enumerable: false
+// });
+//
+// would throw in case of (JS) x.locale = 'us' or (C++) x->Set('locale', 'us').
+
+// First get supported properties.
+// Some of the properties are optional, so we request them.
+var properties = [];
+var options = Intl.DateTimeFormat(
+  'en-US', {dateStyle: 'full', timeStyle: 'full'}).resolvedOptions();
+for (var prop in options) {
+  if (options.hasOwnProperty(prop)) {
+    properties.push(prop);
+  }
+}
+
+// In the order of Table 6 of
+// ecma402 #sec-intl.datetimeformat.prototype.resolvedoptions
+var expectedProperties = [
+  'locale',
+  'calendar',
+  'numberingSystem',
+  'timeZone',
+  'hourCycle',
+  'hour12',
+  'dateStyle',
+  'timeStyle',
+];
+
+assertEquals(expectedProperties.length, properties.length);
+
+properties.forEach(function(prop) {
+  assertFalse(expectedProperties.indexOf(prop) === -1);
+});
+
+taintProperties(properties);
+
+var locale = Intl.DateTimeFormat().resolvedOptions().locale;

deps/v8/test/intl/date-format/property-override-time-style.js

@@ -0,0 +1,48 @@
+// Copyright 2019 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Checks for security holes introduced by Object.property overrides.
+// For example:
+// Object.defineProperty(Array.prototype, 'locale', {
+//   set: function(value) {
+//     throw new Error('blah');
+//   },
+//   configurable: true,
+//   enumerable: false
+// });
+//
+// would throw in case of (JS) x.locale = 'us' or (C++) x->Set('locale', 'us').
+
+// First get supported properties.
+// Some of the properties are optional, so we request them.
+var properties = [];
+var options = Intl.DateTimeFormat(
+  'en-US', {timeStyle: 'full'}).resolvedOptions();
+for (var prop in options) {
+  if (options.hasOwnProperty(prop)) {
+    properties.push(prop);
+  }
+}
+
+// In the order of Table 6 of
+// ecma402 #sec-intl.datetimeformat.prototype.resolvedoptions
+var expectedProperties = [
+  'locale',
+  'calendar',
+  'numberingSystem',
+  'timeZone',
+  'hourCycle',
+  'hour12',
+  'timeStyle',
+];
+
+assertEquals(expectedProperties.length, properties.length);
+
+properties.forEach(function(prop) {
+  assertFalse(expectedProperties.indexOf(prop) === -1);
+});
+
+taintProperties(properties);
+
+var locale = Intl.DateTimeFormat().resolvedOptions().locale;

deps/v8/test/intl/date-format/property-override.js

@@ -0,0 +1,84 @@
+// Copyright 2013 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Checks for security holes introduced by Object.property overrides.
+// For example:
+// Object.defineProperty(Array.prototype, 'locale', {
+//   set: function(value) {
+//     throw new Error('blah');
+//   },
+//   configurable: true,
+//   enumerable: false
+// });
+//
+// would throw in case of (JS) x.locale = 'us' or (C++) x->Set('locale', 'us').
+//
+// Update both date-format.js and date-format.cc so they have the same list of
+// properties.
+
+// First get supported properties.
+// Some of the properties are optional, so we request them.
+var properties = [];
+var options = Intl.DateTimeFormat(
+  'en-US', {weekday: 'short', era: 'short', year: 'numeric', month: 'short',
+            day: 'numeric', hour: 'numeric', minute: 'numeric',
+            second: 'numeric', timeZoneName: 'short'}).resolvedOptions();
+for (var prop in options) {
+  if (options.hasOwnProperty(prop)) {
+    properties.push(prop);
+  }
+}
+
+// In the order of Table 6 of
+// ecma402 #sec-intl.datetimeformat.prototype.resolvedoptions
+var expectedProperties = [
+  'locale',
+  'calendar',
+  'numberingSystem',
+  'timeZone',
+  'hourCycle',
+  'hour12',
+  'weekday',
+  'era',
+  'year',
+  'month',
+  'day',
+  'hour',
+  'minute',
+  'second',
+  'timeZoneName',
+];
+
+assertEquals(expectedProperties.length, properties.length);
+
+properties.forEach(function(prop) {
+  assertFalse(expectedProperties.indexOf(prop) === -1);
+});
+
+taintProperties(properties);
+
+var locale = Intl.DateTimeFormat().resolvedOptions().locale;

deps/v8/test/intl/date-format/related-year.js

@@ -0,0 +1,13 @@
+// Copyright 2019 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Test it will output relatedYear and yearName
+
+let df = new Intl.DateTimeFormat("zh-u-ca-chinese", {year: "numeric"})
+let date = new Date(2019, 5, 1);
+assertEquals("2019己亥年", df.format(date));
+assertEquals([{type: "relatedYear", value: "2019"},
+              {type: "yearName", value: "己亥"},
+              {type: "literal", value: "年"}],
+             df.formatToParts(date));

deps/v8/test/intl/date-format/resolved-options-is-method.js

@@ -0,0 +1,40 @@
+// Copyright 2013 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Test that resolvedOptions is a method, not a property getter and that
+// the result is mutable.
+
+var dtf = new Intl.DateTimeFormat();
+
+var result = dtf.resolvedOptions();
+
+assertTrue(result instanceof Object);
+
+// Result should be mutable.
+result.locale = 'xx';
+
+assertEquals(result.locale, 'xx');

deps/v8/test/intl/date-format/resolved-options-unwrap.js

@@ -0,0 +1,11 @@
+// Copyright 2018 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Test the Intl.DateTimeFormat.prototype.resolvedOptions will properly handle
+// 3. Let dtf be ? UnwrapDateTimeFormat(dtf).
+var x = Object.create(Intl.DateTimeFormat.prototype);
+x = Intl.DateTimeFormat.call(x, 'en');
+
+var resolvedOptions = Intl.DateTimeFormat.prototype.resolvedOptions.call(x);
+assertEquals(resolvedOptions.locale, 'en')

deps/v8/test/intl/date-format/resolved-options.js

@@ -0,0 +1,108 @@
+// Copyright 2013 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Test if resolvedOptions() returns expected fields/values.
+
+// Default (year, month, day) formatter.
+var dtfDefault = Intl.DateTimeFormat('en-US');
+var resolved = dtfDefault.resolvedOptions();
+
+assertTrue(resolved.hasOwnProperty('locale'));
+assertEquals('en-US', resolved.locale);
+assertTrue(resolved.hasOwnProperty('numberingSystem'));
+assertEquals('latn', resolved.numberingSystem);
+assertTrue(resolved.hasOwnProperty('calendar'));
+assertEquals('gregory', resolved.calendar);
+assertTrue(resolved.hasOwnProperty('timeZone'));
+// TODO(littledan): getDefaultTimeZone() is not available from JavaScript
+// assertEquals(getDefaultTimeZone(), resolved.timeZone);
+// These are in by default.
+assertTrue(resolved.hasOwnProperty('year'));
+assertEquals('numeric', resolved.year);
+assertTrue(resolved.hasOwnProperty('month'));
+assertEquals('numeric', resolved.month);
+assertTrue(resolved.hasOwnProperty('day'));
+assertEquals('numeric', resolved.day);
+// These shouldn't be in by default.
+assertFalse(resolved.hasOwnProperty('era'));
+assertFalse(resolved.hasOwnProperty('timeZoneName'));
+assertFalse(resolved.hasOwnProperty('weekday'));
+assertFalse(resolved.hasOwnProperty('hour12'));
+assertFalse(resolved.hasOwnProperty('hour'));
+assertFalse(resolved.hasOwnProperty('minute'));
+assertFalse(resolved.hasOwnProperty('second'));
+
+// Time formatter.
+var dtfTime = Intl.DateTimeFormat(
+  'sr-RS', {hour: 'numeric', minute: 'numeric', second: 'numeric'});
+resolved = dtfTime.resolvedOptions();
+
+assertTrue(resolved.hasOwnProperty('locale'));
+assertTrue(resolved.hasOwnProperty('numberingSystem'));
+assertTrue(resolved.hasOwnProperty('calendar'));
+assertTrue(resolved.hasOwnProperty('timeZone'));
+assertTrue(resolved.hasOwnProperty('hour12'));
+assertEquals(false, resolved.hour12);
+assertTrue(resolved.hasOwnProperty('hour'));
+assertEquals('2-digit', resolved.hour);
+assertTrue(resolved.hasOwnProperty('minute'));
+assertEquals('2-digit', resolved.minute);
+assertTrue(resolved.hasOwnProperty('second'));
+assertEquals('2-digit', resolved.second);
+// Didn't ask for them.
+assertFalse(resolved.hasOwnProperty('year'));
+assertFalse(resolved.hasOwnProperty('month'));
+assertFalse(resolved.hasOwnProperty('day'));
+assertFalse(resolved.hasOwnProperty('era'));
+assertFalse(resolved.hasOwnProperty('timeZoneName'));
+assertFalse(resolved.hasOwnProperty('weekday'));
+
+// Full formatter.
+var dtfFull = Intl.DateTimeFormat(
+  'en-US', {weekday: 'short', era: 'short', year: 'numeric', month: 'short',
+            day: 'numeric', hour: 'numeric', minute: 'numeric',
+            second: 'numeric', timeZoneName: 'short', timeZone: 'UTC'});
+resolved = dtfFull.resolvedOptions();
+
+assertTrue(resolved.hasOwnProperty('locale'));
+assertTrue(resolved.hasOwnProperty('numberingSystem'));
+assertTrue(resolved.hasOwnProperty('calendar'));
+assertTrue(resolved.hasOwnProperty('timeZone'));
+assertTrue(resolved.hasOwnProperty('hour12'));
+assertEquals(true, resolved.hour12);
+assertTrue(resolved.hasOwnProperty('hour'));
+assertTrue(resolved.hasOwnProperty('minute'));
+assertTrue(resolved.hasOwnProperty('second'));
+assertTrue(resolved.hasOwnProperty('year'));
+assertTrue(resolved.hasOwnProperty('month'));
+assertTrue(resolved.hasOwnProperty('day'));
+assertTrue(resolved.hasOwnProperty('era'));
+assertEquals('short', resolved.era);
+assertTrue(resolved.hasOwnProperty('timeZoneName'));
+assertEquals('short', resolved.timeZoneName);
+assertTrue(resolved.hasOwnProperty('weekday'));
+assertEquals('short', resolved.weekday);

deps/v8/test/intl/date-format/time_style_hour_cycle.js

@@ -0,0 +1,54 @@
+// Copyright 2019 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+let midnight = new Date(2019, 3, 4, 0);
+let noon = new Date(2019, 3, 4, 12);
+
+let df_11_t = new Intl.DateTimeFormat(
+    "en", {timeStyle: "short", hourCycle: "h11"})
+assertEquals("h11", df_11_t.resolvedOptions().hourCycle);
+assertEquals("0:00 AM", df_11_t.format(midnight));
+assertEquals("0:00 PM", df_11_t.format(noon));
+
+let df_12_t = new Intl.DateTimeFormat(
+    "en", {timeStyle: "short", hourCycle: "h12"})
+assertEquals("h12", df_12_t.resolvedOptions().hourCycle);
+assertEquals("12:00 AM", df_12_t.format(midnight));
+assertEquals("12:00 PM", df_12_t.format(noon));
+
+let df_23_t = new Intl.DateTimeFormat(
+    "en", {timeStyle: "short", hourCycle: "h23"})
+assertEquals("h23", df_23_t.resolvedOptions().hourCycle);
+assertEquals("00:00", df_23_t.format(midnight));
+assertEquals("12:00" ,df_23_t.format(noon));
+
+let df_24_t = new Intl.DateTimeFormat(
+    "en", {timeStyle: "short", hourCycle: "h24"})
+assertEquals("h24", df_24_t.resolvedOptions().hourCycle);
+assertEquals("24:00", df_24_t.format(midnight));
+assertEquals("12:00", df_24_t.format(noon));
+
+let df_11_ja_t = new Intl.DateTimeFormat(
+    "ja-JP", {timeStyle: "short", hourCycle: "h11"})
+assertEquals("h11", df_11_ja_t.resolvedOptions().hourCycle);
+assertEquals("午前0:00", df_11_ja_t.format(midnight));
+assertEquals("午後0:00", df_11_ja_t.format(noon));
+
+let df_12_ja_t = new Intl.DateTimeFormat(
+    "ja-JP", {timeStyle: "short", hourCycle: "h12"})
+assertEquals("h12", df_12_ja_t.resolvedOptions().hourCycle);
+assertEquals("午前12:00", df_12_ja_t.format(midnight));
+assertEquals("午後12:00", df_12_ja_t.format(noon));
+
+let df_23_ja_t = new Intl.DateTimeFormat(
+    "ja-JP", {timeStyle: "short", hourCycle: "h23"})
+assertEquals("h23", df_23_ja_t.resolvedOptions().hourCycle);
+assertEquals("0:00", df_23_ja_t.format(midnight));
+assertEquals("12:00", df_23_ja_t.format(noon));
+
+let df_24_ja_t = new Intl.DateTimeFormat(
+    "ja-JP", {timeStyle: "short", hourCycle: "h24"})
+assertEquals("h24", df_24_ja_t.resolvedOptions().hourCycle);
+assertEquals("24:00", df_24_ja_t.format(midnight));
+assertEquals("12:00", df_24_ja_t.format(noon));

deps/v8/test/intl/date-format/timezone-conversion.js

@@ -0,0 +1,17 @@
+// Copyright 2018 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// Tests time zone support with conversion.
+
+df = Intl.DateTimeFormat(undefined, {timeZone: 'America/Los_Angeles'});
+assertEquals('America/Los_Angeles', df.resolvedOptions().timeZone);
+
+df = Intl.DateTimeFormat(undefined, {timeZone: {toString() { return 'America/Los_Angeles'}}});
+assertEquals('America/Los_Angeles', df.resolvedOptions().timeZone);
+
+assertThrows(() => Intl.DateTimeFormat(
+    undefined, {timeZone: {toString() { throw new Error("should throw"); }}}));
+
+assertThrows(() => Intl.DateTimeFormat(
+    undefined, {get timeZone() { throw new Error("should throw"); }}));

deps/v8/test/intl/date-format/timezone-name-extended.js

@@ -0,0 +1,59 @@
+// Copyright 2021 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+// Tests time zone names.
+
+// Winter date (PST).
+var winter = new Date(2013, 1, 12, 14, 42, 53, 0);
+
+// Summer date (PDT).
+var summer = new Date(2013, 7, 12, 14, 42, 53, 0);
+
+// Common flags for both formatters.
+var flags = {
+  year: 'numeric', month: 'long', day: 'numeric',
+  hour : '2-digit', minute : '2-digit', second : '2-digit',
+  timeZone: 'America/Los_Angeles'
+};
+
+flags.timeZoneName = "short";
+var dfs = new Intl.DateTimeFormat('en-US', flags);
+
+assertTrue(dfs.format(winter).indexOf('PST') !== -1);
+assertTrue(dfs.format(summer).indexOf('PDT') !== -1);
+assertEquals(flags.timeZoneName, dfs.resolvedOptions().timeZoneName);
+
+flags.timeZoneName = "long";
+var dfl = new Intl.DateTimeFormat('en-US', flags);
+
+assertTrue(dfl.format(winter).indexOf('Pacific Standard Time') !== -1);
+assertTrue(dfl.format(summer).indexOf('Pacific Daylight Time') !== -1);
+assertEquals(flags.timeZoneName, dfl.resolvedOptions().timeZoneName);
+
+flags.timeZoneName = "shortGeneric";
+var dfsg = new Intl.DateTimeFormat('en-US', flags);
+
+assertTrue(dfsg.format(winter).indexOf('PT') !== -1);
+assertTrue(dfsg.format(summer).indexOf('PT') !== -1);
+assertEquals(flags.timeZoneName, dfsg.resolvedOptions().timeZoneName);
+
+flags.timeZoneName = "longGeneric";
+var dflg = new Intl.DateTimeFormat('en-US', flags);
+
+assertTrue(dflg.format(winter).indexOf('Pacific Time') !== -1);
+assertTrue(dflg.format(summer).indexOf('Pacific Time') !== -1);
+assertEquals(flags.timeZoneName, dflg.resolvedOptions().timeZoneName);
+
+flags.timeZoneName = "shortOffset";
+var dfso = new Intl.DateTimeFormat('en-US', flags);
+
+assertTrue(dfso.format(winter).indexOf('GMT-8') !== -1);
+assertTrue(dfso.format(summer).indexOf('GMT-7') !== -1);
+assertEquals(flags.timeZoneName, dfso.resolvedOptions().timeZoneName);
+
+flags.timeZoneName = "longOffset";
+var dflo = new Intl.DateTimeFormat('en-US', flags);
+
+assertTrue(dflo.format(winter).indexOf('GMT-08:00') !== -1);
+assertTrue(dflo.format(summer).indexOf('GMT-07:00') !== -1);
+assertEquals(flags.timeZoneName, dflo.resolvedOptions().timeZoneName);

deps/v8/test/intl/date-format/timezone-name.js

@@ -0,0 +1,53 @@
+// Copyright 2013 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Tests time zone names.
+
+// Winter date (PST).
+var winter = new Date(2013, 1, 12, 14, 42, 53, 0);
+
+// Summer date (PDT).
+var summer = new Date(2013, 7, 12, 14, 42, 53, 0);
+
+// Common flags for both formatters.
+var flags = {
+  year: 'numeric', month: 'long', day: 'numeric',
+  hour : '2-digit', minute : '2-digit', second : '2-digit',
+  timeZone: 'America/Los_Angeles'
+};
+
+flags.timeZoneName = "short";
+var dfs = new Intl.DateTimeFormat('en-US', flags);
+
+assertTrue(dfs.format(winter).indexOf('PST') !== -1);
+assertTrue(dfs.format(summer).indexOf('PDT') !== -1);
+
+flags.timeZoneName = "long";
+var dfl = new Intl.DateTimeFormat('en-US', flags);
+
+assertTrue(dfl.format(winter).indexOf('Pacific Standard Time') !== -1);
+assertTrue(dfl.format(summer).indexOf('Pacific Daylight Time') !== -1);

deps/v8/test/intl/date-format/timezone.js

@@ -0,0 +1,77 @@
+// Copyright 2013 the V8 project authors. All rights reserved.
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+//       notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+//       copyright notice, this list of conditions and the following
+//       disclaimer in the documentation and/or other materials provided
+//       with the distribution.
+//     * Neither the name of Google Inc. nor the names of its
+//       contributors may be used to endorse or promote products derived
+//       from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Tests time zone support.
+
+// TODO(littledan): getDefaultTimeZone() is not available from JavaScript
+// var df = Intl.DateTimeFormat();
+// assertEquals(getDefaultTimeZone(), df.resolvedOptions().timeZone);
+
+[
+  'UtC', 'gmt', 'Etc/UTC', 'Etc/GMT', 'Etc/GMT0', 'Etc/GMT+0',
+  'etc/gmt-0', 'etc/zulu', 'Etc/universal', 'etc/greenwich'
+].forEach((timezone) => {
+  const df = Intl.DateTimeFormat(undefined, {timeZone: timezone});
+  assertEquals('UTC', df.resolvedOptions().timeZone);
+})
+
+// See test/mjsunit/regress/regress-crbug-364374.js for additional/ tests.
+
+df = Intl.DateTimeFormat(undefined, {timeZone: 'America/Los_Angeles'});
+assertEquals('America/Los_Angeles', df.resolvedOptions().timeZone);
+
+df = Intl.DateTimeFormat(undefined, {timeZone: 'Europe/Belgrade'});
+assertEquals('Europe/Belgrade', df.resolvedOptions().timeZone);
+
+df = Intl.DateTimeFormat(undefined, {timeZone: 'euRope/beLGRade'});
+assertEquals('Europe/Belgrade', df.resolvedOptions().timeZone);
+
+// Etc/GMT-14 to Etc/GMT+12 are valid.
+df = Intl.DateTimeFormat(undefined, {timeZone: 'etc/gmt+12'});
+assertEquals('Etc/GMT+12', df.resolvedOptions().timeZone);
+
+df = Intl.DateTimeFormat(undefined, {timeZone: 'etc/gmt+9'});
+assertEquals('Etc/GMT+9', df.resolvedOptions().timeZone);
+
+df = Intl.DateTimeFormat(undefined, {timeZone: 'etc/gmt-9'});
+assertEquals('Etc/GMT-9', df.resolvedOptions().timeZone);
+
+df = Intl.DateTimeFormat(undefined, {timeZone: 'etc/gmt-14'});
+assertEquals('Etc/GMT-14', df.resolvedOptions().timeZone);
+
+assertThrows('Intl.DateTimeFormat(undefined, {timeZone: \'Etc/GMT+13\'})');
+
+// : + - are not allowed, only / _ are.
+assertThrows('Intl.DateTimeFormat(undefined, {timeZone: \'GMT+07:00\'})');
+assertThrows('Intl.DateTimeFormat(undefined, {timeZone: \'GMT+0700\'})');
+assertThrows('Intl.DateTimeFormat(undefined, {timeZone: \'GMT-05:00\'})');
+assertThrows('Intl.DateTimeFormat(undefined, {timeZone: \'GMT-0500\'})');
+assertThrows('Intl.DateTimeFormat(undefined, ' +
+    '{timeZone: \'America/Los-Angeles\'})');
+
+// Throws for unsupported time zones.
+assertThrows('Intl.DateTimeFormat(undefined, {timeZone: \'Aurope/Belgrade\'})');

deps/v8/test/intl/date-format/unmodified-options.js

@@ -0,0 +1,17 @@
+// Copyright 2016 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+let options = {};
+new Intl.DateTimeFormat(undefined, options);
+assertEquals([], Object.getOwnPropertyNames(options));
+
+let date = new Date();
+date.toLocaleString(undefined, options);
+assertEquals([], Object.getOwnPropertyNames(options));
+
+date.toLocaleDateString(undefined, options);
+assertEquals([], Object.getOwnPropertyNames(options));
+
+date.toLocaleTimeString(undefined, options);
+assertEquals([], Object.getOwnPropertyNames(options));