From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001
From: Daniel Baumann <daniel.baumann@progress-linux.org>
Date: Sun, 7 Apr 2024 21:33:14 +0200
Subject: Adding upstream version 115.7.0esr.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
---
 js/src/jit-test/tests/ion/divmodself.js | 664 ++++++++++++++++++++++++++++++++
 1 file changed, 664 insertions(+)
 create mode 100644 js/src/jit-test/tests/ion/divmodself.js

(limited to 'js/src/jit-test/tests/ion/divmodself.js')

diff --git a/js/src/jit-test/tests/ion/divmodself.js b/js/src/jit-test/tests/ion/divmodself.js
new file mode 100644
index 0000000000..524d46d022
--- /dev/null
+++ b/js/src/jit-test/tests/ion/divmodself.js
@@ -0,0 +1,664 @@
+// |jit-test| --ion-eager
+
+// bug 944963
+function bug944963(x, y) {
+    (+(xy))(y % y)
+}
+for (var i = 0; i < 10; i++) {
+    try {
+        (function() {
+            bug944963(0, (~Math.fround(-8)))
+        })()
+    } catch (e) {}
+}
+
+// bug 900437
+function bug900437() {
+    var x = 0.0;
+    for (var i = 0; i < 10; i++)
+        -("") >> (x / x);
+}
+bug900437();
+bug900437();
+
+// bug 715460
+function f(x) {
+    var a = x;
+    return a / 10;
+}
+function g(x) {
+    var y = x + 1;
+    return y / y;
+}
+for (var i=0; i<10; i++)
+    assertEq(f(i * 10), i);
+for (var i=0; i<10; i++)
+    assertEq(g(i), 1);
+
+// bug 939893
+function bug939893() {
+    bug_g();
+}
+function bug_g() {
+    bug_h(undefined >>> 0, +undefined);
+}
+function bug_h(x) {
+    Math.max(x ? ((x / x) | 0) : 0);
+}
+for (var a = 0; a < 2; ++a) {
+  bug939893();
+}
+
+// bug 945860
+function bug945860(x) {
+    return (x % x);
+}
+for (var i = 0; i < 2; i++) {
+    try {
+        (function() {
+            assertEq(bug945860(1), 0);
+        })()
+    } catch (e) {}
+}
+
+// Assorted tests.
+
+function sdiv_truncate(y) {
+  return (y / y)|0;
+}
+assertEq(sdiv_truncate(5), 1);
+assertEq(sdiv_truncate(1), 1);
+assertEq(sdiv_truncate(-1), 1);
+assertEq(sdiv_truncate(0), 0);
+assertEq(sdiv_truncate(-0), 0);
+assertEq(sdiv_truncate(1.1), 1);
+assertEq(sdiv_truncate(-1.1), 1);
+assertEq(sdiv_truncate(Infinity), 0);
+assertEq(sdiv_truncate(NaN), 0);
+assertEq(sdiv_truncate(undefined), 0);
+assertEq(sdiv_truncate(null), 0);
+
+function sdiv(y) {
+  return y / y;
+}
+assertEq(sdiv(5), 1);
+assertEq(sdiv(1), 1);
+assertEq(sdiv(-1), 1);
+assertEq(sdiv(0), NaN);
+assertEq(sdiv(-0), NaN);
+assertEq(sdiv(1.1), 1);
+assertEq(sdiv(-1.1), 1);
+assertEq(sdiv(Infinity), NaN);
+assertEq(sdiv(NaN), NaN);
+assertEq(sdiv(undefined), NaN);
+assertEq(sdiv(null), NaN);
+
+function udiv_truncate(y) {
+  var yu = y>>>0;
+  return (yu / yu)|0;
+}
+assertEq(udiv_truncate(5), 1);
+assertEq(udiv_truncate(1), 1);
+assertEq(udiv_truncate(-1), 1);
+assertEq(udiv_truncate(0), 0);
+assertEq(udiv_truncate(-0), 0);
+assertEq(udiv_truncate(1.1), 1);
+assertEq(udiv_truncate(-1.1), 1);
+assertEq(udiv_truncate(Infinity), 0);
+assertEq(udiv_truncate(NaN), 0);
+assertEq(udiv_truncate(undefined), 0);
+assertEq(udiv_truncate(null), 0);
+
+function shifted_udiv_truncate(y) {
+  var yu = y>>>1;
+  return (yu / yu)|0;
+}
+assertEq(shifted_udiv_truncate(5), 1);
+assertEq(shifted_udiv_truncate(2), 1);
+assertEq(shifted_udiv_truncate(1), 0);
+assertEq(shifted_udiv_truncate(-1), 1);
+assertEq(shifted_udiv_truncate(0), 0);
+assertEq(shifted_udiv_truncate(-0), 0);
+assertEq(shifted_udiv_truncate(1.1), 0);
+assertEq(shifted_udiv_truncate(-1.1), 1);
+assertEq(shifted_udiv_truncate(Infinity), 0);
+assertEq(shifted_udiv_truncate(NaN), 0);
+assertEq(shifted_udiv_truncate(undefined), 0);
+assertEq(shifted_udiv_truncate(null), 0);
+
+function udiv(y) {
+  var yu = y>>>0;
+  return yu / yu;
+}
+assertEq(udiv(5), 1);
+assertEq(udiv(1), 1);
+assertEq(udiv(-1), 1);
+assertEq(udiv(0), NaN);
+assertEq(udiv(-0), NaN);
+assertEq(udiv(1.1), 1);
+assertEq(udiv(-1.1), 1);
+assertEq(udiv(Infinity), NaN);
+assertEq(udiv(NaN), NaN);
+assertEq(udiv(undefined), NaN);
+assertEq(udiv(null), NaN);
+
+function shifted_udiv(y) {
+  var yu = y>>>1;
+  return yu / yu;
+}
+assertEq(shifted_udiv(5), 1);
+assertEq(shifted_udiv(2), 1);
+assertEq(shifted_udiv(1), NaN);
+assertEq(shifted_udiv(-1), 1);
+assertEq(shifted_udiv(0), NaN);
+assertEq(shifted_udiv(-0), NaN);
+assertEq(shifted_udiv(1.1), NaN);
+assertEq(shifted_udiv(-1.1), 1);
+assertEq(shifted_udiv(Infinity), NaN);
+assertEq(shifted_udiv(NaN), NaN);
+assertEq(shifted_udiv(undefined), NaN);
+assertEq(shifted_udiv(null), NaN);
+
+function smod_truncate(y) {
+  return (y % y)|0;
+}
+assertEq(smod_truncate(5), 0);
+assertEq(smod_truncate(1), 0);
+assertEq(smod_truncate(-1), 0);
+assertEq(smod_truncate(0), 0);
+assertEq(smod_truncate(-0), 0);
+assertEq(smod_truncate(1.1), 0);
+assertEq(smod_truncate(-1.1), 0);
+assertEq(smod_truncate(Infinity), 0);
+assertEq(smod_truncate(NaN), 0);
+assertEq(smod_truncate(undefined), 0);
+assertEq(smod_truncate(null), 0);
+
+function smod(y) {
+  return y % y;
+}
+assertEq(smod(5), 0);
+assertEq(smod(1), 0);
+assertEq(smod(-1), -0);
+assertEq(smod(0), NaN);
+assertEq(smod(-0), NaN);
+assertEq(smod(1.1), 0);
+assertEq(smod(-1.1), -0);
+assertEq(smod(Infinity), NaN);
+assertEq(smod(NaN), NaN);
+assertEq(smod(undefined), NaN);
+assertEq(smod(null), NaN);
+
+function umod_truncate(y) {
+  var yu = y>>>0;
+  return (yu % yu)|0;
+}
+assertEq(umod_truncate(5), 0);
+assertEq(umod_truncate(1), 0);
+assertEq(umod_truncate(-1), 0);
+assertEq(umod_truncate(0), 0);
+assertEq(umod_truncate(-0), 0);
+assertEq(umod_truncate(1.1), 0);
+assertEq(umod_truncate(-1.1), 0);
+assertEq(umod_truncate(Infinity), 0);
+assertEq(umod_truncate(NaN), 0);
+assertEq(umod_truncate(undefined), 0);
+assertEq(umod_truncate(null), 0);
+
+function shifted_umod_truncate(y) {
+  var yu = y>>>1;
+  return (yu % yu)|0;
+}
+assertEq(shifted_umod_truncate(5), 0);
+assertEq(shifted_umod_truncate(2), 0);
+assertEq(shifted_umod_truncate(1), 0);
+assertEq(shifted_umod_truncate(-1), 0);
+assertEq(shifted_umod_truncate(0), 0);
+assertEq(shifted_umod_truncate(-0), 0);
+assertEq(shifted_umod_truncate(1.1), 0);
+assertEq(shifted_umod_truncate(-1.1), 0);
+assertEq(shifted_umod_truncate(Infinity), 0);
+assertEq(shifted_umod_truncate(NaN), 0);
+assertEq(shifted_umod_truncate(undefined), 0);
+assertEq(shifted_umod_truncate(null), 0);
+
+function umod(y) {
+  var yu = y>>>0;
+  return yu % yu;
+}
+assertEq(umod(5), 0);
+assertEq(umod(1), 0);
+assertEq(umod(-1), 0);
+assertEq(umod(0), NaN);
+assertEq(umod(-0), NaN);
+assertEq(umod(1.1), 0);
+assertEq(umod(-1.1), 0);
+assertEq(umod(Infinity), NaN);
+assertEq(umod(NaN), NaN);
+assertEq(umod(undefined), NaN);
+assertEq(umod(null), NaN);
+
+function shifted_umod(y) {
+  var yu = y>>>1;
+  return yu % yu;
+}
+assertEq(shifted_umod(5), 0);
+assertEq(shifted_umod(2), 0);
+assertEq(shifted_umod(1), NaN);
+assertEq(shifted_umod(-1), 0);
+assertEq(shifted_umod(0), NaN);
+assertEq(shifted_umod(-0), NaN);
+assertEq(shifted_umod(1.1), NaN);
+assertEq(shifted_umod(-1.1), 0);
+assertEq(shifted_umod(Infinity), NaN);
+assertEq(shifted_umod(NaN), NaN);
+assertEq(shifted_umod(undefined), NaN);
+assertEq(shifted_umod(null), NaN);
+
+function sdiv_truncate_nonzero(y) {
+  if (y == 0) return -202;
+  return (y / y)|0;
+}
+assertEq(sdiv_truncate_nonzero(5), 1);
+assertEq(sdiv_truncate_nonzero(1), 1);
+assertEq(sdiv_truncate_nonzero(-1), 1);
+assertEq(sdiv_truncate_nonzero(0), -202);
+assertEq(sdiv_truncate_nonzero(-0), -202);
+assertEq(sdiv_truncate_nonzero(1.1), 1);
+assertEq(sdiv_truncate_nonzero(-1.1), 1);
+assertEq(sdiv_truncate_nonzero(Infinity), 0);
+assertEq(sdiv_truncate_nonzero(NaN), 0);
+assertEq(sdiv_truncate_nonzero(undefined), 0);
+assertEq(sdiv_truncate_nonzero(null), 0);
+
+function sdiv_nonzero(y) {
+  if (y == 0) return -202;
+  return y / y;
+}
+assertEq(sdiv_nonzero(5), 1);
+assertEq(sdiv_nonzero(1), 1);
+assertEq(sdiv_nonzero(-1), 1);
+assertEq(sdiv_nonzero(0), -202);
+assertEq(sdiv_nonzero(-0), -202);
+assertEq(sdiv_nonzero(1.1), 1);
+assertEq(sdiv_nonzero(-1.1), 1);
+assertEq(sdiv_nonzero(Infinity), NaN);
+assertEq(sdiv_nonzero(NaN), NaN);
+assertEq(sdiv_nonzero(undefined), NaN);
+assertEq(sdiv_nonzero(null), NaN);
+
+function udiv_truncate_nonzero(y) {
+  var yu = y>>>0;
+  if (yu == 0) return -202;
+  return (yu / yu)|0;
+}
+assertEq(udiv_truncate_nonzero(5), 1);
+assertEq(udiv_truncate_nonzero(1), 1);
+assertEq(udiv_truncate_nonzero(-1), 1);
+assertEq(udiv_truncate_nonzero(0), -202);
+assertEq(udiv_truncate_nonzero(-0), -202);
+assertEq(udiv_truncate_nonzero(1.1), 1);
+assertEq(udiv_truncate_nonzero(-1.1), 1);
+assertEq(udiv_truncate_nonzero(Infinity), -202);
+assertEq(udiv_truncate_nonzero(NaN), -202);
+assertEq(udiv_truncate_nonzero(undefined), -202);
+assertEq(udiv_truncate_nonzero(null), -202);
+
+function shifted_udiv_truncate_nonzero(y) {
+  var yu = y>>>1;
+  if (yu == 0) return -202;
+  return (yu / yu)|0;
+}
+assertEq(shifted_udiv_truncate_nonzero(5), 1);
+assertEq(shifted_udiv_truncate_nonzero(2), 1);
+assertEq(shifted_udiv_truncate_nonzero(1), -202);
+assertEq(shifted_udiv_truncate_nonzero(-1), 1);
+assertEq(shifted_udiv_truncate_nonzero(0), -202);
+assertEq(shifted_udiv_truncate_nonzero(-0), -202);
+assertEq(shifted_udiv_truncate_nonzero(1.1), -202);
+assertEq(shifted_udiv_truncate_nonzero(-1.1), 1);
+assertEq(shifted_udiv_truncate_nonzero(Infinity), -202);
+assertEq(shifted_udiv_truncate_nonzero(NaN), -202);
+assertEq(shifted_udiv_truncate_nonzero(undefined), -202);
+assertEq(shifted_udiv_truncate_nonzero(null), -202);
+
+function udiv_nonzero(y) {
+  var yu = y>>>0;
+  if (yu == 0) return -202;
+  return yu / yu;
+}
+assertEq(udiv_nonzero(5), 1);
+assertEq(udiv_nonzero(1), 1);
+assertEq(udiv_nonzero(-1), 1);
+assertEq(udiv_nonzero(0), -202);
+assertEq(udiv_nonzero(-0), -202);
+assertEq(udiv_nonzero(1.1), 1);
+assertEq(udiv_nonzero(-1.1), 1);
+assertEq(udiv_nonzero(Infinity), -202);
+assertEq(udiv_nonzero(NaN), -202);
+assertEq(udiv_nonzero(undefined), -202);
+assertEq(udiv_nonzero(null), -202);
+
+function shifted_udiv_nonzero(y) {
+  var yu = y>>>1;
+  if (yu == 0) return -202;
+  return yu / yu;
+}
+assertEq(shifted_udiv_nonzero(5), 1);
+assertEq(shifted_udiv_nonzero(2), 1);
+assertEq(shifted_udiv_nonzero(1), -202);
+assertEq(shifted_udiv_nonzero(-1), 1);
+assertEq(shifted_udiv_nonzero(0), -202);
+assertEq(shifted_udiv_nonzero(-0), -202);
+assertEq(shifted_udiv_nonzero(1.1), -202);
+assertEq(shifted_udiv_nonzero(-1.1), 1);
+assertEq(shifted_udiv_nonzero(Infinity), -202);
+assertEq(shifted_udiv_nonzero(NaN), -202);
+assertEq(shifted_udiv_nonzero(undefined), -202);
+assertEq(shifted_udiv_nonzero(null), -202);
+
+function smod_truncate_nonzero(y) {
+  if (y == 0) return -202;
+  return (y % y)|0;
+}
+assertEq(smod_truncate_nonzero(5), 0);
+assertEq(smod_truncate_nonzero(1), 0);
+assertEq(smod_truncate_nonzero(-1), 0);
+assertEq(smod_truncate_nonzero(0), -202);
+assertEq(smod_truncate_nonzero(-0), -202);
+assertEq(smod_truncate_nonzero(1.1), 0);
+assertEq(smod_truncate_nonzero(-1.1), 0);
+assertEq(smod_truncate_nonzero(Infinity), 0);
+assertEq(smod_truncate_nonzero(NaN), 0);
+assertEq(smod_truncate_nonzero(undefined), 0);
+assertEq(smod_truncate_nonzero(null), 0);
+
+function smod_nonzero(y) {
+  if (y == 0) return -202;
+  return y % y;
+}
+assertEq(smod_nonzero(5), 0);
+assertEq(smod_nonzero(1), 0);
+assertEq(smod_nonzero(-1), -0);
+assertEq(smod_nonzero(0), -202);
+assertEq(smod_nonzero(-0), -202);
+assertEq(smod_nonzero(1.1), 0);
+assertEq(smod_nonzero(-1.1), -0);
+assertEq(smod_nonzero(Infinity), NaN);
+assertEq(smod_nonzero(NaN), NaN);
+assertEq(smod_nonzero(undefined), NaN);
+assertEq(smod_nonzero(null), NaN);
+
+function umod_truncate_nonzero(y) {
+  var yu = y>>>0;
+  if (yu == 0) return -202;
+  return (yu % yu)|0;
+}
+assertEq(umod_truncate_nonzero(5), 0);
+assertEq(umod_truncate_nonzero(1), 0);
+assertEq(umod_truncate_nonzero(-1), 0);
+assertEq(umod_truncate_nonzero(0), -202);
+assertEq(umod_truncate_nonzero(-0), -202);
+assertEq(umod_truncate_nonzero(1.1), 0);
+assertEq(umod_truncate_nonzero(-1.1), 0);
+assertEq(umod_truncate_nonzero(Infinity), -202);
+assertEq(umod_truncate_nonzero(NaN), -202);
+assertEq(umod_truncate_nonzero(undefined), -202);
+assertEq(umod_truncate_nonzero(null), -202);
+
+function shifted_umod_truncate_nonzero(y) {
+  var yu = y>>>1;
+  if (yu == 0) return -202;
+  return (yu % yu)|0;
+}
+assertEq(shifted_umod_truncate_nonzero(5), 0);
+assertEq(shifted_umod_truncate_nonzero(2), 0);
+assertEq(shifted_umod_truncate_nonzero(1), -202);
+assertEq(shifted_umod_truncate_nonzero(-1), 0);
+assertEq(shifted_umod_truncate_nonzero(0), -202);
+assertEq(shifted_umod_truncate_nonzero(-0), -202);
+assertEq(shifted_umod_truncate_nonzero(1.1), -202);
+assertEq(shifted_umod_truncate_nonzero(-1.1), 0);
+assertEq(shifted_umod_truncate_nonzero(Infinity), -202);
+assertEq(shifted_umod_truncate_nonzero(NaN), -202);
+assertEq(shifted_umod_truncate_nonzero(undefined), -202);
+assertEq(shifted_umod_truncate_nonzero(null), -202);
+
+function umod_nonzero(y) {
+  var yu = y>>>0;
+  if (yu == 0) return -202;
+  return yu % yu;
+}
+assertEq(umod_nonzero(5), 0);
+assertEq(umod_nonzero(1), 0);
+assertEq(umod_nonzero(-1), 0);
+assertEq(umod_nonzero(0), -202);
+assertEq(umod_nonzero(-0), -202);
+assertEq(umod_nonzero(1.1), 0);
+assertEq(umod_nonzero(-1.1), 0);
+assertEq(umod_nonzero(Infinity), -202);
+assertEq(umod_nonzero(NaN), -202);
+assertEq(umod_nonzero(undefined), -202);
+assertEq(umod_nonzero(null), -202);
+
+function shifted_umod_nonzero(y) {
+  var yu = y>>>1;
+  if (yu == 0) return -202;
+  return yu % yu;
+}
+assertEq(shifted_umod_nonzero(5), 0);
+assertEq(shifted_umod_nonzero(2), 0);
+assertEq(shifted_umod_nonzero(1), -202);
+assertEq(shifted_umod_nonzero(-1), 0);
+assertEq(shifted_umod_nonzero(0), -202);
+assertEq(shifted_umod_nonzero(-0), -202);
+assertEq(shifted_umod_nonzero(1.1), -202);
+assertEq(shifted_umod_nonzero(-1.1), 0);
+assertEq(shifted_umod_nonzero(Infinity), -202);
+assertEq(shifted_umod_nonzero(NaN), -202);
+assertEq(shifted_umod_nonzero(undefined), -202);
+assertEq(shifted_umod_nonzero(null), -202);
+
+function sdiv_truncate_positive(y) {
+  if (y <= 0) return -202;
+  return (y / y)|0;
+}
+assertEq(sdiv_truncate_positive(5), 1);
+assertEq(sdiv_truncate_positive(1), 1);
+assertEq(sdiv_truncate_positive(-1), -202);
+assertEq(sdiv_truncate_positive(0), -202);
+assertEq(sdiv_truncate_positive(-0), -202);
+assertEq(sdiv_truncate_positive(1.1), 1);
+assertEq(sdiv_truncate_positive(-1.1), -202);
+assertEq(sdiv_truncate_positive(Infinity), 0);
+assertEq(sdiv_truncate_positive(NaN), 0);
+assertEq(sdiv_truncate_positive(undefined), 0);
+assertEq(sdiv_truncate_positive(null), -202);
+
+function sdiv_positive(y) {
+  if (y <= 0) return -202;
+  return y / y;
+}
+assertEq(sdiv_positive(5), 1);
+assertEq(sdiv_positive(1), 1);
+assertEq(sdiv_positive(-1), -202);
+assertEq(sdiv_positive(0), -202);
+assertEq(sdiv_positive(-0), -202);
+assertEq(sdiv_positive(1.1), 1);
+assertEq(sdiv_positive(-1.1), -202);
+assertEq(sdiv_positive(Infinity), NaN);
+assertEq(sdiv_positive(NaN), NaN);
+assertEq(sdiv_positive(undefined), NaN);
+assertEq(sdiv_positive(null), -202);
+
+function udiv_truncate_positive(y) {
+  var yu = y>>>0;
+  if (yu <= 0) return -202;
+  return (yu / yu)|0;
+}
+assertEq(udiv_truncate_positive(5), 1);
+assertEq(udiv_truncate_positive(1), 1);
+assertEq(udiv_truncate_positive(-1), 1);
+assertEq(udiv_truncate_positive(0), -202);
+assertEq(udiv_truncate_positive(-0), -202);
+assertEq(udiv_truncate_positive(1.1), 1);
+assertEq(udiv_truncate_positive(-1.1), 1);
+assertEq(udiv_truncate_positive(Infinity), -202);
+assertEq(udiv_truncate_positive(NaN), -202);
+assertEq(udiv_truncate_positive(undefined), -202);
+assertEq(udiv_truncate_positive(null), -202);
+
+function shifted_udiv_truncate_positive(y) {
+  var yu = y>>>1;
+  if (yu <= 0) return -202;
+  return (yu / yu)|0;
+}
+assertEq(shifted_udiv_truncate_positive(5), 1);
+assertEq(shifted_udiv_truncate_positive(2), 1);
+assertEq(shifted_udiv_truncate_positive(1), -202);
+assertEq(shifted_udiv_truncate_positive(-1), 1);
+assertEq(shifted_udiv_truncate_positive(0), -202);
+assertEq(shifted_udiv_truncate_positive(-0), -202);
+assertEq(shifted_udiv_truncate_positive(1.1), -202);
+assertEq(shifted_udiv_truncate_positive(-1.1), 1);
+assertEq(shifted_udiv_truncate_positive(Infinity), -202);
+assertEq(shifted_udiv_truncate_positive(NaN), -202);
+assertEq(shifted_udiv_truncate_positive(undefined), -202);
+assertEq(shifted_udiv_truncate_positive(null), -202);
+
+function udiv_positive(y) {
+  var yu = y>>>0;
+  if (yu <= 0) return -202;
+  return yu / yu;
+}
+assertEq(udiv_positive(5), 1);
+assertEq(udiv_positive(1), 1);
+assertEq(udiv_positive(-1), 1);
+assertEq(udiv_positive(0), -202);
+assertEq(udiv_positive(-0), -202);
+assertEq(udiv_positive(1.1), 1);
+assertEq(udiv_positive(-1.1), 1);
+assertEq(udiv_positive(Infinity), -202);
+assertEq(udiv_positive(NaN), -202);
+assertEq(udiv_positive(undefined), -202);
+assertEq(udiv_positive(null), -202);
+
+function shifted_udiv_positive(y) {
+  var yu = y>>>1;
+  if (yu <= 0) return -202;
+  return yu / yu;
+}
+assertEq(shifted_udiv_positive(5), 1);
+assertEq(shifted_udiv_positive(2), 1);
+assertEq(shifted_udiv_positive(1), -202);
+assertEq(shifted_udiv_positive(-1), 1);
+assertEq(shifted_udiv_positive(0), -202);
+assertEq(shifted_udiv_positive(-0), -202);
+assertEq(shifted_udiv_positive(1.1), -202);
+assertEq(shifted_udiv_positive(-1.1), 1);
+assertEq(shifted_udiv_positive(Infinity), -202);
+assertEq(shifted_udiv_positive(NaN), -202);
+assertEq(shifted_udiv_positive(undefined), -202);
+assertEq(shifted_udiv_positive(null), -202);
+
+function smod_truncate_positive(y) {
+  if (y <= 0) return -202;
+  return (y % y)|0;
+}
+assertEq(smod_truncate_positive(5), 0);
+assertEq(smod_truncate_positive(1), 0);
+assertEq(smod_truncate_positive(-1), -202);
+assertEq(smod_truncate_positive(0), -202);
+assertEq(smod_truncate_positive(-0), -202);
+assertEq(smod_truncate_positive(1.1), 0);
+assertEq(smod_truncate_positive(-1.1), -202);
+assertEq(smod_truncate_positive(Infinity), 0);
+assertEq(smod_truncate_positive(NaN), 0);
+assertEq(smod_truncate_positive(undefined), 0);
+assertEq(smod_truncate_positive(null), -202);
+
+function smod_positive(y) {
+  if (y <= 0) return -202;
+  return y % y;
+}
+assertEq(smod_positive(5), 0);
+assertEq(smod_positive(1), 0);
+assertEq(smod_positive(-1), -202);
+assertEq(smod_positive(0), -202);
+assertEq(smod_positive(-0), -202);
+assertEq(smod_positive(1.1), 0);
+assertEq(smod_positive(-1.1), -202);
+assertEq(smod_positive(Infinity), NaN);
+assertEq(smod_positive(NaN), NaN);
+assertEq(smod_positive(undefined), NaN);
+assertEq(smod_positive(null), -202);
+
+function umod_truncate_positive(y) {
+  var yu = y>>>0;
+  if (yu <= 0) return -202;
+  return (yu % yu)|0;
+}
+assertEq(umod_truncate_positive(5), 0);
+assertEq(umod_truncate_positive(1), 0);
+assertEq(umod_truncate_positive(-1), 0);
+assertEq(umod_truncate_positive(0), -202);
+assertEq(umod_truncate_positive(-0), -202);
+assertEq(umod_truncate_positive(1.1), 0);
+assertEq(umod_truncate_positive(-1.1), 0);
+assertEq(umod_truncate_positive(Infinity), -202);
+assertEq(umod_truncate_positive(NaN), -202);
+assertEq(umod_truncate_positive(undefined), -202);
+assertEq(umod_truncate_positive(null), -202);
+
+function shifted_umod_truncate_positive(y) {
+  var yu = y>>>1;
+  if (yu <= 0) return -202;
+  return (yu % yu)|0;
+}
+assertEq(shifted_umod_truncate_positive(5), 0);
+assertEq(shifted_umod_truncate_positive(2), 0);
+assertEq(shifted_umod_truncate_positive(1), -202);
+assertEq(shifted_umod_truncate_positive(-1), 0);
+assertEq(shifted_umod_truncate_positive(0), -202);
+assertEq(shifted_umod_truncate_positive(-0), -202);
+assertEq(shifted_umod_truncate_positive(1.1), -202);
+assertEq(shifted_umod_truncate_positive(-1.1), 0);
+assertEq(shifted_umod_truncate_positive(Infinity), -202);
+assertEq(shifted_umod_truncate_positive(NaN), -202);
+assertEq(shifted_umod_truncate_positive(undefined), -202);
+assertEq(shifted_umod_truncate_positive(null), -202);
+
+function umod_positive(y) {
+  var yu = y>>>0;
+  if (yu <= 0) return -202;
+  return yu % yu;
+}
+assertEq(umod_positive(5), 0);
+assertEq(umod_positive(1), 0);
+assertEq(umod_positive(-1), 0);
+assertEq(umod_positive(0), -202);
+assertEq(umod_positive(-0), -202);
+assertEq(umod_positive(1.1), 0);
+assertEq(umod_positive(-1.1), 0);
+assertEq(umod_positive(Infinity), -202);
+assertEq(umod_positive(NaN), -202);
+assertEq(umod_positive(undefined), -202);
+assertEq(umod_positive(null), -202);
+
+function shifted_umod_positive(y) {
+  var yu = y>>>1;
+  if (yu <= 0) return -202;
+  return yu % yu;
+}
+assertEq(shifted_umod_positive(5), 0);
+assertEq(shifted_umod_positive(2), 0);
+assertEq(shifted_umod_positive(1), -202);
+assertEq(shifted_umod_positive(-1), 0);
+assertEq(shifted_umod_positive(0), -202);
+assertEq(shifted_umod_positive(-0), -202);
+assertEq(shifted_umod_positive(1.1), -202);
+assertEq(shifted_umod_positive(-1.1), 0);
+assertEq(shifted_umod_positive(Infinity), -202);
+assertEq(shifted_umod_positive(NaN), -202);
+assertEq(shifted_umod_positive(undefined), -202);
+assertEq(shifted_umod_positive(null), -202);
-- 
cgit v1.2.3