load(libdir + "asserts.js");

const thisGlobal = this;
const otherGlobalSameCompartment = newGlobal({sameCompartmentAs: thisGlobal});
const otherGlobalNewCompartment = newGlobal({newCompartment: true});

const globals = [thisGlobal, otherGlobalSameCompartment, otherGlobalNewCompartment];

function testWithOptions(fn, variants = [undefined]) {
    for (let variant of variants) {
        for (let global of globals) {
            for (let options of [
                {},
                {proxy: true},
                {object: new FakeDOMObject()},
            ]) {
                fn(options, global, variant);
            }
        }
    }
}

function testWithGlobals(fn) {
    for (let global of globals) {
        fn(global);
    }
}

function testBasic(options, global) {
    let {object: source, transplant} = transplantableObject(options);

    // Validate that |source| is an object and |transplant| is a function.
    assertEq(typeof source, "object");
    assertEq(typeof transplant, "function");

    // |source| is created in the current global.
    assertEq(objectGlobal(source), this);

    // |source|'s prototype is %ObjectPrototype%, unless it's a FakeDOMObject.
    let oldPrototype;
    if (options.object) {
        oldPrototype = FakeDOMObject.prototype;
    } else {
        oldPrototype = Object.prototype;
    }
    assertEq(Object.getPrototypeOf(source), oldPrototype);

    // Properties can be created on |source|.
    assertEq(source.foo, undefined);
    source.foo = 1;
    assertEq(source.foo, 1);

    // Calling |transplant| transplants the object and then returns undefined.
    assertEq(transplant(global), undefined);

    // |source| was moved into the new global. If the new global is in a
    // different compartment, |source| is a now a CCW.
    if (global !== otherGlobalNewCompartment) {
        assertEq(objectGlobal(source), global);
    } else {
        assertEq(objectGlobal(source), null);
        assertEq(isProxy(source), true);
    }

    // The properties are copied over to the swapped object.
    assertEq(source.foo, 1);

    // The prototype was changed to %ObjectPrototype% of |global| or the
    // FakeDOMObject.prototype.
    let newPrototype;
    if (options.object) {
        newPrototype = global.FakeDOMObject.prototype;
    } else {
        newPrototype = global.Object.prototype;
    }
    assertEq(Object.getPrototypeOf(source), newPrototype);
}
testWithOptions(testBasic);

// Objects can be transplanted multiple times between globals.
function testTransplantMulti(options, global1, global2) {
    let {object: source, transplant} = transplantableObject(options);

    transplant(global1);
    transplant(global2);
}
testWithOptions(testTransplantMulti, globals);

// Test the case when the source object already has a wrapper in the target global.
function testHasWrapperInTarget(options, global) {
    let {object: source, transplant} = transplantableObject(options);

    // Create a wrapper for |source| in the other global.
    global.p = source;
    assertEq(global.eval("p"), source);

    if (options.proxy) {
        // It's a proxy object either way.
        assertEq(global.eval("isProxy(p)"), true);
    } else {
        if (global === otherGlobalNewCompartment) {
            // |isProxy| returns true because |p| is a CCW.
            assertEq(global.eval("isProxy(p)"), true);
        } else {
            // |isProxy| returns false because |p| is not a CCW.
            assertEq(global.eval("isProxy(p)"), false);
        }
    }

    // And now transplant it into that global.
    transplant(global);

    assertEq(global.eval("p"), source);

    if (options.proxy) {
        // It's a proxy object either way.
        assertEq(global.eval("isProxy(p)"), true);
    } else {
        // The previous CCW was replaced with a same-compartment object.
        assertEq(global.eval("isProxy(p)"), false);
    }
}
testWithOptions(testHasWrapperInTarget);

// Test the case when the source object has a wrapper, but in a different compartment.
function testHasWrapperOtherCompartment(options, global) {
    let thirdGlobal = newGlobal({newCompartment: true});
    let {object: source, transplant} = transplantableObject(options);

    // Create a wrapper for |source| in the new global.
    thirdGlobal.p = source;
    assertEq(thirdGlobal.eval("p"), source);

    // And now transplant the object.
    transplant(global);

    assertEq(thirdGlobal.eval("p"), source);
}
testWithOptions(testHasWrapperOtherCompartment);

// Ensure a transplanted object is correctly handled by (weak) collections.
function testCollections(options, global, AnySet) {
    let {object, transplant} = transplantableObject(options);

    let set = new AnySet();

    assertEq(set.has(object), false);
    set.add(object);
    assertEq(set.has(object), true);

    transplant(global);

    assertEq(set.has(object), true);
}
testWithOptions(testCollections, [Set, WeakSet]);

// Ensure DOM object slot is correctly transplanted.
function testDOMObjectSlot(global) {
    let domObject = new FakeDOMObject();
    let expectedValue = domObject.x;
    assertEq(typeof expectedValue, "number");

    let {object, transplant} = transplantableObject({object: domObject});
    assertEq(object, domObject);

    transplant(global);

    assertEq(object, domObject);
    assertEq(domObject.x, expectedValue);
}
testWithGlobals(testDOMObjectSlot);

function testArgumentValidation() {
    // Throws an error if too many arguments are present.
    assertThrowsInstanceOf(() => transplantableObject(thisGlobal, {}), Error);

    let {object, transplant} = transplantableObject();

    // Throws an error if called with no arguments.
    assertThrowsInstanceOf(() => transplant(), Error);

    // Throws an error if called with too many arguments.
    assertThrowsInstanceOf(() => transplant(thisGlobal, {}), Error);

    // Throws an error if the first argument isn't an object
    assertThrowsInstanceOf(() => transplant(null), Error);

    // Throws an error if the argument isn't a global object.
    assertThrowsInstanceOf(() => transplant({}), Error);

    // Throws an error if the 'object' option isn't a FakeDOMObject.
    assertThrowsInstanceOf(() => transplant({object: null}), Error);
    assertThrowsInstanceOf(() => transplant({object: {}}), Error);
}
testArgumentValidation();