Split tests and remove duplicated tests

Author: kateinoigakukun

packages/npm-packages/ruby-wasm-wasi/test/eval.test.ts

@@ -0,0 +1,9 @@
+import { initRubyVM } from "./init";
+
+describe("Ruby code evaluation", () => {
+  test("empty expression", async () => {
+    const vm = await initRubyVM();
+    const result = vm.eval("");
+    expect(result.toString()).toBe("");
+  });
+});

packages/npm-packages/ruby-wasm-wasi/test/gc.test.ts

@@ -0,0 +1,85 @@
+import { RbValue } from "../src/index";
+import { initRubyVM } from "./init";
+
+describe("GC integration", () => {
+  test("Wrapped Ruby object should live until wrapper will be released", async () => {
+    const vm = await initRubyVM();
+    const run = vm.eval(`
+      require "js"
+      proc do |imports|
+        imports.call(:mark_js_object_live, JS::Object.wrap(Object.new))
+      end
+    `);
+    const livingObjects = new Set<RbValue>();
+    run.call(
+      "call",
+      vm.wrap({
+        mark_js_object_live: (object: RbValue) => {
+          livingObjects.add(object);
+        },
+      })
+    );
+    vm.eval("GC.start");
+    for (const object of livingObjects) {
+      // Ensure that all objects are still alive
+      object.call("itself");
+    }
+  });
+
+  test("protect exported Ruby objects", async () => {
+    function dropRbValue(value: RbValue) {
+      (value as any).inner.drop();
+    }
+    const vm = await initRubyVM();
+    const initialGCCount = Number(vm.eval("GC.count").toString());
+    const robj = vm.eval("$x = Object.new");
+    const robjId = robj.call("object_id").toString();
+    expect(robjId).not.toEqual("");
+
+    vm.eval("GC.start");
+    expect(robj.call("object_id").toString()).toBe(robjId);
+    expect(Number(vm.eval("GC.count").toString())).toEqual(initialGCCount + 1);
+
+    const robj2 = vm.eval("$x");
+    vm.eval("GC.start");
+    expect(robj2.call("object_id").toString()).toBe(robjId);
+
+    const robj3 = robj2.call("itself");
+    vm.eval("GC.start");
+    expect(robj3.call("object_id").toString()).toBe(robjId);
+
+    dropRbValue(robj);
+    expect(robj2.call("object_id").toString()).toBe(robjId);
+    expect(robj3.call("object_id").toString()).toBe(robjId);
+
+    vm.eval("GC.start");
+    expect(robj2.call("object_id").toString()).toBe(robjId);
+    expect(robj3.call("object_id").toString()).toBe(robjId);
+
+    dropRbValue(robj2);
+    dropRbValue(robj3);
+
+    vm.eval("GC.start");
+  });
+
+  test("protect objects having same hash values from GC", async () => {
+    const vm = await initRubyVM();
+    vm.eval(`
+    class X
+      def hash
+        42
+      end
+      def eql?(other)
+        true
+      end
+    end
+    `);
+
+    const o1 = vm.eval(`X.new`);
+    const o2 = vm.eval(`X.new`);
+    const o3 = vm.eval(`X.new`);
+    vm.eval(`GC.start`);
+    expect(o1.call("hash").toString()).toBe(o2.call("hash").toString());
+    expect(o2.call("hash").toString()).toBe(o3.call("hash").toString());
+  });
+});

packages/npm-packages/ruby-wasm-wasi/test/js_from_rb.test.ts

@@ -1,5 +1,7 @@
 require_relative "./unit/test_js"
 require_relative "./unit/test_object"
+require_relative "./unit/test_object_wrap"
 require_relative "./unit/test_error"
 require_relative "./unit/test_async"
 require_relative "./unit/test_float"
+require_relative "./unit/test_proc"

packages/npm-packages/ruby-wasm-wasi/test/test_unit.rb

@@ -0,0 +1,33 @@
+import { initRubyVM } from "./init";
+
+describe("RbValue#toJS", () => {
+  test.each([
+    { expr: `1`, result: 1 },
+    { expr: `true`, result: true },
+    { expr: `false`, result: false },
+    { expr: `"x"`, result: "x" },
+    { expr: `"x\\0x"`, result: "x\0x" },
+  ])(`Primitive Ruby object`, async (props) => {
+    const vm = await initRubyVM();
+    vm.eval(`require "js"; JS`);
+    const result = vm.eval(props.expr);
+    expect(result.toJS()).toBe(props.result);
+  });
+
+  test.each([
+    { expr: "", result: undefined },
+    { expr: "return undefined", result: undefined },
+    { expr: "return null", result: null },
+    { expr: "return Object", result: Object },
+    { expr: "return 1", result: 1 },
+    { expr: "return 'x'", result: "x" },
+    { expr: "return 'x\\\\0'", result: "x\0" },
+  ])(`Primitive JS object`, async (props) => {
+    const vm = await initRubyVM();
+    const JS = vm.eval(`require "js"; JS`);
+    // TODO(katei): Use RubyVM#toRbValue instead of RubyVM#eval.
+    const result = JS.call("eval", vm.eval(`"${props.expr}"`));
+    expect(result.toJS()).toBe(props.result);
+  });
+
+});

packages/npm-packages/ruby-wasm-wasi/test/to_js.test.ts

@@ -23,4 +23,8 @@ def test_eval
       }
     JS
   end
+
+  def test_try_convert
+    assert_nil JS.try_convert(Object.new)
+  end
 end

packages/npm-packages/ruby-wasm-wasi/test/unit/test_js.rb

@@ -73,8 +73,17 @@ def test_inspect
     assert_equal "str", JS.eval("return 'str';").to_s
     assert_equal "24", JS.eval("return 24;").inspect
     assert_equal "true", JS.eval("return true;").inspect
-    assert_equal "null", JS.eval("return null;").inspect
-    assert_equal "undefined", JS.eval("return undefined;").inspect
+    assert_equal "null", JS::Null.inspect
+    assert_equal "undefined", JS::Undefined.inspect
+    assert_equal "[object Object]", JS.eval("return {}").inspect
+    assert_equal "[object X class]", JS.eval(<<~JS).inspect
+      class X {
+        get [Symbol.toStringTag]() {
+          return 'X class';
+        }
+      }
+      return new X();
+    JS
   end
 
   def test_to_i_from_number
@@ -151,6 +160,18 @@ def test_call
     assert_equal "1,2,3", JS.global.call(:Array, 1, 2, 3).to_s
   end
 
+  def test_call_with_undefined_method
+    assert_raise("which is a undefined and not a function") do
+      JS.global.call(:undefined_method)
+    end
+  end
+
+  def test_call_with_non_js_object
+    assert_raise("argument 2 is not a JS::Object like object") do
+      JS.global.call(:Object, Object.new)
+    end
+  end
+
   def test_call_with_stress_gc
     obj = JS.eval(<<~JS)
       return { takeArg() {} }

packages/npm-packages/ruby-wasm-wasi/test/unit/test_object.rb

@@ -0,0 +1,13 @@
+require "test-unit"
+require "js"
+
+class JS::TestObjectWrap < Test::Unit::TestCase
+  def test_identity
+    intrinsics = JS.eval(<<-JS)
+      return { identity(v) { return v } }
+    JS
+    o1 = Object.new
+    o1_clone = intrinsics.call(:identity, JS::Object.wrap(o1))
+    assert_equal o1.object_id, o1_clone.call("call", "object_id").call("toJS").to_i
+  end
+end