202 lines
5.7 KiB
HTML
202 lines
5.7 KiB
HTML
<!doctype html>
|
|
<html>
|
|
<head>
|
|
<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
|
|
<script>
|
|
function test()
|
|
{
|
|
let suite = InspectorTest.createSyncSuite("InspectorTest.ExpectFunctions.Sync");
|
|
|
|
function toArray(a) {
|
|
return a instanceof Array && a.length ? a : [a];
|
|
}
|
|
|
|
function addTestCase({functionName, passingInputs, failingInputs}) {
|
|
let functionUnderTest = InspectorTest[functionName];
|
|
InspectorTest.assert(typeof functionUnderTest === "function", "Unknown InspectorTest function: " + functionName);
|
|
|
|
suite.addTestCase({
|
|
name: `InspectorTest.${functionName}`,
|
|
test() {
|
|
function exerciseFunction(inputs, shouldPass) {
|
|
if (!inputs || !inputs.length) {
|
|
InspectorTest.fail("exerciseFunction called with no inputs.");
|
|
return;
|
|
}
|
|
|
|
InspectorTest.log("Expected to " + (shouldPass ? "PASS" : "FAIL"));
|
|
for (let input of inputs.map(toArray))
|
|
functionUnderTest.call(InspectorTest, ...input);
|
|
}
|
|
|
|
exerciseFunction(passingInputs, true);
|
|
exerciseFunction(failingInputs, false);
|
|
return true;
|
|
}
|
|
});
|
|
}
|
|
|
|
function addInverseTestCase(functionName, testCase) {
|
|
addTestCase({functionName, passingInputs: testCase.failingInputs, failingInputs: testCase.passingInputs})
|
|
}
|
|
|
|
let expectThatTestCase = {
|
|
functionName: "expectThat",
|
|
passingInputs: [true, 1, "abc", {}, []],
|
|
failingInputs: [false, 0, "", null, undefined, NaN],
|
|
};
|
|
addTestCase(expectThatTestCase);
|
|
addInverseTestCase("expectFalse", expectThatTestCase);
|
|
|
|
let expectEmptyTestCase = {
|
|
functionName: "expectEmpty",
|
|
passingInputs: [null, "", {}, [], new Map, new Set],
|
|
failingInputs: ["test", {test: 1}, ["test"], new Map([["test", 1]]), new Set(["test"]), true, false, 1, undefined],
|
|
};
|
|
addTestCase(expectEmptyTestCase);
|
|
|
|
let expectNotEmptyTestCase = {
|
|
functionName: "expectNotEmpty",
|
|
passingInputs: ["test", {test: 1}, ["test"], new Map([["test", 1]]), new Set(["test"])],
|
|
failingInputs: [null, "", {}, [], new Map, new Set, true, false, 1, undefined],
|
|
};
|
|
addTestCase(expectNotEmptyTestCase);
|
|
|
|
let expectNullTestCase = {
|
|
functionName: "expectNull",
|
|
passingInputs: [null],
|
|
failingInputs: [true, false, 1, "", undefined, {}, []]
|
|
};
|
|
addTestCase(expectNullTestCase);
|
|
addInverseTestCase("expectNotNull", expectNullTestCase);
|
|
|
|
let object1 = {a: 1, b: 2};
|
|
let object2 = {a: 1, b: 2};
|
|
let customObject1 = new WI.SourceCode;
|
|
let customObject2 = new WI.Resource("foo.bar");
|
|
let expectEqualTestCase = {
|
|
functionName: "expectEqual",
|
|
passingInputs: [
|
|
[true, true],
|
|
[object1, object1],
|
|
[customObject1, customObject1],
|
|
[1.23, 1.23],
|
|
["abc", "abc"],
|
|
[null, null],
|
|
[undefined, undefined],
|
|
],
|
|
failingInputs: [
|
|
[true, false],
|
|
[object1, object2],
|
|
[customObject1, customObject2],
|
|
[1.23, 4.56],
|
|
["abc", "def"],
|
|
[null, undefined],
|
|
[NaN, NaN],
|
|
[{}, {}],
|
|
[[], []],
|
|
]
|
|
};
|
|
addTestCase(expectEqualTestCase);
|
|
addInverseTestCase("expectNotEqual", expectEqualTestCase);
|
|
|
|
let expectShallowEqualTestCase = {
|
|
functionName: "expectShallowEqual",
|
|
passingInputs: [
|
|
[{a: 1, b: 2}, {a: 1, b: 2}],
|
|
[{}, {}],
|
|
[[1, 2], [1, 2]],
|
|
[[{a: 1}, {a: 2}], [{a: 1}, {a: 2}]],
|
|
[[{}], [{}]],
|
|
[[], []],
|
|
],
|
|
failingInputs: [
|
|
[{a: 1, b: 2}, {a: 3, b: 4}],
|
|
[{}, []],
|
|
[[1, 2], [3, 4]],
|
|
[[{a: 1}, {a: 2}], [{a: 3}, {a: 4}]],
|
|
[[{a: 1}, {a: 2}], [{b: 1}, {b: 2}]],
|
|
]
|
|
};
|
|
addTestCase(expectShallowEqualTestCase);
|
|
addInverseTestCase("expectNotShallowEqual", expectShallowEqualTestCase);
|
|
|
|
addTestCase({
|
|
functionName: "expectEqualWithAccuracy",
|
|
passingInputs: [
|
|
[0, 0, 0],
|
|
[0, 0, 1],
|
|
[0, 1, 1],
|
|
[1, 0, 1],
|
|
],
|
|
failingInputs: [
|
|
[0, 2, 1],
|
|
[2, 0, 1],
|
|
]
|
|
});
|
|
|
|
addTestCase({
|
|
functionName: "expectLessThan",
|
|
passingInputs: [
|
|
[0, 1],
|
|
["abc", "def"],
|
|
],
|
|
failingInputs: [
|
|
[0, 0],
|
|
[1, 0],
|
|
["abc", "abc"],
|
|
["def", "abc"],
|
|
]
|
|
});
|
|
|
|
addTestCase({
|
|
functionName: "expectLessThanOrEqual",
|
|
passingInputs: [
|
|
[0, 1],
|
|
[0, 0],
|
|
["abc", "def"],
|
|
["abc", "abc"],
|
|
],
|
|
failingInputs: [
|
|
[1, 0],
|
|
["def", "abc"],
|
|
]
|
|
});
|
|
|
|
addTestCase({
|
|
functionName: "expectGreaterThan",
|
|
passingInputs: [
|
|
[1, 0],
|
|
["def", "abc"],
|
|
],
|
|
failingInputs: [
|
|
[0, 0],
|
|
[0, 1],
|
|
["abc", "abc"],
|
|
["abc", "def"],
|
|
]
|
|
});
|
|
|
|
addTestCase({
|
|
functionName: "expectGreaterThanOrEqual",
|
|
passingInputs: [
|
|
[1, 0],
|
|
[0, 0],
|
|
["def", "abc"],
|
|
["abc", "abc"],
|
|
],
|
|
failingInputs: [
|
|
[0, 1],
|
|
["abc", "def"],
|
|
]
|
|
});
|
|
|
|
suite.runTestCasesAndFinish();
|
|
}
|
|
</script>
|
|
</head>
|
|
<body onload="runTest()">
|
|
<p>Testing TestHarness.expect* family of functions.</p>
|
|
</body>
|
|
</html>
|