1 files changed, 114 insertions, 0 deletions
diff --git a/js/src/jit-test/tests/realms/basic.js b/js/src/jit-test/tests/realms/basic.js
new file mode 100644
index 0000000000..3c9bbd4d6d
--- /dev/null
+++ b/js/src/jit-test/tests/realms/basic.js
@@ -0,0 +1,114 @@
+var g1 = newGlobal({sameCompartmentAs: this});
+var g2 = newGlobal({sameCompartmentAs: g1});
+g2.x = g1;
+gc();
+assertEq(objectGlobal(Math), this);
+assertEq(objectGlobal(g1.print), g1);
+assertEq(objectGlobal(g2.x), g1);
+
+assertEq(isSameCompartment(g1, g2), true);
+assertEq(isSameCompartment(g1, Math), true);
+
+// Different-compartment realms have wrappers.
+assertEq(objectGlobal(newGlobal({newCompartment: true}).Math), null);
+
+function testCrossRealmProto() {
+    var g = newGlobal({sameCompartmentAs:this});
+
+    for (var i = 0; i < 20; i++) {
+        var o = Object.create(g.Math);
+        assertEq(objectGlobal(o), this);
+        assertEq(o.__proto__, g.Math);
+
+        var a = Reflect.construct(Array, [], g.Object);
+        assertEq(Array.isArray(a), true);
+        assertEq(objectGlobal(a), this);
+        assertEq(a.__proto__, g.Object.prototype);
+    }
+}
+testCrossRealmProto();
+
+function testSystemNonSystemRealms() {
+    var systemRealm = newGlobal({newCompartment: true, systemPrincipal: true});
+    var ex;
+    try {
+        var nonSystemRealm = newGlobal({sameCompartmentAs: systemRealm, principal: 10});
+    } catch(e) {
+        ex = e;
+    }
+    assertEq(ex.toString().includes("non-system realms"), true);
+    ex = null;
+    try {
+        systemRealm = newGlobal({systemPrincipal: true, sameCompartmentAs: this});
+    } catch(e) {
+        ex = e;
+    }
+    assertEq(ex.toString().includes("non-system realms"), true);
+}
+testSystemNonSystemRealms();
+
+function testNewObjectCache() {
+    // NewObjectCache lookup based on the proto should not return a cross-realm
+    // object.
+    var g = newGlobal({sameCompartmentAs: this});
+    var o1 = g.evaluate("Object.create(Math)");
+    var o2 = Object.create(g.Math);
+    assertEq(objectGlobal(o1), g);
+    assertEq(objectGlobal(o2), this);
+}
+testNewObjectCache();
+
+function testCCWs() {
+    // CCWs are allocated in the first realm.
+    var g1 = newGlobal({newCompartment: true});
+    var g2 = newGlobal({sameCompartmentAs: g1});
+    g1.o1 = {x: 1};
+    g2.o2 = {x: 2};
+    g1 = null;
+    gc();
+    g2.o3 = {x: 3};
+    assertEq(g2.o2.x, 2);
+    assertEq(g2.o3.x, 3);
+}
+testCCWs();
+
+function testTypedArrayLazyBuffer(global) {
+    var arr1 = new global.Int32Array(1);
+    var arr2 = new Int32Array(arr1);
+    assertEq(objectGlobal(arr2.buffer), this);
+    global.buf = arr1.buffer;
+    global.eval("assertEq(objectGlobal(buf), this);");
+}
+testTypedArrayLazyBuffer(newGlobal());
+testTypedArrayLazyBuffer(newGlobal({sameCompartmentAs: this}));
+
+function testEvalcx() {
+    var g = newGlobal();
+    evalcx("this.x = 7", g);
+    assertEq(g.x, 7);
+
+    g = newGlobal({newCompartment: true, invisibleToDebugger: true});
+    var ex, sb;
+    try {
+        sb = g.eval("evalcx('')");
+    } catch(e) {
+        ex = e;
+    }
+    // Check for either an exception or CCW (with --more-compartments).
+    assertEq((sb && objectGlobal(sb) === null) ||
+             ex.toString().includes("visibility"), true);
+
+    // Bug 1524707.
+    var lazysb = evalcx("lazy");
+    Object.setPrototypeOf(lazysb, Math);
+    assertEq(lazysb.__proto__, Math);
+}
+testEvalcx();
+
+function testSetProto() {
+    var o = {};
+    o.__proto__ = newGlobal();
+    o.__proto__ = newGlobal();
+    assertEq(objectGlobal(o), this);
+}
+testSetProto();