mirror of
https://github.com/RGBCube/serenity
synced 2025-07-25 20:37:35 +00:00
test-js: Use prettier and format all files
This commit is contained in:
parent
e532888242
commit
6d58c48c2f
248 changed files with 8291 additions and 7725 deletions
|
@ -1,127 +1,137 @@
|
|||
describe("normal functionality", () => {
|
||||
test("non-configurable property", () => {
|
||||
let o = {};
|
||||
Object.defineProperty(o, "foo", { value: 1, writable: false, enumerable: false });
|
||||
test("non-configurable property", () => {
|
||||
let o = {};
|
||||
Object.defineProperty(o, "foo", { value: 1, writable: false, enumerable: false });
|
||||
|
||||
expect(o.foo).toBe(1);
|
||||
o.foo = 2;
|
||||
expect(o.foo).toBe(1);
|
||||
expect(o.foo).toBe(1);
|
||||
o.foo = 2;
|
||||
expect(o.foo).toBe(1);
|
||||
|
||||
expect(o).not.toHaveConfigurableProperty("foo");
|
||||
expect(o).not.toHaveEnumerableProperty("foo");
|
||||
expect(o).not.toHaveWritableProperty("foo");
|
||||
expect(o).toHaveValueProperty("foo", 1);
|
||||
expect(o).not.toHaveConfigurableProperty("foo");
|
||||
expect(o).not.toHaveEnumerableProperty("foo");
|
||||
expect(o).not.toHaveWritableProperty("foo");
|
||||
expect(o).toHaveValueProperty("foo", 1);
|
||||
});
|
||||
|
||||
test("array index getter", () => {
|
||||
let o = {};
|
||||
Object.defineProperty(o, 2, {
|
||||
get() {
|
||||
return 10;
|
||||
},
|
||||
});
|
||||
expect(o[2]).toBe(10);
|
||||
});
|
||||
|
||||
test("configurable property", () => {
|
||||
let o = {};
|
||||
Object.defineProperty(o, "foo", { value: "hi", writable: true, enumerable: true });
|
||||
|
||||
expect(o.foo).toBe("hi");
|
||||
o.foo = "ho";
|
||||
expect(o.foo).toBe("ho");
|
||||
|
||||
expect(o).not.toHaveConfigurableProperty("foo");
|
||||
expect(o).toHaveEnumerableProperty("foo");
|
||||
expect(o).toHaveWritableProperty("foo");
|
||||
expect(o).toHaveValueProperty("foo", "ho");
|
||||
});
|
||||
|
||||
test("reconfigure configurable property", () => {
|
||||
let o = {};
|
||||
Object.defineProperty(o, "foo", { value: 9, configurable: true, writable: false });
|
||||
Object.defineProperty(o, "foo", { configurable: true, writable: true });
|
||||
|
||||
expect(o).toHaveConfigurableProperty("foo");
|
||||
expect(o).toHaveWritableProperty("foo");
|
||||
expect(o).not.toHaveEnumerableProperty("foo");
|
||||
expect(o).toHaveValueProperty("foo", 9);
|
||||
});
|
||||
|
||||
test("define accessor", () => {
|
||||
let o = {};
|
||||
|
||||
Object.defineProperty(o, "foo", {
|
||||
configurable: true,
|
||||
get() {
|
||||
return o.secret_foo + 1;
|
||||
},
|
||||
set(value) {
|
||||
this.secret_foo = value + 1;
|
||||
},
|
||||
});
|
||||
|
||||
test("array index getter", () => {
|
||||
let o = {};
|
||||
Object.defineProperty(o, 2, { get() { return 10; } });
|
||||
expect(o[2]).toBe(10);
|
||||
});
|
||||
o.foo = 10;
|
||||
expect(o.foo).toBe(12);
|
||||
o.foo = 20;
|
||||
expect(o.foo).toBe(22);
|
||||
|
||||
test("configurable property", () => {
|
||||
let o = {};
|
||||
Object.defineProperty(o, "foo", { value: "hi", writable: true, enumerable: true });
|
||||
Object.defineProperty(o, "foo", { configurable: true, value: 4 });
|
||||
|
||||
expect(o.foo).toBe("hi");
|
||||
o.foo = "ho";
|
||||
expect(o.foo).toBe("ho");
|
||||
|
||||
expect(o).not.toHaveConfigurableProperty("foo");
|
||||
expect(o).toHaveEnumerableProperty("foo");
|
||||
expect(o).toHaveWritableProperty("foo");
|
||||
expect(o).toHaveValueProperty("foo", "ho");
|
||||
});
|
||||
|
||||
test("reconfigure configurable property", () => {
|
||||
let o = {};
|
||||
Object.defineProperty(o, "foo", { value: 9, configurable: true, writable: false });
|
||||
Object.defineProperty(o, "foo", { configurable: true, writable: true });
|
||||
|
||||
expect(o).toHaveConfigurableProperty("foo");
|
||||
expect(o).toHaveWritableProperty("foo");
|
||||
expect(o).not.toHaveEnumerableProperty("foo");
|
||||
expect(o).toHaveValueProperty("foo", 9);
|
||||
});
|
||||
|
||||
test("define accessor", () => {
|
||||
let o = {};
|
||||
|
||||
Object.defineProperty(o, "foo", {
|
||||
configurable: true,
|
||||
get() {
|
||||
return o.secret_foo + 1;
|
||||
},
|
||||
set(value) {
|
||||
this.secret_foo = value + 1;
|
||||
},
|
||||
});
|
||||
|
||||
o.foo = 10;
|
||||
expect(o.foo).toBe(12);
|
||||
o.foo = 20;
|
||||
expect(o.foo).toBe(22);
|
||||
|
||||
Object.defineProperty(o, "foo", { configurable: true, value: 4 });
|
||||
|
||||
expect(o.foo).toBe(4);
|
||||
expect(o.foo = 5).toBe(5);
|
||||
expect(o.foo = 4).toBe(4);
|
||||
});
|
||||
expect(o.foo).toBe(4);
|
||||
expect((o.foo = 5)).toBe(5);
|
||||
expect((o.foo = 4)).toBe(4);
|
||||
});
|
||||
});
|
||||
|
||||
describe("errors", () => {
|
||||
test("redefine non-configurable property", () => {
|
||||
let o = {};
|
||||
Object.defineProperty(o, "foo", { value: 1, writable: true, enumerable: true });
|
||||
test("redefine non-configurable property", () => {
|
||||
let o = {};
|
||||
Object.defineProperty(o, "foo", { value: 1, writable: true, enumerable: true });
|
||||
|
||||
expect(() => {
|
||||
Object.defineProperty(o, "foo", { value: 2, writable: false, enumerable: true });
|
||||
}).toThrowWithMessage(TypeError, "Cannot change attributes of non-configurable property 'foo'");
|
||||
expect(() => {
|
||||
Object.defineProperty(o, "foo", { value: 2, writable: false, enumerable: true });
|
||||
}).toThrowWithMessage(TypeError, "Cannot change attributes of non-configurable property 'foo'");
|
||||
});
|
||||
|
||||
test("cannot define 'value' and 'get' in the same descriptor", () => {
|
||||
let o = {};
|
||||
|
||||
expect(() => {
|
||||
Object.defineProperty(o, "a", {
|
||||
get() {},
|
||||
value: 9,
|
||||
});
|
||||
}).toThrowWithMessage(
|
||||
TypeError,
|
||||
"Accessor property descriptor cannot specify a value or writable key"
|
||||
);
|
||||
});
|
||||
|
||||
test("cannot define 'value' and 'set' in the same descriptor", () => {
|
||||
let o = {};
|
||||
|
||||
expect(() => {
|
||||
Object.defineProperty(o, "a", {
|
||||
set() {},
|
||||
writable: true,
|
||||
});
|
||||
}).toThrowWithMessage(
|
||||
TypeError,
|
||||
"Accessor property descriptor cannot specify a value or writable key"
|
||||
);
|
||||
});
|
||||
|
||||
test("redefine non-configurable accessor", () => {
|
||||
let o = {};
|
||||
|
||||
Object.defineProperty(o, "foo", {
|
||||
configurable: false,
|
||||
get() {
|
||||
return this.secret_foo + 2;
|
||||
},
|
||||
set(value) {
|
||||
o.secret_foo = value + 2;
|
||||
},
|
||||
});
|
||||
|
||||
test("cannot define 'value' and 'get' in the same descriptor", () => {
|
||||
let o = {};
|
||||
|
||||
expect(() => {
|
||||
Object.defineProperty(o, "a", {
|
||||
get() {},
|
||||
value: 9,
|
||||
});
|
||||
}).toThrowWithMessage(TypeError, "Accessor property descriptor cannot specify a value or writable key");
|
||||
});
|
||||
|
||||
test("cannot define 'value' and 'set' in the same descriptor", () => {
|
||||
let o = {};
|
||||
|
||||
expect(() => {
|
||||
Object.defineProperty(o, "a", {
|
||||
set() {},
|
||||
writable: true,
|
||||
});
|
||||
}).toThrowWithMessage(TypeError, "Accessor property descriptor cannot specify a value or writable key");
|
||||
});
|
||||
|
||||
test("redefine non-configurable accessor", () => {
|
||||
let o = {};
|
||||
|
||||
Object.defineProperty(o, "foo", {
|
||||
configurable: false,
|
||||
get() {
|
||||
return this.secret_foo + 2;
|
||||
},
|
||||
set(value) {
|
||||
o.secret_foo = value + 2;
|
||||
},
|
||||
});
|
||||
|
||||
expect(() => {
|
||||
Object.defineProperty(o, "foo", {
|
||||
configurable: false,
|
||||
get() {
|
||||
return this.secret_foo + 2;
|
||||
},
|
||||
});
|
||||
}).toThrowWithMessage(TypeError, "Cannot change attributes of non-configurable property 'foo'");
|
||||
});
|
||||
expect(() => {
|
||||
Object.defineProperty(o, "foo", {
|
||||
configurable: false,
|
||||
get() {
|
||||
return this.secret_foo + 2;
|
||||
},
|
||||
});
|
||||
}).toThrowWithMessage(TypeError, "Cannot change attributes of non-configurable property 'foo'");
|
||||
});
|
||||
});
|
||||
|
|
|
@ -1,45 +1,55 @@
|
|||
describe("basic functionality", () => {
|
||||
test("length", () => {
|
||||
expect(Object.entries).toHaveLength(1);
|
||||
expect(Object.entries(true)).toHaveLength(0);
|
||||
expect(Object.entries(45)).toHaveLength(0);
|
||||
expect(Object.entries(-998)).toHaveLength(0);
|
||||
expect(Object.entries("abcd")).toHaveLength(4);
|
||||
expect(Object.entries([1, 2, 3])).toHaveLength(3);
|
||||
expect(Object.entries({ a: 1, b: 2, c: 3 })).toHaveLength(3);
|
||||
});
|
||||
test("length", () => {
|
||||
expect(Object.entries).toHaveLength(1);
|
||||
expect(Object.entries(true)).toHaveLength(0);
|
||||
expect(Object.entries(45)).toHaveLength(0);
|
||||
expect(Object.entries(-998)).toHaveLength(0);
|
||||
expect(Object.entries("abcd")).toHaveLength(4);
|
||||
expect(Object.entries([1, 2, 3])).toHaveLength(3);
|
||||
expect(Object.entries({ a: 1, b: 2, c: 3 })).toHaveLength(3);
|
||||
});
|
||||
|
||||
test("entries with object", () => {
|
||||
let entries = Object.entries({ foo: 1, bar: 2, baz: 3 });
|
||||
test("entries with object", () => {
|
||||
let entries = Object.entries({ foo: 1, bar: 2, baz: 3 });
|
||||
|
||||
expect(entries).toEqual([["foo", 1], ["bar", 2], ["baz", 3]]);
|
||||
});
|
||||
expect(entries).toEqual([
|
||||
["foo", 1],
|
||||
["bar", 2],
|
||||
["baz", 3],
|
||||
]);
|
||||
});
|
||||
|
||||
test("entries with array", () => {
|
||||
entries = Object.entries(["a", "b", "c"]);
|
||||
expect(entries).toEqual([["0", "a"], ["1", "b"], ["2", "c"]]);
|
||||
});
|
||||
test("entries with array", () => {
|
||||
entries = Object.entries(["a", "b", "c"]);
|
||||
expect(entries).toEqual([
|
||||
["0", "a"],
|
||||
["1", "b"],
|
||||
["2", "c"],
|
||||
]);
|
||||
});
|
||||
|
||||
test("ignores non-enumerable properties", () => {
|
||||
let obj = { foo: 1 };
|
||||
Object.defineProperty(obj, "getFoo", {
|
||||
value: function() { return this.foo; },
|
||||
});
|
||||
let entries = Object.entries(obj);
|
||||
expect(entries).toEqual([["foo", 1]]);
|
||||
test("ignores non-enumerable properties", () => {
|
||||
let obj = { foo: 1 };
|
||||
Object.defineProperty(obj, "getFoo", {
|
||||
value: function () {
|
||||
return this.foo;
|
||||
},
|
||||
});
|
||||
let entries = Object.entries(obj);
|
||||
expect(entries).toEqual([["foo", 1]]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("errors", () => {
|
||||
test("null argument", () => {
|
||||
expect(() => {
|
||||
Object.entries(null);
|
||||
}).toThrowWithMessage(TypeError, "ToObject on null or undefined");
|
||||
});
|
||||
test("null argument", () => {
|
||||
expect(() => {
|
||||
Object.entries(null);
|
||||
}).toThrowWithMessage(TypeError, "ToObject on null or undefined");
|
||||
});
|
||||
|
||||
test("undefined argument", () => {
|
||||
expect(() => {
|
||||
Object.entries(undefined);
|
||||
}).toThrowWithMessage(TypeError, "ToObject on null or undefined");
|
||||
})
|
||||
test("undefined argument", () => {
|
||||
expect(() => {
|
||||
Object.entries(undefined);
|
||||
}).toThrowWithMessage(TypeError, "ToObject on null or undefined");
|
||||
});
|
||||
});
|
||||
|
|
|
@ -1,49 +1,49 @@
|
|||
test("plain property", () => {
|
||||
let o = { foo: "bar" };
|
||||
let o = { foo: "bar" };
|
||||
|
||||
expect(o).toHaveConfigurableProperty("foo");
|
||||
expect(o).toHaveEnumerableProperty("foo");
|
||||
expect(o).toHaveWritableProperty("foo");
|
||||
expect(o).toHaveValueProperty("foo", "bar");
|
||||
expect(o).not.toHaveGetterProperty("foo");
|
||||
expect(o).not.toHaveSetterProperty("foo");
|
||||
expect(o).toHaveConfigurableProperty("foo");
|
||||
expect(o).toHaveEnumerableProperty("foo");
|
||||
expect(o).toHaveWritableProperty("foo");
|
||||
expect(o).toHaveValueProperty("foo", "bar");
|
||||
expect(o).not.toHaveGetterProperty("foo");
|
||||
expect(o).not.toHaveSetterProperty("foo");
|
||||
});
|
||||
|
||||
test("getter property", () => {
|
||||
let o = { get foo() {} };
|
||||
let o = { get foo() {} };
|
||||
|
||||
expect(o).toHaveConfigurableProperty("foo");
|
||||
expect(o).toHaveEnumerableProperty("foo");
|
||||
expect(o).not.toHaveWritableProperty("foo");
|
||||
expect(o).not.toHaveValueProperty("foo");
|
||||
expect(o).toHaveGetterProperty("foo");
|
||||
expect(o).not.toHaveSetterProperty("foo");
|
||||
expect(o).toHaveConfigurableProperty("foo");
|
||||
expect(o).toHaveEnumerableProperty("foo");
|
||||
expect(o).not.toHaveWritableProperty("foo");
|
||||
expect(o).not.toHaveValueProperty("foo");
|
||||
expect(o).toHaveGetterProperty("foo");
|
||||
expect(o).not.toHaveSetterProperty("foo");
|
||||
});
|
||||
|
||||
test("setter property", () => {
|
||||
let o = { set foo(_) {} };
|
||||
let o = { set foo(_) {} };
|
||||
|
||||
expect(o).toHaveConfigurableProperty("foo");
|
||||
expect(o).toHaveEnumerableProperty("foo");
|
||||
expect(o).not.toHaveWritableProperty("foo");
|
||||
expect(o).not.toHaveValueProperty("foo");
|
||||
expect(o).not.toHaveGetterProperty("foo");
|
||||
expect(o).toHaveSetterProperty("foo");
|
||||
expect(o).toHaveConfigurableProperty("foo");
|
||||
expect(o).toHaveEnumerableProperty("foo");
|
||||
expect(o).not.toHaveWritableProperty("foo");
|
||||
expect(o).not.toHaveValueProperty("foo");
|
||||
expect(o).not.toHaveGetterProperty("foo");
|
||||
expect(o).toHaveSetterProperty("foo");
|
||||
});
|
||||
|
||||
test("defined property", () => {
|
||||
let o = {};
|
||||
let o = {};
|
||||
|
||||
Object.defineProperty(o, "foo", {
|
||||
enumerable: false,
|
||||
writable: true,
|
||||
value: 10,
|
||||
});
|
||||
Object.defineProperty(o, "foo", {
|
||||
enumerable: false,
|
||||
writable: true,
|
||||
value: 10,
|
||||
});
|
||||
|
||||
expect(o).not.toHaveConfigurableProperty("foo");
|
||||
expect(o).not.toHaveEnumerableProperty("foo");
|
||||
expect(o).toHaveWritableProperty("foo");
|
||||
expect(o).toHaveValueProperty("foo", 10);
|
||||
expect(o).not.toHaveGetterProperty("foo");
|
||||
expect(o).not.toHaveSetterProperty("foo");
|
||||
expect(o).not.toHaveConfigurableProperty("foo");
|
||||
expect(o).not.toHaveEnumerableProperty("foo");
|
||||
expect(o).toHaveWritableProperty("foo");
|
||||
expect(o).toHaveValueProperty("foo", 10);
|
||||
expect(o).not.toHaveGetterProperty("foo");
|
||||
expect(o).not.toHaveSetterProperty("foo");
|
||||
});
|
||||
|
|
|
@ -1,9 +1,9 @@
|
|||
test("use with array", () => {
|
||||
let names = Object.getOwnPropertyNames([1, 2, 3]);
|
||||
expect(names).toEqual(["0", "1", "2", "length"]);
|
||||
let names = Object.getOwnPropertyNames([1, 2, 3]);
|
||||
expect(names).toEqual(["0", "1", "2", "length"]);
|
||||
});
|
||||
|
||||
test("use with object", () => {
|
||||
let names = Object.getOwnPropertyNames({ foo: 1, bar: 2, baz: 3 });
|
||||
expect(names).toEqual(["foo", "bar", "baz"]);
|
||||
let names = Object.getOwnPropertyNames({ foo: 1, bar: 2, baz: 3 });
|
||||
expect(names).toEqual(["foo", "bar", "baz"]);
|
||||
});
|
||||
|
|
|
@ -1,10 +1,10 @@
|
|||
test("basic functionality", () => {
|
||||
let o1 = new Object();
|
||||
let o2 = {};
|
||||
let o1 = new Object();
|
||||
let o2 = {};
|
||||
|
||||
expect(Object.getPrototypeOf(o1)).toBe(Object.getPrototypeOf(o2));
|
||||
expect(Object.getPrototypeOf(Object.getPrototypeOf(o1))).toBe(null);
|
||||
expect(Object.getPrototypeOf(o1)).toBe(Object.getPrototypeOf(o2));
|
||||
expect(Object.getPrototypeOf(Object.getPrototypeOf(o1))).toBeNull();
|
||||
|
||||
Object.setPrototypeOf(o1, o2);
|
||||
expect(Object.getPrototypeOf(o1)).toBe(o2);
|
||||
Object.setPrototypeOf(o1, o2);
|
||||
expect(Object.getPrototypeOf(o1)).toBe(o2);
|
||||
});
|
||||
|
|
|
@ -1,54 +1,54 @@
|
|||
test("length", () => {
|
||||
expect(Object.is).toHaveLength(2);
|
||||
expect(Object.is).toHaveLength(2);
|
||||
});
|
||||
|
||||
test("arguments that evaluate to true", () => {
|
||||
let a = [1, 2, 3];
|
||||
let o = { foo: "bar" };
|
||||
let a = [1, 2, 3];
|
||||
let o = { foo: "bar" };
|
||||
|
||||
expect(Object.is("", "")).toBeTrue();
|
||||
expect(Object.is("foo", "foo")).toBeTrue();
|
||||
expect(Object.is(0, 0)).toBeTrue();
|
||||
expect(Object.is(+0, +0)).toBeTrue();
|
||||
expect(Object.is(-0, -0)).toBeTrue();
|
||||
expect(Object.is(1.23, 1.23)).toBeTrue();
|
||||
expect(Object.is(42, 42)).toBeTrue();
|
||||
expect(Object.is(NaN, NaN)).toBeTrue();
|
||||
expect(Object.is(Infinity, Infinity)).toBeTrue();
|
||||
expect(Object.is(+Infinity, +Infinity)).toBeTrue();
|
||||
expect(Object.is(-Infinity, -Infinity)).toBeTrue();
|
||||
expect(Object.is(true, true)).toBeTrue();
|
||||
expect(Object.is(false, false)).toBeTrue();
|
||||
expect(Object.is(null, null)).toBeTrue();
|
||||
expect(Object.is(undefined, undefined)).toBeTrue();
|
||||
expect(Object.is(undefined)).toBeTrue();
|
||||
expect(Object.is()).toBeTrue();
|
||||
expect(Object.is(a, a)).toBeTrue();
|
||||
expect(Object.is(o, o)).toBeTrue();
|
||||
expect(Object.is("", "")).toBeTrue();
|
||||
expect(Object.is("foo", "foo")).toBeTrue();
|
||||
expect(Object.is(0, 0)).toBeTrue();
|
||||
expect(Object.is(+0, +0)).toBeTrue();
|
||||
expect(Object.is(-0, -0)).toBeTrue();
|
||||
expect(Object.is(1.23, 1.23)).toBeTrue();
|
||||
expect(Object.is(42, 42)).toBeTrue();
|
||||
expect(Object.is(NaN, NaN)).toBeTrue();
|
||||
expect(Object.is(Infinity, Infinity)).toBeTrue();
|
||||
expect(Object.is(+Infinity, +Infinity)).toBeTrue();
|
||||
expect(Object.is(-Infinity, -Infinity)).toBeTrue();
|
||||
expect(Object.is(true, true)).toBeTrue();
|
||||
expect(Object.is(false, false)).toBeTrue();
|
||||
expect(Object.is(null, null)).toBeTrue();
|
||||
expect(Object.is(undefined, undefined)).toBeTrue();
|
||||
expect(Object.is(undefined)).toBeTrue();
|
||||
expect(Object.is()).toBeTrue();
|
||||
expect(Object.is(a, a)).toBeTrue();
|
||||
expect(Object.is(o, o)).toBeTrue();
|
||||
});
|
||||
|
||||
test("arguments that evaluate to false", () => {
|
||||
let a = [1, 2, 3];
|
||||
let o = { foo: "bar" };
|
||||
let a = [1, 2, 3];
|
||||
let o = { foo: "bar" };
|
||||
|
||||
expect(Object.is("test")).toBeFalse();
|
||||
expect(Object.is("foo", "bar")).toBeFalse();
|
||||
expect(Object.is(1, "1")).toBeFalse();
|
||||
expect(Object.is(+0, -0)).toBeFalse();
|
||||
expect(Object.is(-0, +0)).toBeFalse();
|
||||
expect(Object.is(42, 24)).toBeFalse();
|
||||
expect(Object.is(Infinity, -Infinity)).toBeFalse();
|
||||
expect(Object.is(-Infinity, +Infinity)).toBeFalse();
|
||||
expect(Object.is(true, false)).toBeFalse();
|
||||
expect(Object.is(false, true)).toBeFalse();
|
||||
expect(Object.is(undefined, null)).toBeFalse();
|
||||
expect(Object.is(null, undefined)).toBeFalse();
|
||||
expect(Object.is([], [])).toBeFalse();
|
||||
expect(Object.is(a, [1, 2, 3])).toBeFalse();
|
||||
expect(Object.is([1, 2, 3], a)).toBeFalse();
|
||||
expect(Object.is({}, {})).toBeFalse();
|
||||
expect(Object.is(o, {foo: "bar"})).toBeFalse();
|
||||
expect(Object.is({foo: "bar"}, o)).toBeFalse();
|
||||
expect(Object.is(a, o)).toBeFalse();
|
||||
expect(Object.is(o, a)).toBeFalse();
|
||||
expect(Object.is("test")).toBeFalse();
|
||||
expect(Object.is("foo", "bar")).toBeFalse();
|
||||
expect(Object.is(1, "1")).toBeFalse();
|
||||
expect(Object.is(+0, -0)).toBeFalse();
|
||||
expect(Object.is(-0, +0)).toBeFalse();
|
||||
expect(Object.is(42, 24)).toBeFalse();
|
||||
expect(Object.is(Infinity, -Infinity)).toBeFalse();
|
||||
expect(Object.is(-Infinity, +Infinity)).toBeFalse();
|
||||
expect(Object.is(true, false)).toBeFalse();
|
||||
expect(Object.is(false, true)).toBeFalse();
|
||||
expect(Object.is(undefined, null)).toBeFalse();
|
||||
expect(Object.is(null, undefined)).toBeFalse();
|
||||
expect(Object.is([], [])).toBeFalse();
|
||||
expect(Object.is(a, [1, 2, 3])).toBeFalse();
|
||||
expect(Object.is([1, 2, 3], a)).toBeFalse();
|
||||
expect(Object.is({}, {})).toBeFalse();
|
||||
expect(Object.is(o, { foo: "bar" })).toBeFalse();
|
||||
expect(Object.is({ foo: "bar" }, o)).toBeFalse();
|
||||
expect(Object.is(a, o)).toBeFalse();
|
||||
expect(Object.is(o, a)).toBeFalse();
|
||||
});
|
||||
|
|
|
@ -1,18 +1,18 @@
|
|||
test("basic functionality", () => {
|
||||
expect(Object.isExtensible).toHaveLength(1);
|
||||
expect(Object.isExtensible).toHaveLength(1);
|
||||
|
||||
expect(Object.isExtensible()).toBeFalse();
|
||||
expect(Object.isExtensible(undefined)).toBeFalse();
|
||||
expect(Object.isExtensible(null)).toBeFalse();
|
||||
expect(Object.isExtensible(true)).toBeFalse();
|
||||
expect(Object.isExtensible(6)).toBeFalse();
|
||||
expect(Object.isExtensible("test")).toBeFalse();
|
||||
expect(Object.isExtensible()).toBeFalse();
|
||||
expect(Object.isExtensible(undefined)).toBeFalse();
|
||||
expect(Object.isExtensible(null)).toBeFalse();
|
||||
expect(Object.isExtensible(true)).toBeFalse();
|
||||
expect(Object.isExtensible(6)).toBeFalse();
|
||||
expect(Object.isExtensible("test")).toBeFalse();
|
||||
|
||||
let s = Symbol();
|
||||
expect(Object.isExtensible(s)).toBeFalse();
|
||||
let s = Symbol();
|
||||
expect(Object.isExtensible(s)).toBeFalse();
|
||||
|
||||
let o = { foo: "foo" };
|
||||
expect(Object.isExtensible(o)).toBeTrue();
|
||||
Object.preventExtensions(o);
|
||||
expect(Object.isExtensible(o)).toBeFalse();
|
||||
let o = { foo: "foo" };
|
||||
expect(Object.isExtensible(o)).toBeTrue();
|
||||
Object.preventExtensions(o);
|
||||
expect(Object.isExtensible(o)).toBeFalse();
|
||||
});
|
||||
|
|
|
@ -1,8 +1,8 @@
|
|||
test("basic functionality", () => {
|
||||
expect(Object).toHaveLength(1);
|
||||
expect(Object.name).toBe("Object");
|
||||
expect(Object.prototype.length).toBe(undefined);
|
||||
expect(Object).toHaveLength(1);
|
||||
expect(Object.name).toBe("Object");
|
||||
expect(Object.prototype).not.toHaveProperty("length");
|
||||
|
||||
expect(typeof Object()).toBe("object");
|
||||
expect(typeof new Object()).toBe("object");
|
||||
expect(typeof Object()).toBe("object");
|
||||
expect(typeof new Object()).toBe("object");
|
||||
});
|
||||
|
|
|
@ -1,44 +1,46 @@
|
|||
describe("correct behavior", () => {
|
||||
test("length", () => {
|
||||
expect(Object.keys).toHaveLength(1);
|
||||
expect(Object.keys(true)).toHaveLength(0);
|
||||
expect(Object.keys(45)).toHaveLength(0);
|
||||
expect(Object.keys(-998)).toHaveLength(0);
|
||||
expect(Object.keys("abcd")).toHaveLength(4);
|
||||
expect(Object.keys([1, 2, 3])).toHaveLength(3);
|
||||
expect(Object.keys({ a: 1, b: 2, c: 3 })).toHaveLength(3);
|
||||
});
|
||||
test("length", () => {
|
||||
expect(Object.keys).toHaveLength(1);
|
||||
expect(Object.keys(true)).toHaveLength(0);
|
||||
expect(Object.keys(45)).toHaveLength(0);
|
||||
expect(Object.keys(-998)).toHaveLength(0);
|
||||
expect(Object.keys("abcd")).toHaveLength(4);
|
||||
expect(Object.keys([1, 2, 3])).toHaveLength(3);
|
||||
expect(Object.keys({ a: 1, b: 2, c: 3 })).toHaveLength(3);
|
||||
});
|
||||
|
||||
test("object argument", () => {
|
||||
let keys = Object.keys({ foo: 1, bar: 2, baz: 3 });
|
||||
expect(keys).toEqual(["foo", "bar", "baz"]);
|
||||
});
|
||||
test("object argument", () => {
|
||||
let keys = Object.keys({ foo: 1, bar: 2, baz: 3 });
|
||||
expect(keys).toEqual(["foo", "bar", "baz"]);
|
||||
});
|
||||
|
||||
test("array argument", () => {
|
||||
let keys = Object.keys(["a", "b", "c"]);
|
||||
expect(keys).toEqual(["0", "1", "2"]);
|
||||
});
|
||||
test("array argument", () => {
|
||||
let keys = Object.keys(["a", "b", "c"]);
|
||||
expect(keys).toEqual(["0", "1", "2"]);
|
||||
});
|
||||
|
||||
test("ignores non-enumerable properties", () => {
|
||||
let obj = { foo: 1 };
|
||||
Object.defineProperty(obj, "getFoo", {
|
||||
value: function() { return this.foo; },
|
||||
});
|
||||
keys = Object.keys(obj);
|
||||
expect(keys).toEqual(["foo"]);
|
||||
test("ignores non-enumerable properties", () => {
|
||||
let obj = { foo: 1 };
|
||||
Object.defineProperty(obj, "getFoo", {
|
||||
value: function () {
|
||||
return this.foo;
|
||||
},
|
||||
});
|
||||
keys = Object.keys(obj);
|
||||
expect(keys).toEqual(["foo"]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("errors", () => {
|
||||
test("null argument value", () => {
|
||||
expect(() => {
|
||||
Object.keys(null);
|
||||
}).toThrowWithMessage(TypeError, "ToObject on null or undefined");
|
||||
});
|
||||
test("null argument value", () => {
|
||||
expect(() => {
|
||||
Object.keys(null);
|
||||
}).toThrowWithMessage(TypeError, "ToObject on null or undefined");
|
||||
});
|
||||
|
||||
test("undefined argument value", () => {
|
||||
expect(() => {
|
||||
Object.keys(undefined);
|
||||
}).toThrowWithMessage(TypeError, "ToObject on null or undefined");
|
||||
});
|
||||
test("undefined argument value", () => {
|
||||
expect(() => {
|
||||
Object.keys(undefined);
|
||||
}).toThrowWithMessage(TypeError, "ToObject on null or undefined");
|
||||
});
|
||||
});
|
||||
|
|
|
@ -1,53 +1,53 @@
|
|||
describe("correct behavior", () => {
|
||||
test("non-object arguments", () => {
|
||||
expect(Object.preventExtensions()).toBeUndefined();
|
||||
expect(Object.preventExtensions(undefined)).toBeUndefined();
|
||||
expect(Object.preventExtensions(null)).toBeNull();
|
||||
expect(Object.preventExtensions(true)).toBeTrue();
|
||||
expect(Object.preventExtensions(6)).toBe(6);
|
||||
expect(Object.preventExtensions("test")).toBe("test");
|
||||
test("non-object arguments", () => {
|
||||
expect(Object.preventExtensions()).toBeUndefined();
|
||||
expect(Object.preventExtensions(undefined)).toBeUndefined();
|
||||
expect(Object.preventExtensions(null)).toBeNull();
|
||||
expect(Object.preventExtensions(true)).toBeTrue();
|
||||
expect(Object.preventExtensions(6)).toBe(6);
|
||||
expect(Object.preventExtensions("test")).toBe("test");
|
||||
|
||||
let s = Symbol();
|
||||
expect(Object.preventExtensions(s)).toBe(s);
|
||||
});
|
||||
let s = Symbol();
|
||||
expect(Object.preventExtensions(s)).toBe(s);
|
||||
});
|
||||
|
||||
test("basic functionality", () => {
|
||||
let o = { foo: "foo" };
|
||||
expect(o.foo).toBe("foo");
|
||||
o.bar = "bar";
|
||||
expect(o.bar).toBe("bar");
|
||||
test("basic functionality", () => {
|
||||
let o = { foo: "foo" };
|
||||
expect(o.foo).toBe("foo");
|
||||
o.bar = "bar";
|
||||
expect(o.bar).toBe("bar");
|
||||
|
||||
expect(Object.preventExtensions(o)).toBe(o);
|
||||
expect(o.foo).toBe("foo");
|
||||
expect(o.bar).toBe("bar");
|
||||
expect(Object.preventExtensions(o)).toBe(o);
|
||||
expect(o.foo).toBe("foo");
|
||||
expect(o.bar).toBe("bar");
|
||||
|
||||
o.baz = "baz";
|
||||
expect(o.baz).toBeUndefined();
|
||||
});
|
||||
o.baz = "baz";
|
||||
expect(o.baz).toBeUndefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe("errors", () => {
|
||||
test("defining a property on a non-extensible object", () => {
|
||||
let o = {};
|
||||
Object.preventExtensions(o);
|
||||
test("defining a property on a non-extensible object", () => {
|
||||
let o = {};
|
||||
Object.preventExtensions(o);
|
||||
|
||||
expect(() => {
|
||||
Object.defineProperty(o, "baz", { value: "baz" });
|
||||
}).toThrowWithMessage(TypeError, "Cannot define property baz on non-extensible object");
|
||||
expect(() => {
|
||||
Object.defineProperty(o, "baz", { value: "baz" });
|
||||
}).toThrowWithMessage(TypeError, "Cannot define property baz on non-extensible object");
|
||||
|
||||
expect(o.baz).toBeUndefined();
|
||||
});
|
||||
expect(o.baz).toBeUndefined();
|
||||
});
|
||||
|
||||
test("putting property on a non-extensible object", () => {
|
||||
let o = {};
|
||||
Object.preventExtensions(o);
|
||||
test("putting property on a non-extensible object", () => {
|
||||
let o = {};
|
||||
Object.preventExtensions(o);
|
||||
|
||||
expect(() => {
|
||||
"use strict";
|
||||
o.foo = "foo";
|
||||
}).toThrowWithMessage(TypeError, "Cannot define property foo on non-extensible object");
|
||||
expect(() => {
|
||||
"use strict";
|
||||
o.foo = "foo";
|
||||
}).toThrowWithMessage(TypeError, "Cannot define property foo on non-extensible object");
|
||||
|
||||
expect(o.foo = "foo").toBe("foo");
|
||||
expect(o.foo).toBeUndefined();
|
||||
});
|
||||
expect((o.foo = "foo")).toBe("foo");
|
||||
expect(o.foo).toBeUndefined();
|
||||
});
|
||||
});
|
||||
|
|
|
@ -1,18 +1,18 @@
|
|||
test("basic functionality", () => {
|
||||
[Array, BigInt, Boolean, Date, Error, Function, Number, Object, String].forEach(constructor => {
|
||||
expect(constructor.prototype.constructor).toBe(constructor);
|
||||
if (constructor !== BigInt)
|
||||
expect(Reflect.construct(constructor, []).constructor).toBe(constructor);
|
||||
});
|
||||
[Array, BigInt, Boolean, Date, Error, Function, Number, Object, String].forEach(constructor => {
|
||||
expect(constructor.prototype.constructor).toBe(constructor);
|
||||
if (constructor !== BigInt)
|
||||
expect(Reflect.construct(constructor, []).constructor).toBe(constructor);
|
||||
});
|
||||
|
||||
let o = {};
|
||||
expect(o.constructor).toBe(Object);
|
||||
let o = {};
|
||||
expect(o.constructor).toBe(Object);
|
||||
|
||||
a = [];
|
||||
expect(a.constructor).toBe(Array);
|
||||
a = [];
|
||||
expect(a.constructor).toBe(Array);
|
||||
|
||||
expect(Object.prototype).toHaveConfigurableProperty("constructor");
|
||||
expect(Object.prototype).not.toHaveEnumerableProperty("constructor");
|
||||
expect(Object.prototype).toHaveWritableProperty("constructor");
|
||||
expect(Object.prototype).toHaveValueProperty("constructor", Object);
|
||||
expect(Object.prototype).toHaveConfigurableProperty("constructor");
|
||||
expect(Object.prototype).not.toHaveEnumerableProperty("constructor");
|
||||
expect(Object.prototype).toHaveWritableProperty("constructor");
|
||||
expect(Object.prototype).toHaveValueProperty("constructor", Object);
|
||||
});
|
||||
|
|
|
@ -1,13 +1,13 @@
|
|||
test("basic functionality", () => {
|
||||
var o = {};
|
||||
var o = {};
|
||||
|
||||
o.foo = 1;
|
||||
expect(o.hasOwnProperty("foo")).toBeTrue();
|
||||
expect(o.hasOwnProperty("bar")).toBeFalse();
|
||||
expect(o.hasOwnProperty()).toBeFalse();
|
||||
expect(o.hasOwnProperty(undefined)).toBeFalse();
|
||||
o.foo = 1;
|
||||
expect(o.hasOwnProperty("foo")).toBeTrue();
|
||||
expect(o.hasOwnProperty("bar")).toBeFalse();
|
||||
expect(o.hasOwnProperty()).toBeFalse();
|
||||
expect(o.hasOwnProperty(undefined)).toBeFalse();
|
||||
|
||||
o.undefined = 2;
|
||||
expect(o.hasOwnProperty()).toBeTrue();
|
||||
expect(o.hasOwnProperty(undefined)).toBeTrue();
|
||||
o.undefined = 2;
|
||||
expect(o.hasOwnProperty()).toBeTrue();
|
||||
expect(o.hasOwnProperty(undefined)).toBeTrue();
|
||||
});
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
test("basic functionality", () => {
|
||||
var o = new Object();
|
||||
Object.prototype.foo = 123;
|
||||
expect(o.foo).toBe(123);
|
||||
var o = new Object();
|
||||
Object.prototype.foo = 123;
|
||||
expect(o.foo).toBe(123);
|
||||
});
|
||||
|
|
|
@ -1,31 +1,35 @@
|
|||
describe("correct behavior", () => {
|
||||
test("length", () => {
|
||||
expect(Object.prototype.toLocaleString).toHaveLength(0);
|
||||
})
|
||||
test("length", () => {
|
||||
expect(Object.prototype.toLocaleString).toHaveLength(0);
|
||||
});
|
||||
|
||||
test("basic functionality", () => {
|
||||
let o;
|
||||
test("basic functionality", () => {
|
||||
let o;
|
||||
|
||||
o = {};
|
||||
expect(o.toString()).toBe(o.toLocaleString());
|
||||
o = {};
|
||||
expect(o.toString()).toBe(o.toLocaleString());
|
||||
|
||||
o = { toString: () => 42 };
|
||||
expect(o.toString()).toBe(42);
|
||||
});
|
||||
o = { toString: () => 42 };
|
||||
expect(o.toString()).toBe(42);
|
||||
});
|
||||
});
|
||||
|
||||
describe("errors", () => {
|
||||
test("toString that throws error", () => {
|
||||
let o = { toString: () => { throw new Error(); } };
|
||||
expect(() => {
|
||||
o.toLocaleString();
|
||||
}).toThrow(Error);
|
||||
});
|
||||
test("toString that throws error", () => {
|
||||
let o = {
|
||||
toString: () => {
|
||||
throw new Error();
|
||||
},
|
||||
};
|
||||
expect(() => {
|
||||
o.toLocaleString();
|
||||
}).toThrow(Error);
|
||||
});
|
||||
|
||||
test("toString that is not a function", () => {
|
||||
let o = { toString: "foo" };
|
||||
expect(() => {
|
||||
o.toLocaleString();
|
||||
}).toThrowWithMessage(TypeError, "foo is not a function");
|
||||
});
|
||||
test("toString that is not a function", () => {
|
||||
let o = { toString: "foo" };
|
||||
expect(() => {
|
||||
o.toLocaleString();
|
||||
}).toThrowWithMessage(TypeError, "foo is not a function");
|
||||
});
|
||||
});
|
||||
|
|
|
@ -1,8 +1,8 @@
|
|||
test("basic functionality", () => {
|
||||
expect(Object.prototype.toString).toHaveLength(0);
|
||||
// FIXME: The tag is ObjectPrototype, but should be Object
|
||||
// expect(Object.prototype.toString()).toBe("[object Object]");
|
||||
expect({ foo: 1 }.toString()).toBe("[object Object]");
|
||||
expect([].toString()).toBe("");
|
||||
expect(Object.prototype.toString.call([])).toBe("[object Array]");
|
||||
expect(Object.prototype.toString).toHaveLength(0);
|
||||
// FIXME: The tag is ObjectPrototype, but should be Object
|
||||
// expect(Object.prototype.toString()).toBe("[object Object]");
|
||||
expect({ foo: 1 }.toString()).toBe("[object Object]");
|
||||
expect([].toString()).toBe("");
|
||||
expect(Object.prototype.toString.call([])).toBe("[object Array]");
|
||||
});
|
||||
|
|
|
@ -1,43 +1,43 @@
|
|||
describe("correct behavior", () => {
|
||||
test("length", () => {
|
||||
expect(Object.setPrototypeOf).toHaveLength(2);
|
||||
});
|
||||
test("length", () => {
|
||||
expect(Object.setPrototypeOf).toHaveLength(2);
|
||||
});
|
||||
|
||||
test("basic functionality", () => {
|
||||
let o = {};
|
||||
let p = {};
|
||||
expect(Object.setPrototypeOf(o, p)).toBe(o);
|
||||
expect(Object.getPrototypeOf(o)).toBe(p);
|
||||
});
|
||||
test("basic functionality", () => {
|
||||
let o = {};
|
||||
let p = {};
|
||||
expect(Object.setPrototypeOf(o, p)).toBe(o);
|
||||
expect(Object.getPrototypeOf(o)).toBe(p);
|
||||
});
|
||||
});
|
||||
|
||||
describe("errors", () => {
|
||||
test("requires two arguments", () => {
|
||||
expect(() => {
|
||||
Object.setPrototypeOf();
|
||||
}).toThrowWithMessage(TypeError, "Object.setPrototypeOf requires at least two arguments");
|
||||
test("requires two arguments", () => {
|
||||
expect(() => {
|
||||
Object.setPrototypeOf();
|
||||
}).toThrowWithMessage(TypeError, "Object.setPrototypeOf requires at least two arguments");
|
||||
|
||||
expect(() => {
|
||||
Object.setPrototypeOf({});
|
||||
}).toThrowWithMessage(TypeError, "Object.setPrototypeOf requires at least two arguments");
|
||||
});
|
||||
expect(() => {
|
||||
Object.setPrototypeOf({});
|
||||
}).toThrowWithMessage(TypeError, "Object.setPrototypeOf requires at least two arguments");
|
||||
});
|
||||
|
||||
test("prototype must be an object", () => {
|
||||
expect(() => {
|
||||
Object.setPrototypeOf({}, "foo");
|
||||
}).toThrowWithMessage(TypeError, "Prototype must be an object or null");
|
||||
});
|
||||
test("prototype must be an object", () => {
|
||||
expect(() => {
|
||||
Object.setPrototypeOf({}, "foo");
|
||||
}).toThrowWithMessage(TypeError, "Prototype must be an object or null");
|
||||
});
|
||||
|
||||
test("non-extensible target", () => {
|
||||
let o = {};
|
||||
let p = {};
|
||||
Object.setPrototypeOf(o, p);
|
||||
Object.preventExtensions(o);
|
||||
test("non-extensible target", () => {
|
||||
let o = {};
|
||||
let p = {};
|
||||
Object.setPrototypeOf(o, p);
|
||||
Object.preventExtensions(o);
|
||||
|
||||
expect(() => {
|
||||
Object.setPrototypeOf(o, {});
|
||||
}).toThrowWithMessage(TypeError, "Object's [[SetPrototypeOf]] method returned false");
|
||||
expect(() => {
|
||||
Object.setPrototypeOf(o, {});
|
||||
}).toThrowWithMessage(TypeError, "Object's [[SetPrototypeOf]] method returned false");
|
||||
|
||||
expect(Object.setPrototypeOf(o, p)).toBe(o);
|
||||
});
|
||||
expect(Object.setPrototypeOf(o, p)).toBe(o);
|
||||
});
|
||||
});
|
||||
|
|
|
@ -1,44 +1,46 @@
|
|||
describe("correct behavior", () => {
|
||||
test("lengths", () => {
|
||||
expect(Object.values).toHaveLength(1);
|
||||
expect(Object.values(true)).toHaveLength(0);
|
||||
expect(Object.values(45)).toHaveLength(0);
|
||||
expect(Object.values(-998)).toHaveLength(0);
|
||||
expect(Object.values("abcd")).toHaveLength(4);
|
||||
expect(Object.values([1, 2, 3])).toHaveLength(3);
|
||||
expect(Object.values({ a: 1, b: 2, c: 3 })).toHaveLength(3);
|
||||
});
|
||||
test("lengths", () => {
|
||||
expect(Object.values).toHaveLength(1);
|
||||
expect(Object.values(true)).toHaveLength(0);
|
||||
expect(Object.values(45)).toHaveLength(0);
|
||||
expect(Object.values(-998)).toHaveLength(0);
|
||||
expect(Object.values("abcd")).toHaveLength(4);
|
||||
expect(Object.values([1, 2, 3])).toHaveLength(3);
|
||||
expect(Object.values({ a: 1, b: 2, c: 3 })).toHaveLength(3);
|
||||
});
|
||||
|
||||
test("object argument", () => {
|
||||
let values = Object.values({ foo: 1, bar: 2, baz: 3 });
|
||||
expect(values).toEqual([1, 2, 3]);
|
||||
});
|
||||
test("object argument", () => {
|
||||
let values = Object.values({ foo: 1, bar: 2, baz: 3 });
|
||||
expect(values).toEqual([1, 2, 3]);
|
||||
});
|
||||
|
||||
test("array argument", () => {
|
||||
let values = Object.values(["a", "b", "c"]);
|
||||
expect(values).toEqual(["a", "b", "c"]);
|
||||
});
|
||||
test("array argument", () => {
|
||||
let values = Object.values(["a", "b", "c"]);
|
||||
expect(values).toEqual(["a", "b", "c"]);
|
||||
});
|
||||
|
||||
test("ignores non-enumerable properties", () => {
|
||||
let obj = { foo: 1 };
|
||||
Object.defineProperty(obj, 'getFoo', {
|
||||
value: function() { return this.foo; },
|
||||
});
|
||||
let values = Object.values(obj);
|
||||
expect(values).toEqual([1]);
|
||||
test("ignores non-enumerable properties", () => {
|
||||
let obj = { foo: 1 };
|
||||
Object.defineProperty(obj, "getFoo", {
|
||||
value: function () {
|
||||
return this.foo;
|
||||
},
|
||||
});
|
||||
let values = Object.values(obj);
|
||||
expect(values).toEqual([1]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("errors", () => {
|
||||
test("null argument", () => {
|
||||
expect(() => {
|
||||
Object.values(null);
|
||||
}).toThrowWithMessage(TypeError, "ToObject on null or undefined");
|
||||
});
|
||||
test("null argument", () => {
|
||||
expect(() => {
|
||||
Object.values(null);
|
||||
}).toThrowWithMessage(TypeError, "ToObject on null or undefined");
|
||||
});
|
||||
|
||||
test("undefined argument", () => {
|
||||
expect(() => {
|
||||
Object.values(undefined);
|
||||
}).toThrowWithMessage(TypeError, "ToObject on null or undefined");
|
||||
});
|
||||
test("undefined argument", () => {
|
||||
expect(() => {
|
||||
Object.values(undefined);
|
||||
}).toThrowWithMessage(TypeError, "ToObject on null or undefined");
|
||||
});
|
||||
});
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue