diff --git a/test/staging/Temporal/TimeZone/old/timezone-america-la.js b/test/staging/Intl402/Temporal/old/timezone-america-la.js
similarity index 100%
rename from test/staging/Temporal/TimeZone/old/timezone-america-la.js
rename to test/staging/Intl402/Temporal/old/timezone-america-la.js
diff --git a/test/staging/Intl402/Temporal/old/tzdb-transitions.js b/test/staging/Intl402/Temporal/old/tzdb-transitions.js
new file mode 100644
index 0000000000..441de4e29a
--- /dev/null
+++ b/test/staging/Intl402/Temporal/old/tzdb-transitions.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: Tests that are impractical to do without a TZDB
+features: [Temporal]
+---*/
+
+// getNextTransition()
+
+var nyc = Temporal.TimeZone.from("America/New_York");
+
+// 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");
+
+// casts argument
+assert.sameValue(`${ nyc.getNextTransition("2019-04-16T21:01Z") }`, "2019-11-03T06:00:00Z");
+
+// getPreviousTransition()
+
+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/Duration/old/add.js b/test/staging/Temporal/Duration/old/add.js
index 02868b29bb..a43411657d 100644
--- a/test/staging/Temporal/Duration/old/add.js
+++ b/test/staging/Temporal/Duration/old/add.js
@@ -15,7 +15,7 @@ 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]");
+var relativeTo = Temporal.ZonedDateTime.from("2017-01-01T00:00[+04:30]");
 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]");
@@ -112,10 +112,10 @@ assert.sameValue(`${ oneDay.add(hours24, {
 }) }`, "P2D");
 
 // throws on wrong offset for ZonedDateTime relativeTo string
-assert.throws(RangeError, () => oneDay.add(hours24, { relativeTo: "1971-01-01T00:00+02:00[Africa/Monrovia]" }));
+assert.throws(RangeError, () => oneDay.add(hours24, { relativeTo: "1971-01-01T00:00+02:00[-00:44:30]" }));
 
 // 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");
+assert.sameValue(`${ oneDay.add(hours24, { relativeTo: "1971-01-01T00:00-00:45[-00:44:30]" }) }`, "P2D");
 
 // throws on HH:MM rounded offset for ZonedDateTime relativeTo property bag
 assert.throws(RangeError, () => oneDay.add(hours24, {
@@ -124,7 +124,7 @@ assert.throws(RangeError, () => oneDay.add(hours24, {
     month: 1,
     day: 1,
     offset: "-00:45",
-    timeZone: "Africa/Monrovia"
+    timeZone: "-00:44:30"
   }
 }));
 
diff --git a/test/staging/Temporal/Duration/old/round.js b/test/staging/Temporal/Duration/old/round.js
index 848b688044..354626f338 100644
--- a/test/staging/Temporal/Duration/old/round.js
+++ b/test/staging/Temporal/Duration/old/round.js
@@ -26,7 +26,7 @@ assert.sameValue(`${ hours25.round({
 }) }`, "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]");
+var relativeTo = Temporal.ZonedDateTime.from("2017-01-01T00:00[+04:30]");
 assert.sameValue(`${ hours25.round({
   largestUnit: "days",
   relativeTo
@@ -215,13 +215,13 @@ assert.sameValue(`${ hours25.round({
 // throws on wrong offset for ZonedDateTime relativeTo string
 assert.throws(RangeError, () => d.round({
   smallestUnit: "seconds",
-  relativeTo: "1971-01-01T00:00+02:00[Africa/Monrovia]"
+  relativeTo: "1971-01-01T00:00+02:00[-00:44:30]"
 }));
 
 // 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]"
+  relativeTo: "1971-01-01T00:00-00:45[-00:44:30]"
 }) }`, "P5Y5M5W5DT5H5M5S");
 
 // throws on HH:MM rounded offset for ZonedDateTime relativeTo property bag
@@ -232,7 +232,7 @@ assert.throws(RangeError, () => d.round({
     month: 1,
     day: 1,
     offset: "-00:45",
-    timeZone: "Africa/Monrovia"
+    timeZone: "-00:44:30"
   }
 }));
 
diff --git a/test/staging/Temporal/Duration/old/subtract.js b/test/staging/Temporal/Duration/old/subtract.js
index d9e0b81b6f..bb7ca7660f 100644
--- a/test/staging/Temporal/Duration/old/subtract.js
+++ b/test/staging/Temporal/Duration/old/subtract.js
@@ -15,7 +15,7 @@ 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]");
+var relativeTo = Temporal.ZonedDateTime.from("2017-01-01T00:00[+04:30]");
 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]");
@@ -86,10 +86,10 @@ assert.sameValue(`${ oneDay.subtract(hours24, {
 }) }`, "PT0S");
 
 // throws on wrong offset for ZonedDateTime relativeTo string
-assert.throws(RangeError, () => oneDay.subtract(hours24, { relativeTo: "1971-01-01T00:00+02:00[Africa/Monrovia]" }));
+assert.throws(RangeError, () => oneDay.subtract(hours24, { relativeTo: "1971-01-01T00:00+02:00[-00:44:30]" }));
 
 // 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");
+assert.sameValue(`${ oneDay.subtract(hours24, { relativeTo: "1971-01-01T00:00-00:45[-00:44:30]" }) }`, "PT0S");
 
 // throws on HH:MM rounded offset for ZonedDateTime relativeTo property bag
 assert.throws(RangeError, () => oneDay.subtract(hours24, {
@@ -98,7 +98,7 @@ assert.throws(RangeError, () => oneDay.subtract(hours24, {
     month: 1,
     day: 1,
     offset: "-00:45",
-    timeZone: "Africa/Monrovia"
+    timeZone: "-00:44:30"
   }
 }));
 
diff --git a/test/staging/Temporal/Duration/old/total.js b/test/staging/Temporal/Duration/old/total.js
index e532306503..e3ec3369bd 100644
--- a/test/staging/Temporal/Duration/old/total.js
+++ b/test/staging/Temporal/Duration/old/total.js
@@ -60,14 +60,14 @@ assert.sameValue(s, 0.002031);
 // throws on wrong offset for ZonedDateTime relativeTo string
 assert.throws(RangeError, () => d.total({
   unit: "months",
-  relativeTo: "1971-01-01T00:00+02:00[Africa/Monrovia]"
+  relativeTo: "1971-01-01T00:00+02:00[-00:44:30]"
 }));
 
 // 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]"
+  relativeTo: "1971-01-01T00:00-00:45[-00:44:30]"
 }), 1);
 
 // throws on HH:MM rounded offset for ZonedDateTime relativeTo property bag
@@ -78,7 +78,7 @@ assert.throws(RangeError, () => d.total({
     month: 1,
     day: 1,
     offset: "-00:45",
-    timeZone: "Africa/Monrovia"
+    timeZone: "-00:44:30"
   }
 }));
 
@@ -251,7 +251,7 @@ assert.sameValue(oneDay.total({
 }), 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]");
+var relativeTo = Temporal.ZonedDateTime.from("2017-01-01T00:00[+04:30]");
 assert.sameValue(oneDay.total({
   unit: "hours",
   relativeTo
diff --git a/test/staging/Temporal/Instant/old/toZonedDateTime.js b/test/staging/Temporal/Instant/old/toZonedDateTime.js
index a538f1d4ff..2569beaf0f 100644
--- a/test/staging/Temporal/Instant/old/toZonedDateTime.js
+++ b/test/staging/Temporal/Instant/old/toZonedDateTime.js
@@ -13,22 +13,24 @@ var inst = Temporal.Instant.from("1976-11-18T14:23:30.123456789Z");
 assert.throws(TypeError, () => inst.toZonedDateTime());
 
 // throws with a string parameter
-assert.throws(TypeError, () => inst.toZonedDateTime("Asia/Singapore"));
+assert.throws(TypeError, () => inst.toZonedDateTime("UTC"));
+
+var fakeGregorian = { toString() { return "gregory"; }};
 
 // time zone parameter UTC
 var timeZone = Temporal.TimeZone.from("UTC");
 var zdt = inst.toZonedDateTime({
   timeZone,
-  calendar: "gregory"
+  calendar: fakeGregorian,
 });
 assert.sameValue(inst.epochNanoseconds, zdt.epochNanoseconds);
 assert.sameValue(`${ zdt }`, "1976-11-18T14:23:30.123456789+00:00[UTC][u-ca=gregory]");
 
 // time zone parameter non-UTC
-var timeZone = Temporal.TimeZone.from("America/New_York");
+var timeZone = Temporal.TimeZone.from("-05:00");
 var zdt = inst.toZonedDateTime({
   timeZone,
-  calendar: "gregory"
+  calendar: fakeGregorian,
 });
 assert.sameValue(inst.epochNanoseconds, zdt.epochNanoseconds);
-assert.sameValue(`${ zdt }`, "1976-11-18T09:23:30.123456789-05:00[America/New_York][u-ca=gregory]");
+assert.sameValue(`${ zdt }`, "1976-11-18T09:23:30.123456789-05:00[-05:00][u-ca=gregory]");
diff --git a/test/staging/Temporal/Instant/old/toZonedDateTimeISO.js b/test/staging/Temporal/Instant/old/toZonedDateTimeISO.js
index 61de7de3c4..a5396938b2 100644
--- a/test/staging/Temporal/Instant/old/toZonedDateTimeISO.js
+++ b/test/staging/Temporal/Instant/old/toZonedDateTimeISO.js
@@ -19,7 +19,7 @@ assert.sameValue(inst.epochNanoseconds, zdt.epochNanoseconds);
 assert.sameValue(`${ zdt }`, "1976-11-18T14:23:30.123456789+00:00[UTC]");
 
 // time zone parameter non-UTC
-var tz = Temporal.TimeZone.from("America/New_York");
+var tz = Temporal.TimeZone.from("-05:00");
 var zdt = inst.toZonedDateTimeISO(tz);
 assert.sameValue(inst.epochNanoseconds, zdt.epochNanoseconds);
-assert.sameValue(`${ zdt }`, "1976-11-18T09:23:30.123456789-05:00[America/New_York]");
+assert.sameValue(`${ zdt }`, "1976-11-18T09:23:30.123456789-05:00[-05:00]");
diff --git a/test/staging/Temporal/Regex/old/timezone.js b/test/staging/Temporal/Regex/old/timezone.js
index 93b3b0ba12..13f9b3db5d 100644
--- a/test/staging/Temporal/Regex/old/timezone.js
+++ b/test/staging/Temporal/Regex/old/timezone.js
@@ -17,16 +17,16 @@ function generateTest(dateTimeString, zoneString, expectedName) {
   test(`${ dateTimeString }:30.123456789${ zoneString }`, expectedName);
 }
 [
-  "+01:00",
-  "+01",
-  "+0100",
-  "+01:00:00",
-  "+010000",
-  "+01:00:00.000000000",
-  "+010000.0"
+  "+00:00",
+  "+00",
+  "+0000",
+  "+00:00:00",
+  "+000000",
+  "+00:00:00.000000000",
+  "+000000.0"
 ].forEach(zoneString => {
-  generateTest("1976-11-18T15:23", `${ zoneString }[Europe/Vienna]`, "Europe/Vienna");
-  generateTest("1976-11-18T15:23", `+01:00[${ zoneString }]`, "+01:00");
+  generateTest("1976-11-18T15:23", `${ zoneString }[UTC]`, "UTC");
+  generateTest("1976-11-18T15:23", `+00:00[${ zoneString }]`, "+00:00");
 });
 [
   "-04:00",
@@ -53,7 +53,7 @@ function generateTest(dateTimeString, zoneString, expectedName) {
 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");
+test("1976-11-18T15:23+000000,0[UTC]", "UTC");
 [
   "\u221204:00",
   "\u221204",
@@ -68,11 +68,11 @@ test("1976-11-18T15:23+010000,0[Europe/Vienna]", "Europe/Vienna");
   "1976-11-18T15"
 ].forEach(dateTimeString => {
   [
-    "+01:00",
-    "+01",
-    "+0100",
+    "+00:00",
+    "+00",
+    "+0000",
     ""
-  ].forEach(zoneString => test(`${ dateTimeString }${ zoneString }[Europe/Vienna]`, "Europe/Vienna"));
+  ].forEach(zoneString => test(`${ dateTimeString }${ zoneString }[UTC]`, "UTC"));
   [
     "-04:00",
     "-04",
@@ -97,5 +97,5 @@ 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");
+test("1976-11-18T15:23:30.123456789[UTC][u-ca=iso8601]", "UTC");
+test("1976-11-18T15:23:30.123456789+00:00[UTC][u-ca=iso8601]", "UTC");
diff --git a/test/staging/Temporal/TimeZone/old/getInstantFor.js b/test/staging/Temporal/TimeZone/old/getInstantFor.js
index c86834e771..8eda2c0f84 100644
--- a/test/staging/Temporal/TimeZone/old/getInstantFor.js
+++ b/test/staging/Temporal/TimeZone/old/getInstantFor.js
@@ -10,7 +10,7 @@ features: [Temporal]
 
 // recent date
 var dt = Temporal.PlainDateTime.from("2019-10-29T10:46:38.271986102");
-var tz = Temporal.TimeZone.from("Europe/Amsterdam");
+var tz = Temporal.TimeZone.from("+01:00");
 assert.sameValue(`${ tz.getInstantFor(dt) }`, "2019-10-29T09:46:38.271986102Z");
 
 // year ≤ 99
@@ -31,7 +31,7 @@ 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");
+var tz = Temporal.TimeZone.from("-00:01:15");
 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");
@@ -40,11 +40,11 @@ assert.sameValue(`${ tz.getInstantFor(dt) }`, "0000-02-29T00:01:15Z");
 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");
+var namedTz = Temporal.TimeZone.from("Etc/GMT+12");
 assert.throws(RangeError, () => namedTz.getInstantFor(max));
 
 // casts argument
-var tz = Temporal.TimeZone.from("Europe/Amsterdam");
+var tz = Temporal.TimeZone.from("+01:00");
 assert.sameValue(`${ tz.getInstantFor("2019-10-29T10:46:38.271986102") }`, "2019-10-29T09:46:38.271986102Z");
 assert.sameValue(`${ tz.getInstantFor({
   year: 2019,
diff --git a/test/staging/Temporal/TimeZone/old/getNextTransition.js b/test/staging/Temporal/TimeZone/old/getNextTransition.js
index 8a3e83035c..6aef853367 100644
--- a/test/staging/Temporal/TimeZone/old/getNextTransition.js
+++ b/test/staging/Temporal/TimeZone/old/getNextTransition.js
@@ -7,24 +7,11 @@ 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");
-
+// accepts string as argument
+assert.sameValue(noTransitionTZ.getNextTransition("2019-04-16T21:01Z"), null);
diff --git a/test/staging/Temporal/TimeZone/old/getPossibleInstantsFor.js b/test/staging/Temporal/TimeZone/old/getPossibleInstantsFor.js
index 74fd1ab31c..d8246207b0 100644
--- a/test/staging/Temporal/TimeZone/old/getPossibleInstantsFor.js
+++ b/test/staging/Temporal/TimeZone/old/getPossibleInstantsFor.js
@@ -40,5 +40,5 @@ assert.deepEqual(tz.getPossibleInstantsFor({
 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");
+var tz = Temporal.TimeZone.from("UTC");
 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
index 797ddba382..371f7fc1f5 100644
--- a/test/staging/Temporal/TimeZone/old/getPreviousTransition.js
+++ b/test/staging/Temporal/TimeZone/old/getPreviousTransition.js
@@ -7,18 +7,11 @@ description: Temporal.TimeZone.prototype.getPreviousTransition() works
 features: [Temporal]
 ---*/
 
-var london = Temporal.TimeZone.from("Europe/London");
+var utc = Temporal.TimeZone.from("UTC");
 
-// 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");
+// no transitions without a TZDB
+var instant = Temporal.Instant.from("2020-06-11T21:01Z");
+assert.sameValue(utc.getPreviousTransition(instant), null);
 
-// 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");
+// accepts string as argument
+assert.sameValue(utc.getPreviousTransition("2020-06-11T21:01Z"), null);
diff --git a/test/staging/Temporal/UserCalendar/old/trivial-protocol-implementation.js b/test/staging/Temporal/UserCalendar/old/trivial-protocol-implementation.js
index 73886177cd..514d846acd 100644
--- a/test/staging/Temporal/UserCalendar/old/trivial-protocol-implementation.js
+++ b/test/staging/Temporal/UserCalendar/old/trivial-protocol-implementation.js
@@ -114,7 +114,7 @@ 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]"));
+assert.throws(RangeError, () => Temporal.Calendar.from("2020-06-05T09:34-00:00[UTC][u-ca=decimal]"));
 
 // Temporal.PlainDate.from()
 assert.sameValue(`${ date }`, "2020-06-05[u-ca=decimal]")
diff --git a/test/staging/Temporal/UserCalendar/old/trivial-subclass.js b/test/staging/Temporal/UserCalendar/old/trivial-subclass.js
index 3cac34d5f1..e123c4f026 100644
--- a/test/staging/Temporal/UserCalendar/old/trivial-subclass.js
+++ b/test/staging/Temporal/UserCalendar/old/trivial-subclass.js
@@ -82,7 +82,7 @@ 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]"));
+assert.throws(RangeError, () => Temporal.Calendar.from("2020-06-05T09:34-00:00[UTC][u-ca=two-based]"));
 
 // Temporal.PlainDate.from()
 assert.sameValue(`${ date }`, "2020-04-05[u-ca=two-based]")
diff --git a/test/staging/Temporal/UserTimezone/old/subminute-offset.js b/test/staging/Temporal/UserTimezone/old/subminute-offset.js
index eb277f085c..20d4d34ee3 100644
--- a/test/staging/Temporal/UserTimezone/old/subminute-offset.js
+++ b/test/staging/Temporal/UserTimezone/old/subminute-offset.js
@@ -47,8 +47,9 @@ assert.throws(RangeError, () => Temporal.TimeZone.from("2020-05-26T16:02:46.2511
 assert.sameValue(obj.getOffsetStringFor(inst), "-00:00:01.111111111")
 
 // converts to DateTime
+var fakeGregorian = { toString() { return "gregory"; }};
 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]");
+assert.sameValue(`${ obj.getPlainDateTimeFor(inst, fakeGregorian) }`, "1969-12-31T23:59:58.888888889[u-ca=gregory]");
 
 // converts to Instant
 assert.sameValue(`${ obj.getInstantFor(dt) }`, "1976-11-18T15:23:31.2345679Z");
@@ -71,7 +72,7 @@ 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.plainDateTime(fakeGregorian, obj) instanceof Temporal.PlainDateTime);
 assert(Temporal.Now.plainDateISO(obj) instanceof Temporal.PlainDate);
-assert(Temporal.Now.plainDate("gregory", obj) instanceof Temporal.PlainDate);
+assert(Temporal.Now.plainDate(fakeGregorian, 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
index 17be9197c1..c4059ad3b2 100644
--- a/test/staging/Temporal/UserTimezone/old/trivial-protocol.js
+++ b/test/staging/Temporal/UserTimezone/old/trivial-protocol.js
@@ -32,8 +32,9 @@ 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
+var fakeGregorian = { toString() { return "gregory"; }};
 assert(Temporal.Now.plainDateTimeISO(obj) instanceof Temporal.PlainDateTime);
-assert(Temporal.Now.plainDateTime("gregory", obj) instanceof Temporal.PlainDateTime);
+assert(Temporal.Now.plainDateTime(fakeGregorian, obj) instanceof Temporal.PlainDateTime);
 assert(Temporal.Now.plainDateISO(obj) instanceof Temporal.PlainDate);
-assert(Temporal.Now.plainDate("gregory", obj) instanceof Temporal.PlainDate);
+assert(Temporal.Now.plainDate(fakeGregorian, 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
index 7086456c70..7e536bbebc 100644
--- a/test/staging/Temporal/UserTimezone/old/trivial-subclass.js
+++ b/test/staging/Temporal/UserTimezone/old/trivial-subclass.js
@@ -85,8 +85,9 @@ assert.throws(RangeError, () => Temporal.TimeZone.from("2020-05-26T16:02:46.2511
 assert.sameValue(obj.getOffsetStringFor(inst), "+00:00")
 
 // converts to DateTime
+var fakeGregorian = { toString() { return "gregory"; }};
 assert.sameValue(`${ obj.getPlainDateTimeFor(inst) }`, "1970-01-01T00:00:00");
-assert.sameValue(`${ obj.getPlainDateTimeFor(inst, "gregory") }`, "1970-01-01T00:00:00[u-ca=gregory]");
+assert.sameValue(`${ obj.getPlainDateTimeFor(inst, fakeGregorian) }`, "1970-01-01T00:00:00[u-ca=gregory]");
 
 // converts to Instant
 assert.sameValue(`${ obj.getInstantFor(dt) }`, "1976-11-18T15:23:30.123456789Z");
@@ -109,7 +110,7 @@ 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.plainDateTime(fakeGregorian, obj) instanceof Temporal.PlainDateTime);
 assert(Temporal.Now.plainDateISO(obj) instanceof Temporal.PlainDate);
-assert(Temporal.Now.plainDate("gregory", obj) instanceof Temporal.PlainDate);
+assert(Temporal.Now.plainDate(fakeGregorian, 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
index 6190e1b6cb..22f8e68e4f 100644
--- a/test/staging/Temporal/ZonedDateTime/old/add.js
+++ b/test/staging/Temporal/ZonedDateTime/old/add.js
@@ -36,15 +36,15 @@ 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]");
+var jan31 = Temporal.ZonedDateTime.from("2020-01-31T15:00-08:00[-08:00]");
 
 // 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]");
+assert.sameValue(`${ jan31.add({ months: 1 }) }`, "2020-02-29T15:00:00-08:00[-08:00]");
+assert.sameValue(`${ jan31.add({ months: 1 }, { overflow: "constrain" }) }`, "2020-02-29T15:00:00-08:00[-08:00]");
 
 // 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]");
+assert.sameValue(`${ jan31.add({ minutes: -30 }) }`, "2020-01-31T14:30:00-08:00[-08:00]");
+assert.sameValue(`${ jan31.add({ seconds: -30 }) }`, "2020-01-31T14:59:30-08:00[-08:00]");
 
 // 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
index 023d677c9c..209af7e262 100644
--- a/test/staging/Temporal/ZonedDateTime/old/compare.js
+++ b/test/staging/Temporal/ZonedDateTime/old/compare.js
@@ -7,8 +7,8 @@ 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]");
+var zdt1 = Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456789+01:00[+01:00]");
+var zdt2 = Temporal.ZonedDateTime.from("2019-10-29T10:46:38.271986102+01:00[+01:00]");
 
 // equal
 assert.sameValue(Temporal.ZonedDateTime.compare(zdt1, zdt1), 0)
@@ -25,9 +25,9 @@ assert.sameValue(Temporal.ZonedDateTime.compare({
   month: 11,
   day: 18,
   hour: 15,
-  timeZone: "Europe/Vienna"
+  timeZone: "+01:00"
 }, zdt2), -1);
-assert.sameValue(Temporal.ZonedDateTime.compare("1976-11-18T15:23:30.123456789+01:00[Europe/Vienna]", zdt2), -1);
+assert.sameValue(Temporal.ZonedDateTime.compare("1976-11-18T15:23:30.123456789+01:00[+01:00]", zdt2), -1);
 
 // casts second argument
 assert.sameValue(Temporal.ZonedDateTime.compare(zdt1, {
@@ -35,31 +35,31 @@ assert.sameValue(Temporal.ZonedDateTime.compare(zdt1, {
   month: 10,
   day: 29,
   hour: 10,
-  timeZone: "Europe/Vienna"
+  timeZone: "+01:00"
 }), -1);
-assert.sameValue(Temporal.ZonedDateTime.compare(zdt1, "2019-10-29T10:46:38.271986102+01:00[Europe/Vienna]"), -1);
+assert.sameValue(Temporal.ZonedDateTime.compare(zdt1, "2019-10-29T10:46:38.271986102+01:00[+01:00]"), -1);
 
 // object must contain at least the required properties
 assert.sameValue(Temporal.ZonedDateTime.compare({
   year: 1976,
   month: 11,
   day: 18,
-  timeZone: "Europe/Vienna"
+  timeZone: "+01:00"
 }, zdt2), -1);
 assert.throws(TypeError, () => Temporal.ZonedDateTime.compare({
   month: 11,
   day: 18,
-  timeZone: "Europe/Vienna"
+  timeZone: "+01:00"
 }, zdt2));
 assert.throws(TypeError, () => Temporal.ZonedDateTime.compare({
   year: 1976,
   day: 18,
-  timeZone: "Europe/Vienna"
+  timeZone: "+01:00"
 }, zdt2));
 assert.throws(TypeError, () => Temporal.ZonedDateTime.compare({
   year: 1976,
   month: 11,
-  timeZone: "Europe/Vienna"
+  timeZone: "+01:00"
 }, zdt2));
 assert.throws(TypeError, () => Temporal.ZonedDateTime.compare({
   year: 1976,
@@ -71,28 +71,28 @@ assert.throws(TypeError, () => Temporal.ZonedDateTime.compare({
   months: 11,
   days: 19,
   hours: 15,
-  timeZone: "Europe/Vienna"
+  timeZone: "+01:00"
 }, zdt2));
 assert.sameValue(Temporal.ZonedDateTime.compare(zdt1, {
   year: 2019,
   month: 10,
   day: 29,
-  timeZone: "Europe/Vienna"
+  timeZone: "+01:00"
 }), -1);
 assert.throws(TypeError, () => Temporal.ZonedDateTime.compare(zdt1, {
   month: 10,
   day: 29,
-  timeZone: "Europe/Vienna"
+  timeZone: "+01:00"
 }));
 assert.throws(TypeError, () => Temporal.ZonedDateTime.compare(zdt1, {
   year: 2019,
   day: 29,
-  timeZone: "Europe/Vienna"
+  timeZone: "+01:00"
 }));
 assert.throws(TypeError, () => Temporal.ZonedDateTime.compare(zdt1, {
   year: 2019,
   month: 10,
-  timeZone: "Europe/Vienna"
+  timeZone: "+01:00"
 }));
 assert.throws(TypeError, () => Temporal.ZonedDateTime.compare(zdt1, {
   year: 2019,
@@ -104,17 +104,18 @@ assert.throws(TypeError, () => Temporal.ZonedDateTime.compare(zdt1, {
   months: 10,
   days: 29,
   hours: 10,
-  timeZone: "Europe/Vienna"
+  timeZone: "+01:00"
 }));
 
 // disregards time zone IDs if exact times are equal
-assert.sameValue(Temporal.ZonedDateTime.compare(zdt1, zdt1.withTimeZone("Asia/Kolkata")), 0);
+assert.sameValue(Temporal.ZonedDateTime.compare(zdt1, zdt1.withTimeZone("+05:30")), 0);
 
 // disregards calendar IDs if exact times and time zones are equal
-assert.sameValue(Temporal.ZonedDateTime.compare(zdt1, zdt1.withCalendar("japanese")), 0);
+var fakeJapanese = { toString() { return "japanese"; }};
+assert.sameValue(Temporal.ZonedDateTime.compare(zdt1, zdt1.withCalendar(fakeJapanese)), 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]");
+var clockBefore = Temporal.ZonedDateTime.from("1999-12-31T23:30-08:00[-08:00]");
+var clockAfter = Temporal.ZonedDateTime.from("2000-01-01T01:30-04:00[-04:00]");
 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
index fae241a403..24a486ce36 100644
--- a/test/staging/Temporal/ZonedDateTime/old/construction-and-properties.js
+++ b/test/staging/Temporal/ZonedDateTime/old/construction-and-properties.js
@@ -7,7 +7,7 @@ description: Construction and properties
 features: [Temporal]
 ---*/
 
-var tz = new Temporal.TimeZone("America/Los_Angeles");
+var tz = new Temporal.TimeZone("-08:00");
 var epochMillis = Date.UTC(1976, 10, 18, 15, 23, 30, 123);
 var epochNanos = BigInt(epochMillis) * BigInt(1000000) + BigInt(456789);
 
@@ -50,10 +50,29 @@ 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"
+// Temporal.ZonedDateTime with non-UTC time zone and non-ISO calendar
+// can be constructed
+var fakeGregorian = {
+  era() { return "ce"; },
+  year(date) { return date.withCalendar("iso8601").year; },
+  month(date) { return date.withCalendar("iso8601").month; },
+  monthCode(date) { return date.withCalendar("iso8601").monthCode; },
+  day(date) { return date.withCalendar("iso8601").day; },
+  dayOfWeek(date) { return date.withCalendar("iso8601").dayOfWeek; },
+  dayOfYear(date) { return date.withCalendar("iso8601").dayOfYear; },
+  weekOfYear(date) { return date.withCalendar("iso8601").weekOfYear; },
+  daysInWeek(date) { return date.withCalendar("iso8601").daysInWeek; },
+  daysInMonth(date) { return date.withCalendar("iso8601").daysInMonth; },
+  daysInYear(date) { return date.withCalendar("iso8601").daysInYear; },
+  monthsInYear(date) { return date.withCalendar("iso8601").monthsInYear; },
+  inLeapYear(date) { return date.withCalendar("iso8601").inLeapYear; },
+  toString() { return "gregory"; },
+};
+var fakeVienna = {
+  getOffsetNanosecondsFor() { return 3600_000_000_000; },
+  toString() { return "Europe/Vienna"; },
+}
+var zdt = new Temporal.ZonedDateTime(epochNanos, fakeVienna, fakeGregorian);
 assert(zdt instanceof Temporal.ZonedDateTime);
 assert.sameValue(typeof zdt, "object");
 
diff --git a/test/staging/Temporal/ZonedDateTime/old/date-time-hours-overflow.js b/test/staging/Temporal/ZonedDateTime/old/date-time-hours-overflow.js
index c8cc2f9261..bacd181a83 100644
--- a/test/staging/Temporal/ZonedDateTime/old/date-time-hours-overflow.js
+++ b/test/staging/Temporal/ZonedDateTime/old/date-time-hours-overflow.js
@@ -9,15 +9,15 @@ features: [Temporal]
 
 
 // subtract result
-var later = Temporal.ZonedDateTime.from("2019-10-29T10:46:38.271986102-03:00[America/Santiago]");
+var later = Temporal.ZonedDateTime.from("2019-10-29T10:46:38.271986102-03:00[-03:00]");
 var earlier = later.subtract({ hours: 12 });
-assert.sameValue(`${ earlier }`, "2019-10-28T22:46:38.271986102-03:00[America/Santiago]");
+assert.sameValue(`${ earlier }`, "2019-10-28T22:46:38.271986102-03:00[-03:00]");
 
 // add result
-var earlier = Temporal.ZonedDateTime.from("2020-05-31T23:12:38.271986102-04:00[America/Santiago]");
+var earlier = Temporal.ZonedDateTime.from("2020-05-31T23:12:38.271986102-04:00[-04:00]");
 var later = earlier.add({ hours: 2 });
-assert.sameValue(`${ later }`, "2020-06-01T01:12:38.271986102-04:00[America/Santiago]");
+assert.sameValue(`${ later }`, "2020-06-01T01:12:38.271986102-04:00[-04:00]");
 
 // 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]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("2019-10-29T10:46:38.271986102-03:00[-03:00]").add({ hours: -12 }) }`, "2019-10-28T22:46:38.271986102-03:00[-03:00]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("2020-05-31T23:12:38.271986102-04:00[-04:00]").subtract({ hours: -2 }) }`, "2020-06-01T01:12:38.271986102-04:00[-04:00]");
diff --git a/test/staging/Temporal/ZonedDateTime/old/dst-math.js b/test/staging/Temporal/ZonedDateTime/old/dst-math.js
index 07eca2e1d6..5ae8055303 100644
--- a/test/staging/Temporal/ZonedDateTime/old/dst-math.js
+++ b/test/staging/Temporal/ZonedDateTime/old/dst-math.js
@@ -243,8 +243,8 @@ 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 start = Temporal.ZonedDateTime.from("2020-01-01T00:00-08:00[-08:00]");
+var end = Temporal.ZonedDateTime.from("2020-01-03T23:59-08:00[-08:00]");
 var diff = start.until(end, {
   largestUnit: "days",
   smallestUnit: "hours",
@@ -253,8 +253,8 @@ var diff = start.until(end, {
 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 start = Temporal.ZonedDateTime.from("2020-01-01T00:00-08:00[-08:00]");
+var end = Temporal.ZonedDateTime.from("2020-01-03T23:59-08:00[-08:00]");
 var diff = end.until(start, {
   largestUnit: "days",
   smallestUnit: "hours",
diff --git a/test/staging/Temporal/ZonedDateTime/old/equals.js b/test/staging/Temporal/ZonedDateTime/old/equals.js
index 8f88c5f164..c54608ff91 100644
--- a/test/staging/Temporal/ZonedDateTime/old/equals.js
+++ b/test/staging/Temporal/ZonedDateTime/old/equals.js
@@ -7,12 +7,25 @@ description: Temporal.ZonedDateTime.prototype.equals()
 features: [Temporal]
 ---*/
 
-var tz = Temporal.TimeZone.from("America/New_York");
-var cal = Temporal.Calendar.from("gregory");
+var tz = {
+  getPossibleInstantsFor(pdt) { return Temporal.TimeZone.from("-05:00").getPossibleInstantsFor(pdt); },
+  toString() { return "America/New_York"; },
+};
+var cal = {
+  dateFromFields(...args) { return Temporal.Calendar.from("iso8601").dateFromFields(...args); },
+  toString() { return "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]");
+var zdt2 = Temporal.ZonedDateTime.from({
+  year: 1969,
+  month: 12,
+  day: 31,
+  hour: 19,
+  timeZone: tz,
+  calendar: cal,
+});
 assert(zdt.equals(zdt2));
 assert(zdt2.equals(zdt));
 
@@ -21,7 +34,7 @@ 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);
+var zdt2 = new Temporal.ZonedDateTime(0n, "UTC", cal);
 assert(!zdt.equals(zdt2));
 
 // different calendar not equal
@@ -29,14 +42,14 @@ 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"
+var instance = new Temporal.ZonedDateTime(0n, "UTC", "iso8601");
+assert(instance.equals("1970-01-01T00:00+00:00[UTC][u-ca=iso8601]"));
+assert(instance.equals({
+  year: 1970,
+  month: 1,
+  day: 1,
+  timeZone: "UTC",
+  calendar: "iso8601",
 }));
 
 // at least the required properties must be present
@@ -44,22 +57,22 @@ assert(!zdt.equals({
   year: 1969,
   month: 12,
   day: 31,
-  timeZone: "America/New_York"
+  timeZone: tz
 }));
 assert.throws(TypeError, () => zdt.equals({
   month: 12,
   day: 31,
-  timeZone: "America/New_York"
+  timeZone: tz
 }));
 assert.throws(TypeError, () => zdt.equals({
   year: 1969,
   day: 31,
-  timeZone: "America/New_York"
+  timeZone: tz
 }));
 assert.throws(TypeError, () => zdt.equals({
   year: 1969,
   month: 12,
-  timeZone: "America/New_York"
+  timeZone: tz
 }));
 assert.throws(TypeError, () => zdt.equals({
   year: 1969,
@@ -70,6 +83,6 @@ assert.throws(TypeError, () => zdt.equals({
   years: 1969,
   months: 12,
   days: 31,
-  timeZone: "America/New_York",
+  timeZone: tz,
   calendarName: "gregory"
 }));
diff --git a/test/staging/Temporal/ZonedDateTime/old/order-of-operations.js b/test/staging/Temporal/ZonedDateTime/old/order-of-operations.js
index c1b7230ae3..aabc352b6a 100644
--- a/test/staging/Temporal/ZonedDateTime/old/order-of-operations.js
+++ b/test/staging/Temporal/ZonedDateTime/old/order-of-operations.js
@@ -17,29 +17,29 @@ var breakoutUnits = (op, zdt, d, options) => zdt[op]({ years: d.years }, options
 }, options);
 
 // order of operations: add / none
-var zdt = Temporal.ZonedDateTime.from("2020-01-31T00:00-08:00[America/Los_Angeles]");
+var zdt = Temporal.ZonedDateTime.from("2020-01-31T00:00-08:00[-08:00]");
 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(result.toString(), "2020-03-01T00:00:00-08:00[-08:00]");
 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 zdt = Temporal.ZonedDateTime.from("2020-01-31T00:00-08:00[-08:00]");
 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(result.toString(), "2020-03-01T00:00:00-08:00[-08:00]");
 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 zdt = Temporal.ZonedDateTime.from("2020-01-31T00:00-08:00[-08:00]");
 var d = Temporal.Duration.from({
   months: 1,
   days: 1
@@ -48,29 +48,29 @@ 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 zdt = Temporal.ZonedDateTime.from("2020-03-31T00:00-08:00[-08:00]");
 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(result.toString(), "2020-02-28T00:00:00-08:00[-08:00]");
 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 zdt = Temporal.ZonedDateTime.from("2020-03-31T00:00-08:00[-08:00]");
 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(result.toString(), "2020-02-28T00:00:00-08:00[-08:00]");
 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 zdt = Temporal.ZonedDateTime.from("2020-03-31T00:00-08:00[-08:00]");
 var d = Temporal.Duration.from({
   months: 1,
   days: 1
diff --git a/test/staging/Temporal/ZonedDateTime/old/property-bags.js b/test/staging/Temporal/ZonedDateTime/old/property-bags.js
index b319f7f87b..7c50d41ac9 100644
--- a/test/staging/Temporal/ZonedDateTime/old/property-bags.js
+++ b/test/staging/Temporal/ZonedDateTime/old/property-bags.js
@@ -7,7 +7,7 @@ description: property bags
 features: [Temporal]
 ---*/
 
-var lagos = Temporal.TimeZone.from("Africa/Lagos");
+var lagos = Temporal.TimeZone.from("+01:00");
 
 // can be constructed with monthCode and without month
 assert.sameValue(`${ Temporal.ZonedDateTime.from({
@@ -15,7 +15,7 @@ assert.sameValue(`${ Temporal.ZonedDateTime.from({
   monthCode: "M11",
   day: 18,
   timeZone: lagos
-}) }`, "1976-11-18T00:00:00+01:00[Africa/Lagos]");
+}) }`, "1976-11-18T00:00:00+01:00[+01:00]");
 
 // can be constructed with month and without monthCode
 assert.sameValue(`${ Temporal.ZonedDateTime.from({
@@ -23,7 +23,7 @@ assert.sameValue(`${ Temporal.ZonedDateTime.from({
   month: 11,
   day: 18,
   timeZone: lagos
-}) }`, "1976-11-18T00:00:00+01:00[Africa/Lagos]");
+}) }`, "1976-11-18T00:00:00+01:00[+01:00]");
 
 // month and monthCode must agree
 assert.throws(RangeError, () => Temporal.ZonedDateTime.from({
@@ -53,7 +53,7 @@ assert.sameValue(`${ Temporal.ZonedDateTime.from({
   day: 18,
   timeZone: lagos
 }, () => {
-}) }`, "1976-11-18T00:00:00+01:00[Africa/Lagos]");
+}) }`, "1976-11-18T00:00:00+01:00[+01:00]");
 
 // object must contain at least the required correctly-spelled properties
 assert.throws(TypeError, () => Temporal.ZonedDateTime.from({
@@ -70,7 +70,7 @@ assert.sameValue(`${ Temporal.ZonedDateTime.from({
   day: 18,
   timeZone: lagos,
   hours: 12
-}) }`, "1976-11-18T00:00:00+01:00[Africa/Lagos]");
+}) }`, "1976-11-18T00:00:00+01:00[+01:00]");
 
 // casts offset property
 var zdt = Temporal.ZonedDateTime.from({
@@ -90,12 +90,12 @@ var bad = {
   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]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(bad) }`, "2019-01-31T00:00:00+01:00[+01:00]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from(bad, { overflow: "constrain" }) }`, "2019-01-31T00:00:00+01:00[+01:00]");
 
 // Offset options
 
-// { offset: 'reject' } throws if offset does not match offset time zone 
+// { offset: 'reject' } throws if offset does not match offset time zone
 var obj = {
   year: 2020,
   month: 3,
@@ -107,14 +107,14 @@ var obj = {
 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 
+// { 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"
+  timeZone: "UTC"
 };
 assert.throws(RangeError, () => Temporal.ZonedDateTime.from(obj));
 assert.throws(RangeError, () => Temporal.ZonedDateTime.from(obj, { offset: "reject" }));
@@ -266,17 +266,17 @@ assert.throws(RangeError, () => Temporal.ZonedDateTime.from(obj, {
   3,
   null
 ].forEach(disambiguation => {
-  assert.throws(RangeError, () => Temporal.ZonedDateTime.from("2020-11-01T04:00[America/Los_Angeles]", { disambiguation }));
+  assert.throws(RangeError, () => Temporal.ZonedDateTime.from("2020-11-01T04:00[UTC]", { disambiguation }));
 });
 
 // sub-minute time zone offsets
 
-// does not truncate offset property to minutes 
+// does not truncate offset property to minutes
 var zdt = Temporal.ZonedDateTime.from({
   year: 1971,
   month: 1,
   day: 1,
   hour: 12,
-  timeZone: "Africa/Monrovia"
+  timeZone: "-00:44:30"
 });
 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
index eda153a4da..a3cf4eeaa7 100644
--- a/test/staging/Temporal/ZonedDateTime/old/reversibility-of-differences.js
+++ b/test/staging/Temporal/ZonedDateTime/old/reversibility-of-differences.js
@@ -7,8 +7,8 @@ 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]");
+var earlier = Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456789-03:00[-03:00]");
+var later = Temporal.ZonedDateTime.from("2019-10-29T10:46:38.271986102-03:00[-03:00]");
 [
   "hours",
   "minutes",
diff --git a/test/staging/Temporal/ZonedDateTime/old/round.js b/test/staging/Temporal/ZonedDateTime/old/round.js
index 03c9fee55e..fb05a5065a 100644
--- a/test/staging/Temporal/ZonedDateTime/old/round.js
+++ b/test/staging/Temporal/ZonedDateTime/old/round.js
@@ -7,7 +7,7 @@ description: Temporal.ZonedDateTime.prototype.round()
 features: [Temporal]
 ---*/
 
-var zdt = Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456789+01:00[Europe/Vienna]");
+var zdt = Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456789+01:00[+01:00]");
 
 // throws without parameter
 assert.throws(TypeError, () => zdt.round());
@@ -37,43 +37,43 @@ assert.throws(RangeError, () => zdt.round({
 assert.sameValue(`${ zdt.round({
   smallestUnit: "hour",
   roundingIncrement: 4
-}) }`, "1976-11-18T16:00:00+01:00[Europe/Vienna]");
+}) }`, "1976-11-18T16:00:00+01:00[+01:00]");
 
 // rounds to an increment of minutes
 assert.sameValue(`${ zdt.round({
   smallestUnit: "minute",
   roundingIncrement: 15
-}) }`, "1976-11-18T15:30:00+01:00[Europe/Vienna]");
+}) }`, "1976-11-18T15:30:00+01:00[+01:00]");
 
 // rounds to an increment of seconds
 assert.sameValue(`${ zdt.round({
   smallestUnit: "second",
   roundingIncrement: 30
-}) }`, "1976-11-18T15:23:30+01:00[Europe/Vienna]");
+}) }`, "1976-11-18T15:23:30+01:00[+01:00]");
 
 // rounds to an increment of milliseconds
 assert.sameValue(`${ zdt.round({
   smallestUnit: "millisecond",
   roundingIncrement: 10
-}) }`, "1976-11-18T15:23:30.12+01:00[Europe/Vienna]");
+}) }`, "1976-11-18T15:23:30.12+01:00[+01:00]");
 
 // rounds to an increment of microseconds
 assert.sameValue(`${ zdt.round({
   smallestUnit: "microsecond",
   roundingIncrement: 10
-}) }`, "1976-11-18T15:23:30.12346+01:00[Europe/Vienna]");
+}) }`, "1976-11-18T15:23:30.12346+01:00[+01:00]");
 
 // rounds to an increment of nanoseconds
 assert.sameValue(`${ zdt.round({
   smallestUnit: "nanosecond",
   roundingIncrement: 10
-}) }`, "1976-11-18T15:23:30.12345679+01:00[Europe/Vienna]");
+}) }`, "1976-11-18T15:23:30.12345679+01:00[+01:00]");
 
 // 1 day is a valid increment
 assert.sameValue(`${ zdt.round({
   smallestUnit: "day",
   roundingIncrement: 1
-}) }`, "1976-11-19T00:00:00+01:00[Europe/Vienna]");
+}) }`, "1976-11-19T00:00:00+01:00[+01:00]");
 
 // valid hour increments divide into 24
 var smallestUnit = "hour";
@@ -200,7 +200,7 @@ assert.throws(RangeError, () => zdt.round({
   smallestUnit: "nanosecond",
   roundingIncrement: 1000
 }));
-var bal = Temporal.ZonedDateTime.from("1976-11-18T23:59:59.999999999+01:00[Europe/Vienna]");
+var bal = Temporal.ZonedDateTime.from("1976-11-18T23:59:59.999999999+01:00[+01:00]");
 [
   "day",
   "hour",
@@ -209,7 +209,7 @@ var bal = Temporal.ZonedDateTime.from("1976-11-18T23:59:59.999999999+01:00[Europ
   "millisecond",
   "microsecond"
 ].forEach(smallestUnit => {
-  assert.sameValue(`${ bal.round({ smallestUnit }) }`, "1976-11-19T00:00:00+01:00[Europe/Vienna]");
+  assert.sameValue(`${ bal.round({ smallestUnit }) }`, "1976-11-19T00:00:00+01:00[+01:00]");
 });
 
 // rounds correctly to a 25-hour day
diff --git a/test/staging/Temporal/ZonedDateTime/old/since.js b/test/staging/Temporal/ZonedDateTime/old/since.js
index 68fcea6719..028d4df4e6 100644
--- a/test/staging/Temporal/ZonedDateTime/old/since.js
+++ b/test/staging/Temporal/ZonedDateTime/old/since.js
@@ -7,7 +7,7 @@ description: Temporal.ZonedDateTime.prototype.since()
 features: [Temporal]
 ---*/
 
-var zdt = Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456789+01:00[Europe/Vienna]");
+var zdt = Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456789+01:00[+01:00]");
 
 // zdt.since(earlier) === earlier.until(zdt) with default options
 var earlier = Temporal.ZonedDateTime.from({
@@ -15,7 +15,7 @@ var earlier = Temporal.ZonedDateTime.from({
   month: 3,
   day: 3,
   hour: 18,
-  timeZone: "Europe/Vienna"
+  timeZone: "+01:00"
 });
 assert.sameValue(`${ zdt.since(earlier) }`, `${ earlier.until(zdt) }`);
 
@@ -25,18 +25,18 @@ assert.sameValue(`${ zdt.since({
   month: 10,
   day: 29,
   hour: 10,
-  timeZone: "Europe/Vienna"
+  timeZone: "+01:00"
 }) }`, "-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]");
+assert.sameValue(`${ zdt.since("2019-10-29T10:46:38.271986102+01:00[+01:00]") }`, "-PT376435H23M8.148529313S");
+var feb20 = Temporal.ZonedDateTime.from("2020-02-01T00:00+01:00[+01:00]");
+var feb21 = Temporal.ZonedDateTime.from("2021-02-01T00:00+01:00[+01:00]");
 
 // 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");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("2021-02-01T00:00:00.000000001+01:00[+01:00]").since(feb20) }`, "PT8784H0.000000001S");
+assert.sameValue(`${ feb21.since(Temporal.ZonedDateTime.from("2020-02-01T00:00:00.000000001+01:00[+01:00]")) }`, "PT8783H59M59.999999999S");
 
 // can return lower or higher units
 assert.sameValue(`${ feb21.since(feb20, { largestUnit: "years" }) }`, "P1Y");
@@ -67,8 +67,8 @@ 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]");
+var lastFeb20 = Temporal.ZonedDateTime.from("2020-02-29T00:00+01:00[+01:00]");
+var lastFeb21 = Temporal.ZonedDateTime.from("2021-02-28T00:00+01:00[+01:00]");
 assert.sameValue(`${ lastFeb21.since(lastFeb20) }`, "PT8760H");
 assert.sameValue(`${ lastFeb21.since(lastFeb20, { largestUnit: "months" }) }`, "P11M28D");
 assert.sameValue(`${ lastFeb21.since(lastFeb20, { largestUnit: "years" }) }`, "P11M28D");
@@ -87,11 +87,12 @@ 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"));
+var fakeJapanese = { toString() { return "japanese"; }};
+var zdt2 = new Temporal.ZonedDateTime(0n, "UTC", fakeJapanese);
 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]');
+var earlier = Temporal.ZonedDateTime.from('2019-01-08T09:22:36.123456789+01:00[+01:00]');
+var later = Temporal.ZonedDateTime.from('2021-09-07T13:39:40.987654321+01:00[+01:00]');
 // assumes a different default for largestUnit if smallestUnit is larger than days
 assert.sameValue(`${ later.since(earlier, {
   smallestUnit: "years",
diff --git a/test/staging/Temporal/ZonedDateTime/old/string-parsing.js b/test/staging/Temporal/ZonedDateTime/old/string-parsing.js
index 4b5bbcaac5..0699b8072a 100644
--- a/test/staging/Temporal/ZonedDateTime/old/string-parsing.js
+++ b/test/staging/Temporal/ZonedDateTime/old/string-parsing.js
@@ -7,151 +7,62 @@ 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]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.1-08:00[-08:00]") }`, "1976-11-18T15:23:30.1-08:00[-08:00]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.12-08:00[-08:00]") }`, "1976-11-18T15:23:30.12-08:00[-08:00]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123-08:00[-08:00]") }`, "1976-11-18T15:23:30.123-08:00[-08:00]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.1234-08:00[-08:00]") }`, "1976-11-18T15:23:30.1234-08:00[-08:00]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.12345-08:00[-08:00]") }`, "1976-11-18T15:23:30.12345-08:00[-08:00]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456-08:00[-08:00]") }`, "1976-11-18T15:23:30.123456-08:00[-08:00]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.1234567-08:00[-08:00]") }`, "1976-11-18T15:23:30.1234567-08:00[-08:00]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.12345678-08:00[-08:00]") }`, "1976-11-18T15:23:30.12345678-08:00[-08:00]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456789-08:00[-08:00]") }`, "1976-11-18T15:23:30.123456789-08:00[-08:00]");
 
 // 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]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30,12-08:00[-08:00]") }`, "1976-11-18T15:23:30.12-08:00[-08:00]");
 
 // 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("1976-11-18T15:23:30.12\u221208:00[-08:00]") }`, "1976-11-18T15:23:30.12-08:00[-08:00]");
 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]"));
+  "1976-11-18T152330.1-08:00[-08:00]",
+  "19761118T15:23:30.1-08:00[-08:00]",
+  "1976-11-18T15:23:30.1-0800[-08:00]",
+  "1976-11-18T152330.1-0800[-08:00]",
+  "19761118T15:23:30.1-0800[-08:00]",
+  "19761118T152330.1-08:00[-08:00]",
+  "19761118T152330.1-0800[-08:00]",
+  "+001976-11-18T152330.1-08:00[-08:00]",
+  "+0019761118T15:23:30.1-08:00[-08:00]",
+  "+001976-11-18T15:23:30.1-0800[-08:00]",
+  "+001976-11-18T152330.1-0800[-08:00]",
+  "+0019761118T15:23:30.1-0800[-08:00]",
+  "+0019761118T152330.1-08:00[-08:00]",
+  "+0019761118T152330.1-0800[-08:00]"
+].forEach(input => assert.sameValue(`${ Temporal.ZonedDateTime.from(input) }`, "1976-11-18T15:23:30.1-08:00[-08:00]"));
 
 // 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]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15:23:30-08[-08:00]") }`, "1976-11-18T15:23:30-08:00[-08:00]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("1976-11-18T15-08:00[-08:00]") }`, "1976-11-18T15:00:00-08:00[-08:00]");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("2020-01-01[+09:00]") }`, "2020-01-01T00:00:00+09:00[+09:00]");
 
 // no junk at end of string
-assert.throws(RangeError, () => Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456789-08:00[America/Los_Angeles]junk"))
+assert.throws(RangeError, () => Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456789-08:00[-08:00]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
+assert.throws(RangeError, () => Temporal.ZonedDateTime.from("2020-13-34T24:60[-08:00]", { overflow: "constrain" }));
 
-// { 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: 'reject' } throws if offset does not match IANA time zone
+assert.throws(RangeError, () => Temporal.ZonedDateTime.from("2020-03-08T01:00-04:00[UTC]"));
+assert.throws(RangeError, () => Temporal.ZonedDateTime.from("2020-03-08T01:00-04:00[UTC]", { 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  
+// throw when bad disambiguation
 [
   "",
   "EARLIER",
   "balance"
 ].forEach(disambiguation => {
-  assert.throws(RangeError, () => Temporal.ZonedDateTime.from("2020-11-01T04:00[America/Los_Angeles]", { disambiguation }));
+  assert.throws(RangeError, () => Temporal.ZonedDateTime.from("2020-11-01T04:00[-08:00]", { disambiguation }));
 });
diff --git a/test/staging/Temporal/ZonedDateTime/old/subtract.js b/test/staging/Temporal/ZonedDateTime/old/subtract.js
index 0737765ecb..197dc15f40 100644
--- a/test/staging/Temporal/ZonedDateTime/old/subtract.js
+++ b/test/staging/Temporal/ZonedDateTime/old/subtract.js
@@ -15,15 +15,15 @@ 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]");
+var mar31 = Temporal.ZonedDateTime.from("2020-03-31T15:00+00:00[UTC]");
 
 // 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]");
+assert.sameValue(`${ mar31.subtract({ months: 1 }) }`, "2020-02-29T15:00:00+00:00[UTC]");
+assert.sameValue(`${ mar31.subtract({ months: 1 }, { overflow: "constrain" }) }`, "2020-02-29T15:00:00+00:00[UTC]");
 
 // 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]");
+assert.sameValue(`${ mar31.subtract({ minutes: -30 }) }`, "2020-03-31T15:30:00+00:00[UTC]");
+assert.sameValue(`${ mar31.subtract({ seconds: -30 }) }`, "2020-03-31T15:00:30+00:00[UTC]");
 
 // 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
index c97b4ef1f3..7ca369f843 100644
--- a/test/staging/Temporal/ZonedDateTime/old/toInstant.js
+++ b/test/staging/Temporal/ZonedDateTime/old/toInstant.js
@@ -9,7 +9,7 @@ features: [Temporal]
 
 
 // recent date
-var zdt = Temporal.ZonedDateTime.from("2019-10-29T10:46:38.271986102+01:00[Europe/Amsterdam]");
+var zdt = Temporal.ZonedDateTime.from("2019-10-29T10:46:38.271986102+01:00[+01:00]");
 assert.sameValue(`${ zdt.toInstant() }`, "2019-10-29T09:46:38.271986102Z");
 
 // year ≤ 99
@@ -27,7 +27,7 @@ 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]");
+var zdt = Temporal.ZonedDateTime.from("0000-02-29T00:00-00:01:15[-00:01:15]");
 assert.sameValue(`${ zdt.toInstant() }`, "0000-02-29T00:01:15Z");
-zdt = Temporal.ZonedDateTime.from("+000000-02-29T00:00-00:01:15[Europe/London]");
+zdt = Temporal.ZonedDateTime.from("+000000-02-29T00:00-00:01:15[-00:01:15]");
 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
index 4e966057fb..4c465aebcb 100644
--- a/test/staging/Temporal/ZonedDateTime/old/toPlainDate.js
+++ b/test/staging/Temporal/ZonedDateTime/old/toPlainDate.js
@@ -7,15 +7,16 @@ description: Temporal.ZonedDateTime.prototype.toPlainDate()
 features: [Temporal]
 ---*/
 
-var tz = new Temporal.TimeZone("America/Los_Angeles");
+var tz = new Temporal.TimeZone("-07:00");
 
 // works
 var zdt = Temporal.Instant.from("2019-10-29T09:46:38.271986102Z").toZonedDateTimeISO(tz);
 assert.sameValue(`${ zdt.toPlainDate() }`, "2019-10-29");
 
 // preserves the calendar
+const fakeGregorian = { toString() { return "gregory" }};
 var zdt = Temporal.Instant.from("2019-10-29T09:46:38.271986102Z").toZonedDateTime({
   timeZone: tz,
-  calendar: "gregory"
+  calendar: fakeGregorian
 });
-assert.sameValue(zdt.toPlainDate().calendar.id, "gregory");
+assert.sameValue(zdt.toPlainDate().calendar, fakeGregorian);
diff --git a/test/staging/Temporal/ZonedDateTime/old/toPlainMonthDay.js b/test/staging/Temporal/ZonedDateTime/old/toPlainMonthDay.js
index 3869d2c4cb..34720cf70a 100644
--- a/test/staging/Temporal/ZonedDateTime/old/toPlainMonthDay.js
+++ b/test/staging/Temporal/ZonedDateTime/old/toPlainMonthDay.js
@@ -7,15 +7,25 @@ description: Temporal.ZonedDateTime.prototype.toPlainMonthDay()
 features: [Temporal]
 ---*/
 
-var tz = new Temporal.TimeZone("America/Los_Angeles");
+var tz = new Temporal.TimeZone("-08:00");
 
 // works
 var zdt = Temporal.Instant.from("2019-10-29T09:46:38.271986102Z").toZonedDateTimeISO(tz);
 assert.sameValue(`${ zdt.toPlainMonthDay() }`, "10-29");
 
 // preserves the calendar
+var fakeGregorian = {
+  monthDayFromFields(fields) {
+    var md = Temporal.Calendar.from("iso8601").monthDayFromFields(fields);
+    var {isoYear, isoMonth, isoDay} = md.getISOFields();
+    return new Temporal.PlainMonthDay(isoMonth, isoDay, this, isoYear);
+  },
+  monthCode(date) { return date.withCalendar("iso8601").monthCode; },
+  day(date) { return date.withCalendar("iso8601").day; },
+  toString() { return "gregory"; },
+};
 var zdt = Temporal.Instant.from("2019-10-29T09:46:38.271986102Z").toZonedDateTime({
   timeZone: tz,
-  calendar: "gregory"
+  calendar: fakeGregorian
 });
-assert.sameValue(zdt.toPlainMonthDay().calendar.id, "gregory");
+assert.sameValue(zdt.toPlainMonthDay().calendar, fakeGregorian);
diff --git a/test/staging/Temporal/ZonedDateTime/old/toPlainTime.js b/test/staging/Temporal/ZonedDateTime/old/toPlainTime.js
index b899be5d9f..8e95119cc5 100644
--- a/test/staging/Temporal/ZonedDateTime/old/toPlainTime.js
+++ b/test/staging/Temporal/ZonedDateTime/old/toPlainTime.js
@@ -7,7 +7,7 @@ description: Temporal.ZonedDateTime.prototype.toPlainTime()
 features: [Temporal]
 ---*/
 
-var tz = new Temporal.TimeZone("America/Los_Angeles");
+var tz = new Temporal.TimeZone("-07:00");
 
 // works
 var zdt = Temporal.Instant.from("2019-10-29T09:46:38.271986102Z").toZonedDateTimeISO(tz);
diff --git a/test/staging/Temporal/ZonedDateTime/old/toPlainYearMonth.js b/test/staging/Temporal/ZonedDateTime/old/toPlainYearMonth.js
index c54ed6e8cd..1b848b4bfd 100644
--- a/test/staging/Temporal/ZonedDateTime/old/toPlainYearMonth.js
+++ b/test/staging/Temporal/ZonedDateTime/old/toPlainYearMonth.js
@@ -7,15 +7,25 @@ description: Temporal.ZonedDateTime.prototype.toPlainYearMonth()
 features: [Temporal]
 ---*/
 
-var tz = new Temporal.TimeZone("America/Los_Angeles");
+var tz = new Temporal.TimeZone("-08:00");
 
 // works
 var zdt = Temporal.Instant.from("2019-10-29T09:46:38.271986102Z").toZonedDateTimeISO(tz);
 assert.sameValue(`${ zdt.toPlainYearMonth() }`, "2019-10");
 
 // preserves the calendar
+var fakeGregorian = {
+  yearMonthFromFields(fields) {
+    var ym = Temporal.Calendar.from("iso8601").yearMonthFromFields(fields);
+    var {isoYear, isoMonth, isoDay} = ym.getISOFields();
+    return new Temporal.PlainYearMonth(isoYear, isoMonth, this, isoDay);
+  },
+  year(date) { return date.withCalendar("iso8601").year; },
+  monthCode(date) { return date.withCalendar("iso8601").monthCode; },
+  toString() { return "gregory"; },
+};
 var zdt = Temporal.Instant.from("2019-10-29T09:46:38.271986102Z").toZonedDateTime({
   timeZone: tz,
-  calendar: "gregory"
+  calendar: fakeGregorian
 });
-assert.sameValue(zdt.toPlainYearMonth().calendar.id, "gregory");
+assert.sameValue(zdt.toPlainYearMonth().calendar, fakeGregorian);
diff --git a/test/staging/Temporal/ZonedDateTime/old/toString.js b/test/staging/Temporal/ZonedDateTime/old/toString.js
index 69ef400751..953db10fe9 100644
--- a/test/staging/Temporal/ZonedDateTime/old/toString.js
+++ b/test/staging/Temporal/ZonedDateTime/old/toString.js
@@ -7,17 +7,18 @@ description: Temporal.ZonedDateTime.prototype.toString()
 features: [Temporal]
 ---*/
 
-var zdt1 = Temporal.ZonedDateTime.from("1976-11-18T15:23+01:00[Europe/Vienna]");
+var zdt1 = Temporal.ZonedDateTime.from("1976-11-18T15:23+00:00[UTC]");
+var fakeGregorian = { toString() { return "gregory" }};
 
 // 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]");
+assert.sameValue(zdt1.toString({ calendarName: "auto" }), "1976-11-18T15:23:00+00:00[UTC]");
+assert.sameValue(zdt1.withCalendar(fakeGregorian).toString({ calendarName: "auto" }), "1976-11-18T15:23:00+00:00[UTC][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]");
+assert.sameValue(zdt1.toString({ calendarName: "always" }), "1976-11-18T15:23:00+00:00[UTC][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]");
+assert.sameValue(zdt1.withCalendar(fakeGregorian).toString({ calendarName: "never" }), "1976-11-18T15:23:00+00:00[UTC]");
 
 // throws on invalid calendar
 [
@@ -29,27 +30,27 @@ assert.sameValue(zdt1.withCalendar("gregory").toString({ calendarName: "never" }
 });
 
 // shows time zone if timeZoneName = auto
-assert.sameValue(zdt1.toString({ timeZoneName: "auto" }), "1976-11-18T15:23:00+01:00[Europe/Vienna]");
+assert.sameValue(zdt1.toString({ timeZoneName: "auto" }), "1976-11-18T15:23:00+00:00[UTC]");
 
 // omits time zone if timeZoneName = never
-assert.sameValue(zdt1.toString({ timeZoneName: "never" }), "1976-11-18T15:23:00+01:00");
+assert.sameValue(zdt1.toString({ timeZoneName: "never" }), "1976-11-18T15:23:00+00:00");
 
 // shows offset if offset = auto
-assert.sameValue(zdt1.toString({ offset: "auto" }), "1976-11-18T15:23:00+01:00[Europe/Vienna]");
+assert.sameValue(zdt1.toString({ offset: "auto" }), "1976-11-18T15:23:00+00:00[UTC]");
 
 // omits offset if offset = never
-assert.sameValue(zdt1.toString({ offset: "never" }), "1976-11-18T15:23:00[Europe/Vienna]");
+assert.sameValue(zdt1.toString({ offset: "never" }), "1976-11-18T15:23:00[UTC]");
 
 // combinations of calendar, time zone, and offset
-var zdt = zdt1.withCalendar("gregory");
+var zdt = zdt1.withCalendar(fakeGregorian);
 assert.sameValue(zdt.toString({
   timeZoneName: "never",
   calendarName: "never"
-}), "1976-11-18T15:23:00+01:00");
+}), "1976-11-18T15:23:00+00:00");
 assert.sameValue(zdt.toString({
   offset: "never",
   calendarName: "never"
-}), "1976-11-18T15:23:00[Europe/Vienna]");
+}), "1976-11-18T15:23:00[UTC]");
 assert.sameValue(zdt.toString({
   offset: "never",
   timeZoneName: "never"
diff --git a/test/staging/Temporal/ZonedDateTime/old/until.js b/test/staging/Temporal/ZonedDateTime/old/until.js
index 81c37404fd..876af409d2 100644
--- a/test/staging/Temporal/ZonedDateTime/old/until.js
+++ b/test/staging/Temporal/ZonedDateTime/old/until.js
@@ -7,7 +7,7 @@ description: Temporal.ZonedDateTime.prototype.until()
 features: [Temporal]
 ---*/
 
-var zdt = Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456789+01:00[Europe/Vienna]");
+var zdt = Temporal.ZonedDateTime.from("1976-11-18T15:23:30.123456789+01:00[+01:00]");
 
 // zdt.until(later) === later.since(zdt) with default options
 var later = Temporal.ZonedDateTime.from({
@@ -15,7 +15,7 @@ var later = Temporal.ZonedDateTime.from({
   month: 3,
   day: 3,
   hour: 18,
-  timeZone: "Europe/Vienna"
+  timeZone: "+01:00"
 });
 assert.sameValue(`${ zdt.until(later) }`, `${ later.since(zdt) }`);
 
@@ -25,18 +25,18 @@ assert.sameValue(`${ zdt.until({
   month: 10,
   day: 29,
   hour: 10,
-  timeZone: "Europe/Vienna"
+  timeZone: "+01:00"
 }) }`, "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]");
+assert.sameValue(`${ zdt.until("2019-10-29T10:46:38.271986102+01:00[+01:00]") }`, "PT376435H23M8.148529313S");
+var feb20 = Temporal.ZonedDateTime.from("2020-02-01T00:00+01:00[+01:00]");
+var feb21 = Temporal.ZonedDateTime.from("2021-02-01T00:00+01:00[+01:00]");
 
 // 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");
+assert.sameValue(`${ feb20.until(Temporal.ZonedDateTime.from("2021-02-01T00:00:00.000000001+01:00[+01:00]")) }`, "PT8784H0.000000001S");
+assert.sameValue(`${ Temporal.ZonedDateTime.from("2020-02-01T00:00:00.000000001+01:00[+01:00]").until(feb21) }`, "PT8783H59M59.999999999S");
 
 // can return lower or higher units
 assert.sameValue(`${ feb20.until(feb21, { largestUnit: "years" }) }`, "P1Y");
@@ -67,8 +67,8 @@ 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]");
+var lastFeb20 = Temporal.ZonedDateTime.from("2020-02-29T00:00+01:00[+01:00]");
+var lastJan21 = Temporal.ZonedDateTime.from("2021-01-31T00:00+01:00[+01:00]");
 assert.sameValue(`${ lastFeb20.until(lastJan21) }`, "PT8088H");
 assert.sameValue(`${ lastFeb20.until(lastJan21, { largestUnit: "months" }) }`, "P11M2D");
 assert.sameValue(`${ lastFeb20.until(lastJan21, { largestUnit: "years" }) }`, "P11M2D");
@@ -87,11 +87,12 @@ 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"));
+var fakeJapanese = { toString() { return "japanese"; }};
+var zdt2 = new Temporal.ZonedDateTime(0n, "UTC", fakeJapanese);
 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]');
+var earlier = Temporal.ZonedDateTime.from('2019-01-08T09:22:36.123456789+01:00[+01:00]');
+var later = Temporal.ZonedDateTime.from('2021-09-07T13:39:40.987654321+01:00[+01:00]');
 // assumes a different default for largestUnit if smallestUnit is larger than hours
 assert.sameValue(`${ earlier.until(later, {
   smallestUnit: "years",
diff --git a/test/staging/Temporal/ZonedDateTime/old/with.js b/test/staging/Temporal/ZonedDateTime/old/with.js
index 9273b51b10..0b9a7555d4 100644
--- a/test/staging/Temporal/ZonedDateTime/old/with.js
+++ b/test/staging/Temporal/ZonedDateTime/old/with.js
@@ -240,7 +240,7 @@ assert.sameValue(`${ zdt.with({
 // throws if timeZone is included
 assert.throws(TypeError, () => zdt.with({
   month: 2,
-  timeZone: "Asia/Ulaanbaatar"
+  timeZone: "UTC"
 }));
 
 // throws if given a Temporal object with a time zone
@@ -249,7 +249,7 @@ assert.throws(TypeError, () => zdt.with(dstStartDay));
 // throws if calendarName is included
 assert.throws(TypeError, () => zdt.with({
   month: 2,
-  calendar: "japanese"
+  calendar: "iso8601"
 }));
 
 // throws if given a Temporal object with a calendar
diff --git a/test/staging/Temporal/ZonedDateTime/old/withCalendar.js b/test/staging/Temporal/ZonedDateTime/old/withCalendar.js
index e1e5266413..4abf5568d2 100644
--- a/test/staging/Temporal/ZonedDateTime/old/withCalendar.js
+++ b/test/staging/Temporal/ZonedDateTime/old/withCalendar.js
@@ -7,15 +7,15 @@ description: Temporal.ZonedDateTime.prototype.withCalendar()
 features: [Temporal]
 ---*/
 
-var zdt = Temporal.ZonedDateTime.from("2019-11-18T15:23:30.123456789-08:00[America/Los_Angeles]");
+var zdt = Temporal.ZonedDateTime.from("2019-11-18T15:23:30.123456789-08:00[-08:00]");
 
 // 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]");
+var cal = { toString() { return "japanese"; }};
+assert.sameValue(`${ zdt.withCalendar(cal) }`, "2019-11-18T15:23:30.123456789-08:00[-08:00][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");
+var zdt = Temporal.ZonedDateTime.from("2019-11-18T15:23:30.123456789+01:00[+01:00][u-ca=iso8601]");
+var zdt2 = zdt.withCalendar(cal);
 assert.sameValue(zdt.epochNanoseconds, zdt2.epochNanoseconds);
-assert.sameValue(zdt2.calendar.id, "japanese");
-assert.sameValue(zdt2.timeZone.id, "Europe/Madrid");
+assert.sameValue(zdt2.calendar, cal);
+assert.sameValue(zdt2.timeZone.id, "+01:00");
diff --git a/test/staging/Temporal/ZonedDateTime/old/withPlainTime.js b/test/staging/Temporal/ZonedDateTime/old/withPlainTime.js
index 8b7accbf89..c7f14ad9a0 100644
--- a/test/staging/Temporal/ZonedDateTime/old/withPlainTime.js
+++ b/test/staging/Temporal/ZonedDateTime/old/withPlainTime.js
@@ -7,20 +7,20 @@ description: .withPlainTime manipulation
 features: [Temporal]
 ---*/
 
-var zdt = Temporal.ZonedDateTime.from("2015-12-07T03:24:30.000003500[America/Los_Angeles]");
+var zdt = Temporal.ZonedDateTime.from("2015-12-07T03:24:30.000003500[-08:00]");
 
 // withPlainTime({ hour: 10 }) works
-assert.sameValue(`${ zdt.withPlainTime({ hour: 10 }) }`, "2015-12-07T10:00:00-08:00[America/Los_Angeles]");
+assert.sameValue(`${ zdt.withPlainTime({ hour: 10 }) }`, "2015-12-07T10:00:00-08:00[-08:00]");
 
 // 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]");
+assert.sameValue(`${ zdt.withPlainTime(time) }`, "2015-12-07T11:22:00-08:00[-08:00]");
 
 // withPlainTime('12:34') works
-assert.sameValue(`${ zdt.withPlainTime("12:34") }`, "2015-12-07T12:34:00-08:00[America/Los_Angeles]");
+assert.sameValue(`${ zdt.withPlainTime("12:34") }`, "2015-12-07T12:34:00-08:00[-08:00]");
 
 // incorrectly-spelled properties are ignored
 assert.sameValue(`${ zdt.withPlainTime({
   hour: 10,
   seconds: 55
-}) }`, "2015-12-07T10:00:00-08:00[America/Los_Angeles]");
+}) }`, "2015-12-07T10:00:00-08:00[-08:00]");
diff --git a/test/staging/Temporal/ZonedDateTime/old/withTimezone.js b/test/staging/Temporal/ZonedDateTime/old/withTimezone.js
index 8628aacc28..56b7c54cf1 100644
--- a/test/staging/Temporal/ZonedDateTime/old/withTimezone.js
+++ b/test/staging/Temporal/ZonedDateTime/old/withTimezone.js
@@ -7,14 +7,11 @@ 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");
+var fakeGregorian = { toString() { return "gregory"; }};
+var zdt = Temporal.ZonedDateTime.from("2019-11-18T15:23:30.123456789+01:00[+01:00]").withCalendar(fakeGregorian);
+var zdt2 = zdt.withTimeZone("-08:00");
 assert.sameValue(zdt.epochNanoseconds, zdt2.epochNanoseconds);
-assert.sameValue(zdt2.calendar.id, "gregory");
-assert.sameValue(zdt2.timeZone.id, "America/Vancouver");
+assert.sameValue(zdt2.calendar, fakeGregorian);
+assert.sameValue(zdt2.timeZone.id, "-08:00");
 assert.notSameValue(`${ zdt.toPlainDateTime() }`, `${ zdt2.toPlainDateTime() }`);