blob: b7a8dc0f04d78862e1877550d585fe3d1d74a210 [file] [log] [blame]
<!DOCTYPE html>
<html>
<head>
<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
<script>
function test()
{
let suite = InspectorTest.createSyncSuite("Set");
suite.addTestCase({
name: "Set.prototype.find",
test() {
let set = new Set(["a", "b"]);
InspectorTest.expectEqual(set.find((item) => item === "b"), "b", "Set can find a item it holds.");
InspectorTest.expectEqual(set.find((item) => typeof item === "string"), "a", "Set finds the first item if the given predicate matches multiple items.");
InspectorTest.expectEqual(set.find((item) => typeof item === "number"), undefined, "Set returns 'undefined' when attempting to find an item if the given predicate doesn't match anything.");
},
});
suite.addTestCase({
name: "Set.prototype.pushAll",
test() {
function test(iterable) {
let set = new Set([1, 2]);
function stringify(object)
{
let string = JSON.stringify(Array.from(object), function(key, value) {
if (value instanceof Node)
return "<" + value.localName + ">";
return value;
});
return string.replace(/"(<[^>]*>)"/g, "$1");
}
let before = stringify(set);
set.addAll(iterable);
let after = stringify(set);
InspectorTest.log(before + " => " + after);
}
InspectorTest.log("Array:");
test(["a1", "a2"]);
InspectorTest.newline();
InspectorTest.log("Set:");
const set = new Set(["s1", "s2"]);
test(set);
test(set.entries());
test(set.keys());
test(set.values());
InspectorTest.newline();
InspectorTest.log("Map:");
const map = new Map([["m1k", "m1v"], ["m2k", "m2v"]]);
test(map);
test(map.entries());
test(map.keys());
test(map.values());
InspectorTest.newline();
InspectorTest.log("Object:");
const object = {
o1k: "o1v",
o2k: "o2v",
};
test(Object.entries(object));
test(Object.keys(object));
test(Object.values(object));
InspectorTest.newline();
InspectorTest.log("Generator:");
function* generator() {
yield "g1";
yield "g2";
}
test(generator());
InspectorTest.newline();
InspectorTest.log("Node:");
const node = document.createElement("div");
node.appendChild(document.createElement("n1"));
node.appendChild(document.createElement("n2"));
test(node.children);
test(node.querySelectorAll("*"));
InspectorTest.newline();
InspectorTest.log("Object (doesn't have [Symbol.iterator]):");
InspectorTest.expectException(() => {
test(object);
});
},
});
suite.addTestCase({
name: "Set.prototype.take",
test() {
const key = "key";
let set = new Set;
set.add(key);
InspectorTest.expectTrue(set.take(key), "Set can take `key`.");
InspectorTest.expectFalse(set.has(key), "Set no longer has `key`.");
InspectorTest.expectFalse(set.take(key), "Set can NOT take `key`.");
InspectorTest.expectFalse(set.take("DNE"), "Set can NOT take `DNE`, as it does NOT exist.");
}
});
suite.addTestCase({
name: "Set.prototype.intersects",
test() {
function testTrue(a, b, message) {
InspectorTest.expectThat((new Set(a)).intersects(new Set(b)), message);
}
function testFalse(a, b, message) {
InspectorTest.expectFalse((new Set(a)).intersects(new Set(b)), message);
}
const object1 = {a: 1};
const object2 = {b: 2};
const object3 = {c: 3};
testFalse([], [], "an empty set should not intersect another empty set.");
testFalse([1, "a", object1], [], "a non-empty set should not intersect an empty set.");
testTrue([1, "a", object1], [1, "a", object1], "a set should intersect another set with the same values.");
testFalse([1, "a", object1], [2, "b", object2], "a set should not intersect another set with different values.");
testTrue([1, "a", object1], [1, 3, "a", "c", object1, object3], "a set should intersect another set with same and additional values.");
testTrue([1, 2, "a", "b", object1, object2], [1, 3, "a", "c", object1, object3], "a set should intersect another set with same and different values.");
}
});
suite.addTestCase({
name: "Set.prototype.isSubsetOf",
test() {
function testTrue(a, b, message) {
InspectorTest.expectThat((new Set(a)).isSubsetOf(new Set(b)), message);
}
function testFalse(a, b, message) {
InspectorTest.expectFalse((new Set(a)).isSubsetOf(new Set(b)), message);
}
const object1 = {a: 1};
const object2 = {b: 2};
const object3 = {c: 3};
testTrue([], [], "an empty set should be a subset of another empty set.");
testTrue([], [2, "b", object2], "an empty set should be a subset of a non-empty set.");
testTrue([1, "a", object1], [1, "a", object1], "a set should be a subset of another set with the same values.");
testFalse([1, "a", object1], [2, "b", object2], "a set should not be a subset of another set with different values.");
testTrue([1, "a", object1], [1, 3, "a", "c", object1, object3], "a set should be a subset of another set with same and additional values.");
testFalse([1, 2, "a", "b", object1, object2], [1, 3, "a", "c", object1, object3], "a set should not be a subset of another set with same and different values.");
}
});
suite.addTestCase({
name: "Set.prototype.equals",
test() {
function testTrue(a, b, message) {
InspectorTest.expectThat((new Set(a)).equals(new Set(b)), message);
}
function testFalse(a, b, message) {
InspectorTest.expectFalse((new Set(a)).equals(new Set(b)), message);
}
const object1 = {a: 1};
const object2 = {b: 2};
const object3 = {c: 3};
testTrue([], [], "an empty set should be equal to another empty set.");
testTrue([1, "a", object1], [1, "a", object1], "a set should be equal to another set with the same values.");
testTrue([1, "a", object1], [object1, 1, "a"], "a set should be equal to another set with the same values in a different order.");
testFalse([1, "a", object1], [2, "b", object2], "a set should not be a equal to another set with different values.");
testFalse([1, 2, "a", "b", object1, object2], [1, 3, "a", "c", object1, object3], "a set should not be equal to another set with same and different values.");
}
});
suite.addTestCase({
name: "Set.prototype.difference",
test() {
function testDifference({aValues, bValues, expectedDifference}) {
let a = new Set(aValues);
let b = new Set(bValues);
InspectorTest.log(`Given a Set with values [${aValues}], and another Set with values [${bValues}]:`);
let difference = a.difference(b);
InspectorTest.expectThat(difference.equals(new Set(expectedDifference)), `Set difference should be [${expectedDifference}].`);
InspectorTest.log("");
}
testDifference({
aValues: [],
bValues: [],
expectedDifference: [],
});
testDifference({
aValues: [1, 2, 3],
bValues: [],
expectedDifference: [1, 2, 3],
});
testDifference({
aValues: [],
bValues: [1, 2, 3],
expectedDifference: [],
});
testDifference({
aValues: [1, 2, 3],
bValues: [2, 3, 4],
expectedDifference: [1],
});
}
});
suite.addTestCase({
name: "Set.prototype.firstValue",
test() {
function testFirstValue(values) {
let expected = values[0];
InspectorTest.expectEqual(new Set(values).firstValue, expected, `Set with values [${values}] should have firstValue equal to ${expected}.`);
}
testFirstValue([]);
testFirstValue([1, 2, 3]);
}
});
suite.addTestCase({
name: "Set.prototype.lastValue",
test() {
function testLastValue(values) {
let expected = values.lastValue;
InspectorTest.expectEqual(new Set(values).lastValue, expected, `Set with values [${values}] should have lastValue equal to ${expected}.`);
}
testLastValue([]);
testLastValue([1, 2, 3]);
}
});
suite.runTestCasesAndFinish();
}
</script>
</head>
<body onLoad="runTest()">
</body>
</html>