1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-23 05:07:34 +00:00

LibJS: Convert Proxy tests

This commit is contained in:
Matthew Olsson 2020-07-03 22:43:08 -07:00 committed by Andreas Kling
parent b86faeaeef
commit 449a1cf3a2
14 changed files with 820 additions and 815 deletions

View file

@ -1,18 +1,19 @@
load("test-common.js"); describe("[[Call]] trap normal behavior", () => {
test("forwarding when not defined in handler", () => {
try {
let p = new Proxy(() => 5, { apply: null }); let p = new Proxy(() => 5, { apply: null });
assert(p() === 5); expect(p()).toBe(5);
let p = new Proxy(() => 5, { apply: undefined }); p = new Proxy(() => 5, { apply: undefined });
assert(p() === 5); expect(p()).toBe(5);
let p = new Proxy(() => 5, {}); p = new Proxy(() => 5, {});
assert(p() === 5); expect(p()).toBe(5);
});
test("correct arguments supplied to trap", () => {
const f = (a, b) => a + b; const f = (a, b) => a + b;
const handler = { const handler = {
apply(target, this_, arguments) { apply(target, this_, arguments) {
assert(target === f); expect(target).toBe(f);
assert(this_ === handler); expect(this_).toBe(handler);
if (arguments[2]) if (arguments[2])
return arguments[0] * arguments[1]; return arguments[0] * arguments[1];
return f(...arguments); return f(...arguments);
@ -20,20 +21,17 @@ try {
}; };
p = new Proxy(f, handler); p = new Proxy(f, handler);
assert(p(2, 4) === 6); expect(p(2, 4)).toBe(6);
assert(p(2, 4, true) === 8); expect(p(2, 4, true)).toBe(8);
});
});
// Invariants describe("[[Call]] invariants", () => {
test("target must have a [[Call]] slot", () => {
[{}, [], new Proxy({}, {})].forEach(item => { [{}, [], new Proxy({}, {})].forEach(item => {
assertThrowsError(() => { expect(() => {
new Proxy(item, {})(); new Proxy(item, {})();
}, { }).toThrowWithMessage(TypeError, "[object ProxyObject] is not a function");
error: TypeError,
message: "[object ProxyObject] is not a function",
}); });
}); });
});
console.log("PASS");
} catch (e) {
console.log("FAIL: " + e);
}

View file

@ -1,13 +1,14 @@
load("test-common.js"); describe("[[Construct]] trap normal behavior", () => {
test("forwarding when not defined in handler", () => {
try {
let p = new Proxy(function() { this.x = 5; }, { construct: null }); let p = new Proxy(function() { this.x = 5; }, { construct: null });
assert((new p).x === 5); expect((new p).x).toBe(5);
let p = new Proxy(function() { this.x = 5; }, { construct: undefined }); p = new Proxy(function() { this.x = 5; }, { construct: undefined });
assert((new p).x === 5); expect((new p).x).toBe(5);
let p = new Proxy(function() { this.x = 5; }, {}); p = new Proxy(function() { this.x = 5; }, {});
assert((new p).x === 5); expect((new p).x).toBe(5);
});
test("trapping 'new'", () => {
function f(value) { function f(value) {
this.x = value; this.x = value;
} }
@ -15,8 +16,8 @@ try {
let p; let p;
const handler = { const handler = {
construct(target, arguments, newTarget) { construct(target, arguments, newTarget) {
assert(target === f); expect(target).toBe(f);
assert(newTarget === p); expect(newTarget).toBe(p);
if (arguments[1]) if (arguments[1])
return Reflect.construct(target, [arguments[0] * 2], newTarget); return Reflect.construct(target, [arguments[0] * 2], newTarget);
return Reflect.construct(target, arguments, newTarget); return Reflect.construct(target, arguments, newTarget);
@ -24,15 +25,21 @@ try {
}; };
p = new Proxy(f, handler); p = new Proxy(f, handler);
assert(new p(15).x === 15); expect(new p(15).x).toBe(15);
assert(new p(15, true).x === 30); expect(new p(15, true).x).toBe(30);
});
test("trapping Reflect.construct", () => {
function f(value) {
this.x = value;
}
let p; let p;
function theNewTarget() {}; function theNewTarget() {};
const handler = { const handler = {
construct(target, arguments, newTarget) { construct(target, arguments, newTarget) {
assert(target === f); expect(target).toBe(f);
assert(newTarget === theNewTarget); expect(newTarget).toBe(theNewTarget);
if (arguments[1]) if (arguments[1])
return Reflect.construct(target, [arguments[0] * 2], newTarget); return Reflect.construct(target, [arguments[0] * 2], newTarget);
return Reflect.construct(target, arguments, newTarget); return Reflect.construct(target, arguments, newTarget);
@ -41,18 +48,15 @@ try {
p = new Proxy(f, handler); p = new Proxy(f, handler);
Reflect.construct(p, [15], theNewTarget); Reflect.construct(p, [15], theNewTarget);
});
});
// Invariants describe("[[Construct]] invariants", () => {
test("target must have a [[Construct]] slot", () => {
[{}, [], new Proxy({}, {})].forEach(item => { [{}, [], new Proxy({}, {})].forEach(item => {
assertThrowsError(() => { expect(() => {
new (new Proxy(item, {})); new (new Proxy(item, {}));
}, { }).toThrowWithMessage(TypeError, "[object ProxyObject] is not a constructor");
error: TypeError,
message: "[object ProxyObject] is not a constructor",
}); });
}); });
});
console.log("PASS");
} catch (e) {
console.log("FAIL: " + e);
}

View file

@ -1,31 +1,35 @@
load("test-common.js"); describe("[[DefineProperty]] trap normal behavior", () => {
test("forwarding when not defined in handler", () => {
try {
let p = new Proxy({}, { defineProperty: null }); let p = new Proxy({}, { defineProperty: null });
assert(Object.defineProperty(p, "foo", {}) === p); expect(Object.defineProperty(p, "foo", {})).toBe(p);
p = new Proxy({}, { defineProperty: undefined }); p = new Proxy({}, { defineProperty: undefined });
assert(Object.defineProperty(p, "foo", {}) === p); expect(Object.defineProperty(p, "foo", {})).toBe(p);
p = new Proxy({}, {}); p = new Proxy({}, {});
assert(Object.defineProperty(p, "foo", {}) == p); expect(Object.defineProperty(p, "foo", {})).toBe(p);
});
test("correct arguments passed to trap", () => {
let o = {}; let o = {};
p = new Proxy(o, { p = new Proxy(o, {
defineProperty(target, name, descriptor) { defineProperty(target, name, descriptor) {
assert(target === o); expect(target).toBe(o);
assert(name === "foo"); expect(name).toBe("foo");
assert(descriptor.configurable === true); expect(descriptor.configurable).toBe(true);
assert(descriptor.enumerable === undefined); expect(descriptor.enumerable).toBeUndefined();
assert(descriptor.writable === true); expect(descriptor.writable).toBe(true);
assert(descriptor.value === 10); expect(descriptor.value).toBe(10);
assert(descriptor.get === undefined); expect(descriptor.get).toBeUndefined();
assert(descriptor.set === undefined); expect(descriptor.set).toBeUndefined();
return true; return true;
}, },
}); });
Object.defineProperty(p, "foo", { configurable: true, writable: true, value: 10 }); Object.defineProperty(p, "foo", { configurable: true, writable: true, value: 10 });
});
p = new Proxy(o, { test("optionally ignoring the define call", () => {
let o = {};
let p = new Proxy(o, {
defineProperty(target, name, descriptor) { defineProperty(target, name, descriptor) {
if (target[name] === undefined) if (target[name] === undefined)
Object.defineProperty(target, name, descriptor); Object.defineProperty(target, name, descriptor);
@ -35,73 +39,74 @@ try {
Object.defineProperty(p, "foo", { value: 10, enumerable: true, configurable: false, writable: true }); Object.defineProperty(p, "foo", { value: 10, enumerable: true, configurable: false, writable: true });
let d = Object.getOwnPropertyDescriptor(p, "foo"); let d = Object.getOwnPropertyDescriptor(p, "foo");
assert(d.enumerable === true); expect(d.enumerable).toBe(true);
assert(d.configurable === false); expect(d.configurable).toBe(false);
assert(d.writable === true); expect(d.writable).toBe(true);
assert(d.value === 10); expect(d.value).toBe(10);
assert(d.get === undefined); expect(d.get).toBeUndefined();
assert(d.set === undefined); expect(d.set).toBeUndefined();
Object.defineProperty(p, "foo", { value: 20, enumerable: true, configurable: false, writable: true }); Object.defineProperty(p, "foo", { value: 20, enumerable: true, configurable: false, writable: true });
d = Object.getOwnPropertyDescriptor(p, "foo"); d = Object.getOwnPropertyDescriptor(p, "foo");
assert(d.enumerable === true); expect(d.enumerable).toBe(true);
assert(d.configurable === false); expect(d.configurable).toBe(false);
assert(d.writable === true); expect(d.writable).toBe(true);
assert(d.value === 10); expect(d.value).toBe(10);
assert(d.get === undefined); expect(d.get).toBeUndefined();
assert(d.set === undefined); expect(d.set).toBeUndefined();
});
});
describe("[[DefineProperty]] invariants", () => {
// Invariants test("trap can't return false", () => {
let p = new Proxy({}, {
p = new Proxy({}, {
defineProperty() { return false; } defineProperty() { return false; }
}); });
assertThrowsError(() => { expect(() => {
Object.defineProperty(p, "foo", {}); Object.defineProperty(p, "foo", {});
}, { }).toThrowWithMessage(TypeError, "Object's [[DefineProperty]] method returned false");
error: TypeError,
message: "Object's [[DefineProperty]] method returned false",
}); });
o = {}; test("trap cannot return true for a non-extensible target if the property does not exist", () => {
let o = {};
Object.preventExtensions(o); Object.preventExtensions(o);
p = new Proxy(o, { let p = new Proxy(o, {
defineProperty() { defineProperty() {
return true; return true;
} }
}); });
assertThrowsError(() => {
expect(() => {
Object.defineProperty(p, "foo", {}); Object.defineProperty(p, "foo", {});
}, { }).toThrowWithMessage(TypeError, "Proxy handler's defineProperty trap violates invariant: a property cannot be reported as being defined if the property does not exist on the target and the target is non-extensible");
error: TypeError,
message: "Proxy handler's defineProperty trap violates invariant: a property cannot be reported as being defined if the property does not exist on the target and the target is non-extensible",
}); });
o = {}; test("trap cannot return true for a non-configurable property if it doesn't already exist on the target", () => {
let o = {};
Object.defineProperty(o, "foo", { value: 10, configurable: true }); Object.defineProperty(o, "foo", { value: 10, configurable: true });
p = new Proxy(o, { let p = new Proxy(o, {
defineProperty() { defineProperty() {
return true; return true;
}, },
}); });
assertThrowsError(() => { expect(() => {
Object.defineProperty(p, "bar", { value: 6, configurable: false }); Object.defineProperty(p, "bar", { value: 6, configurable: false });
}, { }).toThrowWithMessage(TypeError, "Proxy handler's defineProperty trap violates invariant: a property cannot be defined as non-configurable if it does not already exist on the target object");
error: TypeError,
message: "Proxy handler's defineProperty trap violates invariant: a property cannot be defined as non-configurable if it does not already exist on the target object",
}); });
assertThrowsError(() => { test("trap cannot return true for a non-configurable property if it already exists as a configurable property", () => {
let o = {};
Object.defineProperty(o, "foo", { value: 10, configurable: true });
let p = new Proxy(o, {
defineProperty() {
return true;
},
});
expect(() => {
Object.defineProperty(p, "foo", { value: 6, configurable: false }); Object.defineProperty(p, "foo", { value: 6, configurable: false });
}, { }).toThrowWithMessage(TypeError, "Proxy handler's defineProperty trap violates invariant: a property cannot be defined as non-configurable if it already exists on the target object as a configurable property");
error: TypeError, })
message: "Proxy handler's defineProperty trap violates invariant: a property cannot be defined as non-configurable if it already exists on the target object as a configurable property", });
});
console.log("PASS");
} catch (e) {
console.log("FAIL: " + e);
}

View file

@ -1,21 +1,24 @@
load("test-common.js"); describe("[[Delete]] trap normal behavior", () => {
test("forwarding when not defined in handler", () => {
try { expect(delete (new Proxy({}, { deleteProperty: undefined })).foo).toBe(true);
assert(delete (new Proxy({}, { deleteProperty: undefined })).foo === true); expect(delete (new Proxy({}, { deleteProperty: null })).foo).toBe(true);
assert(delete (new Proxy({}, { deleteProperty: null })).foo === true); expect(delete (new Proxy({}, {})).foo).toBe(true);
assert(delete (new Proxy({}, {})).foo === true); });
test("correct arguments supplied to trap", () => {
let o = {}; let o = {};
let p = new Proxy(o, { let p = new Proxy(o, {
deleteProperty(target, property) { deleteProperty(target, property) {
assert(target === o); expect(target).toBe(o);
assert(property === "foo"); expect(property).toBe("foo");
return true; return true;
} }
}); });
delete p.foo; delete p.foo;
});
test("conditional deletion", () => {
o = { foo: 1, bar: 2 }; o = { foo: 1, bar: 2 };
p = new Proxy(o, { p = new Proxy(o, {
deleteProperty(target, property) { deleteProperty(target, property) {
@ -27,30 +30,27 @@ try {
} }
}); });
assert(delete p.foo === true); expect(delete p.foo).toBe(true);
assert(delete p.bar === false); expect(delete p.bar).toBe(false);
assert(o.foo === undefined); expect(o.foo).toBe(undefined);
assert(o.bar === 2); expect(o.bar).toBe(2);
});
});
// Invariants
o = {}; describe("[[Delete]] invariants", () => {
test("cannot report a non-configurable own property as deleted", () => {
let o = {};
Object.defineProperty(o, "foo", { configurable: false }); Object.defineProperty(o, "foo", { configurable: false });
p = new Proxy(o, { let p = new Proxy(o, {
deleteProperty() { deleteProperty() {
return true; return true;
}, },
}); });
assertThrowsError(() => { expect(() => {
delete p.foo; delete p.foo;
}, { }).toThrowWithMessage(TypeError, "Proxy handler's deleteProperty trap violates invariant: cannot report a non-configurable own property of the target as deleted");
error: TypeError,
message: "Proxy handler's deleteProperty trap violates invariant: cannot report a non-configurable own property of the target as deleted",
}); });
});
console.log("PASS");
} catch (e) {
console.log("FAIL: " + e);
}

View file

@ -1,23 +1,26 @@
load("test-common.js"); describe("[[Get]] trap normal behavior", () => {
test("forwarding when not defined in handler", () => {
try { expect((new Proxy({}, { get: undefined })).foo).toBeUndefined();
assert((new Proxy({}, { get: undefined })).foo === undefined); expect((new Proxy({}, { get: null })).foo).toBeUndefined();
assert((new Proxy({}, { get: null })).foo === undefined); expect((new Proxy({}, {})).foo).toBeUndefined();
assert((new Proxy({}, {})).foo === undefined); });
test("correct arguments supplied to trap", () => {
let o = {}; let o = {};
let p = new Proxy(o, { let p = new Proxy(o, {
get(target, property, receiver) { get(target, property, receiver) {
assert(target === o); expect(target).toBe(o);
assert(property === "foo"); expect(property).toBe("foo");
assert(receiver === p); expect(receiver).toBe(p);
}, },
}); });
p.foo; p.foo;
});
o = { foo: 1 }; test("conditional return", () => {
p = new Proxy(o, { let o = { foo: 1 };
let p = new Proxy(o, {
get(target, property, receiver) { get(target, property, receiver) {
if (property === "bar") { if (property === "bar") {
return 2; return 2;
@ -30,42 +33,44 @@ try {
} }
}); });
assert(p.foo === 1); expect(p.foo).toBe(1);
assert(p.bar === 2); expect(p.bar).toBe(2);
assert(p.baz === 3); expect(p.baz).toBe(3);
assert(p.qux === 3); expect(p.qux).toBe(3);
assert(p.test === undefined); expect(p.test).toBeUndefined();
});
});
// Invariants describe("[[Get]] invariants", () => {
test("returned value must match the target property value if the property is non-configurable and non-writable", () => {
o = {}; let o = {};
Object.defineProperty(o, "foo", { value: 5, configurable: false, writable: true }); Object.defineProperty(o, "foo", { value: 5, configurable: false, writable: true });
Object.defineProperty(o, "bar", { value: 10, configurable: false, writable: false }); Object.defineProperty(o, "bar", { value: 10, configurable: false, writable: false });
p = new Proxy(o, { let p = new Proxy(o, {
get() { get() {
return 8; return 8;
}, },
}); });
assert(p.foo === 8); expect(p.foo).toBe(8);
expect(() => {
assertThrowsError(() => {
p.bar; p.bar;
}, { }).toThrowWithMessage(TypeError, "Proxy handler's get trap violates invariant: the returned value must match the value on the target if the property exists on the target as a non-writable, non-configurable own data property");
error: TypeError,
message: "Proxy handler's get trap violates invariant: the returned value must match the value on the target if the property exists on the target as a non-writable, non-configurable own data property",
}); });
Object.defineProperty(o, "baz", { configurable: false, set(_) {} }); test("returned value must be undefined if the property is a non-configurable accessor with no getter", () => {
assertThrowsError(() => { let o = {};
p.baz; Object.defineProperty(o, "foo", { configurable: false, set(_) {} });
}, {
error: TypeError, let p = new Proxy(o, {
message: "Proxy handler's get trap violates invariant: the returned value must be undefined if the property exists on the target as a non-configurable accessor property with an undefined get attribute", get() {
return 8;
},
}); });
console.log("PASS"); expect(() => {
} catch (e) { p.foo;
console.log("FAIL: " + e); }).toThrowWithMessage(TypeError, "Proxy handler's get trap violates invariant: the returned value must be undefined if the property exists on the target as a non-configurable accessor property with an undefined get attribute");
} })
});

View file

@ -1,23 +1,27 @@
load("test-common.js"); describe("[Call][GetOwnProperty]] trap normal behavior", () => {
test("forwarding when not defined in handler", () => {
try { expect(Object.getOwnPropertyDescriptor(new Proxy({}, { getOwnPropertyDescriptor: null }), "a")).toBeUndefined();
assert(Object.getOwnPropertyDescriptor(new Proxy({}, { getOwnPropertyDescriptor: null }), "a") === undefined); expect(Object.getOwnPropertyDescriptor(new Proxy({}, { getOwnPropertyDescriptor: undefined }), "a")).toBeUndefined();
assert(Object.getOwnPropertyDescriptor(new Proxy({}, { getOwnPropertyDescriptor: undefined }), "a") === undefined); expect(Object.getOwnPropertyDescriptor(new Proxy({}, {}), "a")).toBeUndefined();
assert(Object.getOwnPropertyDescriptor(new Proxy({}, {}), "a") === undefined); });
test("correct arguments supplied to trap", () => {
let o = {}; let o = {};
let p = new Proxy(o, { let p = new Proxy(o, {
getOwnPropertyDescriptor(target, property) { getOwnPropertyDescriptor(target, property) {
assert(target === o); expect(target).toBe(o);
assert(property === "foo"); expect(property).toBe("foo");
} }
}); });
Object.getOwnPropertyDescriptor(p, "foo"); Object.getOwnPropertyDescriptor(p, "foo");
});
o = { foo: "bar" }; test("conditional returned descriptor", () => {
let o = { foo: "bar" };
Object.defineProperty(o, "baz", { value: "qux", enumerable: false, configurable: true, writable: false }); Object.defineProperty(o, "baz", { value: "qux", enumerable: false, configurable: true, writable: false });
p = new Proxy(o, {
let p = new Proxy(o, {
getOwnPropertyDescriptor(target, property) { getOwnPropertyDescriptor(target, property) {
if (property === "baz") if (property === "baz")
return Object.getOwnPropertyDescriptor(target, "baz"); return Object.getOwnPropertyDescriptor(target, "baz");
@ -26,134 +30,116 @@ try {
}); });
let d = Object.getOwnPropertyDescriptor(p, "baz"); let d = Object.getOwnPropertyDescriptor(p, "baz");
assert(d.configurable === true); expect(d.configurable).toBe(true);
assert(d.enumerable === false); expect(d.enumerable).toBe(false);
assert(d.writable === false); expect(d.writable).toBe(false);
assert(d.value === "qux"); expect(d.value).toBe("qux");
assert(d.get === undefined); expect(d.get).toBeUndefined();
assert(d.set === undefined); expect(d.set).toBeUndefined();
d = Object.getOwnPropertyDescriptor(p, "foo"); d = Object.getOwnPropertyDescriptor(p, "foo");
assert(d.configurable === true); expect(d.configurable).toBe(true);
assert(d.enumerable === false); expect(d.enumerable).toBe(false);
assert(d.writable === true); expect(d.writable).toBe(true);
assert(d.value === "bar"); expect(d.value).toBe("bar");
assert(d.get === undefined); expect(d.get).toBeUndefined();
assert(d.set === undefined); expect(d.set).toBeUndefined();
// Invariants
assertThrowsError(() => {
Object.getOwnPropertyDescriptor(new Proxy({}, {
getOwnPropertyDescriptor: 1
}));
}, {
error: TypeError,
message: "Proxy handler's getOwnPropertyDescriptor trap wasn't undefined, null, or callable",
}); });
});
assertThrowsError(() => { describe("[[GetOwnProperty]] invariants", () => {
test("must return an object or undefined", () => {
expect(() => {
Object.getOwnPropertyDescriptor(new Proxy({}, { Object.getOwnPropertyDescriptor(new Proxy({}, {
getOwnPropertyDescriptor() { getOwnPropertyDescriptor() {
return 1; return 1;
}, },
})); }));
}, { }).toThrowWithMessage(TypeError, "Proxy handler's getOwnPropertyDescriptor trap violates invariant: must return an object or undefined");
error: TypeError,
message: "Proxy handler's getOwnPropertyDescriptor trap violates invariant: must return an object or undefined",
}); });
o = {}; test("cannot return undefined for a non-configurable property", () => {
let o = {};
Object.defineProperty(o, "foo", { value: 10, configurable: false }); Object.defineProperty(o, "foo", { value: 10, configurable: false });
p = new Proxy(o, {
let p = new Proxy(o, {
getOwnPropertyDescriptor() { getOwnPropertyDescriptor() {
return undefined; return undefined;
}, },
}); });
assert(Object.getOwnPropertyDescriptor(p, "bar") === undefined); expect(Object.getOwnPropertyDescriptor(p, "bar")).toBeUndefined();
assertThrowsError(() => { expect(() => {
Object.getOwnPropertyDescriptor(p, "foo"); Object.getOwnPropertyDescriptor(p, "foo");
}, { }).toThrowWithMessage(TypeError, "Proxy handler's getOwnPropertyDescriptor trap violates invariant: cannot return undefined for a property on the target which is a non-configurable property");
error: TypeError,
message: "Proxy handler's getOwnPropertyDescriptor trap violates invariant: cannot return undefined for a property on the target which is a non-configurable property",
}); });
test("cannot return undefined for an existing property if the target is non-extensible", () => {
let o = {};
Object.defineProperty(o, "baz", { value: 20, configurable: true, writable: true, enumerable: true }); Object.defineProperty(o, "baz", { value: 20, configurable: true, writable: true, enumerable: true });
Object.preventExtensions(o); Object.preventExtensions(o);
assertThrowsError(() => { let p = new Proxy(o, {
Object.getOwnPropertyDescriptor(p, "baz"); getOwnPropertyDescriptor() {
}, { return undefined;
error: TypeError, },
message: "Proxy handler's getOwnPropertyDescriptor trap violates invariant: cannot report a property as being undefined if it exists as an own property of the target and the target is non-extensible",
}); });
o = {}; expect(() => {
Object.getOwnPropertyDescriptor(p, "baz");
}).toThrowWithMessage(TypeError, "Proxy handler's getOwnPropertyDescriptor trap violates invariant: cannot report a property as being undefined if it exists as an own property of the target and the target is non-extensible");
});
test("invalid property descriptors", () => {
let o = {};
Object.defineProperty(o, "v1", { value: 10, configurable: false }); Object.defineProperty(o, "v1", { value: 10, configurable: false });
Object.defineProperty(o, "v2", { value: 10, configurable: false, enumerable: true }); Object.defineProperty(o, "v2", { value: 10, configurable: false, enumerable: true });
Object.defineProperty(o, "v3", { configurable: false, get() { return 1; } }); Object.defineProperty(o, "v3", { configurable: false, get() { return 1; } });
Object.defineProperty(o, "v4", { value: 10, configurable: false, writable: false, enumerable: true }); Object.defineProperty(o, "v4", { value: 10, configurable: false, writable: false, enumerable: true });
assertThrowsError(() => { expect(() => {
Object.getOwnPropertyDescriptor(new Proxy(o, { Object.getOwnPropertyDescriptor(new Proxy(o, {
getOwnPropertyDescriptor() { getOwnPropertyDescriptor() {
return { configurable: true }; return { configurable: true };
}, },
}), "v1"); }), "v1");
}, { }).toThrowWithMessage(TypeError, "Proxy handler's getOwnPropertyDescriptor trap violates invariant: invalid property descriptor for existing property on the target");
error: TypeError,
message: "Proxy handler's getOwnPropertyDescriptor trap violates invariant: invalid property descriptor for existing property on the target",
});
assertThrowsError(() => { expect(() => {
Object.getOwnPropertyDescriptor(new Proxy(o, { Object.getOwnPropertyDescriptor(new Proxy(o, {
getOwnPropertyDescriptor() { getOwnPropertyDescriptor() {
return { enumerable: false }; return { enumerable: false };
}, },
}), "v2"); }), "v2");
}, { }).toThrowWithMessage(TypeError, "Proxy handler's getOwnPropertyDescriptor trap violates invariant: invalid property descriptor for existing property on the target");
error: TypeError,
message: "Proxy handler's getOwnPropertyDescriptor trap violates invariant: invalid property descriptor for existing property on the target",
});
assertThrowsError(() => { expect(() => {
Object.getOwnPropertyDescriptor(new Proxy(o, { Object.getOwnPropertyDescriptor(new Proxy(o, {
getOwnPropertyDescriptor() { getOwnPropertyDescriptor() {
return { value: 10 }; return { value: 10 };
}, },
}), "v3"); }), "v3");
}, { }).toThrowWithMessage(TypeError, "Proxy handler's getOwnPropertyDescriptor trap violates invariant: invalid property descriptor for existing property on the target");
error: TypeError,
message: "Proxy handler's getOwnPropertyDescriptor trap violates invariant: invalid property descriptor for existing property on the target",
});
assertThrowsError(() => { expect(() => {
Object.getOwnPropertyDescriptor(new Proxy(o, { Object.getOwnPropertyDescriptor(new Proxy(o, {
getOwnPropertyDescriptor() { getOwnPropertyDescriptor() {
return { value: 10, writable: true }; return { value: 10, writable: true };
}, },
}), "v4"); }), "v4");
}, { }).toThrowWithMessage(TypeError, "Proxy handler's getOwnPropertyDescriptor trap violates invariant: invalid property descriptor for existing property on the target");
error: TypeError,
message: "Proxy handler's getOwnPropertyDescriptor trap violates invariant: invalid property descriptor for existing property on the target",
}); });
o = {}; test("cannot report a property as non-configurable if it does not exist or is non-configurable", () => {
let o = {};
Object.defineProperty(o, "v", { configurable: true }); Object.defineProperty(o, "v", { configurable: true });
assertThrowsError(() => { expect(() => {
Object.getOwnPropertyDescriptor(new Proxy(o, { Object.getOwnPropertyDescriptor(new Proxy(o, {
getOwnPropertyDescriptor() { getOwnPropertyDescriptor() {
return { configurable: false }; return { configurable: false };
}, },
}), "v"); }), "v");
}, { }).toThrowWithMessage(TypeError, "Proxy handler's getOwnPropertyDescriptor trap violates invariant: cannot report target's property as non-configurable if the property does not exist, or if it is configurable");
error: TypeError,
message: "Proxy handler's getOwnPropertyDescriptor trap violates invariant: cannot report target's property as non-configurable if the property does not exist, or if it is configurable",
}); });
});
console.log("PASS");
} catch (e) {
console.log("FAIL: " + e);
}

View file

@ -1,26 +1,32 @@
load("test-common.js"); describe("[[GetPrototypeOf]] trap normal behavior", () => {
test("forwarding when not defined in handler", () => {
let proto = {};
let o = {};
Object.setPrototypeOf(o, proto);
try { let p = new Proxy(o, { prototype: null });
const child = {}; expect(Object.getPrototypeOf(p)).toBe(proto);
const childProto = { foo: "bar" }; p = new Proxy(o, { apply: undefined });
expect(Object.getPrototypeOf(p)).toBe(proto);
Object.setPrototypeOf(child, childProto); p = new Proxy(o, {});
assert(child.foo === "bar"); expect(Object.getPrototypeOf(p)).toBe(proto);
});
Object.getPrototypeOf(new Proxy(child, { getPrototypeOf: null }));
Object.getPrototypeOf(new Proxy(child, { getPrototypeOf: undefined }));
test("correct arguments supplied to trap", () => {
let o = {}; let o = {};
let p = new Proxy(o, { let p = new Proxy(o, {
getPrototypeOf(target) { getPrototypeOf(target) {
assert(target === o); expect(target).toBe(o);
return null; return null;
} }
}); });
Object.getPrototypeOf(p); Object.getPrototypeOf(p);
});
p = new Proxy(o, { test("conditional return", () => {
let o = {};
let p = new Proxy(o, {
getPrototypeOf(target) { getPrototypeOf(target) {
if (target.foo) if (target.foo)
return { bar: 1 }; return { bar: 1 };
@ -28,60 +34,48 @@ try {
}, },
}); });
assert(Object.getPrototypeOf(p).bar === 2); expect(Object.getPrototypeOf(p).bar).toBe(2);
o.foo = 20 o.foo = 20
assert(Object.getPrototypeOf(p).bar === 1); expect(Object.getPrototypeOf(p).bar).toBe(1);
// Invariants
assertThrowsError(() => {
Object.getPrototypeOf(new Proxy(child, { getPrototypeOf: 1 }));
}, {
error: TypeError,
message: "Proxy handler's getPrototypeOf trap wasn't undefined, null, or callable",
}); });
assertThrowsError(() => { test("non-extensible target", () => {
Object.getPrototypeOf(new Proxy(child, { getPrototypeOf() { return 1; } })); let o = {};
}, { let proto = { foo: "bar" };
error: TypeError, Object.setPrototypeOf(o, proto);
message: "Proxy handler's getPrototypeOf trap violates invariant: must return an object or null", Object.preventExtensions(o);
});
p = new Proxy(child, { p = new Proxy(o, {
getPrototypeOf(target) { getPrototypeOf() {
assert(target === child); return proto;
return { baz: "qux" };
},
});
assert(Object.getPrototypeOf(p).baz === "qux");
Object.preventExtensions(child);
p = new Proxy(child, {
getPrototypeOf(target) {
assert(target === child);
return childProto;
} }
}); });
assert(Object.getPrototypeOf(p).foo === "bar"); expect(Object.getPrototypeOf(p).foo).toBe("bar");
});
});
p = new Proxy(child, { describe("[[GetPrototypeOf]] invariants", () => {
test("must return an object or null", () => {
expect(() => {
Object.getPrototypeOf(new Proxy({}, { getPrototypeOf() { return 1; } }));
}).toThrowWithMessage(TypeError, "Proxy handler's getPrototypeOf trap violates invariant: must return an object or null");
});
test("different return object for non-extensible target", () => {
let o = {};
let proto = {};
Object.setPrototypeOf(o, proto);
Object.preventExtensions(o);
let p = new Proxy(o, {
getPrototypeOf(target) { getPrototypeOf(target) {
assert(target === child);
return { baz: "qux" }; return { baz: "qux" };
} }
}); });
assertThrowsError(() => { expect(() => {
Object.getPrototypeOf(p); Object.getPrototypeOf(p);
}, { }).toThrowWithMessage(TypeError, "Proxy handler's getPrototypeOf trap violates invariant: cannot return a different prototype object for a non-extensible target");
error: TypeError,
message: "Proxy handler's getPrototypeOf trap violates invariant: cannot return a different prototype object for a non-extensible target"
}); });
});
console.log("PASS");
} catch (e) {
console.log("FAIL: " + e);
}

View file

@ -1,22 +1,26 @@
load("test-common.js"); describe("[[Has]] trap normal behavior", () => {
test("forwarding when not defined in handler", () => {
try { expect("foo" in new Proxy({}, { has: null })).toBe(false);
assert("foo" in new Proxy({}, { has: null }) === false); expect("foo" in new Proxy({}, { has: undefined})).toBe(false);
assert("foo" in new Proxy({}, { has: undefined}) === false); expect("foo" in new Proxy({}, {})).toBe(false);
assert("foo" in new Proxy({}, {}) === false); });
test("correct arguments supplied to trap", () => {
let o = {}; let o = {};
let p = new Proxy(o, { let p = new Proxy(o, {
has(target, prop) { has(target, prop) {
assert(target === o); expect(target).toBe(o);
assert(prop === "foo"); expect(prop).toBe("foo");
return true; return true;
} }
}); });
"foo" in p; "foo" in p;
});
p = new Proxy(o, { test("conditional return", () => {
let o = {};
let p = new Proxy(o, {
has(target, prop) { has(target, prop) {
if (target.checkedFoo) if (target.checkedFoo)
return true; return true;
@ -26,37 +30,41 @@ try {
} }
}); });
assert("foo" in p === false); expect("foo" in p).toBe(false);
assert("foo" in p === true); expect("foo" in p).toBe(true);
});
});
// Invariants describe("[[Has]] invariants", () => {
test("cannot return false if the property exists and is non-configurable", () => {
o = {}; let o = {};
Object.defineProperty(o, "foo", { configurable: false }); Object.defineProperty(o, "foo", { configurable: false });
Object.defineProperty(o, "bar", { value: 10, configurable: true });
p = new Proxy(o, { p = new Proxy(o, {
has() { has() {
return false; return false;
} }
}); });
assertThrowsError(() => { expect(() => {
"foo" in p; "foo" in p;
}, { }).toThrowWithMessage(TypeError, "Proxy handler's has trap violates invariant: a property cannot be reported as non-existent if it exists on the target as a non-configurable property");
error: TypeError, });
message: "Proxy handler's has trap violates invariant: a property cannot be reported as non-existent if it exists on the target as a non-configurable property",
test("cannot return false if the property exists and the target is non-extensible", () => {
let o = {};
Object.defineProperty(o, "foo", { value: 10, configurable: true });
let p = new Proxy(o, {
has() {
return false;
}
}); });
Object.preventExtensions(o); Object.preventExtensions(o);
assertThrowsError(() => { expect(() => {
"bar" in p; "foo" in p;
}, { }).toThrowWithMessage(TypeError, "Proxy handler's has trap violates invariant: a property cannot be reported as non-existent if it exists on the target and the target is non-extensible");
error: TypeError,
message: "Proxy handler's has trap violates invariant: a property cannot be reported as non-existent if it exists on the target and the target is non-extensible",
}); });
});
console.log("PASS");
} catch (e) {
console.log("FAIL: " + e);
}

View file

@ -1,49 +1,36 @@
load("test-common.js"); describe("[[IsExtensible]] trap normal behavior", () => {
test("forwarding when not defined in handler", () => {
try { expect(Object.isExtensible(new Proxy({}, { isExtensible: null }))).toBe(true);
assert(Object.isExtensible(new Proxy({}, { isExtensible: null })) === true); expect(Object.isExtensible(new Proxy({}, { isExtensible: undefined }))).toBe(true);
assert(Object.isExtensible(new Proxy({}, { isExtensible: undefined })) === true); expect(Object.isExtensible(new Proxy({}, {}))).toBe(true);
assert(Object.isExtensible(new Proxy({}, {})) === true); });
test("correct arguments supplied to trap", () => {
let o = {}; let o = {};
let p = new Proxy(o, { let p = new Proxy(o, {
isExtensible(target) { isExtensible(target) {
assert(target === o); expect(target).toBe(o);
return true; return true;
} }
}); });
Object.isExtensible(p); expect(Object.isExtensible(p)).toBe(true);
});
});
// Invariants describe("[[Call]] invariants", () => {
test("return value must match the target's extensibility", () => {
let o = {};
Object.preventExtensions(o);
o = {}; let p = new Proxy(o, {
p = new Proxy(o, { isExtensible() {
isExtensible(proxyTarget) {
assert(proxyTarget === o);
return true; return true;
}, },
}); });
assert(Object.isExtensible(p) === true); expect(() => {
Object.preventExtensions(o);
assertThrowsError(() => {
Object.isExtensible(p); Object.isExtensible(p);
}, { }).toThrowWithMessage(TypeError, "Proxy handler's isExtensible trap violates invariant: return value must match the target's extensibility");
error: TypeError,
message: "Proxy handler's isExtensible trap violates invariant: return value must match the target's extensibility",
}); });
});
p = new Proxy(o, {
isExtensible(proxyTarget) {
assert(proxyTarget === o);
return false;
},
});
assert(Object.isExtensible(p) === false);
console.log("PASS");
} catch (e) {
console.log("FAIL: " + e);
}

View file

@ -1,55 +1,53 @@
load("test-common.js"); describe("[[PreventExtension]] trap normal behavior", () => {
test("forwarding when not defined in handler", () => {
try {
let p = new Proxy({}, { preventExtensions: null }); let p = new Proxy({}, { preventExtensions: null });
assert(Object.preventExtensions(p) === p); expect(Object.preventExtensions(p)).toBe(p);
p = new Proxy({}, { preventExtensions: undefined }); p = new Proxy({}, { preventExtensions: undefined });
assert(Object.preventExtensions(p) === p); expect(Object.preventExtensions(p)).toBe(p);
p = new Proxy({}, {}); p = new Proxy({}, {});
assert(Object.preventExtensions(p) == p); expect(Object.preventExtensions(p)).toBe(p);
});
test("correct arguments supplied to trap", () => {
let o = {}; let o = {};
p = new Proxy(o, { p = new Proxy(o, {
preventExtensions(target) { preventExtensions(target) {
assert(target === o); expect(target).toBe(o);
return true; return true;
} }
}); });
Object.preventExtensions(o); Object.preventExtensions(o);
Object.preventExtensions(p); Object.preventExtensions(p);
});
});
// Invariants describe("[[PreventExtensions]] invariants", () => {
test("cannot return false", () => {
p = new Proxy({}, { let p = new Proxy({}, {
preventExtensions() { preventExtensions() {
return false; return false;
}, },
}); });
assertThrowsError(() => {
expect(() => {
Object.preventExtensions(p); Object.preventExtensions(p);
}, { }).toThrowWithMessage(TypeError, "Object's [[PreventExtensions]] method returned false");
error: TypeError,
message: "Object's [[PreventExtensions]] method returned false",
}); });
o = {}; test("cannot return true if the target is extensible", () => {
p = new Proxy(o, { let o = {};
let p = new Proxy(o, {
preventExtensions() { preventExtensions() {
return true; return true;
}, },
}); });
assertThrowsError(() => {
expect(() => {
Object.preventExtensions(p); Object.preventExtensions(p);
}, { }).toThrowWithMessage(TypeError, "Proxy handler's preventExtensions trap violates invariant: cannot return true if the target object is extensible");
error: TypeError,
message: "Proxy handler's preventExtensions trap violates invariant: cannot return true if the target object is extensible"
});
Object.preventExtensions(o); Object.preventExtensions(o);
assert(Object.preventExtensions(p) === p); expect(Object.preventExtensions(p)).toBe(p);
});
console.log("PASS"); });
} catch (e) {
console.log("FAIL: " + e);
}

View file

@ -1,25 +1,28 @@
load("test-common.js"); describe("[[Set]] trap normal behavior", () => {
test("forwarding when not defined in handler", () => {
try { expect((new Proxy({}, { set: undefined }).foo = 1)).toBe(1);
assert((new Proxy({}, { set: undefined }).foo = 1) === 1); expect((new Proxy({}, { set: null }).foo = 1)).toBe(1);
assert((new Proxy({}, { set: null }).foo = 1) === 1); expect((new Proxy({}, {}).foo = 1)).toBe(1);
assert((new Proxy({}, {}).foo = 1) === 1); });
test("correct arguments supplied to trap", () => {
let o = {}; let o = {};
let p = new Proxy(o, { let p = new Proxy(o, {
set(target, prop, value, receiver) { set(target, prop, value, receiver) {
assert(target === o); expect(target).toBe(o);
assert(prop === "foo"); expect(prop).toBe("foo");
assert(value === 10); expect(value).toBe(10);
assert(receiver === p); expect(receiver).toBe(p);
return true; return true;
}, },
}); });
p.foo = 10; p.foo = 10;
});
p = new Proxy(o, { test("conditional return value", () => {
set(target, prop, value, receiver) { let p = new Proxy({}, {
set(target, prop, value) {
if (target[prop] === value) { if (target[prop] === value) {
target[prop] *= 2; target[prop] *= 2;
} else { } else {
@ -29,38 +32,42 @@ try {
}); });
p.foo = 10; p.foo = 10;
assert(p.foo === 10); expect(p.foo).toBe(10);
p.foo = 10; p.foo = 10;
assert(p.foo === 20); expect(p.foo).toBe(20);
p.foo = 10; p.foo = 10;
assert(p.foo === 10); expect(p.foo).toBe(10);
});
});
// Invariants describe("[[Set]] invariants", () => {
test("cannot return true for a non-configurable, non-writable property", () => {
o = {}; let o = {};
Object.defineProperty(o, "foo", { value: 10 }); Object.defineProperty(o, "foo", { value: 10 });
p = new Proxy(o, {
let p = new Proxy(o, {
set() { set() {
return true; return true;
}, },
}); });
assertThrowsError(() => { expect(() => {
p.foo = 12; p.foo = 12;
}, { }).toThrowWithMessage(TypeError, "Proxy handler's set trap violates invariant: cannot return true for a property on the target which is a non-configurable, non-writable own data property");
error: TypeError,
message: "Proxy handler's set trap violates invariant: cannot return true for a property on the target which is a non-configurable, non-writable own data property",
}); });
Object.defineProperty(o, "bar", { get() {} }); test("cannot return true for a non-configurable accessor property with no setter", () => {
assertThrowsError(() => { let o = {};
p.bar = 12; Object.defineProperty(o, "foo", { get() {} });
}, {
error: TypeError, let p = new Proxy(o, {
message: "Proxy handler's set trap violates invariant: cannot return true for a property on the target which is a non-configurable own accessor property with an undefined set attribute", set() {
return true;
},
}); });
console.log("PASS"); expect(() => {
} catch (e) { p.foo = 12;
console.log("FAIL: " + e); }).toThrowWithMessage(TypeError, "Proxy handler's set trap violates invariant: cannot return true for a property on the target which is a non-configurable own accessor property with an undefined set attribute");
} });
});

View file

@ -1,28 +1,36 @@
load("test-common.js"); describe("[[SetPrototypeOf]] trap normal behavior", () => {
test("forwarding when not defined in handler", () => {
const o = {};
const proto = { foo: "bar" };
Object.setPrototypeOf(o, proto);
try { let p = new Proxy(o, { setPrototypeOf: null });
const child = {}; expect(Object.setPrototypeOf(p, proto)).toBe(p);
const childProto = { foo: "bar" }; let p = new Proxy(o, { setPrototypeOf: undefined });
expect(Object.setPrototypeOf(p, proto)).toBe(p);
Object.setPrototypeOf(child, childProto); let p = new Proxy(o, {});
assert(child.foo === "bar"); expect(Object.setPrototypeOf(p, proto)).toBe(p);
});
Object.setPrototypeOf(new Proxy(child, { setPrototypeOf: null }), childProto);
Object.setPrototypeOf(new Proxy(child, { setPrototypeOf: undefined }), childProto);
test("correct arguments supplied to trap", () => {
let o = {}; let o = {};
let theNewProto = { foo: "bar" }; let theNewProto = { foo: "bar" };
let p = new Proxy(o, { let p = new Proxy(o, {
setPrototypeOf(target, newProto) { setPrototypeOf(target, newProto) {
assert(target === o); expect(target).toBe(o);
assert(newProto === theNewProto); expect(newProto).toBe(theNewProto);
return true; return true;
} }
}); });
Object.setPrototypeOf(p, theNewProto); Object.setPrototypeOf(p, theNewProto);
});
p = new Proxy(o, { test("conditional setting", () => {
let o = {};
let p = new Proxy(o, {
setPrototypeOf(target, newProto) { setPrototypeOf(target, newProto) {
if (target.shouldSet) if (target.shouldSet)
Object.setPrototypeOf(target, newProto); Object.setPrototypeOf(target, newProto);
@ -31,65 +39,56 @@ try {
}); });
Object.setPrototypeOf(p, { foo: 1 }); Object.setPrototypeOf(p, { foo: 1 });
assert(Object.getPrototypeOf(p).foo === undefined); expect(Object.getPrototypeOf(p).foo).toBeUndefined();
p.shouldSet = true; p.shouldSet = true;
assert(o.shouldSet === true); expect(o.shouldSet).toBe(true);
Object.setPrototypeOf(p, { foo: 1 }); Object.setPrototypeOf(p, { foo: 1 });
assert(Object.getPrototypeOf(p).foo === 1); expect(Object.getPrototypeOf(p).foo).toBe(1);
// Invariants
assertThrowsError(() => {
Object.setPrototypeOf(new Proxy(child, { setPrototypeOf: 1 }), {});
}, {
error: TypeError,
message: "Proxy handler's setPrototypeOf trap wasn't undefined, null, or callable",
}); });
p = new Proxy(child, { test("non-extensible targets", () => {
setPrototypeOf(target, newProto) { let o = {};
assert(target === child); let proto = {};
Object.setPrototypeOf(o, proto);
Object.preventExtensions(o);
p = new Proxy(o, {
setPrototypeOf() {
return true;
},
});
expect(Object.setPrototypeOf(p, proto)).toBe(p);
expect(Object.getPrototypeOf(p)).toBe(proto);
});
});
describe("[[SetPrototypeOf]] invariants", () => {
test("cannot return false", () => {
let o = {};
p = new Proxy(o, {
setPrototypeOf() {
return false; return false;
}, },
}); });
assertThrowsError(() => { expect(() => {
Object.setPrototypeOf(p, {}); Object.setPrototypeOf(p, {});
}, { }).toThrowWithMessage(TypeError, "Object's [[SetPrototypeOf]] method returned false");
error: TypeError,
message: "Object's [[SetPrototypeOf]] method returned false",
}); });
assert(Object.getPrototypeOf(p) === childProto);
p = new Proxy(child, { test("the argument must match the target's prototype if the target is non-extensible", () => {
setPrototypeOf(target, newProto) { let o = {};
assert(target === child); Object.preventExtensions(o);
let p = new Proxy(o, {
setPrototypeOf() {
return true; return true;
}, }
}); });
assert(Object.setPrototypeOf(p, {}) === p); expect(() => {
assert(Object.getPrototypeOf(p) === childProto);
Object.preventExtensions(child);
p = new Proxy(child, {
setPrototypeOf(target, newProto) {
assert(target === child);
return true;
},
});
assert(Object.setPrototypeOf(p, childProto) === p);
assert(Object.getPrototypeOf(p) === childProto);
assertThrowsError(() => {
Object.setPrototypeOf(p, {}); Object.setPrototypeOf(p, {});
}, { }).toThrowWithMessage(TypeError, "Proxy handler's setPrototypeOf trap violates invariant: the argument must match the prototype of the target if the target is non-extensible");
error: TypeError,
message: "Proxy handler's setPrototypeOf trap violates invariant: the argument must match the prototype of the target if the target is non-extensible",
}); });
});
console.log("PASS");
} catch (e) {
console.log("FAIL: " + e);
}

View file

@ -1,30 +1,31 @@
load("test-common.js"); test("constructs properly", () => {
expect(() => {
try {
new Proxy({}, {}); new Proxy({}, {});
}).not.toThrow();
});
assertThrowsError(() => { test("constructor argument count", () => {
expect(() => {
new Proxy(); new Proxy();
}, { }).toThrowWithMessage(TypeError, "Proxy constructor requires at least two arguments");
error: TypeError,
message: "Proxy constructor requires at least two arguments",
});
assertThrowsError(() => { expect(() => {
Proxy(); new Proxy({});
}, { }).toThrowWithMessage(TypeError, "Proxy constructor requires at least two arguments");
error: TypeError, });
message: "Proxy must be called with the 'new' operator",
});
assertThrowsError(() => { test("constructor requires objects", () => {
expect(() => {
new Proxy(1, {}); new Proxy(1, {});
}, { }).toThrowWithMessage(TypeError, "Expected target argument of Proxy constructor to be object, got 1");
error: TypeError,
message: "Expected target argument of Proxy constructor to be object, got 1",
});
console.log("PASS"); expect(() => {
} catch (e) { new Proxy({}, 1);
console.log("FAIL: " + e); }).toThrowWithMessage(TypeError, "Expected handler argument of Proxy constructor to be object, got 1");
} });
test("constructor must be invoked with 'new'", () => {
expect(() => {
Proxy({}, {});
}).toThrowWithMessage(TypeError, "Proxy must be called with the 'new' operator");
});

View file

@ -42,6 +42,19 @@
// FIXME: Will eventually not be necessary when all tests are converted // FIXME: Will eventually not be necessary when all tests are converted
Vector<String> tests_to_run = { Vector<String> tests_to_run = {
"builtins/Proxy/Proxy.js",
"builtins/Proxy/Proxy.handler-apply.js",
"builtins/Proxy/Proxy.handler-construct.js",
"builtins/Proxy/Proxy.handler-defineProperty.js",
"builtins/Proxy/Proxy.handler-deleteProperty.js",
"builtins/Proxy/Proxy.handler-get.js",
"builtins/Proxy/Proxy.handler-getOwnPropertyDescriptor.js",
"builtins/Proxy/Proxy.handler-getPrototypeOf.js",
"builtins/Proxy/Proxy.handler-has.js",
"builtins/Proxy/Proxy.handler-isExtensible.js",
"builtins/Proxy/Proxy.handler-preventExtensions.js",
"builtins/Proxy/Proxy.handler-set.js",
"builtins/Proxy/Proxy.handler-setPrototypeOf.js",
"add-values-to-primitive.js", "add-values-to-primitive.js",
"automatic-semicolon-insertion.js", "automatic-semicolon-insertion.js",
"comments-basic.js", "comments-basic.js",