RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 00:17:46 +00:00
Code Issues Activity Actions

LibJS: Indent tests with 4 spaces instead of 2

Browse source
This commit is contained in:
Matthew Olsson 2020-07-06 07:37:45 -07:00 • committed by Andreas Kling
parent 15de2eda2b
commit 1ef573eb30
261 changed files with 8536 additions and 8497 deletions
Download patch file Download diff file Expand all files Collapse all files

56
Libraries/LibJS/Tests/builtins/Proxy/Proxy.handler-apply.js
View file

@ -1,36 +1,36 @@
describe("[[Call]] trap normal behavior", () => {
test("forwarding when not defined in handler", () => {
let p = new Proxy(() => 5, { apply: null });
expect(p()).toBe(5);
p = new Proxy(() => 5, { apply: undefined });
expect(p()).toBe(5);
p = new Proxy(() => 5, {});
expect(p()).toBe(5);
});
test("forwarding when not defined in handler", () => {
let p = new Proxy(() => 5, { apply: null });
expect(p()).toBe(5);
p = new Proxy(() => 5, { apply: undefined });
expect(p()).toBe(5);
p = new Proxy(() => 5, {});
expect(p()).toBe(5);
});
test("correct arguments supplied to trap", () => {
const f = (a, b) => a + b;
const handler = {
apply(target, this_, arguments) {
expect(target).toBe(f);
expect(this_).toBe(handler);
if (arguments[2]) return arguments[0] * arguments[1];
return f(...arguments);
},
};
p = new Proxy(f, handler);
test("correct arguments supplied to trap", () => {
const f = (a, b) => a + b;
const handler = {
apply(target, this_, arguments) {
expect(target).toBe(f);
expect(this_).toBe(handler);
if (arguments[2]) return arguments[0] * arguments[1];
return f(...arguments);
},
};
p = new Proxy(f, handler);
expect(p(2, 4)).toBe(6);
expect(p(2, 4, true)).toBe(8);
});
expect(p(2, 4)).toBe(6);
expect(p(2, 4, true)).toBe(8);
});
});
describe("[[Call]] invariants", () => {
test("target must have a [[Call]] slot", () => {
[{}, [], new Proxy({}, {})].forEach(item => {
expect(() => {
new Proxy(item, {})();
}).toThrowWithMessage(TypeError, "[object ProxyObject] is not a function");
test("target must have a [[Call]] slot", () => {
[{}, [], new Proxy({}, {})].forEach(item => {
expect(() => {
new Proxy(item, {})();
}).toThrowWithMessage(TypeError, "[object ProxyObject] is not a function");
});
});
});
});

120
Libraries/LibJS/Tests/builtins/Proxy/Proxy.handler-construct.js
View file

@ -1,72 +1,72 @@
describe("[[Construct]] trap normal behavior", () => {
test("forwarding when not defined in handler", () => {
let p = new Proxy(
function () {
this.x = 5;
},
{ construct: null }
);
expect(new p().x).toBe(5);
p = new Proxy(
function () {
this.x = 5;
},
{ construct: undefined }
);
expect(new p().x).toBe(5);
p = new Proxy(function () {
this.x = 5;
}, {});
expect(new p().x).toBe(5);
});
test("forwarding when not defined in handler", () => {
let p = new Proxy(
function () {
this.x = 5;
},
{ construct: null }
);
expect(new p().x).toBe(5);
p = new Proxy(
function () {
this.x = 5;
},
{ construct: undefined }
);
expect(new p().x).toBe(5);
p = new Proxy(function () {
this.x = 5;
}, {});
expect(new p().x).toBe(5);
});
test("trapping 'new'", () => {
function f(value) {
this.x = value;
}
test("trapping 'new'", () => {
function f(value) {
this.x = value;
}
let p;
const handler = {
construct(target, arguments, newTarget) {
expect(target).toBe(f);
expect(newTarget).toBe(p);
if (arguments[1]) return Reflect.construct(target, [arguments[0] * 2], newTarget);
return Reflect.construct(target, arguments, newTarget);
},
};
p = new Proxy(f, handler);
let p;
const handler = {
construct(target, arguments, newTarget) {
expect(target).toBe(f);
expect(newTarget).toBe(p);
if (arguments[1]) return Reflect.construct(target, [arguments[0] * 2], newTarget);
return Reflect.construct(target, arguments, newTarget);
},
};
p = new Proxy(f, handler);
expect(new p(15).x).toBe(15);
expect(new p(15, true).x).toBe(30);
});
expect(new p(15).x).toBe(15);
expect(new p(15, true).x).toBe(30);
});
test("trapping Reflect.construct", () => {
function f(value) {
this.x = value;
}
test("trapping Reflect.construct", () => {
function f(value) {
this.x = value;
}
let p;
function theNewTarget() {}
const handler = {
construct(target, arguments, newTarget) {
expect(target).toBe(f);
expect(newTarget).toBe(theNewTarget);
if (arguments[1]) return Reflect.construct(target, [arguments[0] * 2], newTarget);
return Reflect.construct(target, arguments, newTarget);
},
};
p = new Proxy(f, handler);
let p;
function theNewTarget() {}
const handler = {
construct(target, arguments, newTarget) {
expect(target).toBe(f);
expect(newTarget).toBe(theNewTarget);
if (arguments[1]) return Reflect.construct(target, [arguments[0] * 2], newTarget);
return Reflect.construct(target, arguments, newTarget);
},
};
p = new Proxy(f, handler);
Reflect.construct(p, [15], theNewTarget);
});
Reflect.construct(p, [15], theNewTarget);
});
});
describe("[[Construct]] invariants", () => {
test("target must have a [[Construct]] slot", () => {
[{}, [], new Proxy({}, {})].forEach(item => {
expect(() => {
new new Proxy(item, {})();
}).toThrowWithMessage(TypeError, "[object ProxyObject] is not a constructor");
test("target must have a [[Construct]] slot", () => {
[{}, [], new Proxy({}, {})].forEach(item => {
expect(() => {
new new Proxy(item, {})();
}).toThrowWithMessage(TypeError, "[object ProxyObject] is not a constructor");
});
});
});
});

224
Libraries/LibJS/Tests/builtins/Proxy/Proxy.handler-defineProperty.js
View file

@ -1,133 +1,133 @@
describe("[[DefineProperty]] trap normal behavior", () => {
test("forwarding when not defined in handler", () => {
let p = new Proxy({}, { defineProperty: null });
expect(Object.defineProperty(p, "foo", {})).toBe(p);
p = new Proxy({}, { defineProperty: undefined });
expect(Object.defineProperty(p, "foo", {})).toBe(p);
p = new Proxy({}, {});
expect(Object.defineProperty(p, "foo", {})).toBe(p);
});
test("correct arguments passed to trap", () => {
let o = {};
p = new Proxy(o, {
defineProperty(target, name, descriptor) {
expect(target).toBe(o);
expect(name).toBe("foo");
expect(descriptor.configurable).toBeTrue();
expect(descriptor.enumerable).toBeUndefined();
expect(descriptor.writable).toBeTrue();
expect(descriptor.value).toBe(10);
expect(descriptor.get).toBeUndefined();
expect(descriptor.set).toBeUndefined();
return true;
},
test("forwarding when not defined in handler", () => {
let p = new Proxy({}, { defineProperty: null });
expect(Object.defineProperty(p, "foo", {})).toBe(p);
p = new Proxy({}, { defineProperty: undefined });
expect(Object.defineProperty(p, "foo", {})).toBe(p);
p = new Proxy({}, {});
expect(Object.defineProperty(p, "foo", {})).toBe(p);
});
Object.defineProperty(p, "foo", { configurable: true, writable: true, value: 10 });
});
test("correct arguments passed to trap", () => {
let o = {};
p = new Proxy(o, {
defineProperty(target, name, descriptor) {
expect(target).toBe(o);
expect(name).toBe("foo");
expect(descriptor.configurable).toBeTrue();
expect(descriptor.enumerable).toBeUndefined();
expect(descriptor.writable).toBeTrue();
expect(descriptor.value).toBe(10);
expect(descriptor.get).toBeUndefined();
expect(descriptor.set).toBeUndefined();
return true;
},
});
test("optionally ignoring the define call", () => {
let o = {};
let p = new Proxy(o, {
defineProperty(target, name, descriptor) {
if (target[name] === undefined) Object.defineProperty(target, name, descriptor);
return true;
},
Object.defineProperty(p, "foo", { configurable: true, writable: true, value: 10 });
});
Object.defineProperty(p, "foo", {
value: 10,
enumerable: true,
configurable: false,
writable: true,
});
expect(p).toHaveEnumerableProperty("foo");
expect(p).not.toHaveConfigurableProperty("foo");
expect(p).toHaveWritableProperty("foo");
expect(p).toHaveValueProperty("foo", 10);
expect(p).not.toHaveGetterProperty("foo");
expect(p).not.toHaveSetterProperty("foo");
test("optionally ignoring the define call", () => {
let o = {};
let p = new Proxy(o, {
defineProperty(target, name, descriptor) {
if (target[name] === undefined) Object.defineProperty(target, name, descriptor);
return true;
},
});
Object.defineProperty(p, "foo", {
value: 20,
enumerable: true,
configurable: false,
writable: true,
Object.defineProperty(p, "foo", {
value: 10,
enumerable: true,
configurable: false,
writable: true,
});
expect(p).toHaveEnumerableProperty("foo");
expect(p).not.toHaveConfigurableProperty("foo");
expect(p).toHaveWritableProperty("foo");
expect(p).toHaveValueProperty("foo", 10);
expect(p).not.toHaveGetterProperty("foo");
expect(p).not.toHaveSetterProperty("foo");
Object.defineProperty(p, "foo", {
value: 20,
enumerable: true,
configurable: false,
writable: true,
});
expect(p).toHaveEnumerableProperty("foo");
expect(p).not.toHaveConfigurableProperty("foo");
expect(p).toHaveWritableProperty("foo");
expect(p).toHaveValueProperty("foo", 10);
expect(p).not.toHaveGetterProperty("foo");
expect(p).not.toHaveSetterProperty("foo");
});
expect(p).toHaveEnumerableProperty("foo");
expect(p).not.toHaveConfigurableProperty("foo");
expect(p).toHaveWritableProperty("foo");
expect(p).toHaveValueProperty("foo", 10);
expect(p).not.toHaveGetterProperty("foo");
expect(p).not.toHaveSetterProperty("foo");
});
});
describe("[[DefineProperty]] invariants", () => {
test("trap can't return false", () => {
let p = new Proxy(
{},
{
defineProperty() {
return false;
},
}
);
test("trap can't return false", () => {
let p = new Proxy(
{},
{
defineProperty() {
return false;
},
}
);
expect(() => {
Object.defineProperty(p, "foo", {});
}).toThrowWithMessage(TypeError, "Object's [[DefineProperty]] method returned false");
});
test("trap cannot return true for a non-extensible target if the property does not exist", () => {
let o = {};
Object.preventExtensions(o);
let p = new Proxy(o, {
defineProperty() {
return true;
},
expect(() => {
Object.defineProperty(p, "foo", {});
}).toThrowWithMessage(TypeError, "Object's [[DefineProperty]] method returned false");
});
expect(() => {
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"
);
});
test("trap cannot return true for a non-extensible target if the property does not exist", () => {
let o = {};
Object.preventExtensions(o);
let p = new Proxy(o, {
defineProperty() {
return true;
},
});
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 });
let p = new Proxy(o, {
defineProperty() {
return true;
},
expect(() => {
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"
);
});
expect(() => {
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"
);
});
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 });
let p = new Proxy(o, {
defineProperty() {
return true;
},
});
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, "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"
);
});
expect(() => {
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"
);
});
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 });
}).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"
);
});
});

92
Libraries/LibJS/Tests/builtins/Proxy/Proxy.handler-deleteProperty.js
View file

@ -1,58 +1,58 @@
describe("[[Delete]] trap normal behavior", () => {
test("forwarding when not defined in handler", () => {
expect(delete new Proxy({}, { deleteProperty: undefined }).foo).toBeTrue();
expect(delete new Proxy({}, { deleteProperty: null }).foo).toBeTrue();
expect(delete new Proxy({}, {}).foo).toBeTrue();
});
test("correct arguments supplied to trap", () => {
let o = {};
let p = new Proxy(o, {
deleteProperty(target, property) {
expect(target).toBe(o);
expect(property).toBe("foo");
return true;
},
test("forwarding when not defined in handler", () => {
expect(delete new Proxy({}, { deleteProperty: undefined }).foo).toBeTrue();
expect(delete new Proxy({}, { deleteProperty: null }).foo).toBeTrue();
expect(delete new Proxy({}, {}).foo).toBeTrue();
});
delete p.foo;
});
test("correct arguments supplied to trap", () => {
let o = {};
let p = new Proxy(o, {
deleteProperty(target, property) {
expect(target).toBe(o);
expect(property).toBe("foo");
return true;
},
});
test("conditional deletion", () => {
o = { foo: 1, bar: 2 };
p = new Proxy(o, {
deleteProperty(target, property) {
if (property === "foo") {
delete target[property];
return true;
}
return false;
},
delete p.foo;
});
expect(delete p.foo).toBeTrue();
expect(delete p.bar).toBeFalse();
test("conditional deletion", () => {
o = { foo: 1, bar: 2 };
p = new Proxy(o, {
deleteProperty(target, property) {
if (property === "foo") {
delete target[property];
return true;
}
return false;
},
});
expect(o.foo).toBeUndefined();
expect(o.bar).toBe(2);
});
expect(delete p.foo).toBeTrue();
expect(delete p.bar).toBeFalse();
expect(o.foo).toBeUndefined();
expect(o.bar).toBe(2);
});
});
describe("[[Delete]] invariants", () => {
test("cannot report a non-configurable own property as deleted", () => {
let o = {};
Object.defineProperty(o, "foo", { configurable: false });
let p = new Proxy(o, {
deleteProperty() {
return true;
},
});
test("cannot report a non-configurable own property as deleted", () => {
let o = {};
Object.defineProperty(o, "foo", { configurable: false });
let p = new Proxy(o, {
deleteProperty() {
return true;
},
});
expect(() => {
delete p.foo;
}).toThrowWithMessage(
TypeError,
"Proxy handler's deleteProperty trap violates invariant: cannot report a non-configurable own property of the target as deleted"
);
});
expect(() => {
delete p.foo;
}).toThrowWithMessage(
TypeError,
"Proxy handler's deleteProperty trap violates invariant: cannot report a non-configurable own property of the target as deleted"
);
});
});

132
Libraries/LibJS/Tests/builtins/Proxy/Proxy.handler-get.js
View file

@ -1,82 +1,82 @@
describe("[[Get]] trap normal behavior", () => {
test("forwarding when not defined in handler", () => {
expect(new Proxy({}, { get: undefined }).foo).toBeUndefined();
expect(new Proxy({}, { get: null }).foo).toBeUndefined();
expect(new Proxy({}, {}).foo).toBeUndefined();
});
test("correct arguments supplied to trap", () => {
let o = {};
let p = new Proxy(o, {
get(target, property, receiver) {
expect(target).toBe(o);
expect(property).toBe("foo");
expect(receiver).toBe(p);
},
test("forwarding when not defined in handler", () => {
expect(new Proxy({}, { get: undefined }).foo).toBeUndefined();
expect(new Proxy({}, { get: null }).foo).toBeUndefined();
expect(new Proxy({}, {}).foo).toBeUndefined();
});
p.foo;
});
test("correct arguments supplied to trap", () => {
let o = {};
let p = new Proxy(o, {
get(target, property, receiver) {
expect(target).toBe(o);
expect(property).toBe("foo");
expect(receiver).toBe(p);
},
});
test("conditional return", () => {
let o = { foo: 1 };
let p = new Proxy(o, {
get(target, property, receiver) {
if (property === "bar") {
return 2;
} else if (property === "baz") {
return receiver.qux;
} else if (property === "qux") {
return 3;
}
return target[property];
},
p.foo;
});
expect(p.foo).toBe(1);
expect(p.bar).toBe(2);
expect(p.baz).toBe(3);
expect(p.qux).toBe(3);
expect(p.test).toBeUndefined();
});
test("conditional return", () => {
let o = { foo: 1 };
let p = new Proxy(o, {
get(target, property, receiver) {
if (property === "bar") {
return 2;
} else if (property === "baz") {
return receiver.qux;
} else if (property === "qux") {
return 3;
}
return target[property];
},
});
expect(p.foo).toBe(1);
expect(p.bar).toBe(2);
expect(p.baz).toBe(3);
expect(p.qux).toBe(3);
expect(p.test).toBeUndefined();
});
});
describe("[[Get]] invariants", () => {
test("returned value must match the target property value if the property is non-configurable and non-writable", () => {
let o = {};
Object.defineProperty(o, "foo", { value: 5, configurable: false, writable: true });
Object.defineProperty(o, "bar", { value: 10, configurable: false, writable: false });
test("returned value must match the target property value if the property is non-configurable and non-writable", () => {
let o = {};
Object.defineProperty(o, "foo", { value: 5, configurable: false, writable: true });
Object.defineProperty(o, "bar", { value: 10, configurable: false, writable: false });
let p = new Proxy(o, {
get() {
return 8;
},
let p = new Proxy(o, {
get() {
return 8;
},
});
expect(p.foo).toBe(8);
expect(() => {
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"
);
});
expect(p.foo).toBe(8);
expect(() => {
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"
);
});
test("returned value must be undefined if the property is a non-configurable accessor with no getter", () => {
let o = {};
Object.defineProperty(o, "foo", { configurable: false, set(_) {} });
test("returned value must be undefined if the property is a non-configurable accessor with no getter", () => {
let o = {};
Object.defineProperty(o, "foo", { configurable: false, set(_) {} });
let p = new Proxy(o, {
get() {
return 8;
},
});
let p = new Proxy(o, {
get() {
return 8;
},
expect(() => {
p.foo;
}).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"
);
});
expect(() => {
p.foo;
}).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"
);
});
});

384
Libraries/LibJS/Tests/builtins/Proxy/Proxy.handler-getOwnPropertyDescriptor.js
View file

@ -1,212 +1,220 @@
describe("[Call][GetOwnProperty]] trap normal behavior", () => {
test("forwarding when not defined in handler", () => {
expect(
Object.getOwnPropertyDescriptor(new Proxy({}, { getOwnPropertyDescriptor: null }), "a")
).toBeUndefined();
expect(
Object.getOwnPropertyDescriptor(new Proxy({}, { getOwnPropertyDescriptor: undefined }), "a")
).toBeUndefined();
expect(Object.getOwnPropertyDescriptor(new Proxy({}, {}), "a")).toBeUndefined();
});
test("correct arguments supplied to trap", () => {
let o = {};
let p = new Proxy(o, {
getOwnPropertyDescriptor(target, property) {
expect(target).toBe(o);
expect(property).toBe("foo");
},
test("forwarding when not defined in handler", () => {
expect(
Object.getOwnPropertyDescriptor(new Proxy({}, { getOwnPropertyDescriptor: null }), "a")
).toBeUndefined();
expect(
Object.getOwnPropertyDescriptor(
new Proxy({}, { getOwnPropertyDescriptor: undefined }),
"a"
)
).toBeUndefined();
expect(Object.getOwnPropertyDescriptor(new Proxy({}, {}), "a")).toBeUndefined();
});
Object.getOwnPropertyDescriptor(p, "foo");
});
test("correct arguments supplied to trap", () => {
let o = {};
let p = new Proxy(o, {
getOwnPropertyDescriptor(target, property) {
expect(target).toBe(o);
expect(property).toBe("foo");
},
});
test("conditional returned descriptor", () => {
let o = { foo: "bar" };
Object.defineProperty(o, "baz", {
value: "qux",
enumerable: false,
configurable: true,
writable: false,
Object.getOwnPropertyDescriptor(p, "foo");
});
let p = new Proxy(o, {
getOwnPropertyDescriptor(target, property) {
if (property === "baz") return Object.getOwnPropertyDescriptor(target, "baz");
return { value: target[property], enumerable: false, configurable: true, writable: true };
},
test("conditional returned descriptor", () => {
let o = { foo: "bar" };
Object.defineProperty(o, "baz", {
value: "qux",
enumerable: false,
configurable: true,
writable: false,
});
let p = new Proxy(o, {
getOwnPropertyDescriptor(target, property) {
if (property === "baz") return Object.getOwnPropertyDescriptor(target, "baz");
return {
value: target[property],
enumerable: false,
configurable: true,
writable: true,
};
},
});
expect(p).toHaveConfigurableProperty("baz");
expect(p).not.toHaveEnumerableProperty("baz");
expect(p).not.toHaveWritableProperty("baz");
expect(p).toHaveValueProperty("baz", "qux");
expect(p).not.toHaveGetterProperty("baz");
expect(p).not.toHaveSetterProperty("baz");
d = Object.getOwnPropertyDescriptor(p, "foo");
expect(p).toHaveConfigurableProperty("foo");
expect(p).not.toHaveEnumerableProperty("foo");
expect(p).toHaveWritableProperty("foo");
expect(p).toHaveValueProperty("foo", "bar");
expect(p).not.toHaveGetterProperty("foo");
expect(p).not.toHaveSetterProperty("foo");
});
expect(p).toHaveConfigurableProperty("baz");
expect(p).not.toHaveEnumerableProperty("baz");
expect(p).not.toHaveWritableProperty("baz");
expect(p).toHaveValueProperty("baz", "qux");
expect(p).not.toHaveGetterProperty("baz");
expect(p).not.toHaveSetterProperty("baz");
d = Object.getOwnPropertyDescriptor(p, "foo");
expect(p).toHaveConfigurableProperty("foo");
expect(p).not.toHaveEnumerableProperty("foo");
expect(p).toHaveWritableProperty("foo");
expect(p).toHaveValueProperty("foo", "bar");
expect(p).not.toHaveGetterProperty("foo");
expect(p).not.toHaveSetterProperty("foo");
});
});
describe("[[GetOwnProperty]] invariants", () => {
test("must return an object or undefined", () => {
expect(() => {
Object.getOwnPropertyDescriptor(
new Proxy(
{},
{
test("must return an object or undefined", () => {
expect(() => {
Object.getOwnPropertyDescriptor(
new Proxy(
{},
{
getOwnPropertyDescriptor() {
return 1;
},
}
)
);
}).toThrowWithMessage(
TypeError,
"Proxy handler's getOwnPropertyDescriptor trap violates invariant: must return an object or undefined"
);
});
test("cannot return undefined for a non-configurable property", () => {
let o = {};
Object.defineProperty(o, "foo", { value: 10, configurable: false });
let p = new Proxy(o, {
getOwnPropertyDescriptor() {
return 1;
return undefined;
},
}
)
);
}).toThrowWithMessage(
TypeError,
"Proxy handler's getOwnPropertyDescriptor trap violates invariant: must return an object or undefined"
);
});
});
test("cannot return undefined for a non-configurable property", () => {
let o = {};
Object.defineProperty(o, "foo", { value: 10, configurable: false });
expect(Object.getOwnPropertyDescriptor(p, "bar")).toBeUndefined();
let p = new Proxy(o, {
getOwnPropertyDescriptor() {
return undefined;
},
expect(() => {
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"
);
});
expect(Object.getOwnPropertyDescriptor(p, "bar")).toBeUndefined();
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.preventExtensions(o);
expect(() => {
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"
);
});
let p = new Proxy(o, {
getOwnPropertyDescriptor() {
return undefined;
},
});
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.preventExtensions(o);
let p = new Proxy(o, {
getOwnPropertyDescriptor() {
return undefined;
},
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"
);
});
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, "v2", { value: 10, configurable: false, enumerable: true });
Object.defineProperty(o, "v3", {
configurable: false,
get() {
return 1;
},
});
Object.defineProperty(o, "v4", {
value: 10,
configurable: false,
writable: false,
enumerable: true,
});
test("invalid property descriptors", () => {
let o = {};
Object.defineProperty(o, "v1", { value: 10, configurable: false });
Object.defineProperty(o, "v2", { value: 10, configurable: false, enumerable: true });
Object.defineProperty(o, "v3", {
configurable: false,
get() {
return 1;
},
});
Object.defineProperty(o, "v4", {
value: 10,
configurable: false,
writable: false,
enumerable: true,
expect(() => {
Object.getOwnPropertyDescriptor(
new Proxy(o, {
getOwnPropertyDescriptor() {
return { configurable: true };
},
}),
"v1"
);
}).toThrowWithMessage(
TypeError,
"Proxy handler's getOwnPropertyDescriptor trap violates invariant: invalid property descriptor for existing property on the target"
);
expect(() => {
Object.getOwnPropertyDescriptor(
new Proxy(o, {
getOwnPropertyDescriptor() {
return { enumerable: false };
},
}),
"v2"
);
}).toThrowWithMessage(
TypeError,
"Proxy handler's getOwnPropertyDescriptor trap violates invariant: invalid property descriptor for existing property on the target"
);
expect(() => {
Object.getOwnPropertyDescriptor(
new Proxy(o, {
getOwnPropertyDescriptor() {
return { value: 10 };
},
}),
"v3"
);
}).toThrowWithMessage(
TypeError,
"Proxy handler's getOwnPropertyDescriptor trap violates invariant: invalid property descriptor for existing property on the target"
);
expect(() => {
Object.getOwnPropertyDescriptor(
new Proxy(o, {
getOwnPropertyDescriptor() {
return { value: 10, writable: true };
},
}),
"v4"
);
}).toThrowWithMessage(
TypeError,
"Proxy handler's getOwnPropertyDescriptor trap violates invariant: invalid property descriptor for existing property on the target"
);
});
expect(() => {
Object.getOwnPropertyDescriptor(
new Proxy(o, {
getOwnPropertyDescriptor() {
return { configurable: true };
},
}),
"v1"
);
}).toThrowWithMessage(
TypeError,
"Proxy handler's getOwnPropertyDescriptor trap violates invariant: invalid property descriptor for existing property on the target"
);
expect(() => {
Object.getOwnPropertyDescriptor(
new Proxy(o, {
getOwnPropertyDescriptor() {
return { enumerable: false };
},
}),
"v2"
);
}).toThrowWithMessage(
TypeError,
"Proxy handler's getOwnPropertyDescriptor trap violates invariant: invalid property descriptor for existing property on the target"
);
expect(() => {
Object.getOwnPropertyDescriptor(
new Proxy(o, {
getOwnPropertyDescriptor() {
return { value: 10 };
},
}),
"v3"
);
}).toThrowWithMessage(
TypeError,
"Proxy handler's getOwnPropertyDescriptor trap violates invariant: invalid property descriptor for existing property on the target"
);
expect(() => {
Object.getOwnPropertyDescriptor(
new Proxy(o, {
getOwnPropertyDescriptor() {
return { value: 10, writable: true };
},
}),
"v4"
);
}).toThrowWithMessage(
TypeError,
"Proxy handler's getOwnPropertyDescriptor trap violates invariant: invalid property descriptor for existing property on the target"
);
});
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 });
expect(() => {
Object.getOwnPropertyDescriptor(
new Proxy(o, {
getOwnPropertyDescriptor() {
return { configurable: false };
},
}),
"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"
);
});
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 });
expect(() => {
Object.getOwnPropertyDescriptor(
new Proxy(o, {
getOwnPropertyDescriptor() {
return { configurable: false };
},
}),
"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"
);
});
});

158
Libraries/LibJS/Tests/builtins/Proxy/Proxy.handler-getPrototypeOf.js
View file

@ -1,95 +1,95 @@
describe("[[GetPrototypeOf]] trap normal behavior", () => {
test("forwarding when not defined in handler", () => {
let proto = {};
let o = {};
Object.setPrototypeOf(o, proto);
test("forwarding when not defined in handler", () => {
let proto = {};
let o = {};
Object.setPrototypeOf(o, proto);
let p = new Proxy(o, { prototype: null });
expect(Object.getPrototypeOf(p)).toBe(proto);
p = new Proxy(o, { apply: undefined });
expect(Object.getPrototypeOf(p)).toBe(proto);
p = new Proxy(o, {});
expect(Object.getPrototypeOf(p)).toBe(proto);
});
test("correct arguments supplied to trap", () => {
let o = {};
let p = new Proxy(o, {
getPrototypeOf(target) {
expect(target).toBe(o);
return null;
},
let p = new Proxy(o, { prototype: null });
expect(Object.getPrototypeOf(p)).toBe(proto);
p = new Proxy(o, { apply: undefined });
expect(Object.getPrototypeOf(p)).toBe(proto);
p = new Proxy(o, {});
expect(Object.getPrototypeOf(p)).toBe(proto);
});
Object.getPrototypeOf(p);
});
test("correct arguments supplied to trap", () => {
let o = {};
let p = new Proxy(o, {
getPrototypeOf(target) {
expect(target).toBe(o);
return null;
},
});
test("conditional return", () => {
let o = {};
let p = new Proxy(o, {
getPrototypeOf(target) {
if (target.foo) return { bar: 1 };
return { bar: 2 };
},
Object.getPrototypeOf(p);
});
expect(Object.getPrototypeOf(p).bar).toBe(2);
o.foo = 20;
expect(Object.getPrototypeOf(p).bar).toBe(1);
});
test("conditional return", () => {
let o = {};
let p = new Proxy(o, {
getPrototypeOf(target) {
if (target.foo) return { bar: 1 };
return { bar: 2 };
},
});
test("non-extensible target", () => {
let o = {};
let proto = { foo: "bar" };
Object.setPrototypeOf(o, proto);
Object.preventExtensions(o);
p = new Proxy(o, {
getPrototypeOf() {
return proto;
},
expect(Object.getPrototypeOf(p).bar).toBe(2);
o.foo = 20;
expect(Object.getPrototypeOf(p).bar).toBe(1);
});
expect(Object.getPrototypeOf(p).foo).toBe("bar");
});
test("non-extensible target", () => {
let o = {};
let proto = { foo: "bar" };
Object.setPrototypeOf(o, proto);
Object.preventExtensions(o);
p = new Proxy(o, {
getPrototypeOf() {
return proto;
},
});
expect(Object.getPrototypeOf(p).foo).toBe("bar");
});
});
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) {
return { baz: "qux" };
},
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"
);
});
expect(() => {
Object.getPrototypeOf(p);
}).toThrowWithMessage(
TypeError,
"Proxy handler's getPrototypeOf trap violates invariant: cannot return a different prototype object for a non-extensible target"
);
});
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) {
return { baz: "qux" };
},
});
expect(() => {
Object.getPrototypeOf(p);
}).toThrowWithMessage(
TypeError,
"Proxy handler's getPrototypeOf trap violates invariant: cannot return a different prototype object for a non-extensible target"
);
});
});

116
Libraries/LibJS/Tests/builtins/Proxy/Proxy.handler-has.js
View file

@ -1,74 +1,74 @@
describe("[[Has]] trap normal behavior", () => {
test("forwarding when not defined in handler", () => {
expect("foo" in new Proxy({}, { has: null })).toBeFalse();
expect("foo" in new Proxy({}, { has: undefined })).toBeFalse();
expect("foo" in new Proxy({}, {})).toBeFalse();
});
test("correct arguments supplied to trap", () => {
let o = {};
let p = new Proxy(o, {
has(target, prop) {
expect(target).toBe(o);
expect(prop).toBe("foo");
return true;
},
test("forwarding when not defined in handler", () => {
expect("foo" in new Proxy({}, { has: null })).toBeFalse();
expect("foo" in new Proxy({}, { has: undefined })).toBeFalse();
expect("foo" in new Proxy({}, {})).toBeFalse();
});
"foo" in p;
});
test("correct arguments supplied to trap", () => {
let o = {};
let p = new Proxy(o, {
has(target, prop) {
expect(target).toBe(o);
expect(prop).toBe("foo");
return true;
},
});
test("conditional return", () => {
let o = {};
let p = new Proxy(o, {
has(target, prop) {
if (target.checkedFoo) return true;
if (prop === "foo") target.checkedFoo = true;
return false;
},
"foo" in p;
});
expect("foo" in p).toBeFalse();
expect("foo" in p).toBeTrue();
});
test("conditional return", () => {
let o = {};
let p = new Proxy(o, {
has(target, prop) {
if (target.checkedFoo) return true;
if (prop === "foo") target.checkedFoo = true;
return false;
},
});
expect("foo" in p).toBeFalse();
expect("foo" in p).toBeTrue();
});
});
describe("[[Has]] invariants", () => {
test("cannot return false if the property exists and is non-configurable", () => {
let o = {};
Object.defineProperty(o, "foo", { configurable: false });
test("cannot return false if the property exists and is non-configurable", () => {
let o = {};
Object.defineProperty(o, "foo", { configurable: false });
p = new Proxy(o, {
has() {
return false;
},
p = new Proxy(o, {
has() {
return false;
},
});
expect(() => {
"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"
);
});
expect(() => {
"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"
);
});
test("cannot return false if the property exists and the target is non-extensible", () => {
let o = {};
Object.defineProperty(o, "foo", { value: 10, configurable: true });
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;
},
});
let p = new Proxy(o, {
has() {
return false;
},
Object.preventExtensions(o);
expect(() => {
"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"
);
});
Object.preventExtensions(o);
expect(() => {
"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"
);
});
});

60
Libraries/LibJS/Tests/builtins/Proxy/Proxy.handler-isExtensible.js
View file

@ -1,39 +1,39 @@
describe("[[IsExtensible]] trap normal behavior", () => {
test("forwarding when not defined in handler", () => {
expect(Object.isExtensible(new Proxy({}, { isExtensible: null }))).toBeTrue();
expect(Object.isExtensible(new Proxy({}, { isExtensible: undefined }))).toBeTrue();
expect(Object.isExtensible(new Proxy({}, {}))).toBeTrue();
});
test("correct arguments supplied to trap", () => {
let o = {};
let p = new Proxy(o, {
isExtensible(target) {
expect(target).toBe(o);
return true;
},
test("forwarding when not defined in handler", () => {
expect(Object.isExtensible(new Proxy({}, { isExtensible: null }))).toBeTrue();
expect(Object.isExtensible(new Proxy({}, { isExtensible: undefined }))).toBeTrue();
expect(Object.isExtensible(new Proxy({}, {}))).toBeTrue();
});
expect(Object.isExtensible(p)).toBeTrue();
});
test("correct arguments supplied to trap", () => {
let o = {};
let p = new Proxy(o, {
isExtensible(target) {
expect(target).toBe(o);
return true;
},
});
expect(Object.isExtensible(p)).toBeTrue();
});
});
describe("[[Call]] invariants", () => {
test("return value must match the target's extensibility", () => {
let o = {};
Object.preventExtensions(o);
test("return value must match the target's extensibility", () => {
let o = {};
Object.preventExtensions(o);
let p = new Proxy(o, {
isExtensible() {
return true;
},
let p = new Proxy(o, {
isExtensible() {
return true;
},
});
expect(() => {
Object.isExtensible(p);
}).toThrowWithMessage(
TypeError,
"Proxy handler's isExtensible trap violates invariant: return value must match the target's extensibility"
);
});
expect(() => {
Object.isExtensible(p);
}).toThrowWithMessage(
TypeError,
"Proxy handler's isExtensible trap violates invariant: return value must match the target's extensibility"
);
});
});

96
Libraries/LibJS/Tests/builtins/Proxy/Proxy.handler-preventExtensions.js
View file

@ -1,59 +1,59 @@
describe("[[PreventExtension]] trap normal behavior", () => {
test("forwarding when not defined in handler", () => {
let p = new Proxy({}, { preventExtensions: null });
expect(Object.preventExtensions(p)).toBe(p);
p = new Proxy({}, { preventExtensions: undefined });
expect(Object.preventExtensions(p)).toBe(p);
p = new Proxy({}, {});
expect(Object.preventExtensions(p)).toBe(p);
});
test("correct arguments supplied to trap", () => {
let o = {};
p = new Proxy(o, {
preventExtensions(target) {
expect(target).toBe(o);
return true;
},
test("forwarding when not defined in handler", () => {
let p = new Proxy({}, { preventExtensions: null });
expect(Object.preventExtensions(p)).toBe(p);
p = new Proxy({}, { preventExtensions: undefined });
expect(Object.preventExtensions(p)).toBe(p);
p = new Proxy({}, {});
expect(Object.preventExtensions(p)).toBe(p);
});
Object.preventExtensions(o);
Object.preventExtensions(p);
});
test("correct arguments supplied to trap", () => {
let o = {};
p = new Proxy(o, {
preventExtensions(target) {
expect(target).toBe(o);
return true;
},
});
Object.preventExtensions(o);
Object.preventExtensions(p);
});
});
describe("[[PreventExtensions]] invariants", () => {
test("cannot return false", () => {
let p = new Proxy(
{},
{
preventExtensions() {
return false;
},
}
);
test("cannot return false", () => {
let p = new Proxy(
{},
{
preventExtensions() {
return false;
},
}
);
expect(() => {
Object.preventExtensions(p);
}).toThrowWithMessage(TypeError, "Object's [[PreventExtensions]] method returned false");
});
test("cannot return true if the target is extensible", () => {
let o = {};
let p = new Proxy(o, {
preventExtensions() {
return true;
},
expect(() => {
Object.preventExtensions(p);
}).toThrowWithMessage(TypeError, "Object's [[PreventExtensions]] method returned false");
});
expect(() => {
Object.preventExtensions(p);
}).toThrowWithMessage(
TypeError,
"Proxy handler's preventExtensions trap violates invariant: cannot return true if the target object is extensible"
);
test("cannot return true if the target is extensible", () => {
let o = {};
let p = new Proxy(o, {
preventExtensions() {
return true;
},
});
Object.preventExtensions(o);
expect(Object.preventExtensions(p)).toBe(p);
});
expect(() => {
Object.preventExtensions(p);
}).toThrowWithMessage(
TypeError,
"Proxy handler's preventExtensions trap violates invariant: cannot return true if the target object is extensible"
);
Object.preventExtensions(o);
expect(Object.preventExtensions(p)).toBe(p);
});
});

134
Libraries/LibJS/Tests/builtins/Proxy/Proxy.handler-set.js
View file

@ -1,82 +1,82 @@
describe("[[Set]] trap normal behavior", () => {
test("forwarding when not defined in handler", () => {
expect((new Proxy({}, { set: undefined }).foo = 1)).toBe(1);
expect((new Proxy({}, { set: null }).foo = 1)).toBe(1);
expect((new Proxy({}, {}).foo = 1)).toBe(1);
});
test("correct arguments supplied to trap", () => {
let o = {};
let p = new Proxy(o, {
set(target, prop, value, receiver) {
expect(target).toBe(o);
expect(prop).toBe("foo");
expect(value).toBe(10);
expect(receiver).toBe(p);
return true;
},
test("forwarding when not defined in handler", () => {
expect((new Proxy({}, { set: undefined }).foo = 1)).toBe(1);
expect((new Proxy({}, { set: null }).foo = 1)).toBe(1);
expect((new Proxy({}, {}).foo = 1)).toBe(1);
});
p.foo = 10;
});
test("correct arguments supplied to trap", () => {
let o = {};
let p = new Proxy(o, {
set(target, prop, value, receiver) {
expect(target).toBe(o);
expect(prop).toBe("foo");
expect(value).toBe(10);
expect(receiver).toBe(p);
return true;
},
});
test("conditional return value", () => {
let p = new Proxy(
{},
{
set(target, prop, value) {
if (target[prop] === value) {
target[prop] *= 2;
} else {
target[prop] = value;
}
},
}
);
p.foo = 10;
});
p.foo = 10;
expect(p.foo).toBe(10);
p.foo = 10;
expect(p.foo).toBe(20);
p.foo = 10;
expect(p.foo).toBe(10);
});
test("conditional return value", () => {
let p = new Proxy(
{},
{
set(target, prop, value) {
if (target[prop] === value) {
target[prop] *= 2;
} else {
target[prop] = value;
}
},
}
);
p.foo = 10;
expect(p.foo).toBe(10);
p.foo = 10;
expect(p.foo).toBe(20);
p.foo = 10;
expect(p.foo).toBe(10);
});
});
describe("[[Set]] invariants", () => {
test("cannot return true for a non-configurable, non-writable property", () => {
let o = {};
Object.defineProperty(o, "foo", { value: 10 });
test("cannot return true for a non-configurable, non-writable property", () => {
let o = {};
Object.defineProperty(o, "foo", { value: 10 });
let p = new Proxy(o, {
set() {
return true;
},
let p = new Proxy(o, {
set() {
return true;
},
});
expect(() => {
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"
);
});
expect(() => {
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"
);
});
test("cannot return true for a non-configurable accessor property with no setter", () => {
let o = {};
Object.defineProperty(o, "foo", { get() {} });
test("cannot return true for a non-configurable accessor property with no setter", () => {
let o = {};
Object.defineProperty(o, "foo", { get() {} });
let p = new Proxy(o, {
set() {
return true;
},
});
let p = new Proxy(o, {
set() {
return true;
},
expect(() => {
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 own accessor property with an undefined set attribute"
);
});
expect(() => {
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 own accessor property with an undefined set attribute"
);
});
});

150
Libraries/LibJS/Tests/builtins/Proxy/Proxy.handler-setPrototypeOf.js
View file

@ -1,96 +1,96 @@
describe("[[SetPrototypeOf]] trap normal behavior", () => {
test("forwarding when not defined in handler", () => {
const o = {};
const proto = { foo: "bar" };
Object.setPrototypeOf(o, proto);
test("forwarding when not defined in handler", () => {
const o = {};
const proto = { foo: "bar" };
Object.setPrototypeOf(o, proto);
let p = new Proxy(o, { setPrototypeOf: null });
expect(Object.setPrototypeOf(p, proto)).toBe(p);
let p = new Proxy(o, { setPrototypeOf: undefined });
expect(Object.setPrototypeOf(p, proto)).toBe(p);
let p = new Proxy(o, {});
expect(Object.setPrototypeOf(p, proto)).toBe(p);
});
test("correct arguments supplied to trap", () => {
let o = {};
let theNewProto = { foo: "bar" };
let p = new Proxy(o, {
setPrototypeOf(target, newProto) {
expect(target).toBe(o);
expect(newProto).toBe(theNewProto);
return true;
},
let p = new Proxy(o, { setPrototypeOf: null });
expect(Object.setPrototypeOf(p, proto)).toBe(p);
let p = new Proxy(o, { setPrototypeOf: undefined });
expect(Object.setPrototypeOf(p, proto)).toBe(p);
let p = new Proxy(o, {});
expect(Object.setPrototypeOf(p, proto)).toBe(p);
});
Object.setPrototypeOf(p, theNewProto);
});
test("correct arguments supplied to trap", () => {
let o = {};
let theNewProto = { foo: "bar" };
test("conditional setting", () => {
let o = {};
let p = new Proxy(o, {
setPrototypeOf(target, newProto) {
expect(target).toBe(o);
expect(newProto).toBe(theNewProto);
return true;
},
});
let p = new Proxy(o, {
setPrototypeOf(target, newProto) {
if (target.shouldSet) Object.setPrototypeOf(target, newProto);
return true;
},
Object.setPrototypeOf(p, theNewProto);
});
Object.setPrototypeOf(p, { foo: 1 });
expect(Object.getPrototypeOf(p).foo).toBeUndefined();
p.shouldSet = true;
expect(o.shouldSet).toBeTrue();
Object.setPrototypeOf(p, { foo: 1 });
expect(Object.getPrototypeOf(p).foo).toBe(1);
});
test("conditional setting", () => {
let o = {};
test("non-extensible targets", () => {
let o = {};
let proto = {};
Object.setPrototypeOf(o, proto);
Object.preventExtensions(o);
let p = new Proxy(o, {
setPrototypeOf(target, newProto) {
if (target.shouldSet) Object.setPrototypeOf(target, newProto);
return true;
},
});
p = new Proxy(o, {
setPrototypeOf() {
return true;
},
Object.setPrototypeOf(p, { foo: 1 });
expect(Object.getPrototypeOf(p).foo).toBeUndefined();
p.shouldSet = true;
expect(o.shouldSet).toBeTrue();
Object.setPrototypeOf(p, { foo: 1 });
expect(Object.getPrototypeOf(p).foo).toBe(1);
});
expect(Object.setPrototypeOf(p, proto)).toBe(p);
expect(Object.getPrototypeOf(p)).toBe(proto);
});
test("non-extensible targets", () => {
let o = {};
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;
},
test("cannot return false", () => {
let o = {};
p = new Proxy(o, {
setPrototypeOf() {
return false;
},
});
expect(() => {
Object.setPrototypeOf(p, {});
}).toThrowWithMessage(TypeError, "Object's [[SetPrototypeOf]] method returned false");
});
expect(() => {
Object.setPrototypeOf(p, {});
}).toThrowWithMessage(TypeError, "Object's [[SetPrototypeOf]] method returned false");
});
test("the argument must match the target's prototype if the target is non-extensible", () => {
let o = {};
Object.preventExtensions(o);
test("the argument must match the target's prototype if the target is non-extensible", () => {
let o = {};
Object.preventExtensions(o);
let p = new Proxy(o, {
setPrototypeOf() {
return true;
},
});
let p = new Proxy(o, {
setPrototypeOf() {
return true;
},
expect(() => {
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"
);
});
expect(() => {
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"
);
});
});

48
Libraries/LibJS/Tests/builtins/Proxy/Proxy.js
View file

@ -1,37 +1,37 @@
test("constructs properly", () => {
expect(() => {
new Proxy({}, {});
}).not.toThrow();
expect(() => {
new Proxy({}, {});
}).not.toThrow();
});
test("constructor argument count", () => {
expect(() => {
new Proxy();
}).toThrowWithMessage(TypeError, "Proxy constructor requires at least two arguments");
expect(() => {
new Proxy();
}).toThrowWithMessage(TypeError, "Proxy constructor requires at least two arguments");
expect(() => {
new Proxy({});
}).toThrowWithMessage(TypeError, "Proxy constructor requires at least two arguments");
expect(() => {
new Proxy({});
}).toThrowWithMessage(TypeError, "Proxy constructor requires at least two arguments");
});
test("constructor requires objects", () => {
expect(() => {
new Proxy(1, {});
}).toThrowWithMessage(
TypeError,
"Expected target argument of Proxy constructor to be object, got 1"
);
expect(() => {
new Proxy(1, {});
}).toThrowWithMessage(
TypeError,
"Expected target argument of Proxy constructor to be object, got 1"
);
expect(() => {
new Proxy({}, 1);
}).toThrowWithMessage(
TypeError,
"Expected handler argument of Proxy constructor to be object, got 1"
);
expect(() => {
new Proxy({}, 1);
}).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");
expect(() => {
Proxy({}, {});
}).toThrowWithMessage(TypeError, "Proxy must be called with the 'new' operator");
});