<!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>