From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Fri, 19 Apr 2024 02:47:55 +0200
Subject: Adding upstream version 124.0.1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 .../warp/number-tostring-with-base-uppercase.js    | 92 ++++++++++++++++++++++
 1 file changed, 92 insertions(+)
 create mode 100644 js/src/jit-test/tests/warp/number-tostring-with-base-uppercase.js

(limited to 'js/src/jit-test/tests/warp/number-tostring-with-base-uppercase.js')

diff --git a/js/src/jit-test/tests/warp/number-tostring-with-base-uppercase.js b/js/src/jit-test/tests/warp/number-tostring-with-base-uppercase.js
new file mode 100644
index 0000000000..4dd6b182a8
--- /dev/null
+++ b/js/src/jit-test/tests/warp/number-tostring-with-base-uppercase.js
@@ -0,0 +1,92 @@
+// Copy of "warp/number-tostring-with-base.js" with `toUpperCase()` conversion
+// after `Number.prototype.toString(base)`.
+
+function testConstantBaseFastPathTemplate(xs) {
+  assertEq(xs.length, $BASE * $BASE);
+  for (let j = 0; j < 200;) {
+    // The fast path can be used for all integers below |base * base|.
+    for (let i = 0; i < $BASE * $BASE; ++i, ++j) {
+      assertEq(i.toString($BASE).toUpperCase(), xs[i]);
+    }
+  }
+}
+
+// Test when Number.prototype.toString is called with a constant base argument
+// and the fast path for static strings can be used.
+for (let base = 2; base <= 36; ++base) {
+  let fn = Function(`return ${testConstantBaseFastPathTemplate}`.replaceAll("$BASE", base))();
+  let xs = Array.from({length: base * base}, (_, i) => i.toString(base).toUpperCase());
+  for (let i = 0; i < 2; ++i) {
+    fn(xs);
+  }
+}
+
+function testConstantBaseTemplate(xs) {
+  assertEq(xs.length, $BASE * $BASE * 2);
+  for (let j = 0; j < 200;) {
+    // The fast path can only be used for integers below |base * base|.
+    for (let i = 0; i < $BASE * $BASE * 2; ++i, ++j) {
+      assertEq(i.toString($BASE).toUpperCase(), xs[i]);
+    }
+  }
+}
+
+// Test when Number.prototype.toString is called with a constant base argument
+// and the fast path for static strings can't always be used.
+for (let base = 2; base <= 36; ++base) {
+  let fn = Function(`return ${testConstantBaseTemplate}`.replaceAll("$BASE", base))();
+  let xs = Array.from({length: base * base * 2}, (_, i) => i.toString(base).toUpperCase());
+  for (let i = 0; i < 2; ++i) {
+    fn(xs);
+  }
+}
+
+function testVariableBaseFastPathTemplate(xs, ys) {
+  assertEq(ys.length, 2);
+  assertEq(ys[0], ys[1]);
+  let base = ys[0];
+
+  assertEq(xs.length, base * base);
+
+  for (let j = 0; j < 200;) {
+    // The fast path can be used for all integers below |base * base|.
+    for (let i = 0; i < base * base; ++i, ++j) {
+      assertEq(i.toString(ys[i & 1]).toUpperCase(), xs[i]);
+    }
+  }
+}
+
+// Test when Number.prototype.toString is called with a non-constant base argument
+// and the fast path for static strings can be used.
+for (let base = 2; base <= 36; ++base) {
+  let fn = Function(`return ${testVariableBaseFastPathTemplate}`)();
+  let xs = Array.from({length: base * base}, (_, i) => i.toString(base).toUpperCase());
+  for (let i = 0; i < 2; ++i) {
+    fn(xs, [base, base]);
+  }
+}
+
+function testVariableBaseTemplate(xs, ys) {
+  assertEq(ys.length, 2);
+  assertEq(ys[0], ys[1]);
+  let base = ys[0];
+
+  assertEq(xs.length, base * base * 2);
+
+  for (let j = 0; j < 200;) {
+    // The fast path can only be used for integers below |base * base|.
+    for (let i = 0; i < base * base * 2; ++i, ++j) {
+      assertEq(i.toString(ys[i & 1]).toUpperCase(), xs[i]);
+    }
+  }
+}
+
+// Test when Number.prototype.toString is called with a non-constant base argument
+// and the fast path for static strings can't always be used.
+for (let base = 2; base <= 36; ++base) {
+  let fn = Function(`return ${testVariableBaseTemplate}`)();
+  let xs = Array.from({length: base * base * 2}, (_, i) => i.toString(base).toUpperCase());
+  for (let i = 0; i < 2; ++i) {
+    fn(xs, [base, base]);
+  }
+}
-- 
cgit v1.2.3