@weborigami/language 0.2.0 → 0.2.1

package/test/runtime/ops.test.js

@@ -5,12 +5,42 @@ import { describe, test } from "node:test";
 import { evaluate, ops } from "../../src/runtime/internal.js";
 
 describe("ops", () => {
+  test("ops.addition adds two numbers", async () => {
+    assert.strictEqual(ops.addition(2, 2), 4);
+    assert.strictEqual(ops.addition(2, true), 3);
+  });
+
+  test("ops.addition concatenates two strings", async () => {
+    assert.strictEqual(ops.addition("hello ", "everyone"), "hello everyone");
+    assert.strictEqual(
+      ops.addition("2001", ": A Space Odyssey"),
+      "2001: A Space Odyssey"
+    );
+  });
+
   test("ops.array creates an array", async () => {
     const code = createCode([ops.array, 1, 2, 3]);
     const result = await evaluate.call(null, code);
     assert.deepEqual(result, [1, 2, 3]);
   });
 
+  test("ops.bitwiseAnd", () => {
+    assert.strictEqual(ops.bitwiseAnd(5, 3), 1);
+  });
+
+  test("ops.bitwiseNot", () => {
+    assert.strictEqual(ops.bitwiseNot(5), -6);
+    assert.strictEqual(ops.bitwiseNot(-3), 2);
+  });
+
+  test("ops.bitwiseOr", () => {
+    assert.strictEqual(ops.bitwiseOr(5, 3), 7);
+  });
+
+  test("ops.bitwiseXor", () => {
+    assert.strictEqual(ops.bitwiseXor(5, 3), 6);
+  });
+
   test("ops.builtin gets a value from the top of the scope chain", async () => {
     const root = new ObjectTree({
       a: 1,
@@ -22,6 +52,12 @@ describe("ops", () => {
     assert.strictEqual(result, 1);
   });
 
+  test("ops.comma returns the last value", async () => {
+    const code = createCode([ops.comma, 1, 2, 3]);
+    const result = await evaluate.call(null, code);
+    assert.strictEqual(result, 3);
+  });
+
   test("ops.concat concatenates tree value text", async () => {
     const scope = new ObjectTree({
       name: "world",
@@ -43,12 +79,24 @@ describe("ops", () => {
     assert.strictEqual(await ops.conditional(false, errorFn, trueFn), true);
   });
 
-  test("ops.equal", async () => {
-    assert.strictEqual(await ops.equal(1, 1), true);
-    assert.strictEqual(await ops.equal(1, 2), false);
-    assert.strictEqual(await ops.equal("1", 1), true);
-    assert.strictEqual(await ops.equal("1", "1"), true);
-    assert.strictEqual(await ops.equal(null, undefined), true);
+  test("ops.division divides two numbers", async () => {
+    assert.strictEqual(ops.division(12, 2), 6);
+    assert.strictEqual(ops.division(3, 2), 1.5);
+    assert.strictEqual(ops.division(6, "3"), 2);
+    assert.strictEqual(ops.division(2, 0), Infinity);
+  });
+
+  test("ops.equal", () => {
+    assert(ops.equal(1, 1));
+    assert(!ops.equal(1, 2));
+    assert(ops.equal("1", 1));
+    assert(ops.equal("1", "1"));
+    assert(ops.equal(null, undefined));
+  });
+
+  test("ops.exponentiation", () => {
+    assert.strictEqual(ops.exponentiation(2, 3), 8);
+    assert.strictEqual(ops.exponentiation(2, 0), 1);
   });
 
   test("ops.external looks up a value in scope and memoizes it", async () => {
@@ -65,6 +113,18 @@ describe("ops", () => {
     assert.strictEqual(result2, 1);
   });
 
+  test("ops.greaterThan", () => {
+    assert(ops.greaterThan(5, 3));
+    assert(!ops.greaterThan(3, 3));
+    assert(ops.greaterThan("ab", "aa"));
+  });
+
+  test("ops.greaterThanOrEqual", () => {
+    assert(ops.greaterThanOrEqual(5, 3));
+    assert(ops.greaterThanOrEqual(3, 3));
+    assert(ops.greaterThanOrEqual("ab", "aa"));
+  });
+
   test("ops.inherited searches inherited scope", async () => {
     const parent = new ObjectTree({
       a: 1, // This is the inherited value we want
@@ -109,6 +169,18 @@ describe("ops", () => {
     assert.strictEqual(result, "yx");
   });
 
+  test("ops.lessThan", () => {
+    assert(!ops.lessThan(5, 3));
+    assert(!ops.lessThan(3, 3));
+    assert(ops.lessThan("aa", "ab"));
+  });
+
+  test("ops.lessThanOrEqual", () => {
+    assert(!ops.lessThanOrEqual(5, 3));
+    assert(ops.lessThanOrEqual(3, 3));
+    assert(ops.lessThanOrEqual("aa", "ab"));
+  });
+
   test("ops.logicalAnd", async () => {
     assert.strictEqual(await ops.logicalAnd(true, trueFn), true);
     assert.strictEqual(await ops.logicalAnd(true, falseFn), false);
@@ -141,20 +213,27 @@ describe("ops", () => {
     assert.strictEqual(await ops.logicalOr(true, errorFn), true);
   });
 
-  test("ops.notEqual", async () => {
-    assert.strictEqual(await ops.notEqual(1, 1), false);
-    assert.strictEqual(await ops.notEqual(1, 2), true);
-    assert.strictEqual(await ops.notEqual("1", 1), false);
-    assert.strictEqual(await ops.notEqual("1", "1"), false);
-    assert.strictEqual(await ops.notEqual(null, undefined), false);
+  test("ops.multiplication multiplies two numbers", async () => {
+    assert.strictEqual(ops.multiplication(3, 4), 12);
+    assert.strictEqual(ops.multiplication(-3, 4), -12);
+    assert.strictEqual(ops.multiplication("3", 2), 6);
+    assert.strictEqual(ops.multiplication("foo", 2), NaN);
   });
 
-  test("ops.notStrictEqual", async () => {
-    assert.strictEqual(await ops.notStrictEqual(1, 1), false);
-    assert.strictEqual(await ops.notStrictEqual(1, 2), true);
-    assert.strictEqual(await ops.notStrictEqual("1", 1), true);
-    assert.strictEqual(await ops.notStrictEqual("1", "1"), false);
-    assert.strictEqual(await ops.notStrictEqual(null, undefined), true);
+  test("ops.notEqual", () => {
+    assert(!ops.notEqual(1, 1));
+    assert(ops.notEqual(1, 2));
+    assert(!ops.notEqual("1", 1));
+    assert(!ops.notEqual("1", "1"));
+    assert(!ops.notEqual(null, undefined));
+  });
+
+  test("ops.notStrictEqual", () => {
+    assert(!ops.notStrictEqual(1, 1));
+    assert(ops.notStrictEqual(1, 2));
+    assert(ops.notStrictEqual("1", 1));
+    assert(!ops.notStrictEqual("1", "1"));
+    assert(ops.notStrictEqual(null, undefined));
   });
 
   test("ops.nullishCoalescing", async () => {
@@ -196,14 +275,53 @@ describe("ops", () => {
     assert.deepEqual(result, ["Hello", 1, "WORLD"]);
   });
 
-  test("ops.strictEqual", async () => {
-    assert.strictEqual(await ops.strictEqual(1, 1), true);
-    assert.strictEqual(await ops.strictEqual(1, 2), false);
-    assert.strictEqual(await ops.strictEqual("1", 1), false);
-    assert.strictEqual(await ops.strictEqual("1", "1"), true);
-    assert.strictEqual(await ops.strictEqual(null, undefined), false);
-    assert.strictEqual(await ops.strictEqual(null, null), true);
-    assert.strictEqual(await ops.strictEqual(undefined, undefined), true);
+  test("ops.remainder calculates the remainder of two numbers", async () => {
+    assert.strictEqual(ops.remainder(13, 5), 3);
+    assert.strictEqual(ops.remainder(-13, 5), -3);
+    assert.strictEqual(ops.remainder(4, 2), 0);
+    assert.strictEqual(ops.remainder(-4, 2), -0);
+  });
+
+  test("ops.shiftLeft", () => {
+    assert.strictEqual(ops.shiftLeft(5, 2), 20);
+  });
+
+  test("ops.shiftRightSigned", () => {
+    assert.strictEqual(ops.shiftRightSigned(20, 2), 5);
+    assert.strictEqual(ops.shiftRightSigned(-20, 2), -5);
+  });
+
+  test("ops.shiftRightUnsigned", () => {
+    assert.strictEqual(ops.shiftRightUnsigned(20, 2), 5);
+    assert.strictEqual(ops.shiftRightUnsigned(-5, 2), 1073741822);
+  });
+
+  test("ops.strictEqual", () => {
+    assert(ops.strictEqual(1, 1));
+    assert(!ops.strictEqual(1, 2));
+    assert(!ops.strictEqual("1", 1));
+    assert(ops.strictEqual("1", "1"));
+    assert(!ops.strictEqual(null, undefined));
+    assert(ops.strictEqual(null, null));
+    assert(ops.strictEqual(undefined, undefined));
+  });
+
+  test("ops.subtraction subtracts two numbers", async () => {
+    assert.strictEqual(ops.subtraction(5, 3), 2);
+    assert.strictEqual(ops.subtraction(3.5, 5), -1.5);
+    assert.strictEqual(ops.subtraction(5, "hello"), NaN);
+    assert.strictEqual(ops.subtraction(5, true), 4);
+  });
+
+  test("ops.unaryMinus", () => {
+    assert.strictEqual(ops.unaryMinus(4), -4);
+    assert.strictEqual(ops.unaryMinus(-4), 4);
+  });
+
+  test("ops.unaryPlus", () => {
+    assert.strictEqual(ops.unaryPlus(1), 1);
+    assert.strictEqual(ops.unaryPlus(-1), -1);
+    assert.strictEqual(ops.unaryPlus(""), 0);
   });
 
   test("ops.unpack unpacks a value", async () => {