diff --git a/test/staging/Temporal/Duration/old/add.js b/test/staging/Temporal/Duration/old/add.js
new file mode 100644
index 0000000000..02868b29bb
--- /dev/null
+++ b/test/staging/Temporal/Duration/old/add.js
@@ -0,0 +1,149 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-duration-objects
+description: Temporal.Duration.prototype.add() works as expected
+features: [Temporal]
+---*/
+
+var oneDay = new Temporal.Duration(0, 0, 0, 1);
+var hours24 = new Temporal.Duration(0, 0, 0, 0, 24);
+
+// relativeTo does not affect days if PlainDate
+var relativeTo = Temporal.PlainDate.from("2017-01-01");
+assert.sameValue(`${ oneDay.add(hours24, { relativeTo }) }`, "P2D");
+
+// relativeTo does not affect days if ZonedDateTime, and duration encompasses no DST change
+var relativeTo = Temporal.ZonedDateTime.from("2017-01-01T00:00[America/Montevideo]");
+assert.sameValue(`${ oneDay.add(hours24, { relativeTo }) }`, "P2D");
+var skippedHourDay = Temporal.ZonedDateTime.from("2019-03-10T00:00[America/Vancouver]");
+var repeatedHourDay = Temporal.ZonedDateTime.from("2019-11-03T00:00[America/Vancouver]");
+var inRepeatedHour = Temporal.ZonedDateTime.from("2019-11-03T01:00-07:00[America/Vancouver]");
+var hours12 = new Temporal.Duration(0, 0, 0, 0, 12);
+var hours25 = new Temporal.Duration(0, 0, 0, 0, 25);
+
+// relativeTo affects days if ZonedDateTime, and duration encompasses DST change",
+
+// start inside repeated hour, end after",
+assert.sameValue(`${ hours25.add(oneDay, { relativeTo: inRepeatedHour }) }`, "P2D");
+assert.sameValue(`${ oneDay.add(hours25, { relativeTo: inRepeatedHour }) }`, "P2DT1H");
+
+// start after repeated hour, end inside (negative)"
+var relativeTo = Temporal.ZonedDateTime.from("2019-11-05T01:00[America/Vancouver]");
+assert.sameValue(`${ hours25.negated().add(oneDay.negated(), { relativeTo }) }`, "-P2DT1H");
+assert.sameValue(`${ oneDay.negated().add(hours25.negated(), { relativeTo }) }`, "-P2D");
+
+// start inside repeated hour, end in skipped hour",
+assert.sameValue(`${ hours25.add(Temporal.Duration.from({
+ days: 125,
+ hours: 1
+}), { relativeTo: inRepeatedHour }) }`, "P126DT1H");
+assert.sameValue(`${ oneDay.add(Temporal.Duration.from({
+ days: 125,
+ hours: 1
+}), { relativeTo: inRepeatedHour }) }`, "P126DT1H");
+
+// start in normal hour, end in skipped hour",
+var relativeTo = Temporal.ZonedDateTime.from("2019-03-08T02:30[America/Vancouver]");
+assert.sameValue(`${ oneDay.add(hours25, { relativeTo }) }`, "P2DT1H");
+assert.sameValue(`${ hours25.add(oneDay, { relativeTo }) }`, "P2D");
+
+// start before skipped hour, end >1 day after",
+assert.sameValue(`${ hours25.add(oneDay, { relativeTo: skippedHourDay }) }`, "P2DT2H");
+assert.sameValue(`${ oneDay.add(hours25, { relativeTo: skippedHourDay }) }`, "P2DT1H");
+
+// start after skipped hour, end >1 day before (negative)",
+var relativeTo = Temporal.ZonedDateTime.from("2019-03-11T00:00[America/Vancouver]");
+assert.sameValue(`${ hours25.negated().add(oneDay.negated(), { relativeTo }) }`, "-P2DT2H");
+assert.sameValue(`${ oneDay.negated().add(hours25.negated(), { relativeTo }) }`, "-P2DT1H");
+
+// start before skipped hour, end <1 day after",
+assert.sameValue(`${ hours12.add(oneDay, { relativeTo: skippedHourDay }) }`, "P1DT13H");
+assert.sameValue(`${ oneDay.add(hours12, { relativeTo: skippedHourDay }) }`, "P1DT12H");
+
+// start after skipped hour, end <1 day before (negative)",
+var relativeTo = Temporal.ZonedDateTime.from("2019-03-10T12:00[America/Vancouver]");
+assert.sameValue(`${ hours12.negated().add(oneDay.negated(), { relativeTo }) }`, "-P1DT13H");
+assert.sameValue(`${ oneDay.negated().add(hours12.negated(), { relativeTo }) }`, "-P1DT12H");
+
+// start before repeated hour, end >1 day after",
+assert.sameValue(`${ hours25.add(oneDay, { relativeTo: repeatedHourDay }) }`, "P2D");
+assert.sameValue(`${ oneDay.add(hours25, { relativeTo: repeatedHourDay }) }`, "P2DT1H");
+
+// start after repeated hour, end >1 day before (negative)",
+var relativeTo = Temporal.ZonedDateTime.from("2019-11-04T00:00[America/Vancouver]");
+assert.sameValue(`${ hours25.negated().add(oneDay.negated(), { relativeTo }) }`, "-P2D");
+assert.sameValue(`${ oneDay.negated().add(hours25.negated(), { relativeTo }) }`, "-P2DT1H");
+
+// start before repeated hour, end <1 day after",
+assert.sameValue(`${ hours12.add(oneDay, { relativeTo: repeatedHourDay }) }`, "P1DT11H");
+assert.sameValue(`${ oneDay.add(hours12, { relativeTo: repeatedHourDay }) }`, "P1DT12H");
+
+// start after repeated hour, end <1 day before (negative)",
+var relativeTo = Temporal.ZonedDateTime.from("2019-11-03T12:00[America/Vancouver]");
+assert.sameValue(`${ hours12.negated().add(oneDay.negated(), { relativeTo }) }`, "-P1DT11H");
+assert.sameValue(`${ oneDay.negated().add(hours12.negated(), { relativeTo }) }`, "-P1DT12H");
+
+// Samoa skipped 24 hours",
+var relativeTo = Temporal.ZonedDateTime.from("2011-12-29T12:00-10:00[Pacific/Apia]");
+assert.sameValue(`${ hours25.add(oneDay, { relativeTo }) }`, "P3DT1H");
+assert.sameValue(`${ oneDay.add(hours25, { relativeTo }) }`, "P3DT1H");
+
+// casts relativeTo to ZonedDateTime if possible
+assert.sameValue(`${ oneDay.add(hours24, { relativeTo: "2019-11-02T00:00[America/Vancouver]" }) }`, "P1DT24H");
+assert.sameValue(`${ oneDay.add(hours24, {
+ relativeTo: {
+ year: 2019,
+ month: 11,
+ day: 2,
+ timeZone: "America/Vancouver"
+ }
+}) }`, "P1DT24H");
+
+// casts relativeTo to PlainDate if possible
+assert.sameValue(`${ oneDay.add(hours24, { relativeTo: "2019-11-02" }) }`, "P2D");
+assert.sameValue(`${ oneDay.add(hours24, {
+ relativeTo: {
+ year: 2019,
+ month: 11,
+ day: 2
+ }
+}) }`, "P2D");
+
+// throws on wrong offset for ZonedDateTime relativeTo string
+assert.throws(RangeError, () => oneDay.add(hours24, { relativeTo: "1971-01-01T00:00+02:00[Africa/Monrovia]" }));
+
+// does not throw on HH:MM rounded offset for ZonedDateTime relativeTo string
+assert.sameValue(`${ oneDay.add(hours24, { relativeTo: "1971-01-01T00:00-00:45[Africa/Monrovia]" }) }`, "P2D");
+
+// throws on HH:MM rounded offset for ZonedDateTime relativeTo property bag
+assert.throws(RangeError, () => oneDay.add(hours24, {
+ relativeTo: {
+ year: 1971,
+ month: 1,
+ day: 1,
+ offset: "-00:45",
+ timeZone: "Africa/Monrovia"
+ }
+}));
+
+// at least the required properties must be present in relativeTo
+assert.throws(TypeError, () => oneDay.add(hours24, {
+ relativeTo: {
+ month: 11,
+ day: 3
+ }
+}));
+assert.throws(TypeError, () => oneDay.add(hours24, {
+ relativeTo: {
+ year: 2019,
+ month: 11
+ }
+}));
+assert.throws(TypeError, () => oneDay.add(hours24, {
+ relativeTo: {
+ year: 2019,
+ day: 3
+ }
+}));
diff --git a/test/staging/Temporal/Duration/old/compare-no-precision-loss.js b/test/staging/Temporal/Duration/old/compare-no-precision-loss.js
new file mode 100644
index 0000000000..8cab5ade20
--- /dev/null
+++ b/test/staging/Temporal/Duration/old/compare-no-precision-loss.js
@@ -0,0 +1,13 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-duration-objects
+description: Temporal.Duration.compare() does not lose precision when totaling everything down to nanoseconds
+features: [Temporal]
+---*/
+
+assert.notSameValue(Temporal.Duration.compare({ days: 200 }, {
+ days: 200,
+ nanoseconds: 1
+}), 0);
diff --git a/test/staging/Temporal/Duration/old/limits.js b/test/staging/Temporal/Duration/old/limits.js
new file mode 100644
index 0000000000..eb24e8316b
--- /dev/null
+++ b/test/staging/Temporal/Duration/old/limits.js
@@ -0,0 +1,92 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-duration-objects
+description: min/max values
+features: [Temporal]
+---*/
+
+var units = [
+ "years",
+ "months",
+ "weeks",
+ "days",
+ "hours",
+ "minutes",
+ "seconds",
+ "milliseconds",
+ "microseconds",
+ "nanoseconds"
+];
+
+// minimum is zero
+assert.sameValue(`${ new Temporal.Duration(0, 0, 0, 0, 0, 0, 0, 0, 0, 0) }`, "PT0S");
+units.forEach(unit => assert.sameValue(`${ Temporal.Duration.from({ [unit]: 0 }) }`, "PT0S"));
+[
+ "P0Y",
+ "P0M",
+ "P0W",
+ "P0D",
+ "PT0H",
+ "PT0M",
+ "PT0S"
+].forEach(str => assert.sameValue(`${ Temporal.Duration.from(str) }`, "PT0S"));
+
+// unrepresentable number is not allowed
+units.forEach((unit, ix) => {
+ assert.throws(RangeError, () => new Temporal.Duration(...Array(ix).fill(0), 1e+400));
+ assert.throws(RangeError, () => Temporal.Duration.from({ [unit]: 1e+400 }));
+});
+var manyNines = "9".repeat(309);
+[
+ `P${ manyNines }Y`,
+ `P${ manyNines }M`,
+ `P${ manyNines }W`,
+ `P${ manyNines }D`,
+ `PT${ manyNines }H`,
+ `PT${ manyNines }M`,
+ `PT${ manyNines }S`
+].forEach(str => assert.throws(RangeError, () => Temporal.Duration.from(str)));
+
+// max safe integer is allowed
+[
+ "P9007199254740991Y",
+ "P9007199254740991M",
+ "P9007199254740991W",
+ "P9007199254740991D",
+ "PT9007199254740991H",
+ "PT9007199254740991M",
+ "PT9007199254740991S",
+ "PT9007199254740.991S",
+ "PT9007199254.740991S",
+ "PT9007199.254740991S"
+].forEach((str, ix) => {
+ assert.sameValue(`${ new Temporal.Duration(...Array(ix).fill(0), Number.MAX_SAFE_INTEGER) }`, str);
+ assert.sameValue(`${ Temporal.Duration.from(str) }`, str);
+});
+
+// larger integers are allowed but may lose precision
+function test(ix, prefix, suffix, infix = "") {
+ function doAsserts(duration) {
+ var str = duration.toString();
+ assert.sameValue(str.slice(0, prefix.length + 10), `${ prefix }1000000000`);
+ assert(str.includes(infix));
+ assert.sameValue(str.slice(-1), suffix);
+ assert.sameValue(str.length, prefix.length + suffix.length + infix.length + 27);
+ }
+ doAsserts(new Temporal.Duration(...Array(ix).fill(0), 1e+26, ...Array(9 - ix).fill(0)));
+ doAsserts(Temporal.Duration.from({ [units[ix]]: 1e+26 }));
+ if (!infix)
+ doAsserts(Temporal.Duration.from(`${ prefix }100000000000000000000000000${ suffix }`));
+}
+test(0, "P", "Y");
+test(1, "P", "M");
+test(2, "P", "W");
+test(3, "P", "D");
+test(4, "PT", "H");
+test(5, "PT", "M");
+test(6, "PT", "S");
+test(7, "PT", "S", ".");
+test(8, "PT", "S", ".");
+test(9, "PT", "S", ".");
diff --git a/test/staging/Temporal/Duration/old/round.js b/test/staging/Temporal/Duration/old/round.js
new file mode 100644
index 0000000000..16521cc62a
--- /dev/null
+++ b/test/staging/Temporal/Duration/old/round.js
@@ -0,0 +1,902 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-duration-objects
+description: Temporal.Duration.prototype.round() works as expected
+features: [Temporal]
+---*/
+
+var d = new Temporal.Duration(5, 5, 5, 5, 5, 5, 5, 5, 5, 5);
+var d2 = new Temporal.Duration(0, 0, 0, 5, 5, 5, 5, 5, 5, 5);
+var relativeTo = Temporal.PlainDate.from("2020-01-01");
+
+// succeeds with largestUnit: 'auto'
+assert.sameValue(`${ Temporal.Duration.from({ hours: 25 }).round({ largestUnit: "auto" }) }`, "PT25H");
+var hours25 = new Temporal.Duration(0, 0, 0, 0, 25);
+
+// days are 24 hours if relativeTo not given
+assert.sameValue(`${ hours25.round({ largestUnit: "days" }) }`, "P1DT1H");
+
+// days are 24 hours if relativeTo is PlainDate
+var relativeTo = Temporal.PlainDate.from("2017-01-01");
+assert.sameValue(`${ hours25.round({
+ largestUnit: "days",
+ relativeTo
+}) }`, "P1DT1H");
+
+// days are 24 hours if relativeTo is ZonedDateTime, and duration encompasses no DST change
+var relativeTo = Temporal.ZonedDateTime.from("2017-01-01T00:00[America/Montevideo]");
+assert.sameValue(`${ hours25.round({
+ largestUnit: "days",
+ relativeTo
+}) }`, "P1DT1H");
+var skippedHourDay = Temporal.ZonedDateTime.from("2019-03-10T00:00[America/Vancouver]");
+var repeatedHourDay = Temporal.ZonedDateTime.from("2019-11-03T00:00[America/Vancouver]");
+var inRepeatedHour = Temporal.ZonedDateTime.from("2019-11-03T01:00-07:00[America/Vancouver]");
+var oneDay = new Temporal.Duration(0, 0, 0, 1);
+var hours12 = new Temporal.Duration(0, 0, 0, 0, 12);
+
+// relativeTo affects days if ZonedDateTime, and duration encompasses DST change"
+
+// start inside repeated hour, end after",
+assert.sameValue(`${ hours25.round({
+ largestUnit: "days",
+ relativeTo: inRepeatedHour
+}) }`, "P1D");
+assert.sameValue(`${ oneDay.round({
+ largestUnit: "hours",
+ relativeTo: inRepeatedHour
+}) }`, "PT25H");
+
+// start after repeated hour, end inside (negative)",
+var relativeTo = Temporal.ZonedDateTime.from("2019-11-04T01:00[America/Vancouver]");
+assert.sameValue(`${ hours25.negated().round({
+ largestUnit: "days",
+ relativeTo
+}) }`, "-P1D");
+assert.sameValue(`${ oneDay.negated().round({
+ largestUnit: "hours",
+ relativeTo
+}) }`, "-PT25H");
+
+// start inside repeated hour, end in skipped hour",
+assert.sameValue(`${ Temporal.Duration.from({
+ days: 126,
+ hours: 1
+}).round({
+ largestUnit: "days",
+ relativeTo: inRepeatedHour
+}) }`, "P126DT1H");
+assert.sameValue(`${ Temporal.Duration.from({
+ days: 126,
+ hours: 1
+}).round({
+ largestUnit: "hours",
+ relativeTo: inRepeatedHour
+}) }`, "PT3026H");
+
+// start in normal hour, end in skipped hour",
+var relativeTo = Temporal.ZonedDateTime.from("2019-03-09T02:30[America/Vancouver]");
+assert.sameValue(`${ hours25.round({
+ largestUnit: "days",
+ relativeTo
+}) }`, "P1DT1H");
+assert.sameValue(`${ oneDay.round({
+ largestUnit: "hours",
+ relativeTo
+}) }`, "PT24H");
+
+// start before skipped hour, end >1 day after",
+assert.sameValue(`${ hours25.round({
+ largestUnit: "days",
+ relativeTo: skippedHourDay
+}) }`, "P1DT2H");
+assert.sameValue(`${ oneDay.round({
+ largestUnit: "hours",
+ relativeTo: skippedHourDay
+}) }`, "PT23H");
+
+// start after skipped hour, end >1 day before (negative)",
+var relativeTo = Temporal.ZonedDateTime.from("2019-03-11T00:00[America/Vancouver]");
+assert.sameValue(`${ hours25.negated().round({
+ largestUnit: "days",
+ relativeTo
+}) }`, "-P1DT2H");
+assert.sameValue(`${ oneDay.negated().round({
+ largestUnit: "hours",
+ relativeTo
+}) }`, "-PT23H");
+
+// start before skipped hour, end <1 day after",
+assert.sameValue(`${ hours12.round({
+ largestUnit: "days",
+ relativeTo: skippedHourDay
+}) }`, "PT12H");
+
+// start after skipped hour, end <1 day before (negative)",
+var relativeTo = Temporal.ZonedDateTime.from("2019-03-10T12:00[America/Vancouver]");
+assert.sameValue(`${ hours12.negated().round({
+ largestUnit: "days",
+ relativeTo
+}) }`, "-PT12H");
+
+// start before repeated hour, end >1 day after",
+assert.sameValue(`${ hours25.round({
+ largestUnit: "days",
+ relativeTo: repeatedHourDay
+}) }`, "P1D");
+assert.sameValue(`${ oneDay.round({
+ largestUnit: "hours",
+ relativeTo: repeatedHourDay
+}) }`, "PT25H");
+
+// start after repeated hour, end >1 day before (negative)",
+var relativeTo = Temporal.ZonedDateTime.from("2019-11-04T00:00[America/Vancouver]");
+assert.sameValue(`${ hours25.negated().round({
+ largestUnit: "days",
+ relativeTo
+}) }`, "-P1D");
+assert.sameValue(`${ oneDay.negated().round({
+ largestUnit: "hours",
+ relativeTo
+}) }`, "-PT25H");
+
+// start before repeated hour, end <1 day after",
+assert.sameValue(`${ hours12.round({
+ largestUnit: "days",
+ relativeTo: repeatedHourDay
+}) }`, "PT12H");
+
+// start after repeated hour, end <1 day before (negative)",
+var relativeTo = Temporal.ZonedDateTime.from("2019-11-03T12:00[America/Vancouver]");
+assert.sameValue(`${ hours12.negated().round({
+ largestUnit: "days",
+ relativeTo
+}) }`, "-PT12H");
+
+// Samoa skipped 24 hours",
+var relativeTo = Temporal.ZonedDateTime.from("2011-12-29T12:00-10:00[Pacific/Apia]");
+assert.sameValue(`${ hours25.round({
+ largestUnit: "days",
+ relativeTo
+}) }`, "P2DT1H");
+assert.sameValue(`${ Temporal.Duration.from({ hours: 48 }).round({
+ largestUnit: "days",
+ relativeTo
+}) }`, "P3D");
+
+// casts relativeTo to ZonedDateTime if possible
+assert.sameValue(`${ hours25.round({
+ largestUnit: "days",
+ relativeTo: "2019-11-03T00:00[America/Vancouver]"
+}) }`, "P1D");
+assert.sameValue(`${ hours25.round({
+ largestUnit: "days",
+ relativeTo: {
+ year: 2019,
+ month: 11,
+ day: 3,
+ timeZone: "America/Vancouver"
+ }
+}) }`, "P1D");
+
+// casts relativeTo to PlainDate if possible
+assert.sameValue(`${ hours25.round({
+ largestUnit: "days",
+ relativeTo: "2019-11-02"
+}) }`, "P1DT1H");
+assert.sameValue(`${ hours25.round({
+ largestUnit: "days",
+ relativeTo: {
+ year: 2019,
+ month: 11,
+ day: 2
+ }
+}) }`, "P1DT1H");
+
+// accepts datetime string equivalents or fields for relativeTo
+[
+ "2020-01-01",
+ "2020-01-01T00:00:00.000000000",
+ 20200101n,
+ {
+ year: 2020,
+ month: 1,
+ day: 1
+ }
+].forEach(relativeTo => {
+ assert.sameValue(`${ d.round({
+ smallestUnit: "seconds",
+ relativeTo
+ }) }`, "P5Y5M5W5DT5H5M5S");
+});
+
+// throws on wrong offset for ZonedDateTime relativeTo string
+assert.throws(RangeError, () => d.round({
+ smallestUnit: "seconds",
+ relativeTo: "1971-01-01T00:00+02:00[Africa/Monrovia]"
+}));
+
+// does not throw on HH:MM rounded offset for ZonedDateTime relativeTo string
+assert.sameValue(`${ d.round({
+ smallestUnit: "seconds",
+ relativeTo: "1971-01-01T00:00-00:45[Africa/Monrovia]"
+}) }`, "P5Y5M5W5DT5H5M5S");
+
+// throws on HH:MM rounded offset for ZonedDateTime relativeTo property bag
+assert.throws(RangeError, () => d.round({
+ smallestUnit: "seconds",
+ relativeTo: {
+ year: 1971,
+ month: 1,
+ day: 1,
+ offset: "-00:45",
+ timeZone: "Africa/Monrovia"
+ }
+}));
+
+// relativeTo object must contain at least the required correctly-spelled properties
+assert.throws(TypeError, () => hours25.round({
+ largestUnit: "days",
+ relativeTo: {
+ month: 11,
+ day: 3
+ }
+}));
+assert.throws(TypeError, () => hours25.round({
+ largestUnit: "days",
+ relativeTo: {
+ year: 2019,
+ month: 11
+ }
+}));
+assert.throws(TypeError, () => hours25.round({
+ largestUnit: "days",
+ relativeTo: {
+ year: 2019,
+ day: 3
+ }
+}));
+
+// incorrectly-spelled properties are ignored in relativeTo
+var oneMonth = Temporal.Duration.from({ months: 1 });
+assert.sameValue(`${ oneMonth.round({
+ largestUnit: "days",
+ relativeTo: {
+ year: 2020,
+ month: 1,
+ day: 1,
+ months: 2
+ }
+}) }`, "P31D");
+
+// throws if neither one of largestUnit or smallestUnit is given
+var hoursOnly = new Temporal.Duration(0, 0, 0, 0, 1);
+[
+ {},
+ () => {
+ },
+ { roundingMode: "ceil" }
+].forEach(roundTo => {
+ assert.throws(RangeError, () => d.round(roundTo));
+ assert.throws(RangeError, () => hoursOnly.round(roundTo));
+});
+
+// relativeTo not required to round non-calendar units in durations w/o calendar units (string param)
+assert.sameValue(`${ d2.round("days") }`, "P5D");
+assert.sameValue(`${ d2.round("hours") }`, "P5DT5H");
+assert.sameValue(`${ d2.round("minutes") }`, "P5DT5H5M");
+assert.sameValue(`${ d2.round("seconds") }`, "P5DT5H5M5S");
+assert.sameValue(`${ d2.round("milliseconds") }`, "P5DT5H5M5.005S");
+assert.sameValue(`${ d2.round("microseconds") }`, "P5DT5H5M5.005005S");
+assert.sameValue(`${ d2.round("nanoseconds") }`, "P5DT5H5M5.005005005S");
+
+// relativeTo is required to round calendar units even in durations w/o calendar units (string param)
+assert.throws(RangeError, () => d2.round("years"));
+assert.throws(RangeError, () => d2.round("months"));
+assert.throws(RangeError, () => d2.round("weeks"));
+
+// relativeTo not required to round non-calendar units in durations w/o calendar units (object param)
+assert.sameValue(`${ d2.round({ smallestUnit: "days" }) }`, "P5D");
+assert.sameValue(`${ d2.round({ smallestUnit: "hours" }) }`, "P5DT5H");
+assert.sameValue(`${ d2.round({ smallestUnit: "minutes" }) }`, "P5DT5H5M");
+assert.sameValue(`${ d2.round({ smallestUnit: "seconds" }) }`, "P5DT5H5M5S");
+assert.sameValue(`${ d2.round({ smallestUnit: "milliseconds" }) }`, "P5DT5H5M5.005S");
+assert.sameValue(`${ d2.round({ smallestUnit: "microseconds" }) }`, "P5DT5H5M5.005005S");
+assert.sameValue(`${ d2.round({ smallestUnit: "nanoseconds" }) }`, "P5DT5H5M5.005005005S");
+
+// relativeTo is required to round calendar units even in durations w/o calendar units (object param)
+assert.throws(RangeError, () => d2.round({ smallestUnit: "years" }));
+assert.throws(RangeError, () => d2.round({ smallestUnit: "months" }));
+assert.throws(RangeError, () => d2.round({ smallestUnit: "weeks" }));
+
+// relativeTo is required for rounding durations with calendar units
+assert.throws(RangeError, () => d.round({ largestUnit: "years" }));
+assert.throws(RangeError, () => d.round({ largestUnit: "months" }));
+assert.throws(RangeError, () => d.round({ largestUnit: "weeks" }));
+assert.throws(RangeError, () => d.round({ largestUnit: "days" }));
+assert.throws(RangeError, () => d.round({ largestUnit: "hours" }));
+assert.throws(RangeError, () => d.round({ largestUnit: "minutes" }));
+assert.throws(RangeError, () => d.round({ largestUnit: "seconds" }));
+assert.throws(RangeError, () => d.round({ largestUnit: "milliseconds" }));
+assert.throws(RangeError, () => d.round({ largestUnit: "microseconds" }));
+assert.throws(RangeError, () => d.round({ largestUnit: "nanoseconds" }));
+
+// durations do not balance beyond their current largest unit by default
+var relativeTo = Temporal.PlainDate.from("2020-01-01");
+var fortyDays = Temporal.Duration.from({ days: 40 });
+assert.sameValue(`${ fortyDays.round({ smallestUnit: "seconds" }) }`, "P40D");
+var roundAndBalanceResults = {
+ years: {
+ years: "P6Y",
+ months: "P5Y6M",
+ weeks: "P5Y5M6W",
+ days: "P5Y5M5W5D",
+ hours: "P5Y5M5W5DT5H",
+ minutes: "P5Y5M5W5DT5H5M",
+ seconds: "P5Y5M5W5DT5H5M5S",
+ milliseconds: "P5Y5M5W5DT5H5M5.005S",
+ microseconds: "P5Y5M5W5DT5H5M5.005005S",
+ nanoseconds: "P5Y5M5W5DT5H5M5.005005005S"
+ },
+ months: {
+ months: "P66M",
+ weeks: "P65M6W",
+ days: "P65M5W5D",
+ hours: "P65M5W5DT5H",
+ minutes: "P65M5W5DT5H5M",
+ seconds: "P65M5W5DT5H5M5S",
+ milliseconds: "P65M5W5DT5H5M5.005S",
+ microseconds: "P65M5W5DT5H5M5.005005S",
+ nanoseconds: "P65M5W5DT5H5M5.005005005S"
+ },
+ weeks: {
+ weeks: "P288W",
+ days: "P288W2D",
+ hours: "P288W2DT5H",
+ minutes: "P288W2DT5H5M",
+ seconds: "P288W2DT5H5M5S",
+ milliseconds: "P288W2DT5H5M5.005S",
+ microseconds: "P288W2DT5H5M5.005005S",
+ nanoseconds: "P288W2DT5H5M5.005005005S"
+ },
+ days: {
+ days: "P2018D",
+ hours: "P2018DT5H",
+ minutes: "P2018DT5H5M",
+ seconds: "P2018DT5H5M5S",
+ milliseconds: "P2018DT5H5M5.005S",
+ microseconds: "P2018DT5H5M5.005005S",
+ nanoseconds: "P2018DT5H5M5.005005005S"
+ },
+ hours: {
+ hours: "PT48437H",
+ minutes: "PT48437H5M",
+ seconds: "PT48437H5M5S",
+ milliseconds: "PT48437H5M5.005S",
+ microseconds: "PT48437H5M5.005005S",
+ nanoseconds: "PT48437H5M5.005005005S"
+ },
+ minutes: {
+ minutes: "PT2906225M",
+ seconds: "PT2906225M5S",
+ milliseconds: "PT2906225M5.005S",
+ microseconds: "PT2906225M5.005005S",
+ nanoseconds: "PT2906225M5.005005005S"
+ },
+ seconds: {
+ seconds: "PT174373505S",
+ milliseconds: "PT174373505.005S",
+ microseconds: "PT174373505.005005S",
+ nanoseconds: "PT174373505.005005005S"
+ },
+ milliseconds: {
+ milliseconds: "PT174373505.005S",
+ microseconds: "PT174373505.005005S",
+ nanoseconds: "PT174373505.005005005S"
+ }
+};
+for (var [largestUnit, entry] of Object.entries(roundAndBalanceResults)) {
+ for (var [smallestUnit, expected] of Object.entries(entry)) {
+ assert.sameValue(`${ d.round({
+ largestUnit,
+ smallestUnit,
+ relativeTo
+ }) }`, expected);
+ }
+}
+var balanceLosePrecisionResults = {
+ microseconds: [
+ "microseconds",
+ "nanoseconds"
+ ],
+ nanoseconds: ["nanoseconds"]
+};
+
+// Round may lose precision below ms
+for (var [largestUnit, entry] of Object.entries(balanceLosePrecisionResults)) {
+ for (var smallestUnit of entry) {
+ assert(`${ d.round({
+ largestUnit,
+ smallestUnit,
+ relativeTo
+ }) }`.startsWith("PT174373505.005"));
+ }
+}
+var roundingModeResults = {
+ halfExpand: [
+ "P6Y",
+ "-P6Y"
+ ],
+ ceil: [
+ "P6Y",
+ "-P5Y"
+ ],
+ floor: [
+ "P5Y",
+ "-P6Y"
+ ],
+ trunc: [
+ "P5Y",
+ "-P5Y"
+ ]
+};
+for (var [roundingMode, [posResult, negResult]] of Object.entries(roundingModeResults)) {
+ assert.sameValue(`${ d.round({
+ smallestUnit: "years",
+ relativeTo,
+ roundingMode
+ }) }`, posResult);
+ assert.sameValue(`${ d.negated().round({
+ smallestUnit: "years",
+ relativeTo,
+ roundingMode
+ }) }`, negResult);
+}
+
+// halfExpand is the default
+assert.sameValue(`${ d.round({
+ smallestUnit: "years",
+ relativeTo
+}) }`, "P6Y");
+assert.sameValue(`${ d.negated().round({
+ smallestUnit: "years",
+ relativeTo
+}) }`, "-P6Y");
+
+// balances up differently depending on relativeTo
+var fortyDays = Temporal.Duration.from({ days: 40 });
+assert.sameValue(`${ fortyDays.round({
+ largestUnit: "years",
+ relativeTo: "2020-01-01"
+}) }`, "P1M9D");
+assert.sameValue(`${ fortyDays.round({
+ largestUnit: "years",
+ relativeTo: "2020-02-01"
+}) }`, "P1M11D");
+assert.sameValue(`${ fortyDays.round({
+ largestUnit: "years",
+ relativeTo: "2020-03-01"
+}) }`, "P1M9D");
+assert.sameValue(`${ fortyDays.round({
+ largestUnit: "years",
+ relativeTo: "2020-04-01"
+}) }`, "P1M10D");
+var minusForty = Temporal.Duration.from({ days: -40 });
+assert.sameValue(`${ minusForty.round({
+ largestUnit: "years",
+ relativeTo: "2020-02-01"
+}) }`, "-P1M9D");
+assert.sameValue(`${ minusForty.round({
+ largestUnit: "years",
+ relativeTo: "2020-01-01"
+}) }`, "-P1M9D");
+assert.sameValue(`${ minusForty.round({
+ largestUnit: "years",
+ relativeTo: "2020-03-01"
+}) }`, "-P1M11D");
+assert.sameValue(`${ minusForty.round({
+ largestUnit: "years",
+ relativeTo: "2020-04-01"
+}) }`, "-P1M9D");
+
+// balances up to the next unit after rounding
+var almostWeek = Temporal.Duration.from({
+ days: 6,
+ hours: 20
+});
+assert.sameValue(`${ almostWeek.round({
+ largestUnit: "weeks",
+ smallestUnit: "days",
+ relativeTo: "2020-01-01"
+}) }`, "P1W");
+
+// balances days up to both years and months
+var twoYears = Temporal.Duration.from({
+ months: 11,
+ days: 396
+});
+assert.sameValue(`${ twoYears.round({
+ largestUnit: "years",
+ relativeTo: "2017-01-01"
+}) }`, "P2Y");
+
+// does not balance up to weeks if largestUnit is larger than weeks
+var monthAlmostWeek = Temporal.Duration.from({
+ months: 1,
+ days: 6,
+ hours: 20
+});
+assert.sameValue(`${ monthAlmostWeek.round({
+ smallestUnit: "days",
+ relativeTo: "2020-01-01"
+}) }`, "P1M7D");
+
+// balances down differently depending on relativeTo
+var oneYear = Temporal.Duration.from({ years: 1 });
+assert.sameValue(`${ oneYear.round({
+ largestUnit: "days",
+ relativeTo: "2019-01-01"
+}) }`, "P365D");
+assert.sameValue(`${ oneYear.round({
+ largestUnit: "days",
+ relativeTo: "2019-07-01"
+}) }`, "P366D");
+var minusYear = Temporal.Duration.from({ years: -1 });
+assert.sameValue(`${ minusYear.round({
+ largestUnit: "days",
+ relativeTo: "2020-01-01"
+}) }`, "-P365D");
+assert.sameValue(`${ minusYear.round({
+ largestUnit: "days",
+ relativeTo: "2020-07-01"
+}) }`, "-P366D");
+
+// rounds to an increment of hours
+assert.sameValue(`${ d.round({
+ smallestUnit: "hours",
+ roundingIncrement: 3,
+ relativeTo
+}) }`, "P5Y5M5W5DT6H");
+
+// rounds to an increment of minutes
+assert.sameValue(`${ d.round({
+ smallestUnit: "minutes",
+ roundingIncrement: 30,
+ relativeTo
+}) }`, "P5Y5M5W5DT5H");
+
+// rounds to an increment of seconds
+assert.sameValue(`${ d.round({
+ smallestUnit: "seconds",
+ roundingIncrement: 15,
+ relativeTo
+}) }`, "P5Y5M5W5DT5H5M");
+
+// rounds to an increment of milliseconds
+assert.sameValue(`${ d.round({
+ smallestUnit: "milliseconds",
+ roundingIncrement: 10,
+ relativeTo
+}) }`, "P5Y5M5W5DT5H5M5.01S");
+
+// rounds to an increment of microseconds
+assert.sameValue(`${ d.round({
+ smallestUnit: "microseconds",
+ roundingIncrement: 10,
+ relativeTo
+}) }`, "P5Y5M5W5DT5H5M5.00501S");
+
+// rounds to an increment of nanoseconds
+assert.sameValue(`${ d.round({
+ smallestUnit: "nanoseconds",
+ roundingIncrement: 10,
+ relativeTo
+}) }`, "P5Y5M5W5DT5H5M5.00500501S");
+
+// valid hour increments divide into 24
+[
+ 1,
+ 2,
+ 3,
+ 4,
+ 6,
+ 8,
+ 12
+].forEach(roundingIncrement => {
+ var options = {
+ smallestUnit: "hours",
+ roundingIncrement,
+ relativeTo
+ };
+ assert(d.round(options) instanceof Temporal.Duration);
+});
+[
+ "minutes",
+ "seconds"
+].forEach(smallestUnit => {
+ // valid minutes/seconds increments divide into 60
+ [
+ 1,
+ 2,
+ 3,
+ 4,
+ 5,
+ 6,
+ 10,
+ 12,
+ 15,
+ 20,
+ 30
+ ].forEach(roundingIncrement => {
+ var roundTo = {
+ smallestUnit,
+ roundingIncrement,
+ relativeTo
+ };
+ assert(d.round(roundTo) instanceof Temporal.Duration);
+ });
+ });
+[
+ "milliseconds",
+ "microseconds",
+ "nanoseconds"
+].forEach(smallestUnit => {
+ // valid milliseconds/microseconds/nanoseconds increments divide into 1000
+ [
+ 1,
+ 2,
+ 4,
+ 5,
+ 8,
+ 10,
+ 20,
+ 25,
+ 40,
+ 50,
+ 100,
+ 125,
+ 200,
+ 250,
+ 500
+ ].forEach(roundingIncrement => {
+ var roundTo = {
+ smallestUnit,
+ roundingIncrement,
+ relativeTo
+ };
+ assert(d.round(roundTo) instanceof Temporal.Duration);
+ });
+ });
+
+// throws on increments that do not divide evenly into the next highest
+assert.throws(RangeError, () => d.round({
+ relativeTo,
+ smallestUnit: "hours",
+ roundingIncrement: 11
+}));
+assert.throws(RangeError, () => d.round({
+ relativeTo,
+ smallestUnit: "minutes",
+ roundingIncrement: 29
+}));
+assert.throws(RangeError, () => d.round({
+ relativeTo,
+ smallestUnit: "seconds",
+ roundingIncrement: 29
+}));
+assert.throws(RangeError, () => d.round({
+ relativeTo,
+ smallestUnit: "milliseconds",
+ roundingIncrement: 29
+}));
+assert.throws(RangeError, () => d.round({
+ relativeTo,
+ smallestUnit: "microseconds",
+ roundingIncrement: 29
+}));
+assert.throws(RangeError, () => d.round({
+ relativeTo,
+ smallestUnit: "nanoseconds",
+ roundingIncrement: 29
+}));
+
+// throws on increments that are equal to the next highest
+assert.throws(RangeError, () => d.round({
+ relativeTo,
+ smallestUnit: "hours",
+ roundingIncrement: 24
+}));
+assert.throws(RangeError, () => d.round({
+ relativeTo,
+ smallestUnit: "minutes",
+ roundingIncrement: 60
+}));
+assert.throws(RangeError, () => d.round({
+ relativeTo,
+ smallestUnit: "seconds",
+ roundingIncrement: 60
+}));
+assert.throws(RangeError, () => d.round({
+ relativeTo,
+ smallestUnit: "milliseconds",
+ roundingIncrement: 1000
+}));
+assert.throws(RangeError, () => d.round({
+ relativeTo,
+ smallestUnit: "microseconds",
+ roundingIncrement: 1000
+}));
+assert.throws(RangeError, () => d.round({
+ relativeTo,
+ smallestUnit: "nanoseconds",
+ roundingIncrement: 1000
+}));
+
+// accepts singular units
+assert.sameValue(`${ d.round({
+ largestUnit: "year",
+ relativeTo
+}) }`, `${ d.round({
+ largestUnit: "years",
+ relativeTo
+}) }`);
+assert.sameValue(`${ d.round({
+ smallestUnit: "year",
+ relativeTo
+}) }`, `${ d.round({
+ smallestUnit: "years",
+ relativeTo
+}) }`);
+assert.sameValue(`${ d.round({
+ largestUnit: "month",
+ relativeTo
+}) }`, `${ d.round({
+ largestUnit: "months",
+ relativeTo
+}) }`);
+assert.sameValue(`${ d.round({
+ smallestUnit: "month",
+ relativeTo
+}) }`, `${ d.round({
+ smallestUnit: "months",
+ relativeTo
+}) }`);
+assert.sameValue(`${ d.round({
+ largestUnit: "day",
+ relativeTo
+}) }`, `${ d.round({
+ largestUnit: "days",
+ relativeTo
+}) }`);
+assert.sameValue(`${ d.round({
+ smallestUnit: "day",
+ relativeTo
+}) }`, `${ d.round({
+ smallestUnit: "days",
+ relativeTo
+}) }`);
+assert.sameValue(`${ d.round({
+ largestUnit: "hour",
+ relativeTo
+}) }`, `${ d.round({
+ largestUnit: "hours",
+ relativeTo
+}) }`);
+assert.sameValue(`${ d.round({
+ smallestUnit: "hour",
+ relativeTo
+}) }`, `${ d.round({
+ smallestUnit: "hours",
+ relativeTo
+}) }`);
+assert.sameValue(`${ d.round({
+ largestUnit: "minute",
+ relativeTo
+}) }`, `${ d.round({
+ largestUnit: "minutes",
+ relativeTo
+}) }`);
+assert.sameValue(`${ d.round({
+ smallestUnit: "minute",
+ relativeTo
+}) }`, `${ d.round({
+ smallestUnit: "minutes",
+ relativeTo
+}) }`);
+assert.sameValue(`${ d.round({
+ largestUnit: "second",
+ relativeTo
+}) }`, `${ d.round({
+ largestUnit: "seconds",
+ relativeTo
+}) }`);
+assert.sameValue(`${ d.round({
+ smallestUnit: "second",
+ relativeTo
+}) }`, `${ d.round({
+ smallestUnit: "seconds",
+ relativeTo
+}) }`);
+assert.sameValue(`${ d.round({
+ largestUnit: "millisecond",
+ relativeTo
+}) }`, `${ d.round({
+ largestUnit: "milliseconds",
+ relativeTo
+}) }`);
+assert.sameValue(`${ d.round({
+ smallestUnit: "millisecond",
+ relativeTo
+}) }`, `${ d.round({
+ smallestUnit: "milliseconds",
+ relativeTo
+}) }`);
+assert.sameValue(`${ d.round({
+ largestUnit: "microsecond",
+ relativeTo
+}) }`, `${ d.round({
+ largestUnit: "microseconds",
+ relativeTo
+}) }`);
+assert.sameValue(`${ d.round({
+ smallestUnit: "microsecond",
+ relativeTo
+}) }`, `${ d.round({
+ smallestUnit: "microseconds",
+ relativeTo
+}) }`);
+assert.sameValue(`${ d.round({
+ largestUnit: "nanosecond",
+ relativeTo
+}) }`, `${ d.round({
+ largestUnit: "nanoseconds",
+ relativeTo
+}) }`);
+assert.sameValue(`${ d.round({
+ smallestUnit: "nanosecond",
+ relativeTo
+}) }`, `${ d.round({
+ smallestUnit: "nanoseconds",
+ relativeTo
+}) }`);
+
+// counts the correct number of days when rounding relative to a date
+var days = Temporal.Duration.from({ days: 45 });
+assert.sameValue(`${ days.round({
+ relativeTo: "2019-01-01",
+ smallestUnit: "months"
+}) }`, "P2M");
+assert.sameValue(`${ days.negated().round({
+ relativeTo: "2019-02-15",
+ smallestUnit: "months"
+}) }`, "-P1M");
+var yearAndHalf = Temporal.Duration.from({
+ days: 547,
+ hours: 12
+});
+assert.sameValue(`${ yearAndHalf.round({
+ relativeTo: "2018-01-01",
+ smallestUnit: "years"
+}) }`, "P2Y");
+assert.sameValue(`${ yearAndHalf.round({
+ relativeTo: "2018-07-01",
+ smallestUnit: "years"
+}) }`, "P1Y");
+assert.sameValue(`${ yearAndHalf.round({
+ relativeTo: "2019-01-01",
+ smallestUnit: "years"
+}) }`, "P1Y");
+assert.sameValue(`${ yearAndHalf.round({
+ relativeTo: "2019-07-01",
+ smallestUnit: "years"
+}) }`, "P1Y");
+assert.sameValue(`${ yearAndHalf.round({
+ relativeTo: "2020-01-01",
+ smallestUnit: "years"
+}) }`, "P1Y");
+assert.sameValue(`${ yearAndHalf.round({
+ relativeTo: "2020-07-01",
+ smallestUnit: "years"
+}) }`, "P2Y");
diff --git a/test/staging/Temporal/Duration/old/subtract.js b/test/staging/Temporal/Duration/old/subtract.js
new file mode 100644
index 0000000000..d9e0b81b6f
--- /dev/null
+++ b/test/staging/Temporal/Duration/old/subtract.js
@@ -0,0 +1,123 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-duration-objects
+description: Temporal.Duration.prototype.subtract() works as expected
+features: [Temporal]
+---*/
+
+var oneDay = new Temporal.Duration(0, 0, 0, 1);
+var hours24 = new Temporal.Duration(0, 0, 0, 0, 24);
+
+// relativeTo does not affect days if PlainDate
+var relativeTo = Temporal.PlainDate.from("2017-01-01");
+assert.sameValue(`${ oneDay.subtract(hours24, { relativeTo }) }`, "PT0S");
+
+// relativeTo does not affect days if ZonedDateTime, and duration encompasses no DST change
+var relativeTo = Temporal.ZonedDateTime.from("2017-01-01T00:00[America/Montevideo]");
+assert.sameValue(`${ oneDay.subtract(hours24, { relativeTo }) }`, "PT0S");
+var skippedHourDay = Temporal.ZonedDateTime.from("2019-03-10T00:00[America/Vancouver]");
+var repeatedHourDay = Temporal.ZonedDateTime.from("2019-11-03T00:00[America/Vancouver]");
+var inRepeatedHour = Temporal.ZonedDateTime.from("2019-11-03T01:00-07:00[America/Vancouver]");
+var twoDays = new Temporal.Duration(0, 0, 0, 2);
+var threeDays = new Temporal.Duration(0, 0, 0, 3);
+// relativeTo affects days if ZonedDateTime, and duration encompasses DST change
+
+// start inside repeated hour, end after"
+assert.sameValue(`${ hours24.subtract(oneDay, { relativeTo: inRepeatedHour }) }`, "-PT1H");
+assert.sameValue(`${ oneDay.subtract(hours24, { relativeTo: inRepeatedHour }) }`, "PT1H");
+
+// start inside repeated hour, end in skipped hour
+assert.sameValue(`${ Temporal.Duration.from({
+ days: 127,
+ hours: 1
+}).subtract(oneDay, { relativeTo: inRepeatedHour }) }`, "P126DT1H");
+assert.sameValue(`${ Temporal.Duration.from({
+ days: 127,
+ hours: 1
+}).subtract(hours24, { relativeTo: inRepeatedHour }) }`, "P126D");
+
+// start in normal hour, end in skipped hour
+var relativeTo = Temporal.ZonedDateTime.from("2019-03-09T02:30[America/Vancouver]");
+assert.sameValue(`${ hours24.subtract(oneDay, { relativeTo }) }`, "PT1H");
+assert.sameValue(`${ oneDay.subtract(hours24, { relativeTo }) }`, "PT0S");
+
+// start before skipped hour, end >1 day after
+assert.sameValue(`${ threeDays.subtract(hours24, { relativeTo: skippedHourDay }) }`, "P2D");
+assert.sameValue(`${ hours24.subtract(threeDays, { relativeTo: skippedHourDay }) }`, "-P1DT23H");
+
+// start before skipped hour, end <1 day after
+assert.sameValue(`${ twoDays.subtract(hours24, { relativeTo: skippedHourDay }) }`, "P1D");
+assert.sameValue(`${ hours24.subtract(twoDays, { relativeTo: skippedHourDay }) }`, "-PT23H");
+
+// start before repeated hour, end >1 day after
+assert.sameValue(`${ threeDays.subtract(hours24, { relativeTo: repeatedHourDay }) }`, "P2D");
+assert.sameValue(`${ hours24.subtract(threeDays, { relativeTo: repeatedHourDay }) }`, "-P2DT1H");
+
+// start before repeated hour, end <1 day after
+assert.sameValue(`${ twoDays.subtract(hours24, { relativeTo: repeatedHourDay }) }`, "P1D");
+assert.sameValue(`${ hours24.subtract(twoDays, { relativeTo: repeatedHourDay }) }`, "-P1DT1H");
+
+// Samoa skipped 24 hours
+var relativeTo = Temporal.ZonedDateTime.from("2011-12-29T12:00-10:00[Pacific/Apia]");
+assert.sameValue(`${ twoDays.subtract(Temporal.Duration.from({ hours: 48 }), { relativeTo }) }`, "-P1D");
+assert.sameValue(`${ Temporal.Duration.from({ hours: 48 }).subtract(twoDays, { relativeTo }) }`, "P2D");
+
+// casts relativeTo to ZonedDateTime if possible
+assert.sameValue(`${ oneDay.subtract(hours24, { relativeTo: "2019-11-03T00:00[America/Vancouver]" }) }`, "PT1H");
+assert.sameValue(`${ oneDay.subtract(hours24, {
+ relativeTo: {
+ year: 2019,
+ month: 11,
+ day: 3,
+ timeZone: "America/Vancouver"
+ }
+}) }`, "PT1H");
+
+// casts relativeTo to PlainDate if possible
+assert.sameValue(`${ oneDay.subtract(hours24, { relativeTo: "2019-11-02" }) }`, "PT0S");
+assert.sameValue(`${ oneDay.subtract(hours24, {
+ relativeTo: {
+ year: 2019,
+ month: 11,
+ day: 2
+ }
+}) }`, "PT0S");
+
+// throws on wrong offset for ZonedDateTime relativeTo string
+assert.throws(RangeError, () => oneDay.subtract(hours24, { relativeTo: "1971-01-01T00:00+02:00[Africa/Monrovia]" }));
+
+// does not throw on HH:MM rounded offset for ZonedDateTime relativeTo string
+assert.sameValue(`${ oneDay.subtract(hours24, { relativeTo: "1971-01-01T00:00-00:45[Africa/Monrovia]" }) }`, "PT0S");
+
+// throws on HH:MM rounded offset for ZonedDateTime relativeTo property bag
+assert.throws(RangeError, () => oneDay.subtract(hours24, {
+ relativeTo: {
+ year: 1971,
+ month: 1,
+ day: 1,
+ offset: "-00:45",
+ timeZone: "Africa/Monrovia"
+ }
+}));
+
+// at least the required properties must be present in relativeTo
+assert.throws(TypeError, () => oneDay.subtract(hours24, {
+ relativeTo: {
+ month: 11,
+ day: 3
+ }
+}));
+assert.throws(TypeError, () => oneDay.subtract(hours24, {
+ relativeTo: {
+ year: 2019,
+ month: 11
+ }
+}));
+assert.throws(TypeError, () => oneDay.subtract(hours24, {
+ relativeTo: {
+ year: 2019,
+ day: 3
+ }
+}));
diff --git a/test/staging/Temporal/Duration/old/toString.js b/test/staging/Temporal/Duration/old/toString.js
new file mode 100644
index 0000000000..a08ddf020c
--- /dev/null
+++ b/test/staging/Temporal/Duration/old/toString.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-duration-objects
+description: toString() works as expected
+features: [Temporal]
+---*/
+
+
+// serializing balance doesn't trip out-of-range
+var d = Temporal.Duration.from({
+ seconds: Number.MAX_VALUE,
+ milliseconds: Number.MAX_VALUE
+});
+var str = d.toString();
+assert(str.startsWith("PT"));
+assert(str.endsWith("S"));
+
+// serializing balance doesn't lose precision when values are precise
+var d = Temporal.Duration.from({
+ milliseconds: Number.MAX_SAFE_INTEGER,
+ microseconds: Number.MAX_SAFE_INTEGER
+});
+assert.sameValue(`${ d }`, "PT9016206453995.731991S");
+
+// rounding can affect units up to seconds
+var d4 = Temporal.Duration.from("P1Y1M1W1DT23H59M59.999999999S");
+assert.sameValue(d4.toString({
+ fractionalSecondDigits: 8,
+ roundingMode: "halfExpand"
+}), "P1Y1M1W1DT23H59M60.00000000S");
diff --git a/test/staging/Temporal/Duration/old/total.js b/test/staging/Temporal/Duration/old/total.js
new file mode 100644
index 0000000000..e532306503
--- /dev/null
+++ b/test/staging/Temporal/Duration/old/total.js
@@ -0,0 +1,475 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-duration-objects
+description: Temporal.Duration.prototype.total()
+features: [Temporal]
+---*/
+
+var d = new Temporal.Duration(5, 5, 5, 5, 5, 5, 5, 5, 5, 5);
+var d2 = new Temporal.Duration(0, 0, 0, 5, 5, 5, 5, 5, 5, 5);
+var relativeTo = Temporal.PlainDate.from("2020-01-01");
+
+// throws on disallowed or invalid unit (object param)
+[
+ "era",
+ "nonsense"
+].forEach(unit => {
+ assert.throws(RangeError, () => d.total({ unit }));
+});
+
+// throws on disallowed or invalid unit (string param)
+[
+ "era",
+ "nonsense"
+].forEach(unit => {
+ assert.throws(RangeError, () => d.total(unit));
+});
+
+// does not lose precision for seconds and smaller units
+var s = Temporal.Duration.from({
+ milliseconds: 2,
+ microseconds: 31
+}).total({ unit: "seconds" });
+assert.sameValue(s, 0.002031);
+
+// accepts datetime string equivalents or fields for relativeTo
+[
+ "2020-01-01",
+ "2020-01-01T00:00:00.000000000",
+ 20200101n,
+ {
+ year: 2020,
+ month: 1,
+ day: 1
+ }
+].forEach(relativeTo => {
+ var daysPastJuly1 = 5 * 7 + 5 - 30;
+ var partialDayNanos = d.hours * 3600000000000 + d.minutes * 60000000000 + d.seconds * 1000000000 + d.milliseconds * 1000000 + d.microseconds * 1000 + d.nanoseconds;
+ var partialDay = partialDayNanos / (3600000000000 * 24);
+ var partialMonth = (daysPastJuly1 + partialDay) / 31;
+ var totalMonths = 5 * 12 + 5 + 1 + partialMonth;
+ var total = d.total({
+ unit: "months",
+ relativeTo
+ });
+ assert.sameValue(total.toPrecision(15), totalMonths.toPrecision(15));
+});
+
+// throws on wrong offset for ZonedDateTime relativeTo string
+assert.throws(RangeError, () => d.total({
+ unit: "months",
+ relativeTo: "1971-01-01T00:00+02:00[Africa/Monrovia]"
+}));
+
+// does not throw on HH:MM rounded offset for ZonedDateTime relativeTo string
+var oneMonth = Temporal.Duration.from({ months: 1 });
+assert.sameValue(oneMonth.total({
+ unit: "months",
+ relativeTo: "1971-01-01T00:00-00:45[Africa/Monrovia]"
+}), 1);
+
+// throws on HH:MM rounded offset for ZonedDateTime relativeTo property bag
+assert.throws(RangeError, () => d.total({
+ unit: "months",
+ relativeTo: {
+ year: 1971,
+ month: 1,
+ day: 1,
+ offset: "-00:45",
+ timeZone: "Africa/Monrovia"
+ }
+}));
+
+// relativeTo object must contain at least the required correctly-spelled properties
+assert.throws(TypeError, () => d.total({
+ unit: "months",
+ relativeTo: {}
+}));
+assert.throws(TypeError, () => d.total({
+ unit: "months",
+ relativeTo: {
+ years: 2020,
+ month: 1,
+ day: 1
+ }
+}));
+
+// incorrectly-spelled properties are ignored in relativeTo
+var oneMonth = Temporal.Duration.from({ months: 1 });
+assert.sameValue(oneMonth.total({
+ unit: "months",
+ relativeTo: {
+ year: 2020,
+ month: 1,
+ day: 1,
+ months: 2
+ }
+}), 1);
+
+// throws RangeError if unit property is missing
+[
+ {},
+ () => {
+ },
+ { roundingMode: "ceil" }
+].forEach(roundTo => assert.throws(RangeError, () => d.total(roundTo)));
+
+// relativeTo required to round calendar units even in durations w/o calendar units (object param)
+assert.throws(RangeError, () => d2.total({ unit: "years" }));
+assert.throws(RangeError, () => d2.total({ unit: "months" }));
+assert.throws(RangeError, () => d2.total({ unit: "weeks" }));
+
+// relativeTo required to round calendar units even in durations w/o calendar units (string param)
+assert.throws(RangeError, () => d2.total("years"));
+assert.throws(RangeError, () => d2.total("months"));
+assert.throws(RangeError, () => d2.total("weeks"));
+
+// relativeTo is required to round durations with calendar units (object param)
+assert.throws(RangeError, () => d.total({ unit: "years" }));
+assert.throws(RangeError, () => d.total({ unit: "months" }));
+assert.throws(RangeError, () => d.total({ unit: "weeks" }));
+assert.throws(RangeError, () => d.total({ unit: "days" }));
+assert.throws(RangeError, () => d.total({ unit: "hours" }));
+assert.throws(RangeError, () => d.total({ unit: "minutes" }));
+assert.throws(RangeError, () => d.total({ unit: "seconds" }));
+assert.throws(RangeError, () => d.total({ unit: "milliseconds" }));
+assert.throws(RangeError, () => d.total({ unit: "microseconds" }));
+assert.throws(RangeError, () => d.total({ unit: "nanoseconds" }));
+
+// relativeTo is required to round durations with calendar units (string param)
+assert.throws(RangeError, () => d.total("years"));
+assert.throws(RangeError, () => d.total("months"));
+assert.throws(RangeError, () => d.total("weeks"));
+assert.throws(RangeError, () => d.total("days"));
+assert.throws(RangeError, () => d.total("hours"));
+assert.throws(RangeError, () => d.total("minutes"));
+assert.throws(RangeError, () => d.total("seconds"));
+assert.throws(RangeError, () => d.total("milliseconds"));
+assert.throws(RangeError, () => d.total("microseconds"));
+assert.throws(RangeError, () => d.total("nanoseconds"));
+var d2Nanoseconds = d2.days * 24 * 3600000000000 + d2.hours * 3600000000000 + d2.minutes * 60000000000 + d2.seconds * 1000000000 + d2.milliseconds * 1000000 + d2.microseconds * 1000 + d2.nanoseconds;
+var totalD2 = {
+ days: d2Nanoseconds / (24 * 3600000000000),
+ hours: d2Nanoseconds / 3600000000000,
+ minutes: d2Nanoseconds / 60000000000,
+ seconds: d2Nanoseconds / 1000000000,
+ milliseconds: d2Nanoseconds / 1000000,
+ microseconds: d2Nanoseconds / 1000,
+ nanoseconds: d2Nanoseconds
+};
+
+// relativeTo not required to round fixed-length units in durations without variable units
+assert(Math.abs(d2.total({ unit: "days" }) - totalD2.days) < Number.EPSILON);
+assert(Math.abs(d2.total({ unit: "hours" }) - totalD2.hours) < Number.EPSILON);
+assert(Math.abs(d2.total({ unit: "minutes" }) - totalD2.minutes) < Number.EPSILON);
+assert(Math.abs(d2.total({ unit: "seconds" }) - totalD2.seconds) < Number.EPSILON);
+assert(Math.abs(d2.total({ unit: "milliseconds" }) - totalD2.milliseconds) < Number.EPSILON);
+assert(Math.abs(d2.total({ unit: "microseconds" }) - totalD2.microseconds) < Number.EPSILON);
+assert.sameValue(d2.total({ unit: "nanoseconds" }), totalD2.nanoseconds);
+
+// relativeTo not required to round fixed-length units in durations without variable units (negative)
+var negativeD2 = d2.negated();
+assert(Math.abs(negativeD2.total({ unit: "days" }) - -totalD2.days) < Number.EPSILON);
+assert(Math.abs(negativeD2.total({ unit: "hours" }) - -totalD2.hours) < Number.EPSILON);
+assert(Math.abs(negativeD2.total({ unit: "minutes" }) - -totalD2.minutes) < Number.EPSILON);
+assert(Math.abs(negativeD2.total({ unit: "seconds" }) - -totalD2.seconds) < Number.EPSILON);
+assert(Math.abs(negativeD2.total({ unit: "milliseconds" }) - -totalD2.milliseconds) < Number.EPSILON);
+assert(Math.abs(negativeD2.total({ unit: "microseconds" }) - -totalD2.microseconds) < Number.EPSILON);
+assert.sameValue(negativeD2.total({ unit: "nanoseconds" }), -totalD2.nanoseconds);
+var endpoint = relativeTo.toPlainDateTime().add(d);
+var options = unit => ({
+ largestUnit: unit,
+ smallestUnit: unit,
+ roundingMode: "trunc"
+});
+var fullYears = 5;
+var fullDays = endpoint.since(relativeTo, options("days")).days;
+var fullMilliseconds = endpoint.since(relativeTo, options("milliseconds")).milliseconds;
+var partialDayMilliseconds = fullMilliseconds - fullDays * 24 * 3600000 + 0.005005;
+var fractionalDay = partialDayMilliseconds / (24 * 3600000);
+var partialYearDays = fullDays - (fullYears * 365 + 2);
+var fractionalYear = partialYearDays / 365 + fractionalDay / 365;
+var fractionalMonths = ((endpoint.day - 1) * (24 * 3600000) + partialDayMilliseconds) / (31 * 24 * 3600000);
+var totalResults = {
+ years: fullYears + fractionalYear,
+ months: 66 + fractionalMonths,
+ weeks: (fullDays + fractionalDay) / 7,
+ days: fullDays + fractionalDay,
+ hours: fullDays * 24 + partialDayMilliseconds / 3600000,
+ minutes: fullDays * 24 * 60 + partialDayMilliseconds / 60000,
+ seconds: fullDays * 24 * 60 * 60 + partialDayMilliseconds / 1000,
+ milliseconds: fullMilliseconds + 0.005005,
+ microseconds: fullMilliseconds * 1000 + 5.005,
+ nanoseconds: fullMilliseconds * 1000000 + 5005
+};
+for (var [unit, expected] of Object.entries(totalResults)) {
+ assert.sameValue(d.total({
+ unit,
+ relativeTo
+ }).toPrecision(15), expected.toPrecision(15));
+}
+for (var unit of [
+ "microseconds",
+ "nanoseconds"
+ ]) {
+ assert(d.total({
+ unit,
+ relativeTo
+ }).toString().startsWith("174373505005"));
+}
+
+// balances differently depending on relativeTo
+var fortyDays = Temporal.Duration.from({ days: 40 });
+assert.sameValue(fortyDays.total({
+ unit: "months",
+ relativeTo: "2020-02-01"
+}).toPrecision(16), (1 + 11 / 31).toPrecision(16));
+assert.sameValue(fortyDays.total({
+ unit: "months",
+ relativeTo: "2020-01-01"
+}).toPrecision(16), (1 + 9 / 29).toPrecision(16));
+
+// balances differently depending on relativeTo (negative)
+var negativeFortyDays = Temporal.Duration.from({ days: -40 });
+assert.sameValue(negativeFortyDays.total({
+ unit: "months",
+ relativeTo: "2020-03-01"
+}).toPrecision(16), (-(1 + 11 / 31)).toPrecision(16));
+assert.sameValue(negativeFortyDays.total({
+ unit: "months",
+ relativeTo: "2020-04-01"
+}).toPrecision(16), (-(1 + 9 / 29)).toPrecision(16));
+
+var oneDay = new Temporal.Duration(0, 0, 0, 1);
+// relativeTo does not affect days if PlainDate
+var relativeTo = Temporal.PlainDate.from("2017-01-01");
+assert.sameValue(oneDay.total({
+ unit: "hours",
+ relativeTo
+}), 24);
+
+// relativeTo does not affect days if ZonedDateTime, and duration encompasses no DST change
+var relativeTo = Temporal.ZonedDateTime.from("2017-01-01T00:00[America/Montevideo]");
+assert.sameValue(oneDay.total({
+ unit: "hours",
+ relativeTo
+}), 24);
+var skippedHourDay = Temporal.ZonedDateTime.from("2019-03-10T00:00[America/Vancouver]");
+var repeatedHourDay = Temporal.ZonedDateTime.from("2019-11-03T00:00[America/Vancouver]");
+var inRepeatedHour = Temporal.ZonedDateTime.from("2019-11-03T01:00-07:00[America/Vancouver]");
+var hours12 = new Temporal.Duration(0, 0, 0, 0, 12);
+var hours25 = new Temporal.Duration(0, 0, 0, 0, 25);
+
+//relativeTo affects days if ZonedDateTime, and duration encompasses DST change"
+
+// start inside repeated hour, end after",
+assert.sameValue(hours25.total({
+ unit: "days",
+ relativeTo: inRepeatedHour
+}), 1);
+assert.sameValue(oneDay.total({
+ unit: "hours",
+ relativeTo: inRepeatedHour
+}), 25);
+
+// start after repeated hour, end inside (negative)",
+var relativeTo = Temporal.ZonedDateTime.from("2019-11-04T01:00[America/Vancouver]");
+assert.sameValue(hours25.negated().total({
+ unit: "days",
+ relativeTo
+}), -1);
+assert.sameValue(oneDay.negated().total({
+ unit: "hours",
+ relativeTo
+}), -25);
+
+// start inside repeated hour, end in skipped hour",
+var totalDays = Temporal.Duration.from({
+ days: 126,
+ hours: 1
+}).total({
+ unit: "days",
+ relativeTo: inRepeatedHour
+});
+assert(Math.abs(totalDays - (126 + 1 / 23)) < Number.EPSILON);
+assert.sameValue(Temporal.Duration.from({
+ days: 126,
+ hours: 1
+}).total({
+ unit: "hours",
+ relativeTo: inRepeatedHour
+}), 3026);
+
+// start in normal hour, end in skipped hour",
+var relativeTo = Temporal.ZonedDateTime.from("2019-03-09T02:30[America/Vancouver]");
+var totalDays = hours25.total({
+ unit: "days",
+ relativeTo
+});
+assert(Math.abs(totalDays - (1 + 1 / 24)) < Number.EPSILON);
+assert.sameValue(oneDay.total({
+ unit: "hours",
+ relativeTo
+}), 24);
+
+// start before skipped hour, end >1 day after",
+var totalDays = hours25.total({
+ unit: "days",
+ relativeTo: skippedHourDay
+});
+assert(Math.abs(totalDays - (1 + 2 / 24)) < Number.EPSILON);
+assert.sameValue(oneDay.total({
+ unit: "hours",
+ relativeTo: skippedHourDay
+}), 23);
+
+// start after skipped hour, end >1 day before (negative)",
+var relativeTo = Temporal.ZonedDateTime.from("2019-03-11T00:00[America/Vancouver]");
+var totalDays = hours25.negated().total({
+ unit: "days",
+ relativeTo
+});
+assert(Math.abs(totalDays - (-1 - 2 / 24)) < Number.EPSILON);
+assert.sameValue(oneDay.negated().total({
+ unit: "hours",
+ relativeTo
+}), -23);
+
+// start before skipped hour, end <1 day after",
+var totalDays = hours12.total({
+ unit: "days",
+ relativeTo: skippedHourDay
+});
+assert(Math.abs(totalDays - 12 / 23) < Number.EPSILON);
+
+// start after skipped hour, end <1 day before (negative)",
+var relativeTo = Temporal.ZonedDateTime.from("2019-03-10T12:00[America/Vancouver]");
+var totalDays = hours12.negated().total({
+ unit: "days",
+ relativeTo
+});
+assert(Math.abs(totalDays - -12 / 23) < Number.EPSILON);
+
+// start before repeated hour, end >1 day after",
+assert.sameValue(hours25.total({
+ unit: "days",
+ relativeTo: repeatedHourDay
+}), 1);
+assert.sameValue(oneDay.total({
+ unit: "hours",
+ relativeTo: repeatedHourDay
+}), 25);
+
+// start after repeated hour, end >1 day before (negative)",
+var relativeTo = Temporal.ZonedDateTime.from("2019-11-04T00:00[America/Vancouver]");
+assert.sameValue(hours25.negated().total({
+ unit: "days",
+ relativeTo
+}), -1);
+assert.sameValue(oneDay.negated().total({
+ unit: "hours",
+ relativeTo
+}), -25);
+
+// start before repeated hour, end <1 day after",
+var totalDays = hours12.total({
+ unit: "days",
+ relativeTo: repeatedHourDay
+});
+assert(Math.abs(totalDays - 12 / 25) < Number.EPSILON);
+
+// start after repeated hour, end <1 day before (negative)",
+var relativeTo = Temporal.ZonedDateTime.from("2019-11-03T12:00[America/Vancouver]");
+var totalDays = hours12.negated().total({
+ unit: "days",
+ relativeTo
+});
+assert(Math.abs(totalDays - -12 / 25) < Number.EPSILON);
+
+// Samoa skipped 24 hours",
+var relativeTo = Temporal.ZonedDateTime.from("2011-12-29T12:00-10:00[Pacific/Apia]");
+var totalDays = hours25.total({
+ unit: "days",
+ relativeTo
+});
+assert(Math.abs(totalDays - (2 + 1 / 24)) < Number.EPSILON);
+assert.sameValue(Temporal.Duration.from({ hours: 48 }).total({
+ unit: "days",
+ relativeTo
+}), 3);
+assert.sameValue(Temporal.Duration.from({ days: 2 }).total({
+ unit: "hours",
+ relativeTo
+}), 24);
+assert.sameValue(Temporal.Duration.from({ days: 3 }).total({
+ unit: "hours",
+ relativeTo
+}), 48);
+
+// totaling back up to days
+var relativeTo = Temporal.ZonedDateTime.from("2019-11-02T00:00[America/Vancouver]");
+assert.sameValue(Temporal.Duration.from({ hours: 48 }).total({ unit: "days" }), 2);
+var totalDays = Temporal.Duration.from({ hours: 48 }).total({
+ unit: "days",
+ relativeTo
+});
+assert(Math.abs(totalDays - (1 + 24 / 25)) < Number.EPSILON);
+
+// casts relativeTo to ZonedDateTime if possible
+assert.sameValue(oneDay.total({
+ unit: "hours",
+ relativeTo: "2019-11-03T00:00[America/Vancouver]"
+}), 25);
+assert.sameValue(oneDay.total({
+ unit: "hours",
+ relativeTo: {
+ year: 2019,
+ month: 11,
+ day: 3,
+ timeZone: "America/Vancouver"
+ }
+}), 25);
+
+// balances up to the next unit after rounding
+var almostWeek = Temporal.Duration.from({
+ days: 6,
+ hours: 20
+});
+var totalWeeks = almostWeek.total({
+ unit: "weeks",
+ relativeTo: "2020-01-01"
+});
+assert(Math.abs(totalWeeks - (6 + 20 / 24) / 7) < Number.EPSILON);
+
+// balances up to the next unit after rounding (negative)
+var almostWeek = Temporal.Duration.from({
+ days: -6,
+ hours: -20
+});
+var totalWeeks = almostWeek.total({
+ unit: "weeks",
+ relativeTo: "2020-01-01"
+});
+assert(Math.abs(totalWeeks - -((6 + 20 / 24) / 7)) < Number.EPSILON);
+
+// balances days up to both years and months
+var twoYears = Temporal.Duration.from({
+ months: 11,
+ days: 396
+});
+assert.sameValue(twoYears.total({
+ unit: "years",
+ relativeTo: "2017-01-01"
+}), 2);
+
+// balances days up to both years and months (negative)
+var twoYears = Temporal.Duration.from({
+ months: -11,
+ days: -396
+});
+assert.sameValue(twoYears.total({
+ unit: "years",
+ relativeTo: "2017-01-01"
+}), -2);
diff --git a/test/staging/Temporal/Regex/old/duration.js b/test/staging/Temporal/Regex/old/duration.js
new file mode 100644
index 0000000000..d78e5cdfb9
--- /dev/null
+++ b/test/staging/Temporal/Regex/old/duration.js
@@ -0,0 +1,268 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-duration-objects
+description: Temporal.Duration works as expected
+features: [Temporal]
+---*/
+
+function test(isoString, components) {
+ var {y = 0, mon = 0, w = 0, d = 0, h = 0, min = 0, s = 0, ms = 0, µs = 0, ns = 0} = components;
+ var duration = Temporal.Duration.from(isoString);
+ assert.sameValue(duration.years, y);
+ assert.sameValue(duration.months, mon);
+ assert.sameValue(duration.weeks, w);
+ assert.sameValue(duration.days, d);
+ assert.sameValue(duration.hours, h);
+ assert.sameValue(duration.minutes, min);
+ assert.sameValue(duration.seconds, s);
+ assert.sameValue(duration.milliseconds, ms);
+ assert.sameValue(duration.microseconds, µs);
+ assert.sameValue(duration.nanoseconds, ns);
+}
+var day = [
+ [
+ "",
+ {}
+ ],
+ [
+ "1Y",
+ { y: 1 }
+ ],
+ [
+ "2M",
+ { mon: 2 }
+ ],
+ [
+ "4W",
+ { w: 4 }
+ ],
+ [
+ "3D",
+ { d: 3 }
+ ],
+ [
+ "1Y2M",
+ {
+ y: 1,
+ mon: 2
+ }
+ ],
+ [
+ "1Y3D",
+ {
+ y: 1,
+ d: 3
+ }
+ ],
+ [
+ "2M3D",
+ {
+ mon: 2,
+ d: 3
+ }
+ ],
+ [
+ "4W3D",
+ {
+ w: 4,
+ d: 3
+ }
+ ],
+ [
+ "1Y2M3D",
+ {
+ y: 1,
+ mon: 2,
+ d: 3
+ }
+ ],
+ [
+ "1Y2M4W3D",
+ {
+ y: 1,
+ mon: 2,
+ w: 4,
+ d: 3
+ }
+ ]
+];
+var times = [
+ [
+ "",
+ {}
+ ],
+ [
+ "4H",
+ { h: 4 }
+ ],
+ [
+ "5M",
+ { min: 5 }
+ ],
+ [
+ "4H5M",
+ {
+ h: 4,
+ min: 5
+ }
+ ]
+];
+var sec = [
+ [
+ "",
+ {}
+ ],
+ [
+ "6S",
+ { s: 6 }
+ ],
+ [
+ "7.1S",
+ {
+ s: 7,
+ ms: 100
+ }
+ ],
+ [
+ "7.12S",
+ {
+ s: 7,
+ ms: 120
+ }
+ ],
+ [
+ "7.123S",
+ {
+ s: 7,
+ ms: 123
+ }
+ ],
+ [
+ "8.1234S",
+ {
+ s: 8,
+ ms: 123,
+ µs: 400
+ }
+ ],
+ [
+ "8.12345S",
+ {
+ s: 8,
+ ms: 123,
+ µs: 450
+ }
+ ],
+ [
+ "8.123456S",
+ {
+ s: 8,
+ ms: 123,
+ µs: 456
+ }
+ ],
+ [
+ "9.1234567S",
+ {
+ s: 9,
+ ms: 123,
+ µs: 456,
+ ns: 700
+ }
+ ],
+ [
+ "9.12345678S",
+ {
+ s: 9,
+ ms: 123,
+ µs: 456,
+ ns: 780
+ }
+ ],
+ [
+ "9.123456789S",
+ {
+ s: 9,
+ ms: 123,
+ µs: 456,
+ ns: 789
+ }
+ ],
+ [
+ "0.123S",
+ { ms: 123 }
+ ],
+ [
+ "0,123S",
+ { ms: 123 }
+ ],
+ [
+ "0.123456S",
+ {
+ ms: 123,
+ µs: 456
+ }
+ ],
+ [
+ "0,123456S",
+ {
+ ms: 123,
+ µs: 456
+ }
+ ],
+ [
+ "0.123456789S",
+ {
+ ms: 123,
+ µs: 456,
+ ns: 789
+ }
+ ],
+ [
+ "0,123456789S",
+ {
+ ms: 123,
+ µs: 456,
+ ns: 789
+ }
+ ]
+];
+var tim = sec.reduce((arr, [s, add]) => arr.concat(times.map(([p, expect]) => [
+ `${ p }${ s }`,
+ {
+ ...expect,
+ ...add
+ }
+])), []).slice(1);
+day.slice(1).forEach(([p, expect]) => {
+ test(`P${ p }`, expect);
+ test(`p${ p }`, expect);
+ test(`p${ p.toLowerCase() }`, expect);
+});
+tim.forEach(([p, expect]) => {
+ test(`PT${ p }`, expect);
+ test(`Pt${ p }`, expect);
+ test(`pt${ p.toLowerCase() }`, expect);
+});
+for (var [d, dexpect] of day) {
+ for (var [t, texpect] of tim) {
+ test(`P${ d }T${ t }`, {
+ ...dexpect,
+ ...texpect
+ });
+ test(`p${ d }T${ t.toLowerCase() }`, {
+ ...dexpect,
+ ...texpect
+ });
+ test(`P${ d.toLowerCase() }t${ t }`, {
+ ...dexpect,
+ ...texpect
+ });
+ test(`p${ d.toLowerCase() }t${ t.toLowerCase() }`, {
+ ...dexpect,
+ ...texpect
+ });
+ }
+}
diff --git a/test/staging/Temporal/Regex/old/instant.js b/test/staging/Temporal/Regex/old/instant.js
new file mode 100644
index 0000000000..9602b0fbc4
--- /dev/null
+++ b/test/staging/Temporal/Regex/old/instant.js
@@ -0,0 +1,264 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-instant-objects
+description: Temporal.Instant works as expected
+features: [Temporal]
+---*/
+
+function test(isoString, components) {
+ var [y, mon, d, h = 0, min = 0, s = 0, ms = 0, µs = 0, ns = 0] = components;
+ var instant = Temporal.Instant.from(isoString);
+ var utc = Temporal.TimeZone.from("UTC");
+ var datetime = utc.getPlainDateTimeFor(instant);
+ assert.sameValue(datetime.year, y);
+ assert.sameValue(datetime.month, mon);
+ assert.sameValue(datetime.day, d);
+ assert.sameValue(datetime.hour, h);
+ assert.sameValue(datetime.minute, min);
+ assert.sameValue(datetime.second, s);
+ assert.sameValue(datetime.millisecond, ms);
+ assert.sameValue(datetime.microsecond, µs);
+ assert.sameValue(datetime.nanosecond, ns);
+}
+function generateTest(dateTimeString, zoneString, components) {
+ test(`${ dateTimeString }${ zoneString }`, components.slice(0, 5));
+ test(`${ dateTimeString }:30${ zoneString }`, components.slice(0, 6));
+ test(`${ dateTimeString }:30.123456789${ zoneString }`, components);
+}
+// valid strings
+test("2020-01-01Z", [
+ 2020,
+ 1,
+ 1,
+ 0,
+ 0,
+ 0
+]);
+[
+ "+01:00",
+ "+01",
+ "+0100",
+ "+01:00:00",
+ "+010000",
+ "+01:00:00.000000000",
+ "+010000.0"
+].forEach(zoneString => {
+ generateTest("1976-11-18T15:23", `${ zoneString }[Europe/Vienna]`, [
+ 1976,
+ 11,
+ 18,
+ 14,
+ 23,
+ 30,
+ 123,
+ 456,
+ 789
+ ]);
+ generateTest("1976-11-18T15:23", `+01:00[${ zoneString }]`, [
+ 1976,
+ 11,
+ 18,
+ 14,
+ 23,
+ 30,
+ 123,
+ 456,
+ 789
+ ]);
+});
+[
+ "-04:00",
+ "-04",
+ "-0400",
+ "-04:00:00",
+ "-040000",
+ "-04:00:00.000000000",
+ "-040000.0"
+].forEach(zoneString => generateTest("1976-11-18T15:23", zoneString, [
+ 1976,
+ 11,
+ 18,
+ 19,
+ 23,
+ 30,
+ 123,
+ 456,
+ 789
+]));
+test("1976-11-18T15:23:30.1Z", [
+ 1976,
+ 11,
+ 18,
+ 15,
+ 23,
+ 30,
+ 100
+]);
+test("1976-11-18T15:23:30.12Z", [
+ 1976,
+ 11,
+ 18,
+ 15,
+ 23,
+ 30,
+ 120
+]);
+test("1976-11-18T15:23:30.123Z", [
+ 1976,
+ 11,
+ 18,
+ 15,
+ 23,
+ 30,
+ 123
+]);
+test("1976-11-18T15:23:30.1234Z", [
+ 1976,
+ 11,
+ 18,
+ 15,
+ 23,
+ 30,
+ 123,
+ 400
+]);
+test("1976-11-18T15:23:30.12345Z", [
+ 1976,
+ 11,
+ 18,
+ 15,
+ 23,
+ 30,
+ 123,
+ 450
+]);
+test("1976-11-18T15:23:30.123456Z", [
+ 1976,
+ 11,
+ 18,
+ 15,
+ 23,
+ 30,
+ 123,
+ 456
+]);
+test("1976-11-18T15:23:30.1234567Z", [
+ 1976,
+ 11,
+ 18,
+ 15,
+ 23,
+ 30,
+ 123,
+ 456,
+ 700
+]);
+test("1976-11-18T15:23:30.12345678Z", [
+ 1976,
+ 11,
+ 18,
+ 15,
+ 23,
+ 30,
+ 123,
+ 456,
+ 780
+]);
+generateTest("1976-11-18T15:23", "z", [
+ 1976,
+ 11,
+ 18,
+ 15,
+ 23,
+ 30,
+ 123,
+ 456,
+ 789
+]);
+test("1976-11-18T15:23:30,1234Z", [
+ 1976,
+ 11,
+ 18,
+ 15,
+ 23,
+ 30,
+ 123,
+ 400
+]);
+[
+ "\u221204:00",
+ "\u221204",
+ "\u22120400"
+].forEach(offset => test(`1976-11-18T15:23:30.1234${ offset }`, [
+ 1976,
+ 11,
+ 18,
+ 19,
+ 23,
+ 30,
+ 123,
+ 400
+]));
+test("\u2212009999-11-18T15:23:30.1234Z", [
+ -9999,
+ 11,
+ 18,
+ 15,
+ 23,
+ 30,
+ 123,
+ 400
+]);
+test("1976-11-18T152330Z", [
+ 1976,
+ 11,
+ 18,
+ 15,
+ 23,
+ 30
+]);
+test("1976-11-18T152330.1234Z", [
+ 1976,
+ 11,
+ 18,
+ 15,
+ 23,
+ 30,
+ 123,
+ 400
+]);
+test("19761118T15:23:30Z", [
+ 1976,
+ 11,
+ 18,
+ 15,
+ 23,
+ 30
+]);
+test("19761118T152330Z", [
+ 1976,
+ 11,
+ 18,
+ 15,
+ 23,
+ 30
+]);
+test("19761118T152330.1234Z", [
+ 1976,
+ 11,
+ 18,
+ 15,
+ 23,
+ 30,
+ 123,
+ 400
+]);
+test("1976-11-18T15Z", [
+ 1976,
+ 11,
+ 18,
+ 15
+]);
+
diff --git a/test/staging/Temporal/Regex/old/plaindate.js b/test/staging/Temporal/Regex/old/plaindate.js
new file mode 100644
index 0000000000..30c23a84f9
--- /dev/null
+++ b/test/staging/Temporal/Regex/old/plaindate.js
@@ -0,0 +1,81 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-plainedate-objects
+description: Temporal.PlainDate works as expected
+features: [Temporal]
+---*/
+
+function test(isoString, components) {
+ var [y, m, d, cid = "iso8601"] = components;
+ var date = Temporal.PlainDate.from(isoString);
+ assert.sameValue(date.year, y);
+ assert.sameValue(date.month, m);
+ assert.sameValue(date.day, d);
+ assert.sameValue(date.calendar.id, cid);
+}
+function generateTest(dateTimeString, zoneString) {
+ var components = [
+ 1976,
+ 11,
+ 18
+ ];
+ test(`${ dateTimeString }${ zoneString }`, components);
+ test(`${ dateTimeString }:30${ zoneString }`, components);
+ test(`${ dateTimeString }:30.123456789${ zoneString }`, components);
+}
+[
+ "+0100[Europe/Vienna]",
+ "[Europe/Vienna]",
+ "+01:00[Custom/Vienna]",
+ "-0400",
+ "-04:00:00.000000000",
+ "+01:00[+01:00]",
+ "+01:00[+0100]",
+ ""
+].forEach(zoneString => generateTest("1976-11-18T15:23", zoneString));
+[
+ "1",
+ "12",
+ "123",
+ "1234",
+ "12345",
+ "123456",
+ "1234567",
+ "12345678"
+].forEach(decimals => test(`1976-11-18T15:23:30.${ decimals }`, [
+ 1976,
+ 11,
+ 18
+]));
+test("1976-11-18T15:23:30,1234", [
+ 1976,
+ 11,
+ 18
+]);
+test("\u2212009999-11-18", [
+ -9999,
+ 11,
+ 18
+]);
+test("1976-11-18T15", [
+ 1976,
+ 11,
+ 18
+]);
+[
+ "",
+ "+01:00[Europe/Vienna]",
+ "[Europe/Vienna]",
+ "+01:00[Custom/Vienna]"
+].forEach(zoneString => test(`1976-11-18T15:23:30.123456789${ zoneString }[u-ca=iso8601]`, [
+ 1976,
+ 11,
+ 18
+]));
+test("1976-11-18[u-ca=iso8601]", [
+ 1976,
+ 11,
+ 18
+]);
diff --git a/test/staging/Temporal/Regex/old/plaindatetime.js b/test/staging/Temporal/Regex/old/plaindatetime.js
new file mode 100644
index 0000000000..5771476f8d
--- /dev/null
+++ b/test/staging/Temporal/Regex/old/plaindatetime.js
@@ -0,0 +1,71 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-plaindatetime-objects
+description: Temporal.PlainDateTime works as expected
+features: [Temporal]
+---*/
+
+function test(isoString, components) {
+ var [y, mon, d, h = 0, min = 0, s = 0, ms = 0, µs = 0, ns = 0, cid = "iso8601"] = components;
+ var datetime = Temporal.PlainDateTime.from(isoString);
+ assert.sameValue(datetime.year, y);
+ assert.sameValue(datetime.month, mon);
+ assert.sameValue(datetime.day, d);
+ assert.sameValue(datetime.hour, h);
+ assert.sameValue(datetime.minute, min);
+ assert.sameValue(datetime.second, s);
+ assert.sameValue(datetime.millisecond, ms);
+ assert.sameValue(datetime.microsecond, µs);
+ assert.sameValue(datetime.nanosecond, ns);
+ assert.sameValue(datetime.calendar.id, cid);
+}
+function generateTest(dateTimeString, zoneString) {
+ var components = [
+ 1976,
+ 11,
+ 18,
+ 15,
+ 23,
+ 30,
+ 123,
+ 456,
+ 789
+ ];
+ test(`${ dateTimeString }${ zoneString }`, components.slice(0, 5));
+ test(`${ dateTimeString }:30${ zoneString }`, components.slice(0, 6));
+ test(`${ dateTimeString }:30.123456789${ zoneString }`, components);
+}
+
+//valid strings
+[
+ "+0100[Europe/Vienna]",
+ "+01:00[Europe/Vienna]",
+ "[Europe/Vienna]",
+ "+01:00[Custom/Vienna]",
+ "-0400",
+ "-04:00",
+ "-04:00:00.000000000",
+ "+010000.0[Europe/Vienna]",
+ "+01:00[+01:00]",
+ "+01:00[+0100]",
+ ""
+].forEach(zoneString => generateTest("1976-11-18T15:23", zoneString));
+[
+ "",
+ "+01:00[Europe/Vienna]",
+ "+01:00[Custom/Vienna]",
+ "[Europe/Vienna]"
+].forEach(zoneString => test(`1976-11-18T15:23:30.123456789${ zoneString }[u-ca=iso8601]`, [
+ 1976,
+ 11,
+ 18,
+ 15,
+ 23,
+ 30,
+ 123,
+ 456,
+ 789
+]));
+
diff --git a/test/staging/Temporal/Regex/old/plainmonthday.js b/test/staging/Temporal/Regex/old/plainmonthday.js
new file mode 100644
index 0000000000..6623d912ca
--- /dev/null
+++ b/test/staging/Temporal/Regex/old/plainmonthday.js
@@ -0,0 +1,75 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-plainmonthday-objects
+description: Temporal.PlainMonthDay works as expected
+features: [Temporal]
+---*/
+
+function test(isoString, components) {
+ var [m, d, cid = "iso8601"] = components;
+ var monthDay = Temporal.PlainMonthDay.from(isoString);
+ assert.sameValue(monthDay.monthCode, `M${ m.toString().padStart(2, "0") }`);
+ assert.sameValue(monthDay.day, d);
+ assert.sameValue(monthDay.calendar.id, cid);
+}
+function generateTest(dateTimeString, zoneString) {
+ var components = [
+ 11,
+ 18
+ ];
+ test(`${ dateTimeString }${ zoneString }`, components);
+ test(`${ dateTimeString }:30${ zoneString }`, components);
+ test(`${ dateTimeString }:30.123456789${ zoneString }`, components);
+}
+[
+ "+0100[Europe/Vienna]",
+ "[Europe/Vienna]",
+ "+01:00[Custom/Vienna]",
+ "-0400",
+ "-04:00:00.000000000",
+ "+010000.0[Europe/Vienna]",
+ "+01:00[+01:00]",
+ "+01:00[+0100]",
+ ""
+].forEach(zoneString => generateTest("1976-11-18T15:23", zoneString));
+[
+ "1",
+ "12",
+ "123",
+ "1234",
+ "12345",
+ "123456",
+ "1234567",
+ "12345678"
+].forEach(decimals => test(`1976-11-18T15:23:30.${ decimals }`, [
+ 11,
+ 18
+]));
+[
+ "1976-11-18T15:23:30,1234",
+ "\u2212009999-11-18",
+ "19761118",
+ "+199999-11-18",
+ "+1999991118",
+ "-000300-11-18",
+ "-0003001118",
+ "15121118"
+].forEach(str => test(str, [
+ 11,
+ 18
+]));
+[
+ "",
+ "+01:00[Europe/Vienna]",
+ "[Europe/Vienna]",
+ "+01:00[Custom/Vienna]"
+].forEach(zoneString => test(`1976-11-18T15:23:30.123456789${ zoneString }[u-ca=iso8601]`, [
+ 11,
+ 18
+]));
+test("1972-11-18[u-ca=iso8601]", [
+ 11,
+ 18
+]);
diff --git a/test/staging/Temporal/Regex/old/plaintime.js b/test/staging/Temporal/Regex/old/plaintime.js
new file mode 100644
index 0000000000..130303692c
--- /dev/null
+++ b/test/staging/Temporal/Regex/old/plaintime.js
@@ -0,0 +1,63 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-plaintime-objects
+description: Temporal.PlainTime works as expected
+features: [Temporal]
+---*/
+
+function test(isoString, components) {
+ var [h = 0, m = 0, s = 0, ms = 0, µs = 0, ns = 0] = components;
+ var time = Temporal.PlainTime.from(isoString);
+ assert.sameValue(time.hour, h);
+ assert.sameValue(time.minute, m);
+ assert.sameValue(time.second, s);
+ assert.sameValue(time.millisecond, ms);
+ assert.sameValue(time.microsecond, µs);
+ assert.sameValue(time.nanosecond, ns);
+}
+function generateTest(dateTimeString, zoneString) {
+ var components = [
+ 15,
+ 23,
+ 30,
+ 123,
+ 456,
+ 789
+ ];
+ test(`${ dateTimeString }${ zoneString }`, components.slice(0, 2));
+ test(`${ dateTimeString }:30${ zoneString }`, components.slice(0, 3));
+ test(`${ dateTimeString }:30.123456789${ zoneString }`, components);
+}
+[
+ "+0100[Europe/Vienna]",
+ "+01:00[Custom/Vienna]",
+ "-0400",
+ "-04:00:00.000000000",
+ "+010000.0[Europe/Vienna]",
+ "+01:00[+01:00]",
+ "+01:00[+0100]",
+ ""
+].forEach(zoneString => generateTest("1976-11-18T15:23", zoneString));
+[
+ "+01:00[Europe/Vienna]",
+ "[Europe/Vienna]",
+ "+01:00[Custom/Vienna]",
+ "-04:00",
+ "Z",
+ ""
+].forEach(zoneStr => test(`15${ zoneStr }`, [15]));
+[
+ "",
+ "+01:00[Europe/Vienna]",
+ "[Europe/Vienna]",
+ "+01:00[Custom/Vienna]"
+].forEach(zoneString => test(`1976-11-18T15:23:30.123456789${ zoneString }[u-ca=iso8601]`, [
+ 15,
+ 23,
+ 30,
+ 123,
+ 456,
+ 789
+]));
diff --git a/test/staging/Temporal/Regex/old/plainyearmonth.js b/test/staging/Temporal/Regex/old/plainyearmonth.js
new file mode 100644
index 0000000000..1f34237d41
--- /dev/null
+++ b/test/staging/Temporal/Regex/old/plainyearmonth.js
@@ -0,0 +1,106 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-plainyearmonth-objects
+description: Temporal.PlainYearMonth works as expected
+features: [Temporal]
+---*/
+
+function test(isoString, components) {
+ var [y, m, cid = "iso8601"] = components;
+ var yearMonth = Temporal.PlainYearMonth.from(isoString);
+ assert.sameValue(yearMonth.year, y);
+ assert.sameValue(yearMonth.month, m);
+ assert.sameValue(yearMonth.calendar.id, cid);
+}
+function generateTest(dateTimeString, zoneString) {
+ var components = [
+ 1976,
+ 11
+ ];
+ test(`${ dateTimeString }${ zoneString }`, components);
+ test(`${ dateTimeString }:30${ zoneString }`, components);
+ test(`${ dateTimeString }:30.123456789${ zoneString }`, components);
+}
+[
+ "+0100[Europe/Vienna]",
+ "[Europe/Vienna]",
+ "+01:00[Custom/Vienna]",
+ "-0400",
+ "-04:00:00.000000000",
+ "+01:00:00.0[Europe/Vienna]",
+ "+01:00[+01:00]",
+ "+01:00[+0100]",
+ ""
+].forEach(zoneString => generateTest("1976-11-18T15:23", zoneString));
+[
+ "1",
+ "12",
+ "123",
+ "1234",
+ "12345",
+ "123456",
+ "1234567",
+ "12345678"
+].forEach(decimals => test(`1976-11-18T15:23:30.${ decimals }`, [
+ 1976,
+ 11
+]));
+test("1976-11-18T15:23:30,1234", [
+ 1976,
+ 11
+]);
+test("19761118", [
+ 1976,
+ 11
+]);
+test("+199999-11-18", [
+ 199999,
+ 11
+]);
+test("+1999991118", [
+ 199999,
+ 11
+]);
+test("-000300-11-18", [
+ -300,
+ 11
+]);
+test("-0003001118", [
+ -300,
+ 11
+]);
+test("1512-11-18", [
+ 1512,
+ 11
+]);
+test("+199999-11", [
+ 199999,
+ 11
+]);
+test("+19999911", [
+ 199999,
+ 11
+]);
+test("-000300-11", [
+ -300,
+ 11
+]);
+test("-00030011", [
+ -300,
+ 11
+]);
+[
+ "",
+ "+01:00[Europe/Vienna]",
+ "[Europe/Vienna]",
+ "+01:00[Custom/Vienna]"
+].forEach(zoneString => test(`1976-11-18T15:23:30.123456789${ zoneString }[u-ca=iso8601]`, [
+ 1976,
+ 11
+]));
+test("1976-11-01[u-ca=iso8601]", [
+ 1976,
+ 11
+]);
diff --git a/test/staging/Temporal/Regex/old/timezone.js b/test/staging/Temporal/Regex/old/timezone.js
new file mode 100644
index 0000000000..93b3b0ba12
--- /dev/null
+++ b/test/staging/Temporal/Regex/old/timezone.js
@@ -0,0 +1,101 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-timezone-objects
+description: Temporal.TimeZone works as expected
+features: [Temporal]
+---*/
+
+function test(offsetString, expectedName) {
+ var timeZone = Temporal.TimeZone.from(offsetString);
+ assert.sameValue(timeZone.id, expectedName);
+}
+function generateTest(dateTimeString, zoneString, expectedName) {
+ test(`${ dateTimeString }${ zoneString }`, expectedName);
+ test(`${ dateTimeString }:30${ zoneString }`, expectedName);
+ test(`${ dateTimeString }:30.123456789${ zoneString }`, expectedName);
+}
+[
+ "+01:00",
+ "+01",
+ "+0100",
+ "+01:00:00",
+ "+010000",
+ "+01:00:00.000000000",
+ "+010000.0"
+].forEach(zoneString => {
+ generateTest("1976-11-18T15:23", `${ zoneString }[Europe/Vienna]`, "Europe/Vienna");
+ generateTest("1976-11-18T15:23", `+01:00[${ zoneString }]`, "+01:00");
+});
+[
+ "-04:00",
+ "-04",
+ "-0400",
+ "-04:00:00",
+ "-040000",
+ "-04:00:00.000000000",
+ "-040000.0"
+].forEach(zoneString => generateTest("1976-11-18T15:23", zoneString, "-04:00"));
+[
+ "1",
+ "12",
+ "123",
+ "1234",
+ "12345",
+ "123456",
+ "1234567",
+ "12345678"
+].forEach(decimals => {
+ test(`1976-11-18T15:23:30.${ decimals }Z`, "UTC");
+ test(`1976-11-18T15:23+01:00[+01:00:00.${ decimals }]`, `+01:00:00.${ decimals }`);
+});
+generateTest("1976-11-18T15:23", "z", "UTC");
+test("1976-11-18T15:23:30,1234Z", "UTC");
+test("1976-11-18T15:23-04:00:00,000000000", "-04:00");
+test("1976-11-18T15:23+010000,0[Europe/Vienna]", "Europe/Vienna");
+[
+ "\u221204:00",
+ "\u221204",
+ "\u22120400"
+].forEach(offset => test(`1976-11-18T15:23${ offset }`, "-04:00"));
+[
+ "1976-11-18T152330",
+ "1976-11-18T152330.1234",
+ "19761118T15:23:30",
+ "19761118T152330",
+ "19761118T152330.1234",
+ "1976-11-18T15"
+].forEach(dateTimeString => {
+ [
+ "+01:00",
+ "+01",
+ "+0100",
+ ""
+ ].forEach(zoneString => test(`${ dateTimeString }${ zoneString }[Europe/Vienna]`, "Europe/Vienna"));
+ [
+ "-04:00",
+ "-04",
+ "-0400"
+ ].forEach(zoneString => test(`${ dateTimeString }${ zoneString }`, "-04:00"));
+ test(`${ dateTimeString }Z`, "UTC");
+});
+test("-0000", "+00:00");
+test("-00:00", "+00:00");
+test("+00", "+00:00");
+test("-00", "+00:00");
+test("+03", "+03:00");
+test("-03", "-03:00");
+test("\u22120000", "+00:00");
+test("\u221200:00", "+00:00");
+test("\u221200", "+00:00");
+test("\u22120300", "-03:00");
+test("\u221203:00", "-03:00");
+test("\u221203", "-03:00");
+test("+030000.0", "+03:00");
+test("-03:00:00", "-03:00");
+test("-03:00:00.000000000", "-03:00");
+test("1976-11-18T15:23:30.123456789Z[u-ca=iso8601]", "UTC");
+test("1976-11-18T15:23:30.123456789-04:00[u-ca=iso8601]", "-04:00");
+test("1976-11-18T15:23:30.123456789[Europe/Vienna][u-ca=iso8601]", "Europe/Vienna");
+test("1976-11-18T15:23:30.123456789+01:00[Europe/Vienna][u-ca=iso8601]", "Europe/Vienna");
diff --git a/test/staging/Temporal/TimeZone/old/dst-change.js b/test/staging/Temporal/TimeZone/old/dst-change.js
new file mode 100644
index 0000000000..bcd8372860
--- /dev/null
+++ b/test/staging/Temporal/TimeZone/old/dst-change.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-timezone-objects
+description: with DST change
+features: [Temporal]
+---*/
+
+// clock moving forward
+var zone = new Temporal.TimeZone("Europe/Berlin");
+var dtm = new Temporal.PlainDateTime(2019, 3, 31, 2, 45);
+assert.sameValue(`${ zone.getInstantFor(dtm) }`, "2019-03-31T01:45:00Z");
+assert.sameValue(`${ zone.getInstantFor(dtm, { disambiguation: "earlier" }) }`, "2019-03-31T00:45:00Z");
+assert.sameValue(`${ zone.getInstantFor(dtm, { disambiguation: "later" }) }`, "2019-03-31T01:45:00Z");
+assert.sameValue(`${ zone.getInstantFor(dtm, { disambiguation: "compatible" }) }`, "2019-03-31T01:45:00Z");
+assert.throws(RangeError, () => zone.getInstantFor(dtm, { disambiguation: "reject" }));
+
+// clock moving backward
+var zone = new Temporal.TimeZone("America/Sao_Paulo");
+var dtm = new Temporal.PlainDateTime(2019, 2, 16, 23, 45);
+assert.sameValue(`${ zone.getInstantFor(dtm) }`, "2019-02-17T01:45:00Z");
+assert.sameValue(`${ zone.getInstantFor(dtm, { disambiguation: "earlier" }) }`, "2019-02-17T01:45:00Z");
+assert.sameValue(`${ zone.getInstantFor(dtm, { disambiguation: "later" }) }`, "2019-02-17T02:45:00Z");
+assert.sameValue(`${ zone.getInstantFor(dtm, { disambiguation: "compatible" }) }`, "2019-02-17T01:45:00Z");
+assert.throws(RangeError, () => zone.getInstantFor(dtm, { disambiguation: "reject" }));
diff --git a/test/staging/Temporal/TimeZone/old/getInstantFor-disambiguation.js b/test/staging/Temporal/TimeZone/old/getInstantFor-disambiguation.js
new file mode 100644
index 0000000000..d205717513
--- /dev/null
+++ b/test/staging/Temporal/TimeZone/old/getInstantFor-disambiguation.js
@@ -0,0 +1,47 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-timezone-objects
+description: getInstantFor disambiguation
+features: [Temporal]
+---*/
+
+var dtm = new Temporal.PlainDateTime(2019, 2, 16, 23, 45);
+
+// with constant offset
+var zone = Temporal.TimeZone.from("+03:30");
+for (var disambiguation of [
+ undefined,
+ "compatible",
+ "earlier",
+ "later",
+ "reject"
+ ]) {
+ assert(zone.getInstantFor(dtm, { disambiguation }) instanceof Temporal.Instant);
+}
+
+// with daylight saving change - Fall
+var zone = Temporal.TimeZone.from("America/Sao_Paulo");
+assert.sameValue(`${ zone.getInstantFor(dtm) }`, "2019-02-17T01:45:00Z");
+assert.sameValue(`${ zone.getInstantFor(dtm, { disambiguation: "earlier" }) }`, "2019-02-17T01:45:00Z");
+assert.sameValue(`${ zone.getInstantFor(dtm, { disambiguation: "later" }) }`, "2019-02-17T02:45:00Z");
+assert.sameValue(`${ zone.getInstantFor(dtm, { disambiguation: "compatible" }) }`, "2019-02-17T01:45:00Z");
+assert.throws(RangeError, () => zone.getInstantFor(dtm, { disambiguation: "reject" }));
+
+// with daylight saving change - Spring
+var dtmLA = new Temporal.PlainDateTime(2020, 3, 8, 2, 30);
+var zone = Temporal.TimeZone.from("America/Los_Angeles");
+assert.sameValue(`${ zone.getInstantFor(dtmLA) }`, "2020-03-08T10:30:00Z");
+assert.sameValue(`${ zone.getInstantFor(dtmLA, { disambiguation: "earlier" }) }`, "2020-03-08T09:30:00Z");
+assert.sameValue(`${ zone.getInstantFor(dtmLA, { disambiguation: "later" }) }`, "2020-03-08T10:30:00Z");
+assert.sameValue(`${ zone.getInstantFor(dtmLA, { disambiguation: "compatible" }) }`, "2020-03-08T10:30:00Z");
+assert.throws(RangeError, () => zone.getInstantFor(dtmLA, { disambiguation: "reject" }));
+
+// throws on bad disambiguation
+var zone = Temporal.TimeZone.from("+03:30");
+[
+ "",
+ "EARLIER",
+ "test",
+].forEach(disambiguation => assert.throws(RangeError, () => zone.getInstantFor(dtm, { disambiguation })));
diff --git a/test/staging/Temporal/TimeZone/old/getInstantFor.js b/test/staging/Temporal/TimeZone/old/getInstantFor.js
new file mode 100644
index 0000000000..c86834e771
--- /dev/null
+++ b/test/staging/Temporal/TimeZone/old/getInstantFor.js
@@ -0,0 +1,58 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-timezone-objects
+description: Temporal.TimeZone.prototype.getInstantFor() works
+features: [Temporal]
+---*/
+
+
+// recent date
+var dt = Temporal.PlainDateTime.from("2019-10-29T10:46:38.271986102");
+var tz = Temporal.TimeZone.from("Europe/Amsterdam");
+assert.sameValue(`${ tz.getInstantFor(dt) }`, "2019-10-29T09:46:38.271986102Z");
+
+// year ≤ 99
+var dt = Temporal.PlainDateTime.from("0098-10-29T10:46:38.271986102");
+var tz = Temporal.TimeZone.from("+06:00");
+assert.sameValue(`${ tz.getInstantFor(dt) }`, "0098-10-29T04:46:38.271986102Z");
+dt = Temporal.PlainDateTime.from("+000098-10-29T10:46:38.271986102");
+assert.sameValue(`${ tz.getInstantFor(dt) }`, "0098-10-29T04:46:38.271986102Z");
+
+// year < 1
+var dt = Temporal.PlainDateTime.from("0000-10-29T10:46:38.271986102");
+var tz = Temporal.TimeZone.from("+06:00");
+assert.sameValue(`${ tz.getInstantFor(dt) }`, "0000-10-29T04:46:38.271986102Z");
+dt = Temporal.PlainDateTime.from("+000000-10-29T10:46:38.271986102");
+assert.sameValue(`${ tz.getInstantFor(dt) }`, "0000-10-29T04:46:38.271986102Z");
+dt = Temporal.PlainDateTime.from("-001000-10-29T10:46:38.271986102");
+assert.sameValue(`${ tz.getInstantFor(dt) }`, "-001000-10-29T04:46:38.271986102Z");
+
+// year 0 leap day
+var dt = Temporal.PlainDateTime.from("0000-02-29T00:00");
+var tz = Temporal.TimeZone.from("Europe/London");
+assert.sameValue(`${ tz.getInstantFor(dt) }`, "0000-02-29T00:01:15Z");
+dt = Temporal.PlainDateTime.from("+000000-02-29T00:00");
+assert.sameValue(`${ tz.getInstantFor(dt) }`, "0000-02-29T00:01:15Z");
+
+// outside of Instant range
+var max = Temporal.PlainDateTime.from("+275760-09-13T23:59:59.999999999");
+var offsetTz = Temporal.TimeZone.from("-01:00");
+assert.throws(RangeError, () => offsetTz.getInstantFor(max));
+var namedTz = Temporal.TimeZone.from("America/Godthab");
+assert.throws(RangeError, () => namedTz.getInstantFor(max));
+
+// casts argument
+var tz = Temporal.TimeZone.from("Europe/Amsterdam");
+assert.sameValue(`${ tz.getInstantFor("2019-10-29T10:46:38.271986102") }`, "2019-10-29T09:46:38.271986102Z");
+assert.sameValue(`${ tz.getInstantFor({
+ year: 2019,
+ month: 10,
+ day: 29,
+ hour: 10,
+ minute: 46,
+ second: 38
+}) }`, "2019-10-29T09:46:38Z");
+
+
diff --git a/test/staging/Temporal/TimeZone/old/getNextTransition.js b/test/staging/Temporal/TimeZone/old/getNextTransition.js
new file mode 100644
index 0000000000..8a3e83035c
--- /dev/null
+++ b/test/staging/Temporal/TimeZone/old/getNextTransition.js
@@ -0,0 +1,30 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-timezone-objects
+description: Temporal.TimeZone.prototype.getNextTransition() works as expected
+features: [Temporal]
+---*/
+
+var nyc = Temporal.TimeZone.from("America/New_York");
+var noTransitionTZ = Temporal.TimeZone.from("Etc/GMT+10");
+
+// should not have bug #510
+var a1 = Temporal.Instant.from("2019-04-16T21:01Z");
+var a2 = Temporal.Instant.from("1800-01-01T00:00Z");
+assert.sameValue(nyc.getNextTransition(a1).toString(), "2019-11-03T06:00:00Z");
+assert.sameValue(nyc.getNextTransition(a2).toString(), "1883-11-18T17:00:00Z");
+
+// should not return the same as its input if the input is a transition point
+var inst = Temporal.Instant.from("2019-01-01T00:00Z");
+assert.sameValue(`${ nyc.getNextTransition(inst) }`, "2019-03-10T07:00:00Z");
+assert.sameValue(`${ nyc.getNextTransition(nyc.getNextTransition(inst)) }`, "2019-11-03T06:00:00Z");
+
+// should work for timezones with no scheduled transitions in the near future
+var start = Temporal.Instant.from("1945-10-15T13:00:00Z");
+assert.sameValue(noTransitionTZ.getNextTransition(start), null);
+
+// casts argument
+assert.sameValue(`${ nyc.getNextTransition("2019-04-16T21:01Z") }`, "2019-11-03T06:00:00Z");
+
diff --git a/test/staging/Temporal/TimeZone/old/getPossibleInstantsFor.js b/test/staging/Temporal/TimeZone/old/getPossibleInstantsFor.js
new file mode 100644
index 0000000000..74fd1ab31c
--- /dev/null
+++ b/test/staging/Temporal/TimeZone/old/getPossibleInstantsFor.js
@@ -0,0 +1,44 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-timezone-objects
+description: Temporal.TimeZone.prototype.getPossibleInstantsFor() works as expected
+includes: [deepEqual.js]
+features: [Temporal]
+---*/
+
+
+// with constant offset
+var zone = Temporal.TimeZone.from("+03:30");
+var dt = Temporal.PlainDateTime.from("2019-02-16T23:45");
+assert.deepEqual(zone.getPossibleInstantsFor(dt).map(a => `${ a }`), ["2019-02-16T20:15:00Z"]);
+
+// with clock moving forward
+var zone = Temporal.TimeZone.from("Europe/Berlin");
+var dt = Temporal.PlainDateTime.from("2019-03-31T02:45");
+assert.deepEqual(zone.getPossibleInstantsFor(dt), []);
+
+// with clock moving backward
+var zone = Temporal.TimeZone.from("America/Sao_Paulo");
+var dt = Temporal.PlainDateTime.from("2019-02-16T23:45");
+assert.deepEqual(zone.getPossibleInstantsFor(dt).map(a => `${ a }`), [
+ "2019-02-17T01:45:00Z",
+ "2019-02-17T02:45:00Z"
+]);
+
+// casts argument
+var tz = Temporal.TimeZone.from("+03:30");
+assert.deepEqual(tz.getPossibleInstantsFor({
+ year: 2019,
+ month: 2,
+ day: 16,
+ hour: 23,
+ minute: 45,
+ second: 30
+}).map(a => `${ a }`), ["2019-02-16T20:15:30Z"]);
+assert.deepEqual(tz.getPossibleInstantsFor("2019-02-16T23:45:30").map(a => `${ a }`), ["2019-02-16T20:15:30Z"]);
+
+// object must contain at least the required properties
+var tz = Temporal.TimeZone.from("Europe/Amsterdam");
+assert.throws(TypeError, () => tz.getPossibleInstantsFor({ year: 2019 }));
diff --git a/test/staging/Temporal/TimeZone/old/getPreviousTransition.js b/test/staging/Temporal/TimeZone/old/getPreviousTransition.js
new file mode 100644
index 0000000000..797ddba382
--- /dev/null
+++ b/test/staging/Temporal/TimeZone/old/getPreviousTransition.js
@@ -0,0 +1,24 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-timezone-objects
+description: Temporal.TimeZone.prototype.getPreviousTransition() works
+features: [Temporal]
+---*/
+
+var london = Temporal.TimeZone.from("Europe/London");
+
+// should return first and last transition
+var a1 = Temporal.Instant.from("2020-06-11T21:01Z");
+var a2 = Temporal.Instant.from("1848-01-01T00:00Z");
+assert.sameValue(london.getPreviousTransition(a1).toString(), "2020-03-29T01:00:00Z");
+assert.sameValue(london.getPreviousTransition(a2).toString(), "1847-12-01T00:01:15Z");
+
+// should not return the same as its input if the input is a transition point
+var inst = Temporal.Instant.from("2020-06-01T00:00Z");
+assert.sameValue(`${ london.getPreviousTransition(inst) }`, "2020-03-29T01:00:00Z");
+assert.sameValue(`${ london.getPreviousTransition(london.getPreviousTransition(inst)) }`, "2019-10-27T01:00:00Z");
+
+// casts argument
+assert.sameValue(`${ london.getPreviousTransition("2020-06-11T21:01Z") }`, "2020-03-29T01:00:00Z");
diff --git a/test/staging/Temporal/TimeZone/old/subminute-offset.js b/test/staging/Temporal/TimeZone/old/subminute-offset.js
new file mode 100644
index 0000000000..d87fa63173
--- /dev/null
+++ b/test/staging/Temporal/TimeZone/old/subminute-offset.js
@@ -0,0 +1,17 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-timezone-objects
+description: sub-minute offset
+features: [Temporal]
+---*/
+
+var zone = new Temporal.TimeZone("Europe/Amsterdam");
+var inst = Temporal.Instant.from("1900-01-01T12:00Z");
+var dtm = Temporal.PlainDateTime.from("1900-01-01T12:00");
+assert.sameValue(zone.id, `${ zone }`)
+assert.sameValue(zone.getOffsetNanosecondsFor(inst), 1172000000000)
+assert.sameValue(`${ zone.getInstantFor(dtm) }`, "1900-01-01T11:40:28Z")
+assert.sameValue(`${ zone.getNextTransition(inst) }`, "1916-04-30T23:40:28Z")
+assert.sameValue(zone.getPreviousTransition(inst), null)
diff --git a/test/staging/Temporal/TimeZone/old/timezone-america-la.js b/test/staging/Temporal/TimeZone/old/timezone-america-la.js
new file mode 100644
index 0000000000..5ed6a2b3ad
--- /dev/null
+++ b/test/staging/Temporal/TimeZone/old/timezone-america-la.js
@@ -0,0 +1,28 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-timezone-objects
+description: America/Los_Angeles
+features: [Temporal]
+---*/
+
+var zone = new Temporal.TimeZone("America/Los_Angeles");
+var inst = new Temporal.Instant(0n);
+var dtm = new Temporal.PlainDateTime(1976, 11, 18, 15, 23, 30, 123, 456, 789);
+assert.sameValue(zone.id, `${ zone }`)
+assert.sameValue(zone.getOffsetNanosecondsFor(inst), -8 * 3600000000000)
+assert.sameValue(zone.getOffsetStringFor(inst), "-08:00")
+assert(zone.getInstantFor(dtm) instanceof Temporal.Instant)
+for (var i = 0, txn = inst; i < 4; i++) {
+ var transition = zone.getNextTransition(txn);
+ assert(transition instanceof Temporal.Instant);
+ assert(!transition.equals(txn));
+ txn = transition;
+}
+for (var i = 0, txn = inst; i < 4; i++) {
+ var transition = zone.getPreviousTransition(txn);
+ assert(transition instanceof Temporal.Instant);
+ assert(!transition.equals(txn));
+ txn = transition;
+}
diff --git a/test/staging/Temporal/TimeZone/old/timezone-offset.js b/test/staging/Temporal/TimeZone/old/timezone-offset.js
new file mode 100644
index 0000000000..31ffd7acb1
--- /dev/null
+++ b/test/staging/Temporal/TimeZone/old/timezone-offset.js
@@ -0,0 +1,21 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-timezone-objects
+description: +01:00
+features: [Temporal]
+---*/
+
+var zone = new Temporal.TimeZone("+01:00");
+var inst = Temporal.Instant.fromEpochSeconds(Math.floor(Math.random() * 1000000000));
+var dtm = new Temporal.PlainDateTime(1976, 11, 18, 15, 23, 30, 123, 456, 789);
+assert.sameValue(zone.id, `${ zone }`)
+assert.sameValue(zone.getOffsetNanosecondsFor(inst), 3600000000000)
+assert(zone.getPlainDateTimeFor(inst) instanceof Temporal.PlainDateTime)
+assert(zone.getInstantFor(dtm) instanceof Temporal.Instant)
+assert.sameValue(zone.getNextTransition(inst), null)
+assert.sameValue(zone.getPreviousTransition(inst), null)
+
+// wraps around to the next day
+assert.sameValue(`${ zone.getPlainDateTimeFor(Temporal.Instant.from("2020-02-06T23:59Z")) }`, "2020-02-07T00:59:00")
diff --git a/test/staging/Temporal/TimeZone/old/timezone-utc-offset.js b/test/staging/Temporal/TimeZone/old/timezone-utc-offset.js
new file mode 100644
index 0000000000..4abd2d1ee9
--- /dev/null
+++ b/test/staging/Temporal/TimeZone/old/timezone-utc-offset.js
@@ -0,0 +1,18 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-timezone-objects
+description: UTC
+features: [Temporal]
+---*/
+
+var zone = new Temporal.TimeZone("UTC");
+var inst = Temporal.Instant.fromEpochSeconds(Math.floor(Math.random() * 1000000000));
+var dtm = new Temporal.PlainDateTime(1976, 11, 18, 15, 23, 30, 123, 456, 789);
+assert.sameValue(zone.id, `${ zone }`)
+assert.sameValue(zone.getOffsetNanosecondsFor(inst), 0)
+assert(zone.getPlainDateTimeFor(inst) instanceof Temporal.PlainDateTime)
+assert(zone.getInstantFor(dtm) instanceof Temporal.Instant)
+assert.sameValue(zone.getNextTransition(inst), null)
+assert.sameValue(zone.getPreviousTransition(inst), null)
diff --git a/test/staging/Temporal/UserCalendar/old/calendar-extra-fields.js b/test/staging/Temporal/UserCalendar/old/calendar-extra-fields.js
new file mode 100644
index 0000000000..ee3b006284
--- /dev/null
+++ b/test/staging/Temporal/UserCalendar/old/calendar-extra-fields.js
@@ -0,0 +1,152 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: calendar with extra fields
+features: [Temporal]
+---*/
+
+class SeasonCalendar extends Temporal.Calendar {
+ constructor() {
+ super("iso8601");
+ }
+ toString() {
+ return "season";
+ }
+ month(date) {
+ var {isoMonth} = date.getISOFields();
+ return (isoMonth - 1) % 3 + 1;
+ }
+ monthCode(date) {
+ return `M${ this.month(date).toString().padStart(2, "0") }`;
+ }
+ season(date) {
+ var {isoMonth} = date.getISOFields();
+ return Math.floor((isoMonth - 1) / 3) + 1;
+ }
+ _isoMonthCode(fields) {
+ var month = fields.month || +fields.monthCode.slice(1);
+ return `M${ ((fields.season - 1) * 3 + month).toString().padStart(2, "0") }`;
+ }
+ dateFromFields(fields, options) {
+ var monthCode = this._isoMonthCode(fields);
+ delete fields.month;
+ return super.dateFromFields({
+ ...fields,
+ monthCode
+ }, options);
+ }
+ yearMonthFromFields(fields, options) {
+ var monthCode = this._isoMonthCode(fields);
+ delete fields.month;
+ return super.yearMonthFromFields({
+ ...fields,
+ monthCode
+ }, options);
+ }
+ monthDayFromFields(fields, options) {
+ var monthCode = this._isoMonthCode(fields);
+ delete fields.month;
+ return super.monthDayFromFields({
+ ...fields,
+ monthCode
+ }, options);
+ }
+ fields(fields) {
+ fields = fields.slice();
+ if (fields.includes("month") || fields.includes("monthCode"))
+ fields.push("season");
+ return fields;
+ }
+}
+var calendar = new SeasonCalendar();
+var datetime = new Temporal.PlainDateTime(2019, 9, 15, 0, 0, 0, 0, 0, 0, calendar);
+var date = new Temporal.PlainDate(2019, 9, 15, calendar);
+var yearmonth = new Temporal.PlainYearMonth(2019, 9, calendar);
+var monthday = new Temporal.PlainMonthDay(9, 15, calendar);
+var zoned = new Temporal.ZonedDateTime(1568505600000000000n, "UTC", calendar);
+var propDesc = {
+ get() {
+ return this.calendar.season(this);
+ },
+ configurable: true
+};
+Object.defineProperty(Temporal.PlainDateTime.prototype, "season", propDesc);
+Object.defineProperty(Temporal.PlainDate.prototype, "season", propDesc);
+Object.defineProperty(Temporal.PlainYearMonth.prototype, "season", propDesc);
+Object.defineProperty(Temporal.PlainMonthDay.prototype, "season", propDesc);
+Object.defineProperty(Temporal.ZonedDateTime.prototype, "season", propDesc);
+
+// property getter works
+assert.sameValue(datetime.season, 3);
+assert.sameValue(datetime.month, 3);
+assert.sameValue(datetime.monthCode, "M03");
+assert.sameValue(date.season, 3);
+assert.sameValue(date.month, 3);
+assert.sameValue(date.monthCode, "M03");
+assert.sameValue(yearmonth.season, 3);
+assert.sameValue(yearmonth.month, 3);
+assert.sameValue(yearmonth.monthCode, "M03");
+assert.sameValue(monthday.season, 3);
+assert.sameValue(monthday.monthCode, "M03");
+assert.sameValue(zoned.season, 3);
+assert.sameValue(zoned.month, 3);
+assert.sameValue(zoned.monthCode, "M03");
+
+// accepts season in from()
+assert.sameValue(`${ Temporal.PlainDateTime.from({
+ year: 2019,
+ season: 3,
+ month: 3,
+ day: 15,
+ calendar
+}) }`, "2019-09-15T00:00:00[u-ca=season]");
+assert.sameValue(`${ Temporal.PlainDate.from({
+ year: 2019,
+ season: 3,
+ month: 3,
+ day: 15,
+ calendar
+}) }`, "2019-09-15[u-ca=season]");
+assert.sameValue(`${ Temporal.PlainYearMonth.from({
+ year: 2019,
+ season: 3,
+ month: 3,
+ calendar
+}) }`, "2019-09-01[u-ca=season]");
+assert.sameValue(`${ Temporal.PlainMonthDay.from({
+ season: 3,
+ monthCode: "M03",
+ day: 15,
+ calendar
+}) }`, "1972-09-15[u-ca=season]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from({
+ year: 2019,
+ season: 3,
+ month: 3,
+ day: 15,
+ timeZone: "UTC",
+ calendar
+}) }`, "2019-09-15T00:00:00+00:00[UTC][u-ca=season]");
+
+// accepts season in with()
+assert.sameValue(`${ datetime.with({ season: 2 }) }`, "2019-06-15T00:00:00[u-ca=season]");
+assert.sameValue(`${ date.with({ season: 2 }) }`, "2019-06-15[u-ca=season]");
+assert.sameValue(`${ yearmonth.with({ season: 2 }) }`, "2019-06-01[u-ca=season]");
+assert.sameValue(`${ monthday.with({ season: 2 }) }`, "1972-06-15[u-ca=season]");
+assert.sameValue(`${ zoned.with({ season: 2 }) }`, "2019-06-15T00:00:00+00:00[UTC][u-ca=season]");
+
+// translates month correctly in with()
+assert.sameValue(`${ datetime.with({ month: 2 }) }`, "2019-08-15T00:00:00[u-ca=season]");
+assert.sameValue(`${ date.with({ month: 2 }) }`, "2019-08-15[u-ca=season]");
+assert.sameValue(`${ yearmonth.with({ month: 2 }) }`, "2019-08-01[u-ca=season]");
+assert.sameValue(`${ monthday.with({ monthCode: "M02" }) }`, "1972-08-15[u-ca=season]");
+assert.sameValue(`${ zoned.with({ month: 2 }) }`, "2019-08-15T00:00:00+00:00[UTC][u-ca=season]");
+
+delete Temporal.PlainDateTime.prototype.season;
+delete Temporal.PlainDate.prototype.season;
+delete Temporal.PlainYearMonth.prototype.season;
+delete Temporal.PlainMonthDay.prototype.season;
+delete Temporal.ZonedDateTime.prototype.season;
+
diff --git a/test/staging/Temporal/UserCalendar/old/calendar-non-trivial-mergefields.js b/test/staging/Temporal/UserCalendar/old/calendar-non-trivial-mergefields.js
new file mode 100644
index 0000000000..4a18631e07
--- /dev/null
+++ b/test/staging/Temporal/UserCalendar/old/calendar-non-trivial-mergefields.js
@@ -0,0 +1,146 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: calendar with nontrivial mergeFields implementation
+features: [Temporal]
+---*/
+
+class CenturyCalendar extends Temporal.Calendar {
+ constructor() {
+ super("iso8601");
+ }
+ toString() {
+ return "century";
+ }
+ century(date) {
+ var {isoYear} = date.getISOFields();
+ return Math.ceil(isoYear / 100);
+ }
+ centuryYear(date) {
+ var {isoYear} = date.getISOFields();
+ return isoYear % 100;
+ }
+ _validateFields(fields) {
+ var {year, century, centuryYear} = fields;
+ if (century === undefined !== (centuryYear === undefined)) {
+ throw new TypeError("pass either both or neither of century and centuryYear");
+ }
+ if (year === undefined)
+ return (century - 1) * 100 + centuryYear;
+ if (century !== undefined) {
+ var centuryCalculatedYear = (century - 1) * 100 + centuryYear;
+ if (year !== centuryCalculatedYear) {
+ throw new RangeError("year must agree with century/centuryYear if both given");
+ }
+ }
+ return year;
+ }
+ dateFromFields(fields, options) {
+ var isoYear = this._validateFields(fields);
+ return super.dateFromFields({
+ ...fields,
+ year: isoYear
+ }, options);
+ }
+ yearMonthFromFields(fields, options) {
+ var isoYear = this._validateFields(fields);
+ return super.yearMonthFromFields({
+ ...fields,
+ year: isoYear
+ }, options);
+ }
+ monthDayFromFields(fields, options) {
+ var isoYear = this._validateFields(fields);
+ return super.monthDayFromFields({
+ ...fields,
+ year: isoYear
+ }, options);
+ }
+ fields(fields) {
+ fields = fields.slice();
+ if (fields.includes("year"))
+ fields.push("century", "centuryYear");
+ return fields;
+ }
+ mergeFields(fields, additionalFields) {
+ var {year, century, centuryYear, ...original} = fields;
+ var {
+ year: newYear,
+ century: newCentury,
+ centuryYear: newCenturyYear
+ } = additionalFields;
+ if (newYear === undefined) {
+ original.century = century;
+ original.centuryYear = centuryYear;
+ }
+ if (newCentury === undefined && newCenturyYear === undefined) {
+ original.year === year;
+ }
+ return {
+ ...original,
+ ...additionalFields
+ };
+ }
+}
+var calendar = new CenturyCalendar();
+var datetime = new Temporal.PlainDateTime(2019, 9, 15, 0, 0, 0, 0, 0, 0, calendar);
+var date = new Temporal.PlainDate(2019, 9, 15, calendar);
+var yearmonth = new Temporal.PlainYearMonth(2019, 9, calendar);
+var zoned = new Temporal.ZonedDateTime(1568505600000000000n, "UTC", calendar);
+var propDesc = {
+ century: {
+ get() {
+ return this.calendar.century(this);
+ },
+ configurable: true
+ },
+ centuryYear: {
+ get() {
+ return this.calendar.centuryYear(this);
+ },
+ configurable: true
+ }
+};
+Object.defineProperties(Temporal.PlainDateTime.prototype, propDesc);
+Object.defineProperties(Temporal.PlainDate.prototype, propDesc);
+Object.defineProperties(Temporal.PlainYearMonth.prototype, propDesc);
+Object.defineProperties(Temporal.ZonedDateTime.prototype, propDesc);
+
+// property getters work
+assert.sameValue(datetime.century, 21);
+assert.sameValue(datetime.centuryYear, 19);
+assert.sameValue(date.century, 21);
+assert.sameValue(date.centuryYear, 19);
+assert.sameValue(yearmonth.century, 21);
+assert.sameValue(yearmonth.centuryYear, 19);
+assert.sameValue(zoned.century, 21);
+assert.sameValue(zoned.centuryYear, 19);
+
+// correctly resolves century in with()
+assert.sameValue(`${ datetime.with({ century: 20 }) }`, "1919-09-15T00:00:00[u-ca=century]");
+assert.sameValue(`${ date.with({ century: 20 }) }`, "1919-09-15[u-ca=century]");
+assert.sameValue(`${ yearmonth.with({ century: 20 }) }`, "1919-09-01[u-ca=century]");
+assert.sameValue(`${ zoned.with({ century: 20 }) }`, "1919-09-15T00:00:00+00:00[UTC][u-ca=century]");
+
+// correctly resolves centuryYear in with()
+assert.sameValue(`${ datetime.with({ centuryYear: 5 }) }`, "2005-09-15T00:00:00[u-ca=century]");
+assert.sameValue(`${ date.with({ centuryYear: 5 }) }`, "2005-09-15[u-ca=century]");
+assert.sameValue(`${ yearmonth.with({ centuryYear: 5 }) }`, "2005-09-01[u-ca=century]");
+assert.sameValue(`${ zoned.with({ centuryYear: 5 }) }`, "2005-09-15T00:00:00+00:00[UTC][u-ca=century]");
+
+// correctly resolves year in with()
+assert.sameValue(`${ datetime.with({ year: 1974 }) }`, "1974-09-15T00:00:00[u-ca=century]");
+assert.sameValue(`${ date.with({ year: 1974 }) }`, "1974-09-15[u-ca=century]");
+assert.sameValue(`${ yearmonth.with({ year: 1974 }) }`, "1974-09-01[u-ca=century]");
+assert.sameValue(`${ zoned.with({ year: 1974 }) }`, "1974-09-15T00:00:00+00:00[UTC][u-ca=century]");
+
+delete Temporal.PlainDateTime.prototype.century;
+delete Temporal.PlainDateTime.prototype.centuryYear;
+delete Temporal.PlainDate.prototype.century;
+delete Temporal.PlainDate.prototype.centuryYear;
+delete Temporal.PlainYearMonth.prototype.century;
+delete Temporal.PlainYearMonth.prototype.centuryYear;
+delete Temporal.ZonedDateTime.prototype.century;
+delete Temporal.ZonedDateTime.prototype.centuryYear;
diff --git a/test/staging/Temporal/UserCalendar/old/trivial-protocol-implementation.js b/test/staging/Temporal/UserCalendar/old/trivial-protocol-implementation.js
new file mode 100644
index 0000000000..73886177cd
--- /dev/null
+++ b/test/staging/Temporal/UserCalendar/old/trivial-protocol-implementation.js
@@ -0,0 +1,191 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: Trivial protocol implementation
+features: [Temporal]
+---*/
+
+function decimalToISO(year, month, day, overflow = "constrain") {
+ if (overflow === "constrain") {
+ if (month < 1)
+ month = 1;
+ if (month > 10)
+ month = 10;
+ if (day < 1)
+ day = 1;
+ if (day > 10)
+ day = 10;
+ } else if (overflow === "reject") {
+ if (month < 1 || month > 10 || day < 1 || day > 10) {
+ throw new RangeError("invalid value");
+ }
+ }
+ var days = year * 100 + (month - 1) * 10 + (day - 1);
+ return new Temporal.PlainDate(1970, 1, 1, "iso8601").add({ days });
+}
+function isoToDecimal(date) {
+ var {isoYear, isoMonth, isoDay} = date.getISOFields();
+ var isoDate = new Temporal.PlainDate(isoYear, isoMonth, isoDay);
+ var {days} = isoDate.since(new Temporal.PlainDate(1970, 1, 1), { largestUnit: "days" });
+ var year = Math.floor(days / 100);
+ days %= 100;
+ return {
+ year,
+ days
+ };
+}
+var obj = {
+ toString() {
+ return "decimal";
+ },
+ dateFromFields(fields, options) {
+ var {
+ overflow = "constrain"
+ } = options ? options : {};
+ var {month, monthCode} = fields;
+ if (month === undefined)
+ month = +monthCode.slice(1);
+ var isoDate = decimalToISO(fields.year, month, fields.day, 0, 0, 0, overflow);
+ return new Temporal.PlainDate(isoDate.year, isoDate.month, isoDate.day, this);
+ },
+ yearMonthFromFields(fields, options) {
+ var {
+ overflow = "constrain"
+ } = options ? options : {};
+ var {month, monthCode} = fields;
+ if (month === undefined)
+ month = +monthCode.slice(1);
+ var isoDate = decimalToISO(fields.year, month, 1, 0, 0, 0, overflow);
+ return new Temporal.PlainYearMonth(isoDate.year, isoDate.month, this, isoDate.day);
+ },
+ monthDayFromFields(fields, options) {
+ var {
+ overflow = "constrain"
+ } = options ? options : {};
+ var {month, monthCode} = fields;
+ if (month === undefined)
+ month = +monthCode.slice(1);
+ var isoDate = decimalToISO(0, month, fields.day, 0, 0, 0, overflow);
+ return new Temporal.PlainMonthDay(isoDate.month, isoDate.day, this, isoDate.year);
+ },
+ year(date) {
+ return isoToDecimal(date).year;
+ },
+ month(date) {
+ var {days} = isoToDecimal(date);
+ return Math.floor(days / 10) + 1;
+ },
+ monthCode(date) {
+ return `M${ this.month(date).toString().padStart(2, "0") }`;
+ },
+ day(date) {
+ var {days} = isoToDecimal(date);
+ return days % 10 + 1;
+ }
+};
+var date = Temporal.PlainDate.from({
+ year: 184,
+ month: 2,
+ day: 9,
+ calendar: obj
+});
+var dt = Temporal.PlainDateTime.from({
+ year: 184,
+ month: 2,
+ day: 9,
+ hour: 12,
+ calendar: obj
+});
+var ym = Temporal.PlainYearMonth.from({
+ year: 184,
+ month: 2,
+ calendar: obj
+});
+var md = Temporal.PlainMonthDay.from({
+ monthCode: "M02",
+ day: 9,
+ calendar: obj
+});
+
+// is a calendar
+assert.sameValue(typeof obj, "object")
+
+// .id is not available in from()
+assert.throws(RangeError, () => Temporal.Calendar.from("decimal"));
+assert.throws(RangeError, () => Temporal.Calendar.from("2020-06-05T09:34-07:00[America/Vancouver][u-ca=decimal]"));
+
+// Temporal.PlainDate.from()
+assert.sameValue(`${ date }`, "2020-06-05[u-ca=decimal]")
+
+// Temporal.PlainDate fields
+assert.sameValue(date.year, 184);
+assert.sameValue(date.month, 2);
+assert.sameValue(date.day, 9);
+
+// date.with()
+var date2 = date.with({ year: 0 });
+assert.sameValue(date2.year, 0);
+
+// date.withCalendar()
+var date2 = Temporal.PlainDate.from("2020-06-05T12:00");
+assert(date2.withCalendar(obj).equals(date));
+
+// Temporal.PlainDateTime.from()
+assert.sameValue(`${ dt }`, "2020-06-05T12:00:00[u-ca=decimal]")
+
+// Temporal.PlainDateTime fields
+assert.sameValue(dt.year, 184);
+assert.sameValue(dt.month, 2);
+assert.sameValue(dt.day, 9);
+assert.sameValue(dt.hour, 12);
+assert.sameValue(dt.minute, 0);
+assert.sameValue(dt.second, 0);
+assert.sameValue(dt.millisecond, 0);
+assert.sameValue(dt.microsecond, 0);
+assert.sameValue(dt.nanosecond, 0);
+
+// datetime.with()
+var dt2 = dt.with({ year: 0 });
+assert.sameValue(dt2.year, 0);
+
+// datetime.withCalendar()
+var dt2 = Temporal.PlainDateTime.from("2020-06-05T12:00");
+assert(dt2.withCalendar(obj).equals(dt));
+
+// Temporal.PlainYearMonth.from()
+assert.sameValue(`${ ym }`, "2020-05-28[u-ca=decimal]")
+
+// Temporal.PlainYearMonth fields
+assert.sameValue(dt.year, 184);
+assert.sameValue(dt.month, 2);
+
+// yearmonth.with()
+var ym2 = ym.with({ year: 0 });
+assert.sameValue(ym2.year, 0);
+
+// Temporal.PlainMonthDay.from()
+assert.sameValue(`${ md }`, "1970-01-19[u-ca=decimal]")
+
+// Temporal.PlainMonthDay fields
+assert.sameValue(md.monthCode, "M02");
+assert.sameValue(md.day, 9);
+
+// monthday.with()
+var md2 = md.with({ monthCode: "M01" });
+assert.sameValue(md2.monthCode, "M01");
+
+// timezone.getPlainDateTimeFor()
+var tz = Temporal.TimeZone.from("UTC");
+var inst = Temporal.Instant.fromEpochSeconds(0);
+var dt = tz.getPlainDateTimeFor(inst, obj);
+assert.sameValue(dt.calendar.id, obj.id);
+
+// Temporal.Now.plainDateTime()
+var nowDateTime = Temporal.Now.plainDateTime(obj, "UTC");
+assert.sameValue(nowDateTime.calendar.id, obj.id);
+
+// Temporal.Now.plainDate()
+var nowDate = Temporal.Now.plainDate(obj, "UTC");
+assert.sameValue(nowDate.calendar.id, obj.id);
diff --git a/test/staging/Temporal/UserCalendar/old/trivial-subclass.js b/test/staging/Temporal/UserCalendar/old/trivial-subclass.js
new file mode 100644
index 0000000000..3cac34d5f1
--- /dev/null
+++ b/test/staging/Temporal/UserCalendar/old/trivial-subclass.js
@@ -0,0 +1,159 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: Trivial subclass
+features: [Temporal]
+---*/
+
+class TwoBasedCalendar extends Temporal.Calendar {
+ constructor() {
+ super("iso8601");
+ }
+ toString() {
+ return "two-based";
+ }
+ dateFromFields(fields, options) {
+ var {year, month, monthCode, day} = fields;
+ if (month === undefined)
+ month = +monthCode.slice(1);
+ return super.dateFromFields({
+ year,
+ monthCode: `M${ (month - 1).toString().padStart(2, "0") }`,
+ day
+ }, options);
+ }
+ yearMonthFromFields(fields, options) {
+ var {year, month, monthCode} = fields;
+ if (month === undefined)
+ month = +monthCode.slice(1);
+ return super.yearMonthFromFields({
+ year,
+ monthCode: `M${ (month - 1).toString().padStart(2, "0") }`
+ }, options);
+ }
+ monthDayFromFields(fields, options) {
+ var {month, monthCode, day} = fields;
+ if (month === undefined)
+ month = +monthCode.slice(1);
+ return super.monthDayFromFields({
+ monthCode: `M${ (month - 1).toString().padStart(2, "0") }`,
+ day
+ }, options);
+ }
+ month(date) {
+ return date.getISOFields().isoMonth + 1;
+ }
+ monthCode(date) {
+ return `M${ this.month(date).toString().padStart(2, "0") }`;
+ }
+}
+var obj = new TwoBasedCalendar();
+var date = Temporal.PlainDate.from({
+ year: 2020,
+ month: 5,
+ day: 5,
+ calendar: obj
+});
+var dt = Temporal.PlainDateTime.from({
+ year: 2020,
+ month: 5,
+ day: 5,
+ hour: 12,
+ calendar: obj
+});
+var ym = Temporal.PlainYearMonth.from({
+ year: 2020,
+ month: 5,
+ calendar: obj
+});
+var md = Temporal.PlainMonthDay.from({
+ monthCode: "M05",
+ day: 5,
+ calendar: obj
+});
+
+// is a calendar
+assert.sameValue(typeof obj, "object")
+
+// .id property
+assert.sameValue(obj.id, "two-based")
+
+// .id is not available in from()
+assert.throws(RangeError, () => Temporal.Calendar.from("two-based"));
+assert.throws(RangeError, () => Temporal.Calendar.from("2020-06-05T09:34-07:00[America/Vancouver][u-ca=two-based]"));
+
+// Temporal.PlainDate.from()
+assert.sameValue(`${ date }`, "2020-04-05[u-ca=two-based]")
+
+// Temporal.PlainDate fields
+assert.sameValue(date.year, 2020);
+assert.sameValue(date.month, 5);
+assert.sameValue(date.day, 5);
+
+// date.with()
+var date2 = date.with({ month: 2 });
+assert.sameValue(date2.month, 2);
+
+// date.withCalendar()
+var date2 = Temporal.PlainDate.from("2020-04-05");
+assert(date2.withCalendar(obj).equals(date));
+
+// Temporal.PlainDateTime.from()
+assert.sameValue(`${ dt }`, "2020-04-05T12:00:00[u-ca=two-based]")
+
+// Temporal.PlainDateTime fields
+assert.sameValue(dt.year, 2020);
+assert.sameValue(dt.month, 5);
+assert.sameValue(dt.day, 5);
+assert.sameValue(dt.hour, 12);
+assert.sameValue(dt.minute, 0);
+assert.sameValue(dt.second, 0);
+assert.sameValue(dt.millisecond, 0);
+assert.sameValue(dt.microsecond, 0);
+assert.sameValue(dt.nanosecond, 0);
+
+// datetime.with()
+var dt2 = dt.with({ month: 2 });
+assert.sameValue(dt2.month, 2);
+
+// datetime.withCalendar()
+var dt2 = Temporal.PlainDateTime.from("2020-04-05T12:00");
+assert(dt2.withCalendar(obj).equals(dt));
+
+// Temporal.PlainYearMonth.from()
+assert.sameValue(`${ ym }`, "2020-04-01[u-ca=two-based]")
+
+// Temporal.PlainYearMonth fields
+assert.sameValue(dt.year, 2020);
+assert.sameValue(dt.month, 5);
+
+// yearmonth.with()
+var ym2 = ym.with({ month: 2 });
+assert.sameValue(ym2.month, 2);
+
+// Temporal.PlainMonthDay.from()
+assert.sameValue(`${ md }`, "1972-04-05[u-ca=two-based]")
+
+// Temporal.PlainMonthDay fields
+assert.sameValue(md.monthCode, "M05");
+assert.sameValue(md.day, 5);
+
+// monthday.with()
+var md2 = md.with({ monthCode: "M02" });
+assert.sameValue(md2.monthCode, "M02");
+
+// timezone.getPlainDateTimeFor()
+var tz = Temporal.TimeZone.from("UTC");
+var instant = Temporal.Instant.fromEpochSeconds(0);
+var dt = tz.getPlainDateTimeFor(instant, obj);
+assert.sameValue(dt.calendar.id, obj.id);
+
+// Temporal.Now.plainDateTime()
+var nowDateTime = Temporal.Now.plainDateTime(obj, "UTC");
+assert.sameValue(nowDateTime.calendar.id, obj.id);
+
+// Temporal.Now.plainDate()
+var nowDate = Temporal.Now.plainDate(obj, "UTC");
+assert.sameValue(nowDate.calendar.id, obj.id);
diff --git a/test/staging/Temporal/UserTimezone/old/subminute-offset.js b/test/staging/Temporal/UserTimezone/old/subminute-offset.js
new file mode 100644
index 0000000000..eb277f085c
--- /dev/null
+++ b/test/staging/Temporal/UserTimezone/old/subminute-offset.js
@@ -0,0 +1,77 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: sub-minute offset
+features: [Temporal]
+---*/
+
+class SubminuteTimeZone extends Temporal.TimeZone {
+ constructor() {
+ super("-00:00:01.111111111");
+ }
+ toString() {
+ return "Custom/Subminute";
+ }
+ getOffsetNanosecondsFor() {
+ return -1111111111;
+ }
+ getPossibleInstantsFor(dateTime) {
+ var utc = Temporal.TimeZone.from("UTC");
+ var instant = utc.getInstantFor(dateTime);
+ return [instant.add({ nanoseconds: 1111111111 })];
+ }
+ getNextTransition() {
+ return null;
+ }
+ getPreviousTransition() {
+ return null;
+ }
+}
+var obj = new SubminuteTimeZone();
+var inst = Temporal.Instant.fromEpochNanoseconds(0n);
+var dt = new Temporal.PlainDateTime(1976, 11, 18, 15, 23, 30, 123, 456, 789);
+
+// is a time zone
+assert.sameValue(typeof obj, "object")
+
+// .id property
+assert.sameValue(obj.id, "Custom/Subminute")
+
+// .id is not available in from()
+assert.throws(RangeError, () => Temporal.TimeZone.from("Custom/Subminute"));
+assert.throws(RangeError, () => Temporal.TimeZone.from("2020-05-26T16:02:46.251163036-00:00:01.111111111[Custom/Subminute]"));
+
+// has offset string -00:00:01.111111111
+assert.sameValue(obj.getOffsetStringFor(inst), "-00:00:01.111111111")
+
+// converts to DateTime
+assert.sameValue(`${ obj.getPlainDateTimeFor(inst) }`, "1969-12-31T23:59:58.888888889");
+assert.sameValue(`${ obj.getPlainDateTimeFor(inst, "gregory") }`, "1969-12-31T23:59:58.888888889[u-ca=gregory]");
+
+// converts to Instant
+assert.sameValue(`${ obj.getInstantFor(dt) }`, "1976-11-18T15:23:31.2345679Z");
+
+// converts to string
+assert.sameValue(`${ obj }`, obj.id)
+
+// offset prints with minute precision in instant.toString
+assert.sameValue(inst.toString({ timeZone: obj }), "1969-12-31T23:59:58.888888889+00:00")
+
+// offset prints with minute precision prints in zdt.toString
+var zdt = new Temporal.ZonedDateTime(0n, obj);
+assert.sameValue(zdt.toString(), "1969-12-31T23:59:58.888888889+00:00[Custom/Subminute]");
+
+// has no next transitions
+assert.sameValue(obj.getNextTransition(), null)
+
+// has no previous transitions
+assert.sameValue(obj.getPreviousTransition(), null)
+
+// works in Temporal.Now
+assert(Temporal.Now.plainDateTimeISO(obj) instanceof Temporal.PlainDateTime);
+assert(Temporal.Now.plainDateTime("gregory", obj) instanceof Temporal.PlainDateTime);
+assert(Temporal.Now.plainDateISO(obj) instanceof Temporal.PlainDate);
+assert(Temporal.Now.plainDate("gregory", obj) instanceof Temporal.PlainDate);
+assert(Temporal.Now.plainTimeISO(obj) instanceof Temporal.PlainTime);
diff --git a/test/staging/Temporal/UserTimezone/old/trivial-protocol.js b/test/staging/Temporal/UserTimezone/old/trivial-protocol.js
new file mode 100644
index 0000000000..17be9197c1
--- /dev/null
+++ b/test/staging/Temporal/UserTimezone/old/trivial-protocol.js
@@ -0,0 +1,39 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: Trivial protocol implementation
+features: [Temporal]
+---*/
+
+var obj = {
+ getOffsetNanosecondsFor() {
+ return 0;
+ },
+ getPossibleInstantsFor(dateTime) {
+ var {year, month, day, hour, minute, second, millisecond, microsecond, nanosecond} = dateTime;
+ var dayNum = MakeDay(year, month, day);
+ var time = MakeTime(hour, minute, second, millisecond, microsecond, nanosecond);
+ var epochNs = MakeDate(dayNum, time);
+ return [new Temporal.Instant(epochNs)];
+ },
+ toString() {
+ return "Etc/Custom/UTC_Protocol";
+ }
+};
+var inst = Temporal.Instant.fromEpochNanoseconds(0n);
+
+// offset prints in instant.toString
+assert.sameValue(inst.toString({ timeZone: obj }), "1970-01-01T00:00:00+00:00")
+
+// prints in zdt.toString
+var zdt = new Temporal.ZonedDateTime(0n, obj);
+assert.sameValue(zdt.toString(), "1970-01-01T00:00:00+00:00[Etc/Custom/UTC_Protocol]");
+
+// works in Temporal.Now
+assert(Temporal.Now.plainDateTimeISO(obj) instanceof Temporal.PlainDateTime);
+assert(Temporal.Now.plainDateTime("gregory", obj) instanceof Temporal.PlainDateTime);
+assert(Temporal.Now.plainDateISO(obj) instanceof Temporal.PlainDate);
+assert(Temporal.Now.plainDate("gregory", obj) instanceof Temporal.PlainDate);
+assert(Temporal.Now.plainTimeISO(obj) instanceof Temporal.PlainTime);
diff --git a/test/staging/Temporal/UserTimezone/old/trivial-subclass.js b/test/staging/Temporal/UserTimezone/old/trivial-subclass.js
new file mode 100644
index 0000000000..7086456c70
--- /dev/null
+++ b/test/staging/Temporal/UserTimezone/old/trivial-subclass.js
@@ -0,0 +1,115 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: Trivial subclass
+features: [Temporal]
+---*/
+
+class CustomUTCSubclass extends Temporal.TimeZone {
+ constructor() {
+ super("UTC");
+ }
+ toString() {
+ return "Etc/Custom/UTC_Subclass";
+ }
+ getOffsetNanosecondsFor() {
+ return 0;
+ }
+ getPossibleInstantsFor(dateTime) {
+ var {year, month, day, hour, minute, second, millisecond, microsecond, nanosecond} = dateTime;
+ var dayNum = MakeDay(year, month, day);
+ var time = MakeTime(hour, minute, second, millisecond, microsecond, nanosecond);
+ var epochNs = MakeDate(dayNum, time);
+ return [new Temporal.Instant(epochNs)];
+ }
+ getNextTransition() {
+ return null;
+ }
+ getPreviousTransition() {
+ return null;
+ }
+}
+
+const nsPerDay = 86400_000_000_000n;
+const nsPerMillisecond = 1_000_000n;
+
+function Day(t) {
+ return t / nsPerDay;
+}
+
+function MakeDate(day, time) {
+ return day * nsPerDay + time;
+}
+
+function MakeDay(year, month, day) {
+ const m = month - 1;
+ const ym = year + Math.floor(m / 12);
+ const mn = m % 12;
+ const t = BigInt(Date.UTC(ym, mn, 1)) * nsPerMillisecond;
+ return Day(t) + BigInt(day) - 1n;
+}
+
+function MakeTime(h, min, s, ms, µs, ns) {
+ const MinutesPerHour = 60n;
+ const SecondsPerMinute = 60n;
+ const nsPerSecond = 1_000_000_000n;
+ const nsPerMinute = nsPerSecond * SecondsPerMinute;
+ const nsPerHour = nsPerMinute * MinutesPerHour;
+ return (
+ BigInt(h) * nsPerHour +
+ BigInt(min) * nsPerMinute +
+ BigInt(s) * nsPerSecond +
+ BigInt(ms) * nsPerMillisecond +
+ BigInt(µs) * 1000n +
+ BigInt(ns)
+ );
+}
+
+var obj = new CustomUTCSubclass();
+var inst = Temporal.Instant.fromEpochNanoseconds(0n);
+var dt = new Temporal.PlainDateTime(1976, 11, 18, 15, 23, 30, 123, 456, 789);
+
+// is a time zone
+assert.sameValue(typeof obj, "object")
+
+// .id property
+assert.sameValue(obj.id, "Etc/Custom/UTC_Subclass")
+
+// .id is not available in from()
+assert.throws(RangeError, () => Temporal.TimeZone.from("Etc/Custom/UTC_Subclass"));
+assert.throws(RangeError, () => Temporal.TimeZone.from("2020-05-26T16:02:46.251163036+00:00[Etc/Custom/UTC_Subclass]"));
+
+// has offset string +00:00
+assert.sameValue(obj.getOffsetStringFor(inst), "+00:00")
+
+// converts to DateTime
+assert.sameValue(`${ obj.getPlainDateTimeFor(inst) }`, "1970-01-01T00:00:00");
+assert.sameValue(`${ obj.getPlainDateTimeFor(inst, "gregory") }`, "1970-01-01T00:00:00[u-ca=gregory]");
+
+// converts to Instant
+assert.sameValue(`${ obj.getInstantFor(dt) }`, "1976-11-18T15:23:30.123456789Z");
+
+// converts to string
+assert.sameValue(`${ obj }`, obj.id)
+
+// offset prints in instant.toString
+assert.sameValue(inst.toString({ timeZone: obj }), "1970-01-01T00:00:00+00:00")
+
+// prints in zdt.toString
+var zdt = new Temporal.ZonedDateTime(0n, obj);
+assert.sameValue(zdt.toString(), "1970-01-01T00:00:00+00:00[Etc/Custom/UTC_Subclass]");
+
+// has no next transitions
+assert.sameValue(obj.getNextTransition(), null)
+
+// has no previous transitions
+assert.sameValue(obj.getPreviousTransition(), null)
+
+// works in Temporal.Now
+assert(Temporal.Now.plainDateTimeISO(obj) instanceof Temporal.PlainDateTime);
+assert(Temporal.Now.plainDateTime("gregory", obj) instanceof Temporal.PlainDateTime);
+assert(Temporal.Now.plainDateISO(obj) instanceof Temporal.PlainDate);
+assert(Temporal.Now.plainDate("gregory", obj) instanceof Temporal.PlainDate);
+assert(Temporal.Now.plainTimeISO(obj) instanceof Temporal.PlainTime);
diff --git a/test/staging/Temporal/ZonedDateTime/old/add.js b/test/staging/Temporal/ZonedDateTime/old/add.js
new file mode 100644
index 0000000000..6190e1b6cb
--- /dev/null
+++ b/test/staging/Temporal/ZonedDateTime/old/add.js
@@ -0,0 +1,50 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: Temporal.ZonedDateTime.prototype.add()
+features: [Temporal]
+---*/
+
+var zdt = Temporal.ZonedDateTime.from("1969-12-25T12:23:45.678901234+00:00[UTC]");
+// cross epoch in ms
+ var one = zdt.subtract({
+ hours: 240,
+ nanoseconds: 800
+ });
+ var two = zdt.add({
+ hours: 240,
+ nanoseconds: 800
+ });
+ var three = two.subtract({
+ hours: 480,
+ nanoseconds: 1600
+ });
+ var four = one.add({
+ hours: 480,
+ nanoseconds: 1600
+ });
+assert.sameValue(`${ one }`, "1969-12-15T12:23:45.678900434+00:00[UTC]");
+assert.sameValue(`${ two }`, "1970-01-04T12:23:45.678902034+00:00[UTC]");
+assert(three.equals(one));
+assert(four.equals(two));
+
+// zdt.add(durationObj)
+var later = zdt.add(Temporal.Duration.from("PT240H0.000000800S"));
+assert.sameValue(`${ later }`, "1970-01-04T12:23:45.678902034+00:00[UTC]");
+
+// casts argument
+assert.sameValue(`${ zdt.add("PT240H0.000000800S") }`, "1970-01-04T12:23:45.678902034+00:00[UTC]");
+var jan31 = Temporal.ZonedDateTime.from("2020-01-31T15:00-08:00[America/Vancouver]");
+
+// constrain when ambiguous result
+assert.sameValue(`${ jan31.add({ months: 1 }) }`, "2020-02-29T15:00:00-08:00[America/Vancouver]");
+assert.sameValue(`${ jan31.add({ months: 1 }, { overflow: "constrain" }) }`, "2020-02-29T15:00:00-08:00[America/Vancouver]");
+
+// symmetrical with regard to negative durations in the time part
+assert.sameValue(`${ jan31.add({ minutes: -30 }) }`, "2020-01-31T14:30:00-08:00[America/Vancouver]");
+assert.sameValue(`${ jan31.add({ seconds: -30 }) }`, "2020-01-31T14:59:30-08:00[America/Vancouver]");
+
+// throw when ambiguous result with reject
+assert.throws(RangeError, () => jan31.add({ months: 1 }, { overflow: "reject" }));
diff --git a/test/staging/Temporal/ZonedDateTime/old/compare.js b/test/staging/Temporal/ZonedDateTime/old/compare.js
new file mode 100644
index 0000000000..023d677c9c
--- /dev/null
+++ b/test/staging/Temporal/ZonedDateTime/old/compare.js
@@ -0,0 +1,120 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: Temporal.ZonedDateTime.compare()
+features: [Temporal]
+---*/
+
+var zdt1 = Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456789+01:00[Europe/Vienna]");
+var zdt2 = Temporal.ZonedDateTime.from("2019-10-29T10:46:38.271986102+01:00[Europe/Vienna]");
+
+// equal
+assert.sameValue(Temporal.ZonedDateTime.compare(zdt1, zdt1), 0)
+
+// smaller/larger
+assert.sameValue(Temporal.ZonedDateTime.compare(zdt1, zdt2), -1)
+
+// larger/smaller
+assert.sameValue(Temporal.ZonedDateTime.compare(zdt2, zdt1), 1)
+
+// casts first argument
+assert.sameValue(Temporal.ZonedDateTime.compare({
+ year: 1976,
+ month: 11,
+ day: 18,
+ hour: 15,
+ timeZone: "Europe/Vienna"
+}, zdt2), -1);
+assert.sameValue(Temporal.ZonedDateTime.compare("1976-11-18T15:23:30.123456789+01:00[Europe/Vienna]", zdt2), -1);
+
+// casts second argument
+assert.sameValue(Temporal.ZonedDateTime.compare(zdt1, {
+ year: 2019,
+ month: 10,
+ day: 29,
+ hour: 10,
+ timeZone: "Europe/Vienna"
+}), -1);
+assert.sameValue(Temporal.ZonedDateTime.compare(zdt1, "2019-10-29T10:46:38.271986102+01:00[Europe/Vienna]"), -1);
+
+// object must contain at least the required properties
+assert.sameValue(Temporal.ZonedDateTime.compare({
+ year: 1976,
+ month: 11,
+ day: 18,
+ timeZone: "Europe/Vienna"
+}, zdt2), -1);
+assert.throws(TypeError, () => Temporal.ZonedDateTime.compare({
+ month: 11,
+ day: 18,
+ timeZone: "Europe/Vienna"
+}, zdt2));
+assert.throws(TypeError, () => Temporal.ZonedDateTime.compare({
+ year: 1976,
+ day: 18,
+ timeZone: "Europe/Vienna"
+}, zdt2));
+assert.throws(TypeError, () => Temporal.ZonedDateTime.compare({
+ year: 1976,
+ month: 11,
+ timeZone: "Europe/Vienna"
+}, zdt2));
+assert.throws(TypeError, () => Temporal.ZonedDateTime.compare({
+ year: 1976,
+ month: 11,
+ day: 18
+}, zdt2));
+assert.throws(TypeError, () => Temporal.ZonedDateTime.compare({
+ years: 1976,
+ months: 11,
+ days: 19,
+ hours: 15,
+ timeZone: "Europe/Vienna"
+}, zdt2));
+assert.sameValue(Temporal.ZonedDateTime.compare(zdt1, {
+ year: 2019,
+ month: 10,
+ day: 29,
+ timeZone: "Europe/Vienna"
+}), -1);
+assert.throws(TypeError, () => Temporal.ZonedDateTime.compare(zdt1, {
+ month: 10,
+ day: 29,
+ timeZone: "Europe/Vienna"
+}));
+assert.throws(TypeError, () => Temporal.ZonedDateTime.compare(zdt1, {
+ year: 2019,
+ day: 29,
+ timeZone: "Europe/Vienna"
+}));
+assert.throws(TypeError, () => Temporal.ZonedDateTime.compare(zdt1, {
+ year: 2019,
+ month: 10,
+ timeZone: "Europe/Vienna"
+}));
+assert.throws(TypeError, () => Temporal.ZonedDateTime.compare(zdt1, {
+ year: 2019,
+ month: 10,
+ day: 29
+}));
+assert.throws(TypeError, () => Temporal.ZonedDateTime.compare(zdt1, {
+ years: 2019,
+ months: 10,
+ days: 29,
+ hours: 10,
+ timeZone: "Europe/Vienna"
+}));
+
+// disregards time zone IDs if exact times are equal
+assert.sameValue(Temporal.ZonedDateTime.compare(zdt1, zdt1.withTimeZone("Asia/Kolkata")), 0);
+
+// disregards calendar IDs if exact times and time zones are equal
+assert.sameValue(Temporal.ZonedDateTime.compare(zdt1, zdt1.withCalendar("japanese")), 0);
+
+// compares exact time, not clock time
+var clockBefore = Temporal.ZonedDateTime.from("1999-12-31T23:30-08:00[America/Vancouver]");
+var clockAfter = Temporal.ZonedDateTime.from("2000-01-01T01:30-04:00[America/Halifax]");
+assert.sameValue(Temporal.ZonedDateTime.compare(clockBefore, clockAfter), 1);
+assert.sameValue(Temporal.PlainDateTime.compare(clockBefore.toPlainDateTime(), clockAfter.toPlainDateTime()), -1);
diff --git a/test/staging/Temporal/ZonedDateTime/old/construction-and-properties.js b/test/staging/Temporal/ZonedDateTime/old/construction-and-properties.js
new file mode 100644
index 0000000000..fae241a403
--- /dev/null
+++ b/test/staging/Temporal/ZonedDateTime/old/construction-and-properties.js
@@ -0,0 +1,86 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: Construction and properties
+features: [Temporal]
+---*/
+
+var tz = new Temporal.TimeZone("America/Los_Angeles");
+var epochMillis = Date.UTC(1976, 10, 18, 15, 23, 30, 123);
+var epochNanos = BigInt(epochMillis) * BigInt(1000000) + BigInt(456789);
+
+// works
+var zdt = new Temporal.ZonedDateTime(epochNanos, tz);
+assert(zdt instanceof Temporal.ZonedDateTime);
+assert.sameValue(typeof zdt, "object");
+assert.sameValue(zdt.toInstant().epochSeconds, Math.floor(Date.UTC(1976, 10, 18, 15, 23, 30, 123) / 1000), "epochSeconds");
+assert.sameValue(zdt.toInstant().epochMilliseconds, Date.UTC(1976, 10, 18, 15, 23, 30, 123), "epochMilliseconds");
+
+// Temporal.ZonedDateTime for (1976, 11, 18, 15, 23, 30, 123, 456, 789)"
+ var zdt = new Temporal.ZonedDateTime(epochNanos, new Temporal.TimeZone("UTC"));
+// can be constructed
+assert(zdt instanceof Temporal.ZonedDateTime);
+assert.sameValue(typeof zdt, "object");
+
+assert.sameValue(zdt.year, 1976)
+assert.sameValue(zdt.month, 11);
+assert.sameValue(zdt.monthCode, "M11");
+assert.sameValue(zdt.day, 18);
+assert.sameValue(zdt.hour, 15);
+assert.sameValue(zdt.minute, 23);
+assert.sameValue(zdt.second, 30);
+assert.sameValue(zdt.millisecond, 123);
+assert.sameValue(zdt.microsecond, 456);
+assert.sameValue(zdt.nanosecond, 789);
+assert.sameValue(zdt.epochSeconds, 217178610);
+assert.sameValue(zdt.epochMilliseconds, 217178610123);
+assert.sameValue(zdt.epochMicroseconds, 217178610123456n);
+assert.sameValue(zdt.epochNanoseconds, 217178610123456789n);
+assert.sameValue(zdt.dayOfWeek, 4);
+assert.sameValue(zdt.dayOfYear, 323);
+assert.sameValue(zdt.weekOfYear, 47);
+assert.sameValue(zdt.daysInWeek, 7);
+assert.sameValue(zdt.daysInMonth, 30);
+assert.sameValue(zdt.daysInYear, 366);
+assert.sameValue(zdt.monthsInYear, 12);
+assert.sameValue(zdt.inLeapYear, true);
+assert.sameValue(zdt.offset, "+00:00");
+assert.sameValue(zdt.offsetNanoseconds, 0);
+assert.sameValue(`${ zdt }`, "1976-11-18T15:23:30.123456789+00:00[UTC]");
+
+// Temporal.ZonedDateTime with non-UTC time zone and non-ISO calendar"
+var zdt = new Temporal.ZonedDateTime(epochNanos, Temporal.TimeZone.from("Europe/Vienna"), Temporal.Calendar.from("gregory"));
+
+// can be constructed"
+assert(zdt instanceof Temporal.ZonedDateTime);
+assert.sameValue(typeof zdt, "object");
+
+assert.sameValue(zdt.era, "ce");
+assert.sameValue(zdt.year, 1976);
+assert.sameValue(zdt.month, 11);
+assert.sameValue(zdt.monthCode, "M11");
+assert.sameValue(zdt.day, 18);
+assert.sameValue(zdt.hour, 16);
+assert.sameValue(zdt.minute, 23);
+assert.sameValue(zdt.second, 30);
+assert.sameValue(zdt.millisecond, 123);
+assert.sameValue(zdt.microsecond, 456);
+assert.sameValue(zdt.nanosecond, 789);
+assert.sameValue(zdt.epochSeconds, 217178610);
+assert.sameValue(zdt.epochMilliseconds, 217178610123);
+assert.sameValue(zdt.epochMicroseconds, 217178610123456n);
+assert.sameValue(zdt.epochNanoseconds, 217178610123456789n);
+assert.sameValue(zdt.dayOfWeek, 4);
+assert.sameValue(zdt.dayOfYear, 323);
+assert.sameValue(zdt.weekOfYear, 47);
+assert.sameValue(zdt.daysInWeek, 7);
+assert.sameValue(zdt.daysInMonth, 30);
+assert.sameValue(zdt.daysInYear, 366);
+assert.sameValue(zdt.monthsInYear, 12);
+assert.sameValue(zdt.inLeapYear, true);
+assert.sameValue(zdt.offset, "+01:00");
+assert.sameValue(zdt.offsetNanoseconds, 3600000000000);
+assert.sameValue(`${ zdt }`, "1976-11-18T16:23:30.123456789+01:00[Europe/Vienna][u-ca=gregory]");
+
diff --git a/test/staging/Temporal/ZonedDateTime/old/date-time-hours-overflow.js b/test/staging/Temporal/ZonedDateTime/old/date-time-hours-overflow.js
new file mode 100644
index 0000000000..c8cc2f9261
--- /dev/null
+++ b/test/staging/Temporal/ZonedDateTime/old/date-time-hours-overflow.js
@@ -0,0 +1,23 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: hours overflow
+features: [Temporal]
+---*/
+
+
+// subtract result
+var later = Temporal.ZonedDateTime.from("2019-10-29T10:46:38.271986102-03:00[America/Santiago]");
+var earlier = later.subtract({ hours: 12 });
+assert.sameValue(`${ earlier }`, "2019-10-28T22:46:38.271986102-03:00[America/Santiago]");
+
+// add result
+var earlier = Temporal.ZonedDateTime.from("2020-05-31T23:12:38.271986102-04:00[America/Santiago]");
+var later = earlier.add({ hours: 2 });
+assert.sameValue(`${ later }`, "2020-06-01T01:12:38.271986102-04:00[America/Santiago]");
+
+// symmetrical with regard to negative durations
+assert.sameValue(`${ Temporal.ZonedDateTime.from("2019-10-29T10:46:38.271986102-03:00[America/Santiago]").add({ hours: -12 }) }`, "2019-10-28T22:46:38.271986102-03:00[America/Santiago]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("2020-05-31T23:12:38.271986102-04:00[America/Santiago]").subtract({ hours: -2 }) }`, "2020-06-01T01:12:38.271986102-04:00[America/Santiago]");
diff --git a/test/staging/Temporal/ZonedDateTime/old/dst-math.js b/test/staging/Temporal/ZonedDateTime/old/dst-math.js
new file mode 100644
index 0000000000..07eca2e1d6
--- /dev/null
+++ b/test/staging/Temporal/ZonedDateTime/old/dst-math.js
@@ -0,0 +1,290 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: math around DST
+features: [Temporal]
+---*/
+
+var tz = new Temporal.TimeZone("America/Los_Angeles");
+var hourBeforeDstStart = new Temporal.PlainDateTime(2020, 3, 8, 1).toZonedDateTime(tz);
+var dayBeforeDstStart = new Temporal.PlainDateTime(2020, 3, 7, 2, 30).toZonedDateTime(tz);
+
+// add 1 hour to get to DST start
+var added = hourBeforeDstStart.add({ hours: 1 });
+assert.sameValue(added.hour, 3);
+var diff = hourBeforeDstStart.until(added, { largestUnit: "hours" });
+assert.sameValue(`${ diff }`, "PT1H");
+assert.sameValue(`${ diff }`, `${ added.since(hourBeforeDstStart, { largestUnit: "hours" }) }`);
+var undo = added.subtract(diff);
+assert.sameValue(`${ undo }`, `${ hourBeforeDstStart }`);
+
+// add 2 hours to get to DST start +1
+var added = hourBeforeDstStart.add({ hours: 2 });
+assert.sameValue(added.hour, 4);
+var diff = hourBeforeDstStart.until(added, { largestUnit: "hours" });
+assert.sameValue(`${ diff }`, "PT2H");
+assert.sameValue(`${ diff }`, `${ added.since(hourBeforeDstStart, { largestUnit: "hours" }) }`);
+var undo = added.subtract(diff);
+assert.sameValue(`${ undo }`, `${ hourBeforeDstStart }`);
+
+// add 1.5 hours to get to 0.5 hours after DST start
+var added = hourBeforeDstStart.add({
+ hours: 1,
+ minutes: 30
+});
+assert.sameValue(added.hour, 3);
+assert.sameValue(added.minute, 30);
+var diff = hourBeforeDstStart.until(added, { largestUnit: "hours" });
+assert.sameValue(`${ diff }`, "PT1H30M");
+assert.sameValue(`${ diff }`, `${ added.since(hourBeforeDstStart, { largestUnit: "hours" }) }`);
+var undo = added.subtract(diff);
+assert.sameValue(`${ undo }`, `${ hourBeforeDstStart }`);
+
+// Samoa date line change (add): 10:00PM 29 Dec 2011 -> 11:00PM 31 Dec 2011
+var timeZone = Temporal.TimeZone.from("Pacific/Apia");
+var dayBeforeSamoaDateLineChangeAbs = timeZone.getInstantFor(new Temporal.PlainDateTime(2011, 12, 29, 22));
+var start = dayBeforeSamoaDateLineChangeAbs.toZonedDateTimeISO(timeZone);
+var added = start.add({
+ days: 1,
+ hours: 1
+});
+assert.sameValue(added.day, 31);
+assert.sameValue(added.hour, 23);
+assert.sameValue(added.minute, 0);
+var diff = start.until(added, { largestUnit: "days" });
+assert.sameValue(`${ diff }`, "P2DT1H");
+var undo = added.subtract(diff);
+assert.sameValue(`${ undo }`, `${ start }`);
+
+// Samoa date line change (subtract): 11:00PM 31 Dec 2011 -> 10:00PM 29 Dec 2011
+var timeZone = Temporal.TimeZone.from("Pacific/Apia");
+var dayAfterSamoaDateLineChangeAbs = timeZone.getInstantFor(new Temporal.PlainDateTime(2011, 12, 31, 23));
+var start = dayAfterSamoaDateLineChangeAbs.toZonedDateTimeISO(timeZone);
+var skipped = start.subtract({
+ days: 1,
+ hours: 1
+});
+assert.sameValue(skipped.day, 31);
+assert.sameValue(skipped.hour, 22);
+assert.sameValue(skipped.minute, 0);
+var end = start.subtract({
+ days: 2,
+ hours: 1
+});
+assert.sameValue(end.day, 29);
+assert.sameValue(end.hour, 22);
+assert.sameValue(end.minute, 0);
+var diff = end.since(start, { largestUnit: "days" });
+assert.sameValue(`${ diff }`, "-P2DT1H");
+var undo = start.add(diff);
+assert.sameValue(`${ undo }`, `${ end }`);
+
+// 3:30 day before DST start -> 3:30 day of DST start
+var start = dayBeforeDstStart.add({ hours: 1 });
+var added = start.add({ days: 1 });
+assert.sameValue(added.day, 8);
+assert.sameValue(added.hour, 3);
+assert.sameValue(added.minute, 30);
+var diff = start.until(added, { largestUnit: "days" });
+assert.sameValue(`${ diff }`, "P1D");
+var undo = added.subtract(diff);
+assert.sameValue(`${ undo }`, `${ start }`);
+
+// 2:30 day before DST start -> 3:30 day of DST start
+var added = dayBeforeDstStart.add({ days: 1 });
+assert.sameValue(added.day, 8);
+assert.sameValue(added.hour, 3);
+assert.sameValue(added.minute, 30);
+var diff = dayBeforeDstStart.until(added, { largestUnit: "days" });
+assert.sameValue(`${ diff }`, "P1D");
+var undo = dayBeforeDstStart.add(diff);
+assert.sameValue(`${ undo }`, `${ added }`);
+
+// 1:30 day DST starts -> 4:30 day DST starts
+var start = dayBeforeDstStart.add({ hours: 23 });
+var added = start.add({ hours: 2 });
+assert.sameValue(added.day, 8);
+assert.sameValue(added.hour, 4);
+assert.sameValue(added.minute, 30);
+var diff = start.until(added, { largestUnit: "days" });
+assert.sameValue(`${ diff }`, "PT2H");
+var undo = added.subtract(diff);
+assert.sameValue(`${ undo }`, `${ start }`);
+
+// 2:00 day before DST starts -> 3:00 day DST starts
+var start = hourBeforeDstStart.subtract({ days: 1 }).add({ hours: 1 });
+var added = start.add({ days: 1 });
+assert.sameValue(added.day, 8);
+assert.sameValue(added.hour, 3);
+assert.sameValue(added.minute, 0);
+var diff = start.until(added, { largestUnit: "days" });
+assert.sameValue(`${ diff }`, "P1D");
+var undo = start.add(diff);
+assert.sameValue(`${ undo }`, `${ added }`);
+
+// 1:00AM day DST starts -> (add 24 hours) -> 2:00AM day after DST starts
+var start = hourBeforeDstStart;
+var added = start.add({ hours: 24 });
+assert.sameValue(added.day, 9);
+assert.sameValue(added.hour, 2);
+assert.sameValue(added.minute, 0);
+var diff = start.until(added, { largestUnit: "days" });
+assert.sameValue(`${ diff }`, "P1DT1H");
+var undo = added.subtract(diff);
+assert.sameValue(`${ undo }`, `${ start }`);
+
+// 12:00AM day DST starts -> (add 24 hours) -> 1:00AM day after DST starts
+var start = hourBeforeDstStart.subtract({ hours: 1 });
+var added = start.add({ hours: 24 });
+assert.sameValue(added.day, 9);
+assert.sameValue(added.hour, 1);
+assert.sameValue(added.minute, 0);
+var diff = start.until(added, { largestUnit: "days" });
+assert.sameValue(`${ diff }`, "P1DT1H");
+var undo = added.subtract(diff);
+assert.sameValue(`${ undo }`, `${ start }`);
+
+// Difference can return day length > 24 hours
+var start = Temporal.ZonedDateTime.from("2020-10-30T01:45-07:00[America/Los_Angeles]");
+var end = Temporal.ZonedDateTime.from("2020-11-02T01:15-08:00[America/Los_Angeles]");
+var diff = start.until(end, { largestUnit: "days" });
+assert.sameValue(`${ diff }`, "P2DT24H30M");
+var undo = start.add(diff);
+assert.sameValue(`${ undo }`, `${ end }`);
+
+// Difference rounding (nearest day) is DST-aware
+var start = Temporal.ZonedDateTime.from("2020-03-10T02:30-07:00[America/Los_Angeles]");
+var end = Temporal.ZonedDateTime.from("2020-03-07T14:15-08:00[America/Los_Angeles]");
+var diff = start.until(end, {
+ smallestUnit: "days",
+ roundingMode: "halfExpand"
+});
+assert.sameValue(`${ diff }`, "-P3D");
+
+// Difference rounding (ceil day) is DST-aware
+var start = Temporal.ZonedDateTime.from("2020-03-10T02:30-07:00[America/Los_Angeles]");
+var end = Temporal.ZonedDateTime.from("2020-03-07T14:15-08:00[America/Los_Angeles]");
+var diff = start.until(end, {
+ smallestUnit: "days",
+ roundingMode: "ceil"
+});
+assert.sameValue(`${ diff }`, "-P2D");
+
+// Difference rounding (trunc day) is DST-aware
+var start = Temporal.ZonedDateTime.from("2020-03-10T02:30-07:00[America/Los_Angeles]");
+var end = Temporal.ZonedDateTime.from("2020-03-07T14:15-08:00[America/Los_Angeles]");
+var diff = start.until(end, {
+ smallestUnit: "days",
+ roundingMode: "trunc"
+});
+assert.sameValue(`${ diff }`, "-P2D");
+
+// Difference rounding (floor day) is DST-aware
+var start = Temporal.ZonedDateTime.from("2020-03-10T02:30-07:00[America/Los_Angeles]");
+var end = Temporal.ZonedDateTime.from("2020-03-07T14:15-08:00[America/Los_Angeles]");
+var diff = start.until(end, {
+ smallestUnit: "days",
+ roundingMode: "floor"
+});
+assert.sameValue(`${ diff }`, "-P3D");
+
+// Difference rounding (nearest hour) is DST-aware
+var start = Temporal.ZonedDateTime.from("2020-03-10T02:30-07:00[America/Los_Angeles]");
+var end = Temporal.ZonedDateTime.from("2020-03-07T14:15-08:00[America/Los_Angeles]");
+var diff = start.until(end, {
+ largestUnit: "days",
+ smallestUnit: "hours",
+ roundingMode: "halfExpand"
+});
+assert.sameValue(`${ diff }`, "-P2DT12H");
+
+// Difference rounding (ceil hour) is DST-aware
+var start = Temporal.ZonedDateTime.from("2020-03-10T02:30-07:00[America/Los_Angeles]");
+var end = Temporal.ZonedDateTime.from("2020-03-07T14:15-08:00[America/Los_Angeles]");
+var diff = start.until(end, {
+ largestUnit: "days",
+ smallestUnit: "hours",
+ roundingMode: "ceil"
+});
+assert.sameValue(`${ diff }`, "-P2DT12H");
+
+// Difference rounding (trunc hour) is DST-aware
+var start = Temporal.ZonedDateTime.from("2020-03-10T02:30-07:00[America/Los_Angeles]");
+var end = Temporal.ZonedDateTime.from("2020-03-07T14:15-08:00[America/Los_Angeles]");
+var diff = start.until(end, {
+ largestUnit: "days",
+ smallestUnit: "hours",
+ roundingMode: "trunc"
+});
+assert.sameValue(`${ diff }`, "-P2DT12H");
+
+// Difference rounding (floor hour) is DST-aware
+var start = Temporal.ZonedDateTime.from("2020-03-10T02:30-07:00[America/Los_Angeles]");
+var end = Temporal.ZonedDateTime.from("2020-03-07T14:15-08:00[America/Los_Angeles]");
+var diff = start.until(end, {
+ largestUnit: "days",
+ smallestUnit: "hours",
+ roundingMode: "floor"
+});
+assert.sameValue(`${ diff }`, "-P2DT13H");
+
+// Difference when date portion ends inside a DST-skipped period
+var start = Temporal.ZonedDateTime.from("2020-03-07T02:30-08:00[America/Los_Angeles]");
+var end = Temporal.ZonedDateTime.from("2020-03-08T03:15-07:00[America/Los_Angeles]");
+var diff = start.until(end, { largestUnit: "days" });
+assert.sameValue(`${ diff }`, "PT23H45M");
+
+// Difference when date portion ends inside day skipped by Samoa's 24hr 2011 transition
+var end = Temporal.ZonedDateTime.from("2011-12-31T05:00+14:00[Pacific/Apia]");
+var start = Temporal.ZonedDateTime.from("2011-12-28T10:00-10:00[Pacific/Apia]");
+var diff = start.until(end, { largestUnit: "days" });
+assert.sameValue(`${ diff }`, "P1DT19H");
+
+// Rounding up to hours causes one more day of overflow (positive)
+var start = Temporal.ZonedDateTime.from("2020-01-01T00:00-08:00[America/Los_Angeles]");
+var end = Temporal.ZonedDateTime.from("2020-01-03T23:59-08:00[America/Los_Angeles]");
+var diff = start.until(end, {
+ largestUnit: "days",
+ smallestUnit: "hours",
+ roundingMode: "halfExpand"
+});
+assert.sameValue(`${ diff }`, "P3D");
+
+// Rounding up to hours causes one more day of overflow (negative)
+var start = Temporal.ZonedDateTime.from("2020-01-01T00:00-08:00[America/Los_Angeles]");
+var end = Temporal.ZonedDateTime.from("2020-01-03T23:59-08:00[America/Los_Angeles]");
+var diff = end.until(start, {
+ largestUnit: "days",
+ smallestUnit: "hours",
+ roundingMode: "halfExpand"
+});
+assert.sameValue(`${ diff }`, "-P3D");
+
+// addition and difference work near DST start
+var stepsPerHour = 2;
+var minutesPerStep = 60 / stepsPerHour;
+var hoursUntilEnd = 26;
+var startHourRange = 3;
+for (var i = 0; i < startHourRange * stepsPerHour; i++) {
+ var start = hourBeforeDstStart.add({ minutes: minutesPerStep * i });
+ for (var j = 0; j < hoursUntilEnd * stepsPerHour; j++) {
+ var end = start.add({ minutes: j * minutesPerStep });
+ var diff = start.until(end, { largestUnit: "days" });
+ var expectedMinutes = minutesPerStep * (j % stepsPerHour);
+ assert.sameValue(diff.minutes, expectedMinutes);
+ var diff60 = Math.floor(j / stepsPerHour);
+ if (i >= stepsPerHour) {
+ var expectedDays = diff60 < 24 ? 0 : diff60 < 48 ? 1 : 2;
+ var expectedHours = diff60 < 24 ? diff60 : diff60 < 48 ? diff60 - 24 : diff60 - 48;
+ assert.sameValue(diff.hours, expectedHours);
+ assert.sameValue(diff.days, expectedDays);
+ } else {
+ var expectedDays = diff60 < 23 ? 0 : diff60 < 47 ? 1 : 2;
+ var expectedHours = diff60 < 23 ? diff60 : diff60 < 47 ? diff60 - 23 : diff60 - 47;
+ assert.sameValue(diff.hours, expectedHours);
+ assert.sameValue(diff.days, expectedDays);
+ }
+ }
+}
diff --git a/test/staging/Temporal/ZonedDateTime/old/dst-properties.js b/test/staging/Temporal/ZonedDateTime/old/dst-properties.js
new file mode 100644
index 0000000000..504b4c12e0
--- /dev/null
+++ b/test/staging/Temporal/ZonedDateTime/old/dst-properties.js
@@ -0,0 +1,57 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: properties around DST
+features: [Temporal]
+---*/
+
+var tz = new Temporal.TimeZone("America/Los_Angeles");
+var hourBeforeDstStart = new Temporal.PlainDateTime(2020, 3, 8, 1).toZonedDateTime(tz);
+var dayBeforeDstStart = new Temporal.PlainDateTime(2020, 3, 7, 2, 30).toZonedDateTime(tz);
+
+// hoursInDay works with DST start
+assert.sameValue(hourBeforeDstStart.hoursInDay, 23);
+
+// hoursInDay works with non-DST days
+assert.sameValue(dayBeforeDstStart.hoursInDay, 24);
+
+// hoursInDay works with DST end
+var dstEnd = Temporal.ZonedDateTime.from("2020-11-01T01:00-08:00[America/Los_Angeles]");
+assert.sameValue(dstEnd.hoursInDay, 25);
+
+// hoursInDay works with non-hour DST change
+var zdt1 = Temporal.ZonedDateTime.from("2020-10-04T12:00[Australia/Lord_Howe]");
+assert.sameValue(zdt1.hoursInDay, 23.5);
+var zdt2 = Temporal.ZonedDateTime.from("2020-04-05T12:00[Australia/Lord_Howe]");
+assert.sameValue(zdt2.hoursInDay, 24.5);
+
+// hoursInDay works with non-half-hour DST change
+var zdt = Temporal.ZonedDateTime.from("1933-01-01T12:00[Asia/Singapore]");
+assert(Math.abs(zdt.hoursInDay - 23.666666666666668) < Number.EPSILON);
+
+// hoursInDay works when day starts at 1:00 due to DST start at midnight
+var zdt = Temporal.ZonedDateTime.from("2015-10-18T12:00:00-02:00[America/Sao_Paulo]");
+assert.sameValue(zdt.hoursInDay, 23);
+
+// startOfDay works
+var start = dayBeforeDstStart.startOfDay();
+assert.sameValue(`${ start.toPlainDate() }`, `${ dayBeforeDstStart.toPlainDate() }`);
+assert.sameValue(`${ start.toPlainTime() }`, "00:00:00");
+
+// startOfDay works when day starts at 1:00 due to DST start at midnight
+var zdt = Temporal.ZonedDateTime.from("2015-10-18T12:00:00-02:00[America/Sao_Paulo]");
+assert.sameValue(`${ zdt.startOfDay().toPlainTime() }`, "01:00:00");
+var dayAfterSamoaDateLineChange = Temporal.ZonedDateTime.from("2011-12-31T22:00+14:00[Pacific/Apia]");
+var dayBeforeSamoaDateLineChange = Temporal.ZonedDateTime.from("2011-12-29T22:00-10:00[Pacific/Apia]");
+
+// startOfDay works after Samoa date line change
+var start = dayAfterSamoaDateLineChange.startOfDay();
+assert.sameValue(`${ start.toPlainTime() }`, "00:00:00");
+
+// hoursInDay works after Samoa date line change
+assert.sameValue(dayAfterSamoaDateLineChange.hoursInDay, 24);
+
+// hoursInDay works before Samoa date line change
+assert.sameValue(dayBeforeSamoaDateLineChange.hoursInDay, 24);
diff --git a/test/staging/Temporal/ZonedDateTime/old/equals.js b/test/staging/Temporal/ZonedDateTime/old/equals.js
new file mode 100644
index 0000000000..8f88c5f164
--- /dev/null
+++ b/test/staging/Temporal/ZonedDateTime/old/equals.js
@@ -0,0 +1,75 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: Temporal.ZonedDateTime.prototype.equals()
+features: [Temporal]
+---*/
+
+var tz = Temporal.TimeZone.from("America/New_York");
+var cal = Temporal.Calendar.from("gregory");
+var zdt = new Temporal.ZonedDateTime(0n, tz, cal);
+
+// constructed from equivalent parameters are equal
+var zdt2 = Temporal.ZonedDateTime.from("1969-12-31T19:00-05:00[America/New_York][u-ca=gregory]");
+assert(zdt.equals(zdt2));
+assert(zdt2.equals(zdt));
+
+// different instant not equal
+var zdt2 = new Temporal.ZonedDateTime(1n, tz, cal);
+assert(!zdt.equals(zdt2));
+
+// different time zone not equal
+var zdt2 = new Temporal.ZonedDateTime(0n, "America/Chicago", cal);
+assert(!zdt.equals(zdt2));
+
+// different calendar not equal
+var zdt2 = new Temporal.ZonedDateTime(0n, tz, "iso8601");
+assert(!zdt.equals(zdt2));
+
+// casts its argument
+assert(zdt.equals("1969-12-31T19:00-05:00[America/New_York][u-ca=gregory]"));
+assert(zdt.equals({
+ year: 1969,
+ month: 12,
+ day: 31,
+ hour: 19,
+ timeZone: "America/New_York",
+ calendar: "gregory"
+}));
+
+// at least the required properties must be present
+assert(!zdt.equals({
+ year: 1969,
+ month: 12,
+ day: 31,
+ timeZone: "America/New_York"
+}));
+assert.throws(TypeError, () => zdt.equals({
+ month: 12,
+ day: 31,
+ timeZone: "America/New_York"
+}));
+assert.throws(TypeError, () => zdt.equals({
+ year: 1969,
+ day: 31,
+ timeZone: "America/New_York"
+}));
+assert.throws(TypeError, () => zdt.equals({
+ year: 1969,
+ month: 12,
+ timeZone: "America/New_York"
+}));
+assert.throws(TypeError, () => zdt.equals({
+ year: 1969,
+ month: 12,
+ day: 31
+}));
+assert.throws(TypeError, () => zdt.equals({
+ years: 1969,
+ months: 12,
+ days: 31,
+ timeZone: "America/New_York",
+ calendarName: "gregory"
+}));
diff --git a/test/staging/Temporal/ZonedDateTime/old/order-of-operations.js b/test/staging/Temporal/ZonedDateTime/old/order-of-operations.js
new file mode 100644
index 0000000000..c1b7230ae3
--- /dev/null
+++ b/test/staging/Temporal/ZonedDateTime/old/order-of-operations.js
@@ -0,0 +1,79 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: math order of operations and options
+features: [Temporal]
+---*/
+
+var breakoutUnits = (op, zdt, d, options) => zdt[op]({ years: d.years }, options)[op]({ months: d.months }, options)[op]({ weeks: d.weeks }, options)[op]({ days: d.days }, options)[op]({
+ hours: d.hours,
+ minutes: d.minutes,
+ seconds: d.seconds,
+ milliseconds: d.milliseconds,
+ microseconds: d.microseconds,
+ nanoseconds: d.nanoseconds
+}, options);
+
+// order of operations: add / none
+var zdt = Temporal.ZonedDateTime.from("2020-01-31T00:00-08:00[America/Los_Angeles]");
+var d = Temporal.Duration.from({
+ months: 1,
+ days: 1
+});
+var options = undefined;
+var result = zdt.add(d, options);
+assert.sameValue(result.toString(), "2020-03-01T00:00:00-08:00[America/Los_Angeles]");
+assert.sameValue(breakoutUnits("add", zdt, d, options).toString(), result.toString());
+
+// order of operations: add / constrain
+var zdt = Temporal.ZonedDateTime.from("2020-01-31T00:00-08:00[America/Los_Angeles]");
+var d = Temporal.Duration.from({
+ months: 1,
+ days: 1
+});
+var options = { overflow: "constrain" };
+var result = zdt.add(d, options);
+assert.sameValue(result.toString(), "2020-03-01T00:00:00-08:00[America/Los_Angeles]");
+assert.sameValue(breakoutUnits("add", zdt, d, options).toString(), result.toString());
+
+// order of operations: add / reject
+var zdt = Temporal.ZonedDateTime.from("2020-01-31T00:00-08:00[America/Los_Angeles]");
+var d = Temporal.Duration.from({
+ months: 1,
+ days: 1
+});
+var options = { overflow: "reject" };
+assert.throws(RangeError, () => zdt.add(d, options));
+
+// order of operations: subtract / none
+var zdt = Temporal.ZonedDateTime.from("2020-03-31T00:00-07:00[America/Los_Angeles]");
+var d = Temporal.Duration.from({
+ months: 1,
+ days: 1
+});
+var options = undefined;
+var result = zdt.subtract(d, options);
+assert.sameValue(result.toString(), "2020-02-28T00:00:00-08:00[America/Los_Angeles]");
+assert.sameValue(breakoutUnits("subtract", zdt, d, options).toString(), result.toString());
+
+// order of operations: subtract / constrain
+var zdt = Temporal.ZonedDateTime.from("2020-03-31T00:00-07:00[America/Los_Angeles]");
+var d = Temporal.Duration.from({
+ months: 1,
+ days: 1
+});
+var options = { overflow: "constrain" };
+var result = zdt.subtract(d, options);
+assert.sameValue(result.toString(), "2020-02-28T00:00:00-08:00[America/Los_Angeles]");
+assert.sameValue(breakoutUnits("subtract", zdt, d, options).toString(), result.toString());
+
+// order of operations: subtract / reject
+var zdt = Temporal.ZonedDateTime.from("2020-03-31T00:00-07:00[America/Los_Angeles]");
+var d = Temporal.Duration.from({
+ months: 1,
+ days: 1
+});
+var options = { overflow: "reject" };
+assert.throws(RangeError, () => zdt.subtract(d, options));
diff --git a/test/staging/Temporal/ZonedDateTime/old/property-bags.js b/test/staging/Temporal/ZonedDateTime/old/property-bags.js
new file mode 100644
index 0000000000..b319f7f87b
--- /dev/null
+++ b/test/staging/Temporal/ZonedDateTime/old/property-bags.js
@@ -0,0 +1,282 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: property bags
+features: [Temporal]
+---*/
+
+var lagos = Temporal.TimeZone.from("Africa/Lagos");
+
+// can be constructed with monthCode and without month
+assert.sameValue(`${ Temporal.ZonedDateTime.from({
+ year: 1976,
+ monthCode: "M11",
+ day: 18,
+ timeZone: lagos
+}) }`, "1976-11-18T00:00:00+01:00[Africa/Lagos]");
+
+// can be constructed with month and without monthCode
+assert.sameValue(`${ Temporal.ZonedDateTime.from({
+ year: 1976,
+ month: 11,
+ day: 18,
+ timeZone: lagos
+}) }`, "1976-11-18T00:00:00+01:00[Africa/Lagos]");
+
+// month and monthCode must agree
+assert.throws(RangeError, () => Temporal.ZonedDateTime.from({
+ year: 1976,
+ month: 11,
+ monthCode: "M12",
+ day: 18,
+ timeZone: lagos
+}));
+
+// Temporal.ZonedDateTime.from({}) throws
+assert.throws(TypeError, () => Temporal.ZonedDateTime.from({}))
+
+// Temporal.ZonedDateTime.from(required prop undefined) throws
+assert.throws(TypeError, () => Temporal.ZonedDateTime.from({
+ year: 1976,
+ month: undefined,
+ monthCode: undefined,
+ day: 18,
+ timeZone: lagos
+}))
+
+// options may be a function object
+assert.sameValue(`${ Temporal.ZonedDateTime.from({
+ year: 1976,
+ month: 11,
+ day: 18,
+ timeZone: lagos
+}, () => {
+}) }`, "1976-11-18T00:00:00+01:00[Africa/Lagos]");
+
+// object must contain at least the required correctly-spelled properties
+assert.throws(TypeError, () => Temporal.ZonedDateTime.from({
+ years: 1976,
+ months: 11,
+ days: 18,
+ timeZone: lagos
+}));
+
+// incorrectly-spelled properties are ignored
+assert.sameValue(`${ Temporal.ZonedDateTime.from({
+ year: 1976,
+ month: 11,
+ day: 18,
+ timeZone: lagos,
+ hours: 12
+}) }`, "1976-11-18T00:00:00+01:00[Africa/Lagos]");
+
+// casts offset property
+var zdt = Temporal.ZonedDateTime.from({
+ year: 1976,
+ month: 11,
+ day: 18,
+ offset: -1030,
+ timeZone: Temporal.TimeZone.from("-10:30")
+});
+assert.sameValue(`${ zdt }`, "1976-11-18T00:00:00-10:30[-10:30]");
+
+// overflow options
+var bad = {
+ year: 2019,
+ month: 1,
+ day: 32,
+ timeZone: lagos
+};
+assert.throws(RangeError, () => Temporal.ZonedDateTime.from(bad, { overflow: "reject" }));
+assert.sameValue(`${ Temporal.ZonedDateTime.from(bad) }`, "2019-01-31T00:00:00+01:00[Africa/Lagos]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(bad, { overflow: "constrain" }) }`, "2019-01-31T00:00:00+01:00[Africa/Lagos]");
+
+// Offset options
+
+// { offset: 'reject' } throws if offset does not match offset time zone
+var obj = {
+ year: 2020,
+ month: 3,
+ day: 8,
+ hour: 1,
+ offset: "-04:00",
+ timeZone: "-08:00"
+};
+assert.throws(RangeError, () => Temporal.ZonedDateTime.from(obj));
+assert.throws(RangeError, () => Temporal.ZonedDateTime.from(obj, { offset: "reject" }));
+
+// { offset: 'reject' } throws if offset does not match IANA time zone
+var obj = {
+ year: 2020,
+ month: 3,
+ day: 8,
+ hour: 1,
+ offset: "-04:00",
+ timeZone: "America/Chicago"
+};
+assert.throws(RangeError, () => Temporal.ZonedDateTime.from(obj));
+assert.throws(RangeError, () => Temporal.ZonedDateTime.from(obj, { offset: "reject" }));
+
+var cali = Temporal.TimeZone.from("America/Los_Angeles");
+var date = {
+year: 2020,
+month: 11,
+day: 1,
+timeZone: cali
+};
+// { offset: 'prefer' } if offset matches time zone (first 1:30 when DST ends)
+var obj = {
+ ...date,
+ hour: 1,
+ minute: 30,
+ offset: "-07:00"
+};
+assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { offset: "prefer" }) }`, "2020-11-01T01:30:00-07:00[America/Los_Angeles]");
+
+// { offset: 'prefer' } if offset matches time zone (second 1:30 when DST ends)
+var obj = {
+ ...date,
+ hour: 1,
+ minute: 30,
+ offset: "-08:00"
+};
+assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { offset: "prefer" }) }`, "2020-11-01T01:30:00-08:00[America/Los_Angeles]");
+
+// { offset: 'prefer' } if offset does not match time zone"
+var obj = {
+ ...date,
+ hour: 4,
+ offset: "-07:00"
+};
+assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { offset: "prefer" }) }`, "2020-11-01T04:00:00-08:00[America/Los_Angeles]");
+
+// { offset: 'ignore' } uses time zone only
+var obj = {
+ ...date,
+ hour: 4,
+ offset: "-12:00"
+};
+assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { offset: "ignore" }) }`, "2020-11-01T04:00:00-08:00[America/Los_Angeles]");
+
+// { offset: 'use' } uses offset only
+var obj = {
+ ...date,
+ hour: 4,
+ offset: "-07:00"
+};
+assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { offset: "use" }) }`, "2020-11-01T03:00:00-08:00[America/Los_Angeles]");
+
+// Disambiguation options
+
+// plain datetime with multiple instants - Fall DST in Brazil
+var brazil = Temporal.TimeZone.from("America/Sao_Paulo");
+var obj = {
+ year: 2019,
+ month: 2,
+ day: 16,
+ hour: 23,
+ minute: 45,
+ timeZone: brazil
+};
+assert.sameValue(`${ Temporal.ZonedDateTime.from(obj) }`, "2019-02-16T23:45:00-02:00[America/Sao_Paulo]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { disambiguation: "compatible" }) }`, "2019-02-16T23:45:00-02:00[America/Sao_Paulo]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { disambiguation: "earlier" }) }`, "2019-02-16T23:45:00-02:00[America/Sao_Paulo]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { disambiguation: "later" }) }`, "2019-02-16T23:45:00-03:00[America/Sao_Paulo]");
+assert.throws(RangeError, () => Temporal.ZonedDateTime.from(obj, { disambiguation: "reject" }));
+
+// plain datetime with multiple instants - Spring DST in Los Angeles
+var cali = Temporal.TimeZone.from("America/Los_Angeles");
+var obj = {
+ year: 2020,
+ month: 3,
+ day: 8,
+ hour: 2,
+ minute: 30,
+ timeZone: cali
+};
+assert.sameValue(`${ Temporal.ZonedDateTime.from(obj) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { disambiguation: "compatible" }) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { disambiguation: "earlier" }) }`, "2020-03-08T01:30:00-08:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { disambiguation: "later" }) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]");
+assert.throws(RangeError, () => Temporal.ZonedDateTime.from(obj, { disambiguation: "reject" }));
+
+// uses disambiguation if offset is ignored
+var cali = Temporal.TimeZone.from("America/Los_Angeles");
+var obj = {
+ year: 2020,
+ month: 3,
+ day: 8,
+ hour: 2,
+ minute: 30,
+ timeZone: cali
+};
+var offset = "ignore";
+assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { offset }) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, {
+ offset,
+ disambiguation: "compatible"
+}) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, {
+ offset,
+ disambiguation: "earlier"
+}) }`, "2020-03-08T01:30:00-08:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, {
+ offset,
+ disambiguation: "later"
+}) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]");
+assert.throws(RangeError, () => Temporal.ZonedDateTime.from(obj, { disambiguation: "reject" }));
+
+// uses disambiguation if offset is wrong and option is prefer
+var cali = Temporal.TimeZone.from("America/Los_Angeles");
+var obj = {
+ year: 2020,
+ month: 3,
+ day: 8,
+ hour: 2,
+ minute: 30,
+ offset: "-23:59",
+ timeZone: cali
+};
+var offset = "prefer";
+assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, { offset }) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, {
+ offset,
+ disambiguation: "compatible"
+}) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, {
+ offset,
+ disambiguation: "earlier"
+}) }`, "2020-03-08T01:30:00-08:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(obj, {
+ offset,
+ disambiguation: "later"
+}) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]");
+assert.throws(RangeError, () => Temporal.ZonedDateTime.from(obj, {
+ offset,
+ disambiguation: "reject"
+}));
+
+// throw when bad disambiguation
+[
+ "",
+ "EARLIER",
+ "balance",
+ 3,
+ null
+].forEach(disambiguation => {
+ assert.throws(RangeError, () => Temporal.ZonedDateTime.from("2020-11-01T04:00[America/Los_Angeles]", { disambiguation }));
+});
+
+// sub-minute time zone offsets
+
+// does not truncate offset property to minutes
+var zdt = Temporal.ZonedDateTime.from({
+ year: 1971,
+ month: 1,
+ day: 1,
+ hour: 12,
+ timeZone: "Africa/Monrovia"
+});
+assert.sameValue(zdt.offset, "-00:44:30");
diff --git a/test/staging/Temporal/ZonedDateTime/old/reversibility-of-differences.js b/test/staging/Temporal/ZonedDateTime/old/reversibility-of-differences.js
new file mode 100644
index 0000000000..eda153a4da
--- /dev/null
+++ b/test/staging/Temporal/ZonedDateTime/old/reversibility-of-differences.js
@@ -0,0 +1,37 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: Reversibility of differences
+features: [Temporal]
+---*/
+
+var earlier = Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456789-03:00[America/Santiago]");
+var later = Temporal.ZonedDateTime.from("2019-10-29T10:46:38.271986102-03:00[America/Santiago]");
+[
+ "hours",
+ "minutes",
+ "seconds"
+].forEach(largestUnit => {
+ var diff = later.since(earlier, { largestUnit });
+assert.sameValue(`${ earlier.since(later, { largestUnit }) }`, `${ diff.negated() }`);
+assert.sameValue(`${ earlier.until(later, { largestUnit }) }`, `${ diff }`);
+// difference symmetrical with regard to negative durations
+ assert(earlier.subtract(diff.negated()).equals(later));
+ assert(later.add(diff.negated()).equals(earlier));
+ });
+[
+ "years",
+ "months",
+ "weeks",
+ "days",
+ "hours",
+ "minutes",
+ "seconds"
+].forEach(largestUnit => {
+ var diff1 = earlier.until(later, { largestUnit });
+ var diff2 = later.since(earlier, { largestUnit });
+ assert(earlier.add(diff1).equals(later));
+ assert(later.subtract(diff2).equals(earlier));
+});
diff --git a/test/staging/Temporal/ZonedDateTime/old/round.js b/test/staging/Temporal/ZonedDateTime/old/round.js
new file mode 100644
index 0000000000..42df0c57c4
--- /dev/null
+++ b/test/staging/Temporal/ZonedDateTime/old/round.js
@@ -0,0 +1,348 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: Temporal.ZonedDateTime.prototype.round()
+features: [Temporal]
+---*/
+
+var zdt = Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456789+01:00[Europe/Vienna]");
+
+// throws without parameter
+assert.throws(TypeError, () => zdt.round());
+
+// throws without required smallestUnit parameter
+assert.throws(RangeError, () => zdt.round({}));
+assert.throws(RangeError, () => zdt.round({
+ roundingIncrement: 1,
+ roundingMode: "ceil"
+}));
+
+// throws on disallowed or invalid smallestUnit (string param)
+[
+ "era",
+ "year",
+ "month",
+ "week",
+ "years",
+ "months",
+ "weeks",
+ "nonsense"
+].forEach(smallestUnit => {
+ assert.throws(RangeError, () => zdt.round(smallestUnit));
+});
+var incrementOneNearest = [
+ [
+ "day",
+ "1976-11-19T00:00:00+01:00[Europe/Vienna]"
+ ],
+ [
+ "hour",
+ "1976-11-18T15:00:00+01:00[Europe/Vienna]"
+ ],
+ [
+ "minute",
+ "1976-11-18T15:24:00+01:00[Europe/Vienna]"
+ ],
+ [
+ "second",
+ "1976-11-18T15:23:30+01:00[Europe/Vienna]"
+ ],
+ [
+ "millisecond",
+ "1976-11-18T15:23:30.123+01:00[Europe/Vienna]"
+ ],
+ [
+ "microsecond",
+ "1976-11-18T15:23:30.123457+01:00[Europe/Vienna]"
+ ],
+ [
+ "nanosecond",
+ "1976-11-18T15:23:30.123456789+01:00[Europe/Vienna]"
+ ]
+];
+incrementOneNearest.forEach(([smallestUnit, expected]) => {
+ assert.sameValue(`${ zdt.round({
+ smallestUnit,
+ roundingMode: "halfExpand"
+ }) }`, expected);
+});
+var incrementOneCeil = [
+ [
+ "day",
+ "1976-11-19T00:00:00+01:00[Europe/Vienna]"
+ ],
+ [
+ "hour",
+ "1976-11-18T16:00:00+01:00[Europe/Vienna]"
+ ],
+ [
+ "minute",
+ "1976-11-18T15:24:00+01:00[Europe/Vienna]"
+ ],
+ [
+ "second",
+ "1976-11-18T15:23:31+01:00[Europe/Vienna]"
+ ],
+ [
+ "millisecond",
+ "1976-11-18T15:23:30.124+01:00[Europe/Vienna]"
+ ],
+ [
+ "microsecond",
+ "1976-11-18T15:23:30.123457+01:00[Europe/Vienna]"
+ ],
+ [
+ "nanosecond",
+ "1976-11-18T15:23:30.123456789+01:00[Europe/Vienna]"
+ ]
+];
+incrementOneCeil.forEach(([smallestUnit, expected]) => {
+ assert.sameValue(`${ zdt.round({
+ smallestUnit,
+ roundingMode: "ceil"
+ }) }`, expected);
+});
+var incrementOneFloor = [
+ [
+ "day",
+ "1976-11-18T00:00:00+01:00[Europe/Vienna]"
+ ],
+ [
+ "hour",
+ "1976-11-18T15:00:00+01:00[Europe/Vienna]"
+ ],
+ [
+ "minute",
+ "1976-11-18T15:23:00+01:00[Europe/Vienna]"
+ ],
+ [
+ "second",
+ "1976-11-18T15:23:30+01:00[Europe/Vienna]"
+ ],
+ [
+ "millisecond",
+ "1976-11-18T15:23:30.123+01:00[Europe/Vienna]"
+ ],
+ [
+ "microsecond",
+ "1976-11-18T15:23:30.123456+01:00[Europe/Vienna]"
+ ],
+ [
+ "nanosecond",
+ "1976-11-18T15:23:30.123456789+01:00[Europe/Vienna]"
+ ]
+];
+incrementOneFloor.forEach(([smallestUnit, expected]) => {
+ assert.sameValue(`${ zdt.round({
+ smallestUnit,
+ roundingMode: "floor"
+ }) }`, expected);
+ assert.sameValue(`${ zdt.round({
+ smallestUnit,
+ roundingMode: "trunc"
+ }) }`, expected);
+});
+
+// rounds to an increment of hours
+assert.sameValue(`${ zdt.round({
+ smallestUnit: "hour",
+ roundingIncrement: 4
+}) }`, "1976-11-18T16:00:00+01:00[Europe/Vienna]");
+
+// rounds to an increment of minutes
+assert.sameValue(`${ zdt.round({
+ smallestUnit: "minute",
+ roundingIncrement: 15
+}) }`, "1976-11-18T15:30:00+01:00[Europe/Vienna]");
+
+// rounds to an increment of seconds
+assert.sameValue(`${ zdt.round({
+ smallestUnit: "second",
+ roundingIncrement: 30
+}) }`, "1976-11-18T15:23:30+01:00[Europe/Vienna]");
+
+// rounds to an increment of milliseconds
+assert.sameValue(`${ zdt.round({
+ smallestUnit: "millisecond",
+ roundingIncrement: 10
+}) }`, "1976-11-18T15:23:30.12+01:00[Europe/Vienna]");
+
+// rounds to an increment of microseconds
+assert.sameValue(`${ zdt.round({
+ smallestUnit: "microsecond",
+ roundingIncrement: 10
+}) }`, "1976-11-18T15:23:30.12346+01:00[Europe/Vienna]");
+
+// rounds to an increment of nanoseconds
+assert.sameValue(`${ zdt.round({
+ smallestUnit: "nanosecond",
+ roundingIncrement: 10
+}) }`, "1976-11-18T15:23:30.12345679+01:00[Europe/Vienna]");
+
+// 1 day is a valid increment
+assert.sameValue(`${ zdt.round({
+ smallestUnit: "day",
+ roundingIncrement: 1
+}) }`, "1976-11-19T00:00:00+01:00[Europe/Vienna]");
+
+// valid hour increments divide into 24
+var smallestUnit = "hour";
+[
+ 1,
+ 2,
+ 3,
+ 4,
+ 6,
+ 8,
+ 12
+].forEach(roundingIncrement => {
+ assert(zdt.round({
+ smallestUnit,
+ roundingIncrement
+ }) instanceof Temporal.ZonedDateTime);
+});
+[
+ "minute",
+ "second"
+].forEach(smallestUnit => {
+ // valid minutes/seconds increments divide into 60`, () => {
+ [
+ 1,
+ 2,
+ 3,
+ 4,
+ 5,
+ 6,
+ 10,
+ 12,
+ 15,
+ 20,
+ 30
+ ].forEach(roundingIncrement => {
+ assert(zdt.round({
+ smallestUnit,
+ roundingIncrement
+ }) instanceof Temporal.ZonedDateTime);
+ });
+ });
+[
+ "millisecond",
+ "microsecond",
+ "nanosecond"
+].forEach(smallestUnit => {
+ // valid increments divide into 1000`
+ [
+ 1,
+ 2,
+ 4,
+ 5,
+ 8,
+ 10,
+ 20,
+ 25,
+ 40,
+ 50,
+ 100,
+ 125,
+ 200,
+ 250,
+ 500
+ ].forEach(roundingIncrement => {
+ assert(zdt.round({
+ smallestUnit,
+ roundingIncrement
+ }) instanceof Temporal.ZonedDateTime);
+ });
+ });
+
+// throws on increments that do not divide evenly into the next highest
+assert.throws(RangeError, () => zdt.round({
+ smallestUnit: "day",
+ roundingIncrement: 29
+}));
+assert.throws(RangeError, () => zdt.round({
+ smallestUnit: "hour",
+ roundingIncrement: 29
+}));
+assert.throws(RangeError, () => zdt.round({
+ smallestUnit: "minute",
+ roundingIncrement: 29
+}));
+assert.throws(RangeError, () => zdt.round({
+ smallestUnit: "second",
+ roundingIncrement: 29
+}));
+assert.throws(RangeError, () => zdt.round({
+ smallestUnit: "millisecond",
+ roundingIncrement: 29
+}));
+assert.throws(RangeError, () => zdt.round({
+ smallestUnit: "microsecond",
+ roundingIncrement: 29
+}));
+assert.throws(RangeError, () => zdt.round({
+ smallestUnit: "nanosecond",
+ roundingIncrement: 29
+}));
+
+// throws on increments that are equal to the next highest
+assert.throws(RangeError, () => zdt.round({
+ smallestUnit: "hour",
+ roundingIncrement: 24
+}));
+assert.throws(RangeError, () => zdt.round({
+ smallestUnit: "minute",
+ roundingIncrement: 60
+}));
+assert.throws(RangeError, () => zdt.round({
+ smallestUnit: "second",
+ roundingIncrement: 60
+}));
+assert.throws(RangeError, () => zdt.round({
+ smallestUnit: "millisecond",
+ roundingIncrement: 1000
+}));
+assert.throws(RangeError, () => zdt.round({
+ smallestUnit: "microsecond",
+ roundingIncrement: 1000
+}));
+assert.throws(RangeError, () => zdt.round({
+ smallestUnit: "nanosecond",
+ roundingIncrement: 1000
+}));
+var bal = Temporal.ZonedDateTime.from("1976-11-18T23:59:59.999999999+01:00[Europe/Vienna]");
+[
+ "day",
+ "hour",
+ "minute",
+ "second",
+ "millisecond",
+ "microsecond"
+].forEach(smallestUnit => {
+ assert.sameValue(`${ bal.round({ smallestUnit }) }`, "1976-11-19T00:00:00+01:00[Europe/Vienna]");
+});
+
+// rounds correctly to a 25-hour day
+var roundTo = { smallestUnit: "day" };
+var roundMeDown = Temporal.ZonedDateTime.from("2020-11-01T12:29:59-08:00[America/Vancouver]");
+assert.sameValue(`${ roundMeDown.round(roundTo) }`, "2020-11-01T00:00:00-07:00[America/Vancouver]");
+var roundMeUp = Temporal.ZonedDateTime.from("2020-11-01T12:30:01-08:00[America/Vancouver]");
+assert.sameValue(`${ roundMeUp.round(roundTo) }`, "2020-11-02T00:00:00-08:00[America/Vancouver]");
+
+// rounds correctly to a 23-hour day
+var roundTo = { smallestUnit: "day" };
+var roundMeDown = Temporal.ZonedDateTime.from("2020-03-08T11:29:59-07:00[America/Vancouver]");
+assert.sameValue(`${ roundMeDown.round(roundTo) }`, "2020-03-08T00:00:00-08:00[America/Vancouver]");
+var roundMeUp = Temporal.ZonedDateTime.from("2020-03-08T11:30:01-07:00[America/Vancouver]");
+assert.sameValue(`${ roundMeUp.round(roundTo) }`, "2020-03-09T00:00:00-07:00[America/Vancouver]");
+
+// rounding up to a nonexistent wall-clock time
+var almostSkipped = Temporal.ZonedDateTime.from("2018-11-03T23:59:59.999999999-03:00[America/Sao_Paulo]");
+var rounded = almostSkipped.round({
+ smallestUnit: "microsecond",
+ roundingMode: "halfExpand"
+});
+assert.sameValue(`${ rounded }`, "2018-11-04T01:00:00-02:00[America/Sao_Paulo]");
+assert.sameValue(rounded.epochNanoseconds - almostSkipped.epochNanoseconds, 1n);
diff --git a/test/staging/Temporal/ZonedDateTime/old/since.js b/test/staging/Temporal/ZonedDateTime/old/since.js
new file mode 100644
index 0000000000..59b4dc4886
--- /dev/null
+++ b/test/staging/Temporal/ZonedDateTime/old/since.js
@@ -0,0 +1,516 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: Temporal.ZonedDateTime.prototype.since()
+features: [Temporal]
+---*/
+
+var zdt = Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456789+01:00[Europe/Vienna]");
+
+// zdt.since(earlier) === earlier.until(zdt) with default options
+var earlier = Temporal.ZonedDateTime.from({
+ year: 1966,
+ month: 3,
+ day: 3,
+ hour: 18,
+ timeZone: "Europe/Vienna"
+});
+assert.sameValue(`${ zdt.since(earlier) }`, `${ earlier.until(zdt) }`);
+
+// casts argument
+assert.sameValue(`${ zdt.since({
+ year: 2019,
+ month: 10,
+ day: 29,
+ hour: 10,
+ timeZone: "Europe/Vienna"
+}) }`, "-PT376434H36M29.876543211S");
+assert.sameValue(`${ zdt.since("2019-10-29T10:46:38.271986102+01:00[Europe/Vienna]") }`, "-PT376435H23M8.148529313S");
+var feb20 = Temporal.ZonedDateTime.from("2020-02-01T00:00+01:00[Europe/Vienna]");
+var feb21 = Temporal.ZonedDateTime.from("2021-02-01T00:00+01:00[Europe/Vienna]");
+
+// defaults to returning hours
+assert.sameValue(`${ feb21.since(feb20) }`, "PT8784H");
+assert.sameValue(`${ feb21.since(feb20, { largestUnit: "auto" }) }`, "PT8784H");
+assert.sameValue(`${ feb21.since(feb20, { largestUnit: "hours" }) }`, "PT8784H");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("2021-02-01T00:00:00.000000001+01:00[Europe/Vienna]").since(feb20) }`, "PT8784H0.000000001S");
+assert.sameValue(`${ feb21.since(Temporal.ZonedDateTime.from("2020-02-01T00:00:00.000000001+01:00[Europe/Vienna]")) }`, "PT8783H59M59.999999999S");
+
+// can return lower or higher units
+assert.sameValue(`${ feb21.since(feb20, { largestUnit: "years" }) }`, "P1Y");
+assert.sameValue(`${ feb21.since(feb20, { largestUnit: "months" }) }`, "P12M");
+assert.sameValue(`${ feb21.since(feb20, { largestUnit: "weeks" }) }`, "P52W2D");
+assert.sameValue(`${ feb21.since(feb20, { largestUnit: "days" }) }`, "P366D");
+assert.sameValue(`${ feb21.since(feb20, { largestUnit: "minutes" }) }`, "PT527040M");
+assert.sameValue(`${ feb21.since(feb20, { largestUnit: "seconds" }) }`, "PT31622400S");
+
+// can return subseconds
+var later = feb20.add({
+ days: 1,
+ milliseconds: 250,
+ microseconds: 250,
+ nanoseconds: 250
+});
+var msDiff = later.since(feb20, { largestUnit: "milliseconds" });
+assert.sameValue(msDiff.seconds, 0);
+assert.sameValue(msDiff.milliseconds, 86400250);
+assert.sameValue(msDiff.microseconds, 250);
+assert.sameValue(msDiff.nanoseconds, 250);
+var µsDiff = later.since(feb20, { largestUnit: "microseconds" });
+assert.sameValue(µsDiff.milliseconds, 0);
+assert.sameValue(µsDiff.microseconds, 86400250250);
+assert.sameValue(µsDiff.nanoseconds, 250);
+var nsDiff = later.since(feb20, { largestUnit: "nanoseconds" });
+assert.sameValue(nsDiff.microseconds, 0);
+assert.sameValue(nsDiff.nanoseconds, 86400250250250);
+
+// does not include higher units than necessary
+var lastFeb20 = Temporal.ZonedDateTime.from("2020-02-29T00:00+01:00[Europe/Vienna]");
+var lastFeb21 = Temporal.ZonedDateTime.from("2021-02-28T00:00+01:00[Europe/Vienna]");
+assert.sameValue(`${ lastFeb21.since(lastFeb20) }`, "PT8760H");
+assert.sameValue(`${ lastFeb21.since(lastFeb20, { largestUnit: "months" }) }`, "P11M28D");
+assert.sameValue(`${ lastFeb21.since(lastFeb20, { largestUnit: "years" }) }`, "P11M28D");
+
+// weeks and months are mutually exclusive
+var laterDateTime = zdt.add({
+ days: 42,
+ hours: 3
+});
+var weeksDifference = laterDateTime.since(zdt, { largestUnit: "weeks" });
+assert.notSameValue(weeksDifference.weeks, 0);
+assert.sameValue(weeksDifference.months, 0);
+var monthsDifference = laterDateTime.since(zdt, { largestUnit: "months" });
+assert.sameValue(monthsDifference.weeks, 0);
+assert.notSameValue(monthsDifference.months, 0);
+
+// no two different calendars
+var zdt1 = new Temporal.ZonedDateTime(0n, "UTC");
+var zdt2 = new Temporal.ZonedDateTime(0n, "UTC", Temporal.Calendar.from("japanese"));
+assert.throws(RangeError, () => zdt1.since(zdt2));
+
+var earlier = Temporal.ZonedDateTime.from('2019-01-08T09:22:36.123456789+01:00[Europe/Vienna]');
+var later = Temporal.ZonedDateTime.from('2021-09-07T14:39:40.987654321+02:00[Europe/Vienna]');
+// assumes a different default for largestUnit if smallestUnit is larger than days
+assert.sameValue(`${ later.since(earlier, {
+ smallestUnit: "years",
+ roundingMode: "halfExpand"
+}) }`, "P3Y");
+assert.sameValue(`${ later.since(earlier, {
+ smallestUnit: "months",
+ roundingMode: "halfExpand"
+}) }`, "P32M");
+assert.sameValue(`${ later.since(earlier, {
+ smallestUnit: "weeks",
+ roundingMode: "halfExpand"
+}) }`, "P139W");
+var incrementOneNearest = [
+ [
+ "years",
+ "P3Y"
+ ],
+ [
+ "months",
+ "P32M"
+ ],
+ [
+ "weeks",
+ "P139W"
+ ],
+ [
+ "days",
+ "P973D"
+ ],
+ [
+ "hours",
+ "PT23356H"
+ ],
+ [
+ "minutes",
+ "PT23356H17M"
+ ],
+ [
+ "seconds",
+ "PT23356H17M5S"
+ ],
+ [
+ "milliseconds",
+ "PT23356H17M4.864S"
+ ],
+ [
+ "microseconds",
+ "PT23356H17M4.864198S"
+ ],
+ [
+ "nanoseconds",
+ "PT23356H17M4.864197532S"
+ ]
+];
+incrementOneNearest.forEach(([smallestUnit, expected]) => {
+ var roundingMode = "halfExpand";
+ assert.sameValue(`${ later.since(earlier, {
+ smallestUnit,
+ roundingMode
+ }) }`, expected);
+ assert.sameValue(`${ earlier.since(later, {
+ smallestUnit,
+ roundingMode
+ }) }`, `-${ expected }`);
+});
+var incrementOneCeil = [
+ [
+ "years",
+ "P3Y",
+ "-P2Y"
+ ],
+ [
+ "months",
+ "P32M",
+ "-P31M"
+ ],
+ [
+ "weeks",
+ "P140W",
+ "-P139W"
+ ],
+ [
+ "days",
+ "P974D",
+ "-P973D"
+ ],
+ [
+ "hours",
+ "PT23357H",
+ "-PT23356H"
+ ],
+ [
+ "minutes",
+ "PT23356H18M",
+ "-PT23356H17M"
+ ],
+ [
+ "seconds",
+ "PT23356H17M5S",
+ "-PT23356H17M4S"
+ ],
+ [
+ "milliseconds",
+ "PT23356H17M4.865S",
+ "-PT23356H17M4.864S"
+ ],
+ [
+ "microseconds",
+ "PT23356H17M4.864198S",
+ "-PT23356H17M4.864197S"
+ ],
+ [
+ "nanoseconds",
+ "PT23356H17M4.864197532S",
+ "-PT23356H17M4.864197532S"
+ ]
+];
+incrementOneCeil.forEach(([smallestUnit, expectedPositive, expectedNegative]) => {
+ var roundingMode = "ceil";
+ assert.sameValue(`${ later.since(earlier, {
+ smallestUnit,
+ roundingMode
+ }) }`, expectedPositive);
+ assert.sameValue(`${ earlier.since(later, {
+ smallestUnit,
+ roundingMode
+ }) }`, expectedNegative);
+});
+var incrementOneFloor = [
+ [
+ "years",
+ "P2Y",
+ "-P3Y"
+ ],
+ [
+ "months",
+ "P31M",
+ "-P32M"
+ ],
+ [
+ "weeks",
+ "P139W",
+ "-P140W"
+ ],
+ [
+ "days",
+ "P973D",
+ "-P974D"
+ ],
+ [
+ "hours",
+ "PT23356H",
+ "-PT23357H"
+ ],
+ [
+ "minutes",
+ "PT23356H17M",
+ "-PT23356H18M"
+ ],
+ [
+ "seconds",
+ "PT23356H17M4S",
+ "-PT23356H17M5S"
+ ],
+ [
+ "milliseconds",
+ "PT23356H17M4.864S",
+ "-PT23356H17M4.865S"
+ ],
+ [
+ "microseconds",
+ "PT23356H17M4.864197S",
+ "-PT23356H17M4.864198S"
+ ],
+ [
+ "nanoseconds",
+ "PT23356H17M4.864197532S",
+ "-PT23356H17M4.864197532S"
+ ]
+];
+incrementOneFloor.forEach(([smallestUnit, expectedPositive, expectedNegative]) => {
+ var roundingMode = "floor";
+ assert.sameValue(`${ later.since(earlier, {
+ smallestUnit,
+ roundingMode
+ }) }`, expectedPositive);
+ assert.sameValue(`${ earlier.since(later, {
+ smallestUnit,
+ roundingMode
+ }) }`, expectedNegative);
+});
+var incrementOneTrunc = [
+ [
+ "years",
+ "P2Y"
+ ],
+ [
+ "months",
+ "P31M"
+ ],
+ [
+ "weeks",
+ "P139W"
+ ],
+ [
+ "days",
+ "P973D"
+ ],
+ [
+ "hours",
+ "PT23356H"
+ ],
+ [
+ "minutes",
+ "PT23356H17M"
+ ],
+ [
+ "seconds",
+ "PT23356H17M4S"
+ ],
+ [
+ "milliseconds",
+ "PT23356H17M4.864S"
+ ],
+ [
+ "microseconds",
+ "PT23356H17M4.864197S"
+ ],
+ [
+ "nanoseconds",
+ "PT23356H17M4.864197532S"
+ ]
+];
+incrementOneTrunc.forEach(([smallestUnit, expected]) => {
+ var roundingMode = "trunc";
+ assert.sameValue(`${ later.since(earlier, {
+ smallestUnit,
+ roundingMode
+ }) }`, expected);
+ assert.sameValue(`${ earlier.since(later, {
+ smallestUnit,
+ roundingMode
+ }) }`, `-${ expected }`);
+});
+
+// rounds to an increment of hours
+assert.sameValue(`${ later.since(earlier, {
+ smallestUnit: "hours",
+ roundingIncrement: 3,
+ roundingMode: "halfExpand"
+}) }`, "PT23355H");
+
+// rounds to an increment of minutes
+assert.sameValue(`${ later.since(earlier, {
+ smallestUnit: "minutes",
+ roundingIncrement: 30,
+ roundingMode: "halfExpand"
+}) }`, "PT23356H30M");
+
+// rounds to an increment of seconds
+assert.sameValue(`${ later.since(earlier, {
+ smallestUnit: "seconds",
+ roundingIncrement: 15,
+ roundingMode: "halfExpand"
+}) }`, "PT23356H17M");
+
+// rounds to an increment of milliseconds
+assert.sameValue(`${ later.since(earlier, {
+ smallestUnit: "milliseconds",
+ roundingIncrement: 10,
+ roundingMode: "halfExpand"
+}) }`, "PT23356H17M4.86S");
+
+// rounds to an increment of microseconds
+assert.sameValue(`${ later.since(earlier, {
+ smallestUnit: "microseconds",
+ roundingIncrement: 10,
+ roundingMode: "halfExpand"
+}) }`, "PT23356H17M4.8642S");
+
+// rounds to an increment of nanoseconds
+assert.sameValue(`${ later.since(earlier, {
+ smallestUnit: "nanoseconds",
+ roundingIncrement: 10,
+ roundingMode: "halfExpand"
+}) }`, "PT23356H17M4.86419753S");
+
+// valid hour increments divide into 24
+[
+ 1,
+ 2,
+ 3,
+ 4,
+ 6,
+ 8,
+ 12
+].forEach(roundingIncrement => {
+ var options = {
+ smallestUnit: "hours",
+ roundingIncrement
+ };
+ assert(later.since(earlier, options) instanceof Temporal.Duration);
+});
+[
+ "minutes",
+ "seconds"
+].forEach(smallestUnit => {
+ [
+ 1,
+ 2,
+ 3,
+ 4,
+ 5,
+ 6,
+ 10,
+ 12,
+ 15,
+ 20,
+ 30
+ ].forEach(roundingIncrement => {
+ var options = {
+ smallestUnit,
+ roundingIncrement
+ };
+ assert(later.since(earlier, options) instanceof Temporal.Duration);
+ });
+});
+[
+ "milliseconds",
+ "microseconds",
+ "nanoseconds"
+].forEach(smallestUnit => {
+ [
+ 1,
+ 2,
+ 4,
+ 5,
+ 8,
+ 10,
+ 20,
+ 25,
+ 40,
+ 50,
+ 100,
+ 125,
+ 200,
+ 250,
+ 500
+ ].forEach(roundingIncrement => {
+ var options = {
+ smallestUnit,
+ roundingIncrement
+ };
+ assert(later.since(earlier, options) instanceof Temporal.Duration);
+ });
+});
+
+// throws on increments that do not divide evenly into the next highest
+assert.throws(RangeError, () => later.since(earlier, {
+ smallestUnit: "hours",
+ roundingIncrement: 11
+}));
+assert.throws(RangeError, () => later.since(earlier, {
+ smallestUnit: "minutes",
+ roundingIncrement: 29
+}));
+assert.throws(RangeError, () => later.since(earlier, {
+ smallestUnit: "seconds",
+ roundingIncrement: 29
+}));
+assert.throws(RangeError, () => later.since(earlier, {
+ smallestUnit: "milliseconds",
+ roundingIncrement: 29
+}));
+assert.throws(RangeError, () => later.since(earlier, {
+ smallestUnit: "microseconds",
+ roundingIncrement: 29
+}));
+assert.throws(RangeError, () => later.since(earlier, {
+ smallestUnit: "nanoseconds",
+ roundingIncrement: 29
+}));
+
+// throws on increments that are equal to the next highest
+assert.throws(RangeError, () => later.since(earlier, {
+ smallestUnit: "hours",
+ roundingIncrement: 24
+}));
+assert.throws(RangeError, () => later.since(earlier, {
+ smallestUnit: "minutes",
+ roundingIncrement: 60
+}));
+assert.throws(RangeError, () => later.since(earlier, {
+ smallestUnit: "seconds",
+ roundingIncrement: 60
+}));
+assert.throws(RangeError, () => later.since(earlier, {
+ smallestUnit: "milliseconds",
+ roundingIncrement: 1000
+}));
+assert.throws(RangeError, () => later.since(earlier, {
+ smallestUnit: "microseconds",
+ roundingIncrement: 1000
+}));
+assert.throws(RangeError, () => later.since(earlier, {
+ smallestUnit: "nanoseconds",
+ roundingIncrement: 1000
+}));
+
+// rounds relative to the receiver
+var dt1 = Temporal.ZonedDateTime.from("2019-01-01T00:00+00:00[UTC]");
+var dt2 = Temporal.ZonedDateTime.from("2020-07-02T00:00+00:00[UTC]");
+assert.sameValue(`${ dt2.since(dt1, {
+ smallestUnit: "years",
+ roundingMode: "halfExpand"
+}) }`, "P1Y");
+assert.sameValue(`${ dt1.since(dt2, {
+ smallestUnit: "years",
+ roundingMode: "halfExpand"
+}) }`, "-P2Y");
+
diff --git a/test/staging/Temporal/ZonedDateTime/old/string-parsing.js b/test/staging/Temporal/ZonedDateTime/old/string-parsing.js
new file mode 100644
index 0000000000..4b5bbcaac5
--- /dev/null
+++ b/test/staging/Temporal/ZonedDateTime/old/string-parsing.js
@@ -0,0 +1,157 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: string parsing
+features: [Temporal]
+---*/
+
+// parses with an IANA zone but no offset (with disambiguation)
+var zdt = Temporal.ZonedDateTime.from("2020-03-08T02:30[America/Los_Angeles]", { disambiguation: "earlier" });
+assert.sameValue(zdt.toString(), "2020-03-08T01:30:00-08:00[America/Los_Angeles]");
+
+// "Z" means preserve the exact time in the given IANA time zone
+var zdt = Temporal.ZonedDateTime.from("2020-03-08T09:00:00Z[America/Los_Angeles]");
+assert.sameValue(zdt.toString(), "2020-03-08T01:00:00-08:00[America/Los_Angeles]");
+
+// any number of decimal places
+assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.1-08:00[America/Los_Angeles]") }`, "1976-11-18T15:23:30.1-08:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.12-08:00[America/Los_Angeles]") }`, "1976-11-18T15:23:30.12-08:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123-08:00[America/Los_Angeles]") }`, "1976-11-18T15:23:30.123-08:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.1234-08:00[America/Los_Angeles]") }`, "1976-11-18T15:23:30.1234-08:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.12345-08:00[America/Los_Angeles]") }`, "1976-11-18T15:23:30.12345-08:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456-08:00[America/Los_Angeles]") }`, "1976-11-18T15:23:30.123456-08:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.1234567-08:00[America/Los_Angeles]") }`, "1976-11-18T15:23:30.1234567-08:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.12345678-08:00[America/Los_Angeles]") }`, "1976-11-18T15:23:30.12345678-08:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456789-08:00[America/Los_Angeles]") }`, "1976-11-18T15:23:30.123456789-08:00[America/Los_Angeles]");
+
+// variant decimal separator
+assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30,12-08:00[America/Los_Angeles]") }`, "1976-11-18T15:23:30.12-08:00[America/Los_Angeles]");
+
+// variant minus sign
+assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.12\u221208:00[America/Los_Angeles]") }`, "1976-11-18T15:23:30.12-08:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("\u2212009999-11-18T15:23:30.12+00:00[UTC]") }`, "-009999-11-18T15:23:30.12+00:00[UTC]");
+
+// mixture of basic and extended format
+[
+ "1976-11-18T152330.1-08:00[America/Los_Angeles]",
+ "19761118T15:23:30.1-08:00[America/Los_Angeles]",
+ "1976-11-18T15:23:30.1-0800[America/Los_Angeles]",
+ "1976-11-18T152330.1-0800[America/Los_Angeles]",
+ "19761118T15:23:30.1-0800[America/Los_Angeles]",
+ "19761118T152330.1-08:00[America/Los_Angeles]",
+ "19761118T152330.1-0800[America/Los_Angeles]",
+ "+001976-11-18T152330.1-08:00[America/Los_Angeles]",
+ "+0019761118T15:23:30.1-08:00[America/Los_Angeles]",
+ "+001976-11-18T15:23:30.1-0800[America/Los_Angeles]",
+ "+001976-11-18T152330.1-0800[America/Los_Angeles]",
+ "+0019761118T15:23:30.1-0800[America/Los_Angeles]",
+ "+0019761118T152330.1-08:00[America/Los_Angeles]",
+ "+0019761118T152330.1-0800[America/Los_Angeles]"
+].forEach(input => assert.sameValue(`${ Temporal.ZonedDateTime.from(input) }`, "1976-11-18T15:23:30.1-08:00[America/Los_Angeles]"));
+
+// optional parts
+assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30-08[America/Los_Angeles]") }`, "1976-11-18T15:23:30-08:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15-08:00[America/Los_Angeles]") }`, "1976-11-18T15:00:00-08:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("2020-01-01[Asia/Tokyo]") }`, "2020-01-01T00:00:00+09:00[Asia/Tokyo]");
+
+// no junk at end of string
+assert.throws(RangeError, () => Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456789-08:00[America/Los_Angeles]junk"))
+
+// constrain has no effect on invalid ISO string
+assert.throws(RangeError, () => Temporal.ZonedDateTime.from("2020-13-34T24:60[America/Los_Angeles]", { overflow: "constrain" }));
+// Offset options
+
+// { offset: 'reject' } throws if offset does not match IANA time zone
+assert.throws(RangeError, () => Temporal.ZonedDateTime.from("2020-03-08T01:00-04:00[America/Chicago]"));
+assert.throws(RangeError, () => Temporal.ZonedDateTime.from("2020-03-08T01:00-04:00[America/Chicago]", { offset: "reject" }));
+
+// { offset: 'prefer' } if offset matches time zone (first 1:30 when DST ends)
+var zdt = Temporal.ZonedDateTime.from("2020-11-01T01:30-07:00[America/Los_Angeles]", { offset: "prefer" });
+assert.sameValue(zdt.toString(), "2020-11-01T01:30:00-07:00[America/Los_Angeles]");
+
+// { offset: 'prefer' } if offset matches time zone (second 1:30 when DST ends)
+var zdt = Temporal.ZonedDateTime.from("2020-11-01T01:30-08:00[America/Los_Angeles]", { offset: "prefer" });
+assert.sameValue(zdt.toString(), "2020-11-01T01:30:00-08:00[America/Los_Angeles]");
+
+// { offset: 'prefer' } if offset does not match time zone
+var zdt = Temporal.ZonedDateTime.from("2020-11-01T04:00-07:00[America/Los_Angeles]", { offset: "prefer" });
+assert.sameValue(zdt.toString(), "2020-11-01T04:00:00-08:00[America/Los_Angeles]");
+
+// { offset: 'ignore' } uses time zone only
+var zdt = Temporal.ZonedDateTime.from("2020-11-01T04:00-12:00[America/Los_Angeles]", { offset: "ignore" });
+assert.sameValue(zdt.toString(), "2020-11-01T04:00:00-08:00[America/Los_Angeles]");
+
+// { offset: 'use' } uses offset only
+var zdt = Temporal.ZonedDateTime.from("2020-11-01T04:00-07:00[America/Los_Angeles]", { offset: "use" });
+assert.sameValue(zdt.toString(), "2020-11-01T03:00:00-08:00[America/Los_Angeles]");
+
+// Disambiguation options
+
+// plain datetime with multiple instants - Fall DST in Brazil
+var str = "2019-02-16T23:45[America/Sao_Paulo]";
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str) }`, "2019-02-16T23:45:00-02:00[America/Sao_Paulo]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { disambiguation: "compatible" }) }`, "2019-02-16T23:45:00-02:00[America/Sao_Paulo]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { disambiguation: "earlier" }) }`, "2019-02-16T23:45:00-02:00[America/Sao_Paulo]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { disambiguation: "later" }) }`, "2019-02-16T23:45:00-03:00[America/Sao_Paulo]");
+assert.throws(RangeError, () => Temporal.ZonedDateTime.from(str, { disambiguation: "reject" }));
+
+// plain datetime with multiple instants - Spring DST in Los Angeles
+var str = "2020-03-08T02:30[America/Los_Angeles]";
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { disambiguation: "compatible" }) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { disambiguation: "earlier" }) }`, "2020-03-08T01:30:00-08:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { disambiguation: "later" }) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]");
+assert.throws(RangeError, () => Temporal.ZonedDateTime.from(str, { disambiguation: "reject" }));
+
+// uses disambiguation if offset is ignored
+var str = "2020-03-08T02:30[America/Los_Angeles]";
+var offset = "ignore";
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { offset }) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str, {
+ offset,
+ disambiguation: "compatible"
+}) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str, {
+ offset,
+ disambiguation: "earlier"
+}) }`, "2020-03-08T01:30:00-08:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str, {
+ offset,
+ disambiguation: "later"
+}) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]");
+assert.throws(RangeError, () => Temporal.ZonedDateTime.from(str, {
+ offset,
+ disambiguation: "reject"
+}));
+
+// uses disambiguation if offset is wrong and option is prefer
+var str = "2020-03-08T02:30-23:59[America/Los_Angeles]";
+var offset = "prefer";
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str, { offset }) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str, {
+ offset,
+ disambiguation: "compatible"
+}) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str, {
+ offset,
+ disambiguation: "earlier"
+}) }`, "2020-03-08T01:30:00-08:00[America/Los_Angeles]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(str, {
+ offset,
+ disambiguation: "later"
+}) }`, "2020-03-08T03:30:00-07:00[America/Los_Angeles]");
+assert.throws(RangeError, () => Temporal.ZonedDateTime.from(str, {
+ offset,
+ disambiguation: "reject"
+}));
+
+// throw when bad disambiguation
+[
+ "",
+ "EARLIER",
+ "balance"
+].forEach(disambiguation => {
+ assert.throws(RangeError, () => Temporal.ZonedDateTime.from("2020-11-01T04:00[America/Los_Angeles]", { disambiguation }));
+});
diff --git a/test/staging/Temporal/ZonedDateTime/old/subtract.js b/test/staging/Temporal/ZonedDateTime/old/subtract.js
new file mode 100644
index 0000000000..0737765ecb
--- /dev/null
+++ b/test/staging/Temporal/ZonedDateTime/old/subtract.js
@@ -0,0 +1,29 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: Temporal.ZonedDateTime.prototype.subtract()
+features: [Temporal]
+---*/
+
+var zdt = Temporal.ZonedDateTime.from("1969-12-25T12:23:45.678901234+00:00[UTC]");
+
+// inst.subtract(durationObj)
+var earlier = zdt.subtract(Temporal.Duration.from("PT240H0.000000800S"));
+assert.sameValue(`${ earlier }`, "1969-12-15T12:23:45.678900434+00:00[UTC]");
+
+// casts argument
+assert.sameValue(`${ zdt.subtract("PT240H0.000000800S") }`, "1969-12-15T12:23:45.678900434+00:00[UTC]");
+var mar31 = Temporal.ZonedDateTime.from("2020-03-31T15:00-07:00[America/Vancouver]");
+
+// constrain when ambiguous result
+assert.sameValue(`${ mar31.subtract({ months: 1 }) }`, "2020-02-29T15:00:00-08:00[America/Vancouver]");
+assert.sameValue(`${ mar31.subtract({ months: 1 }, { overflow: "constrain" }) }`, "2020-02-29T15:00:00-08:00[America/Vancouver]");
+
+// symmetrical with regard to negative durations in the time part
+assert.sameValue(`${ mar31.subtract({ minutes: -30 }) }`, "2020-03-31T15:30:00-07:00[America/Vancouver]");
+assert.sameValue(`${ mar31.subtract({ seconds: -30 }) }`, "2020-03-31T15:00:30-07:00[America/Vancouver]");
+
+// throw when ambiguous result with reject
+assert.throws(RangeError, () => mar31.subtract({ months: 1 }, { overflow: "reject" }));
diff --git a/test/staging/Temporal/ZonedDateTime/old/toInstant.js b/test/staging/Temporal/ZonedDateTime/old/toInstant.js
new file mode 100644
index 0000000000..c97b4ef1f3
--- /dev/null
+++ b/test/staging/Temporal/ZonedDateTime/old/toInstant.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: Temporal.ZonedDateTime.prototype.toInstant()
+features: [Temporal]
+---*/
+
+
+// recent date
+var zdt = Temporal.ZonedDateTime.from("2019-10-29T10:46:38.271986102+01:00[Europe/Amsterdam]");
+assert.sameValue(`${ zdt.toInstant() }`, "2019-10-29T09:46:38.271986102Z");
+
+// year ≤ 99
+var zdt = Temporal.ZonedDateTime.from("0098-10-29T10:46:38.271986102+00:00[UTC]");
+assert.sameValue(`${ zdt.toInstant() }`, "0098-10-29T10:46:38.271986102Z");
+zdt = Temporal.ZonedDateTime.from("+000098-10-29T10:46:38.271986102+00:00[UTC]");
+assert.sameValue(`${ zdt.toInstant() }`, "0098-10-29T10:46:38.271986102Z");
+
+// year < 1
+var zdt = Temporal.ZonedDateTime.from("0000-10-29T10:46:38.271986102+00:00[UTC]");
+assert.sameValue(`${ zdt.toInstant() }`, "0000-10-29T10:46:38.271986102Z");
+zdt = Temporal.ZonedDateTime.from("+000000-10-29T10:46:38.271986102+00:00[UTC]");
+assert.sameValue(`${ zdt.toInstant() }`, "0000-10-29T10:46:38.271986102Z");
+zdt = Temporal.ZonedDateTime.from("-001000-10-29T10:46:38.271986102+00:00[UTC]");
+assert.sameValue(`${ zdt.toInstant() }`, "-001000-10-29T10:46:38.271986102Z");
+
+// year 0 leap day
+var zdt = Temporal.ZonedDateTime.from("0000-02-29T00:00-00:01:15[Europe/London]");
+assert.sameValue(`${ zdt.toInstant() }`, "0000-02-29T00:01:15Z");
+zdt = Temporal.ZonedDateTime.from("+000000-02-29T00:00-00:01:15[Europe/London]");
+assert.sameValue(`${ zdt.toInstant() }`, "0000-02-29T00:01:15Z");
diff --git a/test/staging/Temporal/ZonedDateTime/old/toPlainDate.js b/test/staging/Temporal/ZonedDateTime/old/toPlainDate.js
new file mode 100644
index 0000000000..4e966057fb
--- /dev/null
+++ b/test/staging/Temporal/ZonedDateTime/old/toPlainDate.js
@@ -0,0 +1,21 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: Temporal.ZonedDateTime.prototype.toPlainDate()
+features: [Temporal]
+---*/
+
+var tz = new Temporal.TimeZone("America/Los_Angeles");
+
+// works
+var zdt = Temporal.Instant.from("2019-10-29T09:46:38.271986102Z").toZonedDateTimeISO(tz);
+assert.sameValue(`${ zdt.toPlainDate() }`, "2019-10-29");
+
+// preserves the calendar
+var zdt = Temporal.Instant.from("2019-10-29T09:46:38.271986102Z").toZonedDateTime({
+ timeZone: tz,
+ calendar: "gregory"
+});
+assert.sameValue(zdt.toPlainDate().calendar.id, "gregory");
diff --git a/test/staging/Temporal/ZonedDateTime/old/toPlainMonthDay.js b/test/staging/Temporal/ZonedDateTime/old/toPlainMonthDay.js
new file mode 100644
index 0000000000..3869d2c4cb
--- /dev/null
+++ b/test/staging/Temporal/ZonedDateTime/old/toPlainMonthDay.js
@@ -0,0 +1,21 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: Temporal.ZonedDateTime.prototype.toPlainMonthDay()
+features: [Temporal]
+---*/
+
+var tz = new Temporal.TimeZone("America/Los_Angeles");
+
+// works
+var zdt = Temporal.Instant.from("2019-10-29T09:46:38.271986102Z").toZonedDateTimeISO(tz);
+assert.sameValue(`${ zdt.toPlainMonthDay() }`, "10-29");
+
+// preserves the calendar
+var zdt = Temporal.Instant.from("2019-10-29T09:46:38.271986102Z").toZonedDateTime({
+ timeZone: tz,
+ calendar: "gregory"
+});
+assert.sameValue(zdt.toPlainMonthDay().calendar.id, "gregory");
diff --git a/test/staging/Temporal/ZonedDateTime/old/toPlainTime.js b/test/staging/Temporal/ZonedDateTime/old/toPlainTime.js
new file mode 100644
index 0000000000..b899be5d9f
--- /dev/null
+++ b/test/staging/Temporal/ZonedDateTime/old/toPlainTime.js
@@ -0,0 +1,14 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: Temporal.ZonedDateTime.prototype.toPlainTime()
+features: [Temporal]
+---*/
+
+var tz = new Temporal.TimeZone("America/Los_Angeles");
+
+// works
+var zdt = Temporal.Instant.from("2019-10-29T09:46:38.271986102Z").toZonedDateTimeISO(tz);
+assert.sameValue(`${ zdt.toPlainTime() }`, "02:46:38.271986102");
diff --git a/test/staging/Temporal/ZonedDateTime/old/toPlainYearMonth.js b/test/staging/Temporal/ZonedDateTime/old/toPlainYearMonth.js
new file mode 100644
index 0000000000..c54ed6e8cd
--- /dev/null
+++ b/test/staging/Temporal/ZonedDateTime/old/toPlainYearMonth.js
@@ -0,0 +1,21 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: Temporal.ZonedDateTime.prototype.toPlainYearMonth()
+features: [Temporal]
+---*/
+
+var tz = new Temporal.TimeZone("America/Los_Angeles");
+
+// works
+var zdt = Temporal.Instant.from("2019-10-29T09:46:38.271986102Z").toZonedDateTimeISO(tz);
+assert.sameValue(`${ zdt.toPlainYearMonth() }`, "2019-10");
+
+// preserves the calendar
+var zdt = Temporal.Instant.from("2019-10-29T09:46:38.271986102Z").toZonedDateTime({
+ timeZone: tz,
+ calendar: "gregory"
+});
+assert.sameValue(zdt.toPlainYearMonth().calendar.id, "gregory");
diff --git a/test/staging/Temporal/ZonedDateTime/old/toString.js b/test/staging/Temporal/ZonedDateTime/old/toString.js
new file mode 100644
index 0000000000..69ef400751
--- /dev/null
+++ b/test/staging/Temporal/ZonedDateTime/old/toString.js
@@ -0,0 +1,71 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: Temporal.ZonedDateTime.prototype.toString()
+features: [Temporal]
+---*/
+
+var zdt1 = Temporal.ZonedDateTime.from("1976-11-18T15:23+01:00[Europe/Vienna]");
+
+// shows only non-ISO calendar if calendarName = auto
+assert.sameValue(zdt1.toString({ calendarName: "auto" }), "1976-11-18T15:23:00+01:00[Europe/Vienna]");
+assert.sameValue(zdt1.withCalendar("gregory").toString({ calendarName: "auto" }), "1976-11-18T15:23:00+01:00[Europe/Vienna][u-ca=gregory]");
+
+// shows ISO calendar if calendarName = always
+assert.sameValue(zdt1.toString({ calendarName: "always" }), "1976-11-18T15:23:00+01:00[Europe/Vienna][u-ca=iso8601]");
+
+// omits non-ISO calendar if calendarName = never
+assert.sameValue(zdt1.withCalendar("gregory").toString({ calendarName: "never" }), "1976-11-18T15:23:00+01:00[Europe/Vienna]");
+
+// throws on invalid calendar
+[
+ "ALWAYS",
+ "sometimes",
+ false,
+].forEach(calendarName => {
+ assert.throws(RangeError, () => zdt1.toString({ calendarName }));
+});
+
+// shows time zone if timeZoneName = auto
+assert.sameValue(zdt1.toString({ timeZoneName: "auto" }), "1976-11-18T15:23:00+01:00[Europe/Vienna]");
+
+// omits time zone if timeZoneName = never
+assert.sameValue(zdt1.toString({ timeZoneName: "never" }), "1976-11-18T15:23:00+01:00");
+
+// shows offset if offset = auto
+assert.sameValue(zdt1.toString({ offset: "auto" }), "1976-11-18T15:23:00+01:00[Europe/Vienna]");
+
+// omits offset if offset = never
+assert.sameValue(zdt1.toString({ offset: "never" }), "1976-11-18T15:23:00[Europe/Vienna]");
+
+// combinations of calendar, time zone, and offset
+var zdt = zdt1.withCalendar("gregory");
+assert.sameValue(zdt.toString({
+ timeZoneName: "never",
+ calendarName: "never"
+}), "1976-11-18T15:23:00+01:00");
+assert.sameValue(zdt.toString({
+ offset: "never",
+ calendarName: "never"
+}), "1976-11-18T15:23:00[Europe/Vienna]");
+assert.sameValue(zdt.toString({
+ offset: "never",
+ timeZoneName: "never"
+}), "1976-11-18T15:23:00[u-ca=gregory]");
+assert.sameValue(zdt.toString({
+ offset: "never",
+ timeZoneName: "never",
+ calendarName: "never"
+}), "1976-11-18T15:23:00");
+
+// rounding up to a nonexistent wall-clock time
+var zdt5 = Temporal.ZonedDateTime.from("2018-11-03T23:59:59.999999999-03:00[America/Sao_Paulo]");
+var roundedString = zdt5.toString({
+ fractionalSecondDigits: 8,
+ roundingMode: "halfExpand"
+});
+assert.sameValue(roundedString, "2018-11-04T01:00:00.00000000-02:00[America/Sao_Paulo]");
+var zdt6 = Temporal.ZonedDateTime.from(roundedString);
+assert.sameValue(zdt6.epochNanoseconds - zdt5.epochNanoseconds, 1n);
diff --git a/test/staging/Temporal/ZonedDateTime/old/until.js b/test/staging/Temporal/ZonedDateTime/old/until.js
new file mode 100644
index 0000000000..43ab4c2294
--- /dev/null
+++ b/test/staging/Temporal/ZonedDateTime/old/until.js
@@ -0,0 +1,520 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: Temporal.ZonedDateTime.prototype.until()
+features: [Temporal]
+---*/
+
+var zdt = Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456789+01:00[Europe/Vienna]");
+
+// zdt.until(later) === later.since(zdt) with default options
+var later = Temporal.ZonedDateTime.from({
+ year: 2016,
+ month: 3,
+ day: 3,
+ hour: 18,
+ timeZone: "Europe/Vienna"
+});
+assert.sameValue(`${ zdt.until(later) }`, `${ later.since(zdt) }`);
+
+// casts argument
+assert.sameValue(`${ zdt.until({
+ year: 2019,
+ month: 10,
+ day: 29,
+ hour: 10,
+ timeZone: "Europe/Vienna"
+}) }`, "PT376434H36M29.876543211S");
+assert.sameValue(`${ zdt.until("2019-10-29T10:46:38.271986102+01:00[Europe/Vienna]") }`, "PT376435H23M8.148529313S");
+var feb20 = Temporal.ZonedDateTime.from("2020-02-01T00:00+01:00[Europe/Vienna]");
+var feb21 = Temporal.ZonedDateTime.from("2021-02-01T00:00+01:00[Europe/Vienna]");
+
+// defaults to returning hours
+assert.sameValue(`${ feb20.until(feb21) }`, "PT8784H");
+assert.sameValue(`${ feb20.until(feb21, { largestUnit: "auto" }) }`, "PT8784H");
+assert.sameValue(`${ feb20.until(feb21, { largestUnit: "hours" }) }`, "PT8784H");
+assert.sameValue(`${ feb20.until(Temporal.ZonedDateTime.from("2021-02-01T00:00:00.000000001+01:00[Europe/Vienna]")) }`, "PT8784H0.000000001S");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("2020-02-01T00:00:00.000000001+01:00[Europe/Vienna]").until(feb21) }`, "PT8783H59M59.999999999S");
+
+// can return lower or higher units
+assert.sameValue(`${ feb20.until(feb21, { largestUnit: "years" }) }`, "P1Y");
+assert.sameValue(`${ feb20.until(feb21, { largestUnit: "months" }) }`, "P12M");
+assert.sameValue(`${ feb20.until(feb21, { largestUnit: "weeks" }) }`, "P52W2D");
+assert.sameValue(`${ feb20.until(feb21, { largestUnit: "days" }) }`, "P366D");
+assert.sameValue(`${ feb20.until(feb21, { largestUnit: "minutes" }) }`, "PT527040M");
+assert.sameValue(`${ feb20.until(feb21, { largestUnit: "seconds" }) }`, "PT31622400S");
+
+// can return subseconds
+var later = feb20.add({
+ days: 1,
+ milliseconds: 250,
+ microseconds: 250,
+ nanoseconds: 250
+});
+var msDiff = feb20.until(later, { largestUnit: "milliseconds" });
+assert.sameValue(msDiff.seconds, 0);
+assert.sameValue(msDiff.milliseconds, 86400250);
+assert.sameValue(msDiff.microseconds, 250);
+assert.sameValue(msDiff.nanoseconds, 250);
+var µsDiff = feb20.until(later, { largestUnit: "microseconds" });
+assert.sameValue(µsDiff.milliseconds, 0);
+assert.sameValue(µsDiff.microseconds, 86400250250);
+assert.sameValue(µsDiff.nanoseconds, 250);
+var nsDiff = feb20.until(later, { largestUnit: "nanoseconds" });
+assert.sameValue(nsDiff.microseconds, 0);
+assert.sameValue(nsDiff.nanoseconds, 86400250250250);
+
+// does not include higher units than necessary
+var lastFeb20 = Temporal.ZonedDateTime.from("2020-02-29T00:00+01:00[Europe/Vienna]");
+var lastJan21 = Temporal.ZonedDateTime.from("2021-01-31T00:00+01:00[Europe/Vienna]");
+assert.sameValue(`${ lastFeb20.until(lastJan21) }`, "PT8088H");
+assert.sameValue(`${ lastFeb20.until(lastJan21, { largestUnit: "months" }) }`, "P11M2D");
+assert.sameValue(`${ lastFeb20.until(lastJan21, { largestUnit: "years" }) }`, "P11M2D");
+
+// weeks and months are mutually exclusive
+var laterDateTime = zdt.add({
+ days: 42,
+ hours: 3
+});
+var weeksDifference = zdt.until(laterDateTime, { largestUnit: "weeks" });
+assert.notSameValue(weeksDifference.weeks, 0);
+assert.sameValue(weeksDifference.months, 0);
+var monthsDifference = zdt.until(laterDateTime, { largestUnit: "months" });
+assert.sameValue(monthsDifference.weeks, 0);
+assert.notSameValue(monthsDifference.months, 0);
+
+// no two different calendars
+var zdt1 = new Temporal.ZonedDateTime(0n, "UTC");
+var zdt2 = new Temporal.ZonedDateTime(0n, "UTC", Temporal.Calendar.from("japanese"));
+assert.throws(RangeError, () => zdt1.until(zdt2));
+
+var earlier = Temporal.ZonedDateTime.from('2019-01-08T09:22:36.123456789+01:00[Europe/Vienna]');
+var later = Temporal.ZonedDateTime.from('2021-09-07T14:39:40.987654321+02:00[Europe/Vienna]');
+// assumes a different default for largestUnit if smallestUnit is larger than hours
+assert.sameValue(`${ earlier.until(later, {
+ smallestUnit: "years",
+ roundingMode: "halfExpand"
+}) }`, "P3Y");
+assert.sameValue(`${ earlier.until(later, {
+ smallestUnit: "months",
+ roundingMode: "halfExpand"
+}) }`, "P32M");
+assert.sameValue(`${ earlier.until(later, {
+ smallestUnit: "weeks",
+ roundingMode: "halfExpand"
+}) }`, "P139W");
+assert.sameValue(`${ earlier.until(later, {
+ smallestUnit: "days",
+ roundingMode: "halfExpand"
+}) }`, "P973D");
+var incrementOneNearest = [
+ [
+ "years",
+ "P3Y"
+ ],
+ [
+ "months",
+ "P32M"
+ ],
+ [
+ "weeks",
+ "P139W"
+ ],
+ [
+ "days",
+ "P973D"
+ ],
+ [
+ "hours",
+ "PT23356H"
+ ],
+ [
+ "minutes",
+ "PT23356H17M"
+ ],
+ [
+ "seconds",
+ "PT23356H17M5S"
+ ],
+ [
+ "milliseconds",
+ "PT23356H17M4.864S"
+ ],
+ [
+ "microseconds",
+ "PT23356H17M4.864198S"
+ ],
+ [
+ "nanoseconds",
+ "PT23356H17M4.864197532S"
+ ]
+];
+incrementOneNearest.forEach(([smallestUnit, expected]) => {
+ var roundingMode = "halfExpand";
+ assert.sameValue(`${ earlier.until(later, {
+ smallestUnit,
+ roundingMode
+ }) }`, expected);
+ assert.sameValue(`${ later.until(earlier, {
+ smallestUnit,
+ roundingMode
+ }) }`, `-${ expected }`);
+});
+var incrementOneCeil = [
+ [
+ "years",
+ "P3Y",
+ "-P2Y"
+ ],
+ [
+ "months",
+ "P32M",
+ "-P31M"
+ ],
+ [
+ "weeks",
+ "P140W",
+ "-P139W"
+ ],
+ [
+ "days",
+ "P974D",
+ "-P973D"
+ ],
+ [
+ "hours",
+ "PT23357H",
+ "-PT23356H"
+ ],
+ [
+ "minutes",
+ "PT23356H18M",
+ "-PT23356H17M"
+ ],
+ [
+ "seconds",
+ "PT23356H17M5S",
+ "-PT23356H17M4S"
+ ],
+ [
+ "milliseconds",
+ "PT23356H17M4.865S",
+ "-PT23356H17M4.864S"
+ ],
+ [
+ "microseconds",
+ "PT23356H17M4.864198S",
+ "-PT23356H17M4.864197S"
+ ],
+ [
+ "nanoseconds",
+ "PT23356H17M4.864197532S",
+ "-PT23356H17M4.864197532S"
+ ]
+];
+incrementOneCeil.forEach(([smallestUnit, expectedPositive, expectedNegative]) => {
+ var roundingMode = "ceil";
+ assert.sameValue(`${ earlier.until(later, {
+ smallestUnit,
+ roundingMode
+ }) }`, expectedPositive);
+ assert.sameValue(`${ later.until(earlier, {
+ smallestUnit,
+ roundingMode
+ }) }`, expectedNegative);
+});
+var incrementOneFloor = [
+ [
+ "years",
+ "P2Y",
+ "-P3Y"
+ ],
+ [
+ "months",
+ "P31M",
+ "-P32M"
+ ],
+ [
+ "weeks",
+ "P139W",
+ "-P140W"
+ ],
+ [
+ "days",
+ "P973D",
+ "-P974D"
+ ],
+ [
+ "hours",
+ "PT23356H",
+ "-PT23357H"
+ ],
+ [
+ "minutes",
+ "PT23356H17M",
+ "-PT23356H18M"
+ ],
+ [
+ "seconds",
+ "PT23356H17M4S",
+ "-PT23356H17M5S"
+ ],
+ [
+ "milliseconds",
+ "PT23356H17M4.864S",
+ "-PT23356H17M4.865S"
+ ],
+ [
+ "microseconds",
+ "PT23356H17M4.864197S",
+ "-PT23356H17M4.864198S"
+ ],
+ [
+ "nanoseconds",
+ "PT23356H17M4.864197532S",
+ "-PT23356H17M4.864197532S"
+ ]
+];
+incrementOneFloor.forEach(([smallestUnit, expectedPositive, expectedNegative]) => {
+ var roundingMode = "floor";
+ assert.sameValue(`${ earlier.until(later, {
+ smallestUnit,
+ roundingMode
+ }) }`, expectedPositive);
+ assert.sameValue(`${ later.until(earlier, {
+ smallestUnit,
+ roundingMode
+ }) }`, expectedNegative);
+});
+var incrementOneTrunc = [
+ [
+ "years",
+ "P2Y"
+ ],
+ [
+ "months",
+ "P31M"
+ ],
+ [
+ "weeks",
+ "P139W"
+ ],
+ [
+ "days",
+ "P973D"
+ ],
+ [
+ "hours",
+ "PT23356H"
+ ],
+ [
+ "minutes",
+ "PT23356H17M"
+ ],
+ [
+ "seconds",
+ "PT23356H17M4S"
+ ],
+ [
+ "milliseconds",
+ "PT23356H17M4.864S"
+ ],
+ [
+ "microseconds",
+ "PT23356H17M4.864197S"
+ ],
+ [
+ "nanoseconds",
+ "PT23356H17M4.864197532S"
+ ]
+];
+incrementOneTrunc.forEach(([smallestUnit, expected]) => {
+ var roundingMode = "trunc";
+ assert.sameValue(`${ earlier.until(later, {
+ smallestUnit,
+ roundingMode
+ }) }`, expected);
+ assert.sameValue(`${ later.until(earlier, {
+ smallestUnit,
+ roundingMode
+ }) }`, `-${ expected }`);
+});
+
+// rounds to an increment of hours
+assert.sameValue(`${ earlier.until(later, {
+ smallestUnit: "hours",
+ roundingIncrement: 3,
+ roundingMode: "halfExpand"
+}) }`, "PT23355H");
+
+// rounds to an increment of minutes
+assert.sameValue(`${ earlier.until(later, {
+ smallestUnit: "minutes",
+ roundingIncrement: 30,
+ roundingMode: "halfExpand"
+}) }`, "PT23356H30M");
+
+// rounds to an increment of seconds
+assert.sameValue(`${ earlier.until(later, {
+ smallestUnit: "seconds",
+ roundingIncrement: 15,
+ roundingMode: "halfExpand"
+}) }`, "PT23356H17M");
+
+// rounds to an increment of milliseconds
+assert.sameValue(`${ earlier.until(later, {
+ smallestUnit: "milliseconds",
+ roundingIncrement: 10,
+ roundingMode: "halfExpand"
+}) }`, "PT23356H17M4.86S");
+
+// rounds to an increment of microseconds
+assert.sameValue(`${ earlier.until(later, {
+ smallestUnit: "microseconds",
+ roundingIncrement: 10,
+ roundingMode: "halfExpand"
+}) }`, "PT23356H17M4.8642S");
+
+// rounds to an increment of nanoseconds
+assert.sameValue(`${ earlier.until(later, {
+ smallestUnit: "nanoseconds",
+ roundingIncrement: 10,
+ roundingMode: "halfExpand"
+}) }`, "PT23356H17M4.86419753S");
+
+// valid hour increments divide into 24
+[
+ 1,
+ 2,
+ 3,
+ 4,
+ 6,
+ 8,
+ 12
+].forEach(roundingIncrement => {
+ var options = {
+ smallestUnit: "hours",
+ roundingIncrement
+ };
+ assert(earlier.until(later, options) instanceof Temporal.Duration);
+});
+[
+ "minutes",
+ "seconds"
+].forEach(smallestUnit => {
+ [
+ 1,
+ 2,
+ 3,
+ 4,
+ 5,
+ 6,
+ 10,
+ 12,
+ 15,
+ 20,
+ 30
+ ].forEach(roundingIncrement => {
+ var options = {
+ smallestUnit,
+ roundingIncrement
+ };
+ assert(earlier.until(later, options) instanceof Temporal.Duration);
+ });
+});
+[
+ "milliseconds",
+ "microseconds",
+ "nanoseconds"
+].forEach(smallestUnit => {
+ [
+ 1,
+ 2,
+ 4,
+ 5,
+ 8,
+ 10,
+ 20,
+ 25,
+ 40,
+ 50,
+ 100,
+ 125,
+ 200,
+ 250,
+ 500
+ ].forEach(roundingIncrement => {
+ var options = {
+ smallestUnit,
+ roundingIncrement
+ };
+ assert(earlier.until(later, options) instanceof Temporal.Duration);
+ });
+});
+
+// throws on increments that do not divide evenly into the next highest
+assert.throws(RangeError, () => earlier.until(later, {
+ smallestUnit: "hours",
+ roundingIncrement: 11
+}));
+assert.throws(RangeError, () => earlier.until(later, {
+ smallestUnit: "minutes",
+ roundingIncrement: 29
+}));
+assert.throws(RangeError, () => earlier.until(later, {
+ smallestUnit: "seconds",
+ roundingIncrement: 29
+}));
+assert.throws(RangeError, () => earlier.until(later, {
+ smallestUnit: "milliseconds",
+ roundingIncrement: 29
+}));
+assert.throws(RangeError, () => earlier.until(later, {
+ smallestUnit: "microseconds",
+ roundingIncrement: 29
+}));
+assert.throws(RangeError, () => earlier.until(later, {
+ smallestUnit: "nanoseconds",
+ roundingIncrement: 29
+}));
+
+// throws on increments that are equal to the next highest
+assert.throws(RangeError, () => earlier.until(later, {
+ smallestUnit: "hours",
+ roundingIncrement: 24
+}));
+assert.throws(RangeError, () => earlier.until(later, {
+ smallestUnit: "minutes",
+ roundingIncrement: 60
+}));
+assert.throws(RangeError, () => earlier.until(later, {
+ smallestUnit: "seconds",
+ roundingIncrement: 60
+}));
+assert.throws(RangeError, () => earlier.until(later, {
+ smallestUnit: "milliseconds",
+ roundingIncrement: 1000
+}));
+assert.throws(RangeError, () => earlier.until(later, {
+ smallestUnit: "microseconds",
+ roundingIncrement: 1000
+}));
+assert.throws(RangeError, () => earlier.until(later, {
+ smallestUnit: "nanoseconds",
+ roundingIncrement: 1000
+}));
+
+// rounds relative to the receiver
+var dt1 = Temporal.ZonedDateTime.from("2019-01-01T00:00+00:00[UTC]");
+var dt2 = Temporal.ZonedDateTime.from("2020-07-02T00:00+00:00[UTC]");
+assert.sameValue(`${ dt1.until(dt2, {
+ smallestUnit: "years",
+ roundingMode: "halfExpand"
+}) }`, "P2Y");
+assert.sameValue(`${ dt2.until(dt1, {
+ smallestUnit: "years",
+ roundingMode: "halfExpand"
+}) }`, "-P1Y");
+
diff --git a/test/staging/Temporal/ZonedDateTime/old/with.js b/test/staging/Temporal/ZonedDateTime/old/with.js
new file mode 100644
index 0000000000..9273b51b10
--- /dev/null
+++ b/test/staging/Temporal/ZonedDateTime/old/with.js
@@ -0,0 +1,267 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: Temporal.ZonedDateTime.prototype.with()
+features: [Temporal]
+---*/
+
+var zdt = new Temporal.PlainDateTime(1976, 11, 18, 15, 23, 30, 123, 456, 789).toZonedDateTime("UTC");
+
+// zdt.with({ year: 2019 } works
+assert.sameValue(`${ zdt.with({ year: 2019 }) }`, "2019-11-18T15:23:30.123456789+00:00[UTC]");
+
+// zdt.with({ month: 5 } works
+assert.sameValue(`${ zdt.with({ month: 5 }) }`, "1976-05-18T15:23:30.123456789+00:00[UTC]");
+
+// zdt.with({ monthCode: "M05" }) works
+assert.sameValue(`${ zdt.with({ monthCode: "M05" }) }`, "1976-05-18T15:23:30.123456789+00:00[UTC]");
+
+// month and monthCode must agree
+assert.throws(RangeError, () => zdt.with({
+ month: 5,
+ monthCode: "M06"
+}));
+
+// zdt.with({ day: 5 } works
+assert.sameValue(`${ zdt.with({ day: 5 }) }`, "1976-11-05T15:23:30.123456789+00:00[UTC]");
+
+// zdt.with({ hour: 5 } works
+assert.sameValue(`${ zdt.with({ hour: 5 }) }`, "1976-11-18T05:23:30.123456789+00:00[UTC]");
+
+// zdt.with({ minute: 5 } works
+assert.sameValue(`${ zdt.with({ minute: 5 }) }`, "1976-11-18T15:05:30.123456789+00:00[UTC]");
+
+// zdt.with({ second: 5 } works
+assert.sameValue(`${ zdt.with({ second: 5 }) }`, "1976-11-18T15:23:05.123456789+00:00[UTC]");
+
+// zdt.with({ millisecond: 5 } works
+assert.sameValue(`${ zdt.with({ millisecond: 5 }) }`, "1976-11-18T15:23:30.005456789+00:00[UTC]");
+
+// zdt.with({ microsecond: 5 } works
+assert.sameValue(`${ zdt.with({ microsecond: 5 }) }`, "1976-11-18T15:23:30.123005789+00:00[UTC]");
+
+// zdt.with({ nanosecond: 5 } works
+assert.sameValue(`${ zdt.with({ nanosecond: 5 }) }`, "1976-11-18T15:23:30.123456005+00:00[UTC]");
+
+// zdt.with({ month: 5, second: 15 } works
+assert.sameValue(`${ zdt.with({
+ month: 5,
+ second: 15
+}) }`, "1976-05-18T15:23:15.123456789+00:00[UTC]");
+
+// Overflow options
+// constrain
+var overflow = "constrain";
+assert.sameValue(`${ zdt.with({ month: 29 }, { overflow }) }`, "1976-12-18T15:23:30.123456789+00:00[UTC]");
+assert.sameValue(`${ zdt.with({ day: 31 }, { overflow }) }`, "1976-11-30T15:23:30.123456789+00:00[UTC]");
+assert.sameValue(`${ zdt.with({ hour: 29 }, { overflow }) }`, "1976-11-18T23:23:30.123456789+00:00[UTC]");
+assert.sameValue(`${ zdt.with({ nanosecond: 9000 }, { overflow }) }`, "1976-11-18T15:23:30.123456999+00:00[UTC]");
+
+// reject
+var overflow = "reject";
+assert.throws(RangeError, () => zdt.with({ month: 29 }, { overflow }));
+assert.throws(RangeError, () => zdt.with({ day: 31 }, { overflow }));
+assert.throws(RangeError, () => zdt.with({ hour: 29 }, { overflow }));
+assert.throws(RangeError, () => zdt.with({ nanosecond: 9000 }, { overflow }));
+
+var dstStartDay = Temporal.ZonedDateTime.from("2019-03-10T12:00:01-02:30[America/St_Johns]");
+var dstEndDay = Temporal.ZonedDateTime.from("2019-11-03T12:00:01-03:30[America/St_Johns]");
+var oneThirty = {
+hour: 1,
+minute: 30
+};
+var twoThirty = {
+hour: 2,
+minute: 30
+};
+
+// Disambiguation options
+var offset = "ignore";
+// compatible, skipped wall time
+assert.sameValue(`${ dstStartDay.with(twoThirty, {
+ offset,
+ disambiguation: "compatible"
+}) }`, "2019-03-10T03:30:01-02:30[America/St_Johns]");
+
+// earlier, skipped wall time
+assert.sameValue(`${ dstStartDay.with(twoThirty, {
+ offset,
+ disambiguation: "earlier"
+}) }`, "2019-03-10T01:30:01-03:30[America/St_Johns]");
+
+// later, skipped wall time
+assert.sameValue(`${ dstStartDay.with(twoThirty, {
+ offset,
+ disambiguation: "later"
+}) }`, "2019-03-10T03:30:01-02:30[America/St_Johns]");
+
+// compatible, repeated wall time
+assert.sameValue(`${ dstEndDay.with(oneThirty, {
+ offset,
+ disambiguation: "compatible"
+}) }`, "2019-11-03T01:30:01-02:30[America/St_Johns]");
+
+// earlier, repeated wall time
+assert.sameValue(`${ dstEndDay.with(oneThirty, {
+ offset,
+ disambiguation: "earlier"
+}) }`, "2019-11-03T01:30:01-02:30[America/St_Johns]");
+
+// later, repeated wall time
+assert.sameValue(`${ dstEndDay.with(oneThirty, {
+ offset,
+ disambiguation: "later"
+}) }`, "2019-11-03T01:30:01-03:30[America/St_Johns]");
+
+// reject
+assert.throws(RangeError, () => dstStartDay.with(twoThirty, {
+ offset,
+ disambiguation: "reject"
+}));
+assert.throws(RangeError, () => dstEndDay.with(oneThirty, {
+ offset,
+ disambiguation: "reject"
+}));
+
+// compatible is the default
+assert.sameValue(`${ dstStartDay.with(twoThirty, { offset }) }`, `${ dstStartDay.with(twoThirty, {
+ offset,
+ disambiguation: "compatible"
+}) }`);
+assert.sameValue(`${ dstEndDay.with(twoThirty, { offset }) }`, `${ dstEndDay.with(twoThirty, {
+ offset,
+ disambiguation: "compatible"
+}) }`);
+
+// invalid disambiguation
+[
+ "",
+ "EARLIER",
+ "balance"
+].forEach(disambiguation => assert.throws(RangeError, () => zdt.with({ day: 5 }, { disambiguation })));
+
+// Offset options
+var bogus = {
+ ...twoThirty,
+ offset: "+23:59"
+};
+// use, with bogus offset, changes to the exact time with the offset
+var preserveExact = dstStartDay.with(bogus, { offset: "use" });
+assert.sameValue(`${ preserveExact }`, "2019-03-08T23:01:01-03:30[America/St_Johns]");
+assert.sameValue(preserveExact.epochNanoseconds, Temporal.Instant.from("2019-03-10T02:30:01+23:59").epochNanoseconds);
+
+// ignore, with bogus offset, defers to disambiguation option
+var offset = "ignore";
+assert.sameValue(`${ dstStartDay.with(bogus, {
+ offset,
+ disambiguation: "earlier"
+}) }`, "2019-03-10T01:30:01-03:30[America/St_Johns]");
+assert.sameValue(`${ dstStartDay.with(bogus, {
+ offset,
+ disambiguation: "later"
+}) }`, "2019-03-10T03:30:01-02:30[America/St_Johns]");
+
+// prefer, with bogus offset, defers to disambiguation option
+var offset = "prefer";
+assert.sameValue(`${ dstStartDay.with(bogus, {
+ offset,
+ disambiguation: "earlier"
+}) }`, "2019-03-10T01:30:01-03:30[America/St_Johns]");
+assert.sameValue(`${ dstStartDay.with(bogus, {
+ offset,
+ disambiguation: "later"
+}) }`, "2019-03-10T03:30:01-02:30[America/St_Johns]");
+
+// reject, with bogus offset, throws
+assert.throws(RangeError, () => dstStartDay.with({
+ ...twoThirty,
+ offset: "+23:59"
+}, { offset: "reject" }));
+
+var doubleTime = Temporal.ZonedDateTime.from("2019-11-03T01:30:01-03:30[America/St_Johns]");
+// use changes to the exact time with the offset
+var preserveExact = doubleTime.with({ offset: "-02:30" }, { offset: "use" });
+assert.sameValue(preserveExact.offset, "-02:30");
+assert.sameValue(preserveExact.epochNanoseconds, Temporal.Instant.from("2019-11-03T01:30:01-02:30").epochNanoseconds);
+
+// ignore defers to disambiguation option
+var offset = "ignore";
+assert.sameValue(doubleTime.with({ offset: "-02:30" }, {
+ offset,
+ disambiguation: "earlier"
+}).offset, "-02:30");
+assert.sameValue(doubleTime.with({ offset: "-02:30" }, {
+ offset,
+ disambiguation: "later"
+}).offset, "-03:30");
+
+// prefer adjusts offset of repeated clock time
+assert.sameValue(doubleTime.with({ offset: "-02:30" }, { offset: "prefer" }).offset, "-02:30");
+
+// reject adjusts offset of repeated clock time
+assert.sameValue(doubleTime.with({ offset: "-02:30" }, { offset: "reject" }).offset, "-02:30");
+
+// use does not cause the offset to change when adjusting repeated clock time
+assert.sameValue(doubleTime.with({ minute: 31 }, { offset: "use" }).offset, "-03:30");
+
+// ignore may cause the offset to change when adjusting repeated clock time
+assert.sameValue(doubleTime.with({ minute: 31 }, { offset: "ignore" }).offset, "-02:30");
+
+// prefer does not cause the offset to change when adjusting repeated clock time
+assert.sameValue(doubleTime.with({ minute: 31 }, { offset: "prefer" }).offset, "-03:30");
+
+// reject does not cause the offset to change when adjusting repeated clock time
+assert.sameValue(doubleTime.with({ minute: 31 }, { offset: "reject" }).offset, "-03:30");
+
+// prefer is the default
+assert.sameValue(`${ dstStartDay.with(twoThirty) }`, `${ dstStartDay.with(twoThirty, { offset: "prefer" }) }`);
+assert.sameValue(`${ dstEndDay.with(twoThirty) }`, `${ dstEndDay.with(twoThirty, { offset: "prefer" }) }`);
+assert.sameValue(`${ doubleTime.with({ minute: 31 }) }`, `${ doubleTime.with({ minute: 31 }, { offset: "prefer" }) }`);
+
+// invalid offset
+[
+ "",
+ "PREFER",
+ "balance"
+].forEach(offset => assert.throws(RangeError, () => zdt.with({ day: 5 }, { offset })));
+
+// object must contain at least one correctly-spelled property
+assert.throws(TypeError, () => zdt.with({}));
+assert.throws(TypeError, () => zdt.with({ months: 12 }));
+
+// incorrectly-spelled properties are ignored
+assert.sameValue(`${ zdt.with({
+ month: 12,
+ days: 15
+}) }`, "1976-12-18T15:23:30.123456789+00:00[UTC]");
+
+// throws if timeZone is included
+assert.throws(TypeError, () => zdt.with({
+ month: 2,
+ timeZone: "Asia/Ulaanbaatar"
+}));
+
+// throws if given a Temporal object with a time zone
+assert.throws(TypeError, () => zdt.with(dstStartDay));
+
+// throws if calendarName is included
+assert.throws(TypeError, () => zdt.with({
+ month: 2,
+ calendar: "japanese"
+}));
+
+// throws if given a Temporal object with a calendar
+assert.throws(TypeError, () => zdt.with(Temporal.PlainDateTime.from("1976-11-18T12:00")));
+assert.throws(TypeError, () => zdt.with(Temporal.PlainDate.from("1976-11-18")));
+assert.throws(TypeError, () => zdt.with(Temporal.PlainTime.from("12:00")));
+assert.throws(TypeError, () => zdt.with(Temporal.PlainYearMonth.from("1976-11")));
+assert.throws(TypeError, () => zdt.with(Temporal.PlainMonthDay.from("11-18")));
+
+// throws if given a string
+assert.throws(TypeError, () => zdt.with("1976-11-18T12:00+00:00[UTC]"));
+assert.throws(TypeError, () => zdt.with("1976-11-18"));
+assert.throws(TypeError, () => zdt.with("12:00"));
+assert.throws(TypeError, () => zdt.with("invalid"));
+
diff --git a/test/staging/Temporal/ZonedDateTime/old/withCalendar.js b/test/staging/Temporal/ZonedDateTime/old/withCalendar.js
new file mode 100644
index 0000000000..e1e5266413
--- /dev/null
+++ b/test/staging/Temporal/ZonedDateTime/old/withCalendar.js
@@ -0,0 +1,21 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: Temporal.ZonedDateTime.prototype.withCalendar()
+features: [Temporal]
+---*/
+
+var zdt = Temporal.ZonedDateTime.from("2019-11-18T15:23:30.123456789-08:00[America/Los_Angeles]");
+
+// zonedDateTime.withCalendar(japanese) works
+var cal = Temporal.Calendar.from("japanese");
+assert.sameValue(`${ zdt.withCalendar(cal) }`, "2019-11-18T15:23:30.123456789-08:00[America/Los_Angeles][u-ca=japanese]");
+
+// keeps instant and time zone the same
+var zdt = Temporal.ZonedDateTime.from("2019-11-18T15:23:30.123456789+01:00[Europe/Madrid][u-ca=gregory]");
+var zdt2 = zdt.withCalendar("japanese");
+assert.sameValue(zdt.epochNanoseconds, zdt2.epochNanoseconds);
+assert.sameValue(zdt2.calendar.id, "japanese");
+assert.sameValue(zdt2.timeZone.id, "Europe/Madrid");
diff --git a/test/staging/Temporal/ZonedDateTime/old/withPlainDate.js b/test/staging/Temporal/ZonedDateTime/old/withPlainDate.js
new file mode 100644
index 0000000000..a728c1f9d9
--- /dev/null
+++ b/test/staging/Temporal/ZonedDateTime/old/withPlainDate.js
@@ -0,0 +1,45 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: .withPlainDate manipulation
+features: [Temporal]
+---*/
+
+var zdt = Temporal.ZonedDateTime.from("1995-12-07T03:24:30[America/Los_Angeles]");
+
+// withPlainDate({ year: 2000, month: 6, day: 1 }) works
+assert.sameValue(`${ zdt.withPlainDate({
+ year: 2000,
+ month: 6,
+ day: 1
+}) }`, "2000-06-01T03:24:30-07:00[America/Los_Angeles]");
+
+// withPlainDate(plainDate) works
+var date = Temporal.PlainDate.from("2020-01-23");
+assert.sameValue(`${ zdt.withPlainDate(date) }`, "2020-01-23T03:24:30-08:00[America/Los_Angeles]");
+
+// withPlainDate('2018-09-15') works
+assert.sameValue(`${ zdt.withPlainDate("2018-09-15") }`, "2018-09-15T03:24:30-07:00[America/Los_Angeles]");
+
+// result contains a non-ISO calendar if present in the input
+assert.sameValue(`${ zdt.withCalendar("japanese").withPlainDate("2008-09-06") }`, "2008-09-06T03:24:30-07:00[America/Los_Angeles][u-ca=japanese]");
+
+// calendar is unchanged if input has ISO calendar
+assert.sameValue(`${ zdt.withPlainDate("2008-09-06[u-ca=japanese]") }`, "2008-09-06T03:24:30-07:00[America/Los_Angeles][u-ca=japanese]");
+
+// throws if both `this` and `other` have a non-ISO calendar
+assert.throws(RangeError, () => zdt.withCalendar("gregory").withPlainDate("2008-09-06-07:00[America/Los_Angeles][u-ca=japanese]"));
+
+// object must contain at least one correctly-spelled property
+assert.throws(TypeError, () => zdt.withPlainDate({}));
+assert.throws(TypeError, () => zdt.withPlainDate({ months: 12 }));
+
+// incorrectly-spelled properties are ignored
+assert.sameValue(`${ zdt.withPlainDate({
+ year: 2000,
+ month: 6,
+ day: 1,
+ months: 123
+}) }`, "2000-06-01T03:24:30-07:00[America/Los_Angeles]");
diff --git a/test/staging/Temporal/ZonedDateTime/old/withPlainTime.js b/test/staging/Temporal/ZonedDateTime/old/withPlainTime.js
new file mode 100644
index 0000000000..8b7accbf89
--- /dev/null
+++ b/test/staging/Temporal/ZonedDateTime/old/withPlainTime.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: .withPlainTime manipulation
+features: [Temporal]
+---*/
+
+var zdt = Temporal.ZonedDateTime.from("2015-12-07T03:24:30.000003500[America/Los_Angeles]");
+
+// withPlainTime({ hour: 10 }) works
+assert.sameValue(`${ zdt.withPlainTime({ hour: 10 }) }`, "2015-12-07T10:00:00-08:00[America/Los_Angeles]");
+
+// withPlainTime(time) works
+var time = Temporal.PlainTime.from("11:22");
+assert.sameValue(`${ zdt.withPlainTime(time) }`, "2015-12-07T11:22:00-08:00[America/Los_Angeles]");
+
+// withPlainTime('12:34') works
+assert.sameValue(`${ zdt.withPlainTime("12:34") }`, "2015-12-07T12:34:00-08:00[America/Los_Angeles]");
+
+// incorrectly-spelled properties are ignored
+assert.sameValue(`${ zdt.withPlainTime({
+ hour: 10,
+ seconds: 55
+}) }`, "2015-12-07T10:00:00-08:00[America/Los_Angeles]");
diff --git a/test/staging/Temporal/ZonedDateTime/old/withTimezone.js b/test/staging/Temporal/ZonedDateTime/old/withTimezone.js
new file mode 100644
index 0000000000..8628aacc28
--- /dev/null
+++ b/test/staging/Temporal/ZonedDateTime/old/withTimezone.js
@@ -0,0 +1,20 @@
+// Copyright (C) 2018 Bloomberg LP. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+esid: sec-temporal-zoneddatetime-objects
+description: Temporal.ZonedDateTime.prototype.withTimeZone()
+features: [Temporal]
+---*/
+
+var tz = new Temporal.TimeZone("America/Los_Angeles");
+var instant = Temporal.Instant.from("2019-11-18T15:23:30.123456789-08:00[America/Los_Angeles]");
+var zdt = instant.toZonedDateTimeISO("UTC");
+
+// keeps instant and calendar the same
+var zdt = Temporal.ZonedDateTime.from("2019-11-18T15:23:30.123456789+01:00[Europe/Madrid][u-ca=gregory]");
+var zdt2 = zdt.withTimeZone("America/Vancouver");
+assert.sameValue(zdt.epochNanoseconds, zdt2.epochNanoseconds);
+assert.sameValue(zdt2.calendar.id, "gregory");
+assert.sameValue(zdt2.timeZone.id, "America/Vancouver");
+assert.notSameValue(`${ zdt.toPlainDateTime() }`, `${ zdt2.toPlainDateTime() }`);