Thorough tests for all types' string parsers

Snapshot tests for millions of string inputs to each Temporal type's
from() method, covering as many variations of the string format as
possible.

Author: ptomato

polyfill/test/thorough/all.sh

@@ -20,37 +20,45 @@ for test in \
   dateaddition \
   datedifference \
   datemodify \
+  dateparsing \
   dateroundtrip \
   datetimeaddition \
   datetimedifference \
   datetimemodify \
+  datetimeparsing \
   datetimerounding \
   datetimeroundtrip \
   durationaddition \
   durationmodify \
+  durationparsing \
   durationroundtrip \
   durationtotal \
   instantaddition \
   instantdifference \
+  instantparsing \
   instantrounding \
   instantroundtrip \
+  monthdayparsing \
   monthdayrefyear \
   monthdaymodify \
   monthdayroundtrip \
   startofday \
   timeaddition \
   timedifference \
   timemodify \
+  timeparsing \
   timerounding \
   timeroundtrip \
   yearcycle \
   yearmonthaddition \
   yearmonthdifference \
   yearmonthmodify \
+  yearmonthparsing \
   yearmonthroundtrip \
   zonedaddition \
   zoneddifference \
   zonedmodify \
+  zonedparsing \
   zonedrounding \
   zonedroundtrip
 do

polyfill/test/thorough/dateparsing.mjs

@@ -0,0 +1,57 @@
+import {
+  assertTemporalEqual,
+  getProgressBar,
+  parseableAnnotations,
+  parseableDates,
+  parseableNegativeOffsets,
+  parseablePlus1Zones,
+  parseablePositiveOffsets,
+  parseableTimes,
+  parseableZeroOffsets,
+  temporalImpl as T,
+  time
+} from './support.mjs';
+
+const zones = [...parseablePlus1Zones, 'Custom/Vienna'];
+
+const testCases = [];
+
+for (const [dstr, [y, m, d]] of parseableDates) {
+  const expected = new T.PlainDate(y, m, d);
+
+  for (const annotation of parseableAnnotations) {
+    testCases.push([`${dstr}${annotation}`, expected]);
+
+    for (const [tstr] of parseableTimes) {
+      for (const t of ['T', 't', ' ']) {
+        for (const offset of ['', ...parseableZeroOffsets, ...parseableNegativeOffsets, ...parseablePositiveOffsets]) {
+          testCases.push([`${dstr}${t}${tstr}${offset}${annotation}`, expected]);
+        }
+
+        for (const offset of ['', ...parseablePositiveOffsets]) {
+          for (const zone of zones) {
+            testCases.push([`${dstr}${t}${tstr}${offset}[${zone}]${annotation}`, expected]);
+          }
+        }
+      }
+    }
+
+    for (const zone of zones) {
+      testCases.push([`${dstr}[${zone}]${annotation}`, expected]);
+    }
+  }
+}
+
+const total = testCases.length;
+
+await time((start) => {
+  const progress = getProgressBar(start, total);
+
+  for (const [isoString, expected] of testCases) {
+    progress.tick(1, { test: isoString.slice(0, 40) });
+    const actual = T.PlainDate.from(isoString);
+    assertTemporalEqual(actual, expected, isoString);
+  }
+
+  return total;
+});

polyfill/test/thorough/datetimeparsing.mjs

@@ -0,0 +1,60 @@
+import {
+  assertTemporalEqual,
+  getProgressBar,
+  parseableAnnotations,
+  parseableDates,
+  parseableNegativeOffsets,
+  parseablePlus1Zones,
+  parseablePositiveOffsets,
+  parseableTimes,
+  parseableZeroOffsets,
+  temporalImpl as T,
+  time
+} from './support.mjs';
+
+const zones = [...parseablePlus1Zones, 'Custom/Vienna'];
+
+const testCases = [];
+
+for (const [dstr, [y, mon, d]] of parseableDates) {
+  for (const [tstr, [h, min = 0, s = 0, ms = 0, µs = 0, ns = 0]] of parseableTimes) {
+    const expected = new T.PlainDateTime(y, mon, d, h, min, s, ms, µs, ns);
+
+    for (const t of ['T', 't', ' ']) {
+      for (const annotation of parseableAnnotations) {
+        for (const offset of ['', ...parseableZeroOffsets, ...parseableNegativeOffsets, ...parseablePositiveOffsets]) {
+          testCases.push([`${dstr}${t}${tstr}${offset}${annotation}`, expected]);
+        }
+
+        for (const offset of ['', ...parseablePositiveOffsets]) {
+          for (const zone of zones) {
+            testCases.push([`${dstr}${t}${tstr}${offset}[${zone}]${annotation}`, expected]);
+          }
+        }
+      }
+    }
+  }
+
+  const expected = new T.PlainDateTime(y, mon, d);
+  for (const annotation of parseableAnnotations) {
+    testCases.push([`${dstr}${annotation}`, expected]);
+
+    for (const zone of zones) {
+      testCases.push([`${dstr}[${zone}]${annotation}`, expected]);
+    }
+  }
+}
+
+const total = testCases.length;
+
+await time((start) => {
+  const progress = getProgressBar(start, total);
+
+  for (const [isoString, expected] of testCases) {
+    progress.tick(1, { test: isoString.slice(0, 40) });
+    const actual = T.PlainDateTime.from(isoString);
+    assertTemporalEqual(actual, expected, isoString);
+  }
+
+  return total;
+});

polyfill/test/thorough/durationparsing.mjs

@@ -0,0 +1,107 @@
+import { assertDurationsEqual, getProgressBar, time, temporalImpl as T } from './support.mjs';
+
+const day = [
+  ['', {}],
+  ['1Y', { y: 1 }],
+  ['2M', { mon: 2 }],
+  ['4W', { w: 4 }],
+  ['3D', { d: 3 }],
+  ['1Y2M', { y: 1, mon: 2 }],
+  ['1Y4W', { y: 1, w: 4 }],
+  ['1Y3D', { y: 1, d: 3 }],
+  ['2M4W', { mon: 2, w: 4 }],
+  ['2M3D', { mon: 2, d: 3 }],
+  ['4W3D', { w: 4, d: 3 }],
+  ['1Y2M4W', { y: 1, mon: 2, w: 4 }],
+  ['1Y2M3D', { y: 1, mon: 2, d: 3 }],
+  ['1Y4W3D', { y: 1, w: 4, d: 3 }],
+  ['2M4W3D', { mon: 2, w: 4, d: 3 }],
+  ['1Y2M4W3D', { y: 1, mon: 2, w: 4, d: 3 }]
+];
+const times = [
+  ['', {}],
+  ['4H', { h: 4 }],
+  ['5M', { min: 5 }],
+  ['4H5M', { h: 4, min: 5 }]
+];
+const 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.000456S', { µs: 456 }],
+  ['0.000000789S', { ns: 789 }],
+  ['0.123456S', { ms: 123, µs: 456 }],
+  ['0.123000789S', { ms: 123, ns: 789 }],
+  ['0.000456789S', { µs: 456, ns: 789 }],
+  ['0.123456789S', { ms: 123, µs: 456, ns: 789 }]
+];
+for (const [str, expect] of sec) {
+  if (str.includes('.')) sec.push([str.replace('.', ','), expect]);
+}
+
+var tim = sec
+  .reduce((arr, [s, add]) => arr.concat(times.map(([p, expect]) => [`${p}${s}`, { ...expect, ...add }])), [])
+  .slice(1);
+
+const testCases = [];
+
+for (const [str, expectation] of day.slice(1)) {
+  const { y = 0, mon = 0, w = 0, d = 0 } = expectation;
+  const expected = new T.Duration(y, mon, w, d);
+
+  for (const s of [str, str.toLowerCase()]) {
+    for (const p of ['P', 'p']) {
+      testCases.push([`${p}${s}`, expected]);
+    }
+  }
+}
+for (const [str, expectation] of tim) {
+  const { h = 0, min = 0, s = 0, ms = 0, µs = 0, ns = 0 } = expectation;
+  const expected = new T.Duration(0, 0, 0, 0, h, min, s, ms, µs, ns);
+
+  for (const s of [str, str.toLowerCase()]) {
+    for (const p of ['P', 'p']) {
+      for (const t of ['T', 't']) {
+        testCases.push([`${p}${t}${s}`, expected]);
+      }
+    }
+  }
+}
+for (const [dstr, { y = 0, mon = 0, w = 0, d = 0 }] of day) {
+  for (const [tstr, { h = 0, min = 0, s = 0, ms = 0, µs = 0, ns = 0 }] of tim) {
+    const expected = new T.Duration(y, mon, w, d, h, min, s, ms, µs, ns);
+
+    for (const ds of [dstr, dstr.toLowerCase()]) {
+      for (const ts of [tstr, tstr.toLowerCase()]) {
+        for (const p of ['P', 'p']) {
+          for (const t of ['T', 't']) {
+            testCases.push([`${p}${ds}${t}${ts}`, expected]);
+          }
+        }
+      }
+    }
+  }
+}
+
+const total = testCases.length;
+
+await time(async (start) => {
+  const progress = getProgressBar(start, total);
+
+  for (const [isoString, expected] of testCases) {
+    progress.tick(1, { test: isoString });
+    const actual = T.Duration.from(isoString);
+    assertDurationsEqual(actual, expected, isoString);
+  }
+
+  return total;
+});

polyfill/test/thorough/instantparsing.mjs

@@ -0,0 +1,56 @@
+import {
+  assertTemporalEqual,
+  getProgressBar,
+  parseableAnnotations,
+  parseableDates,
+  parseableNegativeOffsets,
+  parseablePlus1Zones,
+  parseablePositiveOffsets,
+  parseableTimes,
+  parseableZeroOffsets,
+  temporalImpl as T,
+  time
+} from './support.mjs';
+
+const testCases = [];
+
+for (const [dstr, [y, mon, d]] of parseableDates) {
+  for (const [tstr, [h, min = 0, s = 0, ms = 0, µs = 0, ns = 0]] of parseableTimes) {
+    const expected = new T.PlainDateTime(y, mon, d, h, min, s, ms, µs, ns);
+    const negOffsetExpected = new T.PlainDateTime(y, mon, d, h + 4, min, s, ms, µs, ns);
+    const posOffsetExpected = new T.PlainDateTime(y, mon, d, h - 1, min, s, ms, µs, ns);
+
+    for (const t of ['T', 't', ' ']) {
+      for (const annotation of parseableAnnotations) {
+        for (const z of ['Z', 'z', ...parseableZeroOffsets]) {
+          testCases.push([`${dstr}${t}${tstr}${z}${annotation}`, expected]);
+        }
+
+        for (const offset of parseableNegativeOffsets) {
+          testCases.push([`${dstr}${t}${tstr}${offset}${annotation}`, negOffsetExpected]);
+        }
+
+        for (const offset of parseablePositiveOffsets) {
+          for (const zone of parseablePlus1Zones) {
+            testCases.push([`${dstr}${t}${tstr}${offset}[${zone}]${annotation}`, posOffsetExpected]);
+          }
+        }
+      }
+    }
+  }
+}
+
+const total = testCases.length;
+
+await time((start) => {
+  const progress = getProgressBar(start, total);
+
+  for (const [isoString, expected] of testCases) {
+    progress.tick(1, { test: isoString.slice(0, 40) });
+    const instant = T.Instant.from(isoString);
+    const datetime = instant.toZonedDateTimeISO('UTC').toPlainDateTime();
+    assertTemporalEqual(datetime, expected, isoString);
+  }
+
+  return total;
+});

polyfill/test/thorough/monthdayparsing.mjs

@@ -0,0 +1,62 @@
+import {
+  assertTemporalEqual,
+  getProgressBar,
+  parseableAnnotations,
+  parseableDates,
+  parseableNegativeOffsets,
+  parseablePlus1Zones,
+  parseablePositiveOffsets,
+  parseableTimes,
+  parseableZeroOffsets,
+  temporalImpl as T,
+  time
+} from './support.mjs';
+
+const zones = [...parseablePlus1Zones, 'Custom/Vienna'];
+
+const testCases = [];
+
+for (const annotation of parseableAnnotations) {
+  for (const [dstr] of parseableDates) {
+    testCases.push(`${dstr}${annotation}`);
+
+    for (const [tstr] of parseableTimes) {
+      for (const t of ['T', 't', ' ']) {
+        for (const offset of ['', ...parseableZeroOffsets, ...parseableNegativeOffsets, ...parseablePositiveOffsets]) {
+          testCases.push(`${dstr}${t}${tstr}${offset}${annotation}`);
+        }
+
+        for (const offset of ['', ...parseablePositiveOffsets]) {
+          for (const zone of zones) {
+            testCases.push(`${dstr}${t}${tstr}${offset}[${zone}]${annotation}`);
+          }
+        }
+      }
+    }
+
+    for (const zone of zones) {
+      testCases.push(`${dstr}[${zone}]${annotation}`);
+    }
+  }
+
+  for (const mdstr of ['11-18', '1118', '--11-18', '--1118']) {
+    for (const zone of zones) {
+      testCases.push(`${mdstr}[${zone}]${annotation}`);
+    }
+  }
+}
+
+const total = testCases.length;
+const expected = new T.PlainMonthDay(11, 18);
+
+await time((start) => {
+  const progress = getProgressBar(start, total);
+
+  for (const isoString of testCases) {
+    progress.tick(1, { test: isoString.slice(0, 40) });
+    const actual = T.PlainMonthDay.from(isoString);
+    assertTemporalEqual(actual, expected, isoString);
+  }
+
+  return total;
+});