<!DOCTYPE html>
<html>
<head>
<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
<script>
function test()
{
    let suite = InspectorTest.createAsyncSuite("AuditTestGroup");

    function addPayloadTest({name, payload}) {
        suite.addTestCase({
            name,
            async test() {
                let object = await WI.AuditTestGroup.fromPayload(payload);
                InspectorTest.log(object ? JSON.stringify(object, null, 2) : object);
            },
        });
    }

    let payloadTests = [
        {
            name: "AuditTestGroup.fromPayload.nullObject",
            payload: null,
        },
        {
            name: "AuditTestGroup.fromPayload.nonObject",
            payload: "INVALID",
        },
        {
            name: "AuditTestGroup.fromPayload.emptyObject",
            payload: {},
        },
        {
            name: "AuditTestGroup.fromPayload.invalidTopLevelMembers",
            payload: {
                type: null,
                name: null,
                tests: null,
            },
        },
        {
            name: "AuditTestGroup.fromPayload.missingSubMembers",
            payload: {
                type: WI.AuditTestGroup.TypeIdentifier,
                name: "missingSubMembers group name",
                tests: [],
            },
        },
        {
            name: "AuditTestGroup.fromPayload.invalidSubMembers",
            payload: {
                type: WI.AuditTestGroup.TypeIdentifier,
                name: "invalidSubMembers group name",
                tests: [
                    null,
                ],
            },
        },
        {
            name: "AuditTestGroup.fromPayload.valid",
            payload: {
                type: WI.AuditTestGroup.TypeIdentifier,
                name: "valid group name",
                tests: [
                    {
                        type: WI.AuditTestCase.TypeIdentifier,
                        name: "valid test name",
                        test: "valid test function",
                    },
                ],
            },
        },
        {
            name: "AuditTestGroup.fromPayload.validWithInvalidOptionals",
            payload: {
                type: WI.AuditTestGroup.TypeIdentifier,
                name: "validWithInvalidOptionals group name",
                description: null,
                supports: WI.AuditTestBase.Version + 1,
                setup: null,
                tests: [
                    {
                        type: WI.AuditTestCase.TypeIdentifier,
                        name: "validWithInvalidOptionals test name",
                        description: null,
                        supports: WI.AuditTestBase.Version + 2,
                        setup: null,
                        test: "validWithInvalidOptionals test function",
                    },
                ],
            },
        },
        {
            name: "AuditTestGroup.fromPayload.validWithValidOptionals",
            payload: {
                type: WI.AuditTestGroup.TypeIdentifier,
                name: "validWithValidOptionals group name",
                description: "validWithValidOptionals group description",
                supports: WI.AuditTestBase.Version - 1,
                setup: "validWithValidOptionals group setup",
                tests: [
                    {
                        type: WI.AuditTestCase.TypeIdentifier,
                        name: "validWithValidOptionals test name",
                        description: "validWithValidOptionals test description",
                        supports: WI.AuditTestBase.Version - 2,
                        setup: "validWithValidOptionals test setup",
                        test: "validWithValidOptionals test function",
                    },
                ],
            },
        },
        {
            name: "AuditTestGroup.fromPayload.validNested",
            payload: {
                type: WI.AuditTestGroup.TypeIdentifier,
                name: "validNested group name",
                description: "validNested group description",
                supports: WI.AuditTestBase.Version - 1,
                setup: "validNested group setup",
                tests: [
                    {
                        type: WI.AuditTestGroup.TypeIdentifier,
                        name: "validNested nested group name",
                        description: "validNested nested group description",
                        supports: WI.AuditTestBase.Version - 2,
                        setup: "validNested nested group setup",
                        tests: [
                            {
                                type: WI.AuditTestCase.TypeIdentifier,
                                name: "validNested nested test name",
                                description: "validNested nested test description",
                                supports: WI.AuditTestBase.Version - 3,
                                setup: "validNested nested test setup",
                                test: "validNested nested test function",
                            },
                        ],
                    },
                    {
                        type: WI.AuditTestCase.TypeIdentifier,
                        name: "validNested test name",
                        description: "validNested test description",
                        supports: WI.AuditTestBase.Version - 4,
                        setup: "validNested test setup",
                        test: "validNested test function",
                    },
                ],
            },
        },
    ];
    payloadTests.forEach(addPayloadTest);

    suite.addTestCase({
        name: "AuditTestGroup.Disabled.Constructor.Enabled",
        description: "Check that `disabled` constructor option properly propagates.",
        async test() {
            let group = new WI.AuditTestGroup("Group", [
                new WI.AuditTestCase("Test1", "function() {}"),
                new WI.AuditTestCase("Test2", "function() {}"),
            ]);

            InspectorTest.expectFalse(group.disabled, "Group should not be disabled.");
            InspectorTest.expectFalse(group.tests[0].disabled, "Test1 should not be disabled.");
            InspectorTest.expectFalse(group.tests[1].disabled, "Test2 should not be disabled.");
        },
    });

    suite.addTestCase({
        name: "AuditTestGroup.Disabled.Constructor.Disabled",
        description: "Check that `disabled` constructor option properly propagates.",
        async test() {
            let group = new WI.AuditTestGroup("Group", [
                new WI.AuditTestCase("Test1", "function() {}"),
                new WI.AuditTestCase("Test2", "function() {}"),
            ], {disabled: true});

            InspectorTest.expectTrue(group.disabled, "Group should be disabled.");
            InspectorTest.expectTrue(group.tests[0].disabled, "Test1 should be disabled.");
            InspectorTest.expectTrue(group.tests[1].disabled, "Test2 should be disabled.");
        },
    });

    suite.addTestCase({
        name: "AuditTestGroup.Disabled.ChangeGroup.Enabled",
        description: "Check that `disabled` is propagated to tests when set on group.",
        async test() {
            let group = new WI.AuditTestGroup("Group", [
                new WI.AuditTestCase("Test1", "function() {}"),
                new WI.AuditTestCase("Test2", "function() {}"),
            ]);

            InspectorTest.expectFalse(group.disabled, "Group should not be disabled.");
            InspectorTest.expectFalse(group.tests[0].disabled, "Test1 should not be disabled.");
            InspectorTest.expectFalse(group.tests[1].disabled, "Test2 should not be disabled.");

            InspectorTest.newline();
            InspectorTest.log("Marking group as disabled...");

            group.disabled = true;
            InspectorTest.expectTrue(group.disabled, "Group should be disabled.");
            InspectorTest.expectTrue(group.tests[0].disabled, "Test1 should be disabled.");
            InspectorTest.expectTrue(group.tests[1].disabled, "Test2 should be disabled.");
        },
    });

    suite.addTestCase({
        name: "AuditTestGroup.Disabled.ChangeGroup.DisabledGroup",
        description: "Check that `disabled` is propagated to tests when set on group.",
        async test() {
            let group = new WI.AuditTestGroup("Group", [
                new WI.AuditTestCase("Test1", "function() {}"),
                new WI.AuditTestCase("Test2", "function() {}"),
            ], {disabled: true});

            InspectorTest.expectTrue(group.disabled, "Group should be disabled.");
            InspectorTest.expectTrue(group.tests[0].disabled, "Test1 should be disabled.");
            InspectorTest.expectTrue(group.tests[1].disabled, "Test2 should be disabled.");

            InspectorTest.newline();
            InspectorTest.log("Marking group as enabled...");

            group.disabled = false;
            InspectorTest.expectFalse(group.disabled, "Group should not be disabled.");
            InspectorTest.expectFalse(group.tests[0].disabled, "Test1 should not be disabled.");
            InspectorTest.expectFalse(group.tests[1].disabled, "Test2 should not be disabled.");
        },
    });

    suite.addTestCase({
        name: "AuditTestGroup.Disabled.ChangeGroup.DisabledTests",
        description: "Check that `disabled` is propagated to tests when set on group.",
        async test() {
            let group = new WI.AuditTestGroup("Group", [
                new WI.AuditTestCase("Test1", "function() {}", {disabled: true}),
                new WI.AuditTestCase("Test2", "function() {}", {disabled: true}),
            ]);

            InspectorTest.expectTrue(group.disabled, "Group should be disabled.");
            InspectorTest.expectTrue(group.tests[0].disabled, "Test1 should be disabled.");
            InspectorTest.expectTrue(group.tests[1].disabled, "Test2 should be disabled.");

            InspectorTest.newline();
            InspectorTest.log("Marking group as enabled...");

            group.disabled = false;
            InspectorTest.expectFalse(group.disabled, "Group should not be disabled.");
            InspectorTest.expectFalse(group.tests[0].disabled, "Test1 should not be disabled.");
            InspectorTest.expectFalse(group.tests[1].disabled, "Test2 should not be disabled.");
        },
    });

    suite.addTestCase({
        name: "AuditTestGroup.Disabled.ChangeTests.Enabled",
        description: "Check that `disabled` is propagated to group when set on tests.",
        async test() {
            let group = new WI.AuditTestGroup("Group", [
                new WI.AuditTestCase("Test1", "function() {}"),
                new WI.AuditTestCase("Test2", "function() {}"),
            ]);

            InspectorTest.expectFalse(group.disabled, "Group should not be disabled.");
            InspectorTest.expectFalse(group.tests[0].disabled, "Test1 should not be disabled.");
            InspectorTest.expectFalse(group.tests[1].disabled, "Test2 should not be disabled.");

            InspectorTest.newline();
            InspectorTest.log("Marking Test1 as disabled...");

            group.tests[0].disabled = true;
            InspectorTest.expectFalse(group.disabled, "Group should not be disabled.");
            InspectorTest.expectTrue(group.tests[0].disabled, "Test1 should be disabled.");
            InspectorTest.expectFalse(group.tests[1].disabled, "Test2 should not be disabled.");

            InspectorTest.newline();
            InspectorTest.log("Marking Test2 as disabled...");

            group.tests[1].disabled = true;
            InspectorTest.expectTrue(group.disabled, "Group should be disabled.");
            InspectorTest.expectTrue(group.tests[0].disabled, "Test1 should be disabled.");
            InspectorTest.expectTrue(group.tests[1].disabled, "Test2 should be disabled.");
        },
    });

    suite.addTestCase({
        name: "AuditTestGroup.Disabled.ChangeTests.DisabledGroup",
        description: "Check that `disabled` is propagated to group when set on tests.",
        async test() {
            let group = new WI.AuditTestGroup("Group", [
                new WI.AuditTestCase("Test1", "function() {}"),
                new WI.AuditTestCase("Test2", "function() {}"),
            ], {disabled: true});

            InspectorTest.expectTrue(group.disabled, "Group should be disabled.");
            InspectorTest.expectTrue(group.tests[0].disabled, "Test1 should be disabled.");
            InspectorTest.expectTrue(group.tests[1].disabled, "Test2 should be disabled.");

            InspectorTest.newline();
            InspectorTest.log("Marking test as enabled 1...");

            group.tests[0].disabled = false;
            InspectorTest.expectFalse(group.disabled, "Group should not be disabled.");
            InspectorTest.expectFalse(group.tests[0].disabled, "Test1 should not be disabled.");
            InspectorTest.expectTrue(group.tests[1].disabled, "Test2 should be disabled.");

            InspectorTest.newline();
            InspectorTest.log("Marking test as enabled 2...");

            group.tests[1].disabled = false;
            InspectorTest.expectFalse(group.disabled, "Group should not be disabled.");
            InspectorTest.expectFalse(group.tests[0].disabled, "Test1 should not be disabled.");
            InspectorTest.expectFalse(group.tests[1].disabled, "Test2 should not be disabled.");
        },
    });

    suite.addTestCase({
        name: "AuditTestGroup.Disabled.ChangeTests.DisabledTests",
        description: "Check that `disabled` is propagated to group when set on tests.",
        async test() {
            let group = new WI.AuditTestGroup("Group", [
                new WI.AuditTestCase("Test1", "function() {}", {disabled: true}),
                new WI.AuditTestCase("Test2", "function() {}", {disabled: true}),
            ]);

            InspectorTest.expectTrue(group.disabled, "Group should be disabled.");
            InspectorTest.expectTrue(group.tests[0].disabled, "Test1 should be disabled.");
            InspectorTest.expectTrue(group.tests[1].disabled, "Test2 should be disabled.");

            InspectorTest.newline();
            InspectorTest.log("Marking test as enabled 1...");

            group.tests[0].disabled = false;
            InspectorTest.expectFalse(group.disabled, "Group should not be disabled.");
            InspectorTest.expectFalse(group.tests[0].disabled, "Test1 should not be disabled.");
            InspectorTest.expectTrue(group.tests[1].disabled, "Test2 should be disabled.");

            InspectorTest.newline();
            InspectorTest.log("Marking test as enabled 2...");

            group.tests[1].disabled = false;
            InspectorTest.expectFalse(group.disabled, "Group should not be disabled.");
            InspectorTest.expectFalse(group.tests[0].disabled, "Test1 should not be disabled.");
            InspectorTest.expectFalse(group.tests[1].disabled, "Test2 should not be disabled.");
        },
    });

    suite.addTestCase({
        name: "AuditTestGroup.Supports.Constructor.Supported",
        description: "Check that `supported` properly propagates with `supports` constructor option.",
        async test() {
            let group = new WI.AuditTestGroup("Group", [
                new WI.AuditTestCase("Test1", "function() {}"),
                new WI.AuditTestCase("Test2", "function() {}"),
            ]);

            InspectorTest.expectTrue(group.supported, "Group should be supported.");
            InspectorTest.expectTrue(group.tests[0].supported, "Test1 should be supported.");
            InspectorTest.expectTrue(group.tests[1].supported, "Test2 should be supported.");
        },
    });

    suite.addTestCase({
        name: "AuditTestGroup.Supports.Constructor.Unsupported",
        description: "Check that `supported` properly propagates with `supports` constructor option.",
        async test() {
            let group = new WI.AuditTestGroup("Group", [
                new WI.AuditTestCase("Test1", "function() {}"),
                new WI.AuditTestCase("Test2", "function() {}"),
            ], {supports: WI.AuditTestBase.Version + 1});

            InspectorTest.expectFalse(group.supported, "Group should not be supported.");
            InspectorTest.expectFalse(group.tests[0].supported, "Test1 should not be supported.");
            InspectorTest.expectFalse(group.tests[1].supported, "Test2 should not be supported.");
        },
    });

    suite.addTestCase({
        name: "AuditTestGroup.Supports.ChangeGroup.Supported",
        description: "Check that `supported` properly propagates to tests when `supports` is set on group.",
        async test() {
            let group = new WI.AuditTestGroup("Group", [
                new WI.AuditTestCase("Test1", "function() {}"),
                new WI.AuditTestCase("Test2", "function() {}"),
            ]);

            InspectorTest.expectTrue(group.supported, "Group should be supported.");
            InspectorTest.expectTrue(group.tests[0].supported, "Test1 should be supported.");
            InspectorTest.expectTrue(group.tests[1].supported, "Test2 should be supported.");

            InspectorTest.newline();
            InspectorTest.log("Marking group as unsupported...");

            group.supports = WI.AuditTestBase.Version + 1;
            InspectorTest.expectFalse(group.supported, "Group should not be supported.");
            InspectorTest.expectFalse(group.tests[0].supported, "Test1 should not be supported.");
            InspectorTest.expectFalse(group.tests[1].supported, "Test2 should not be supported.");
        },
    });

    suite.addTestCase({
        name: "AuditTestGroup.Supports.ChangeGroup.UnsupportedGroup",
        description: "Check that `supported` properly propagates to tests when `supports` is set on group.",
        async test() {
            let group = new WI.AuditTestGroup("Group", [
                new WI.AuditTestCase("Test1", "function() {}"),
                new WI.AuditTestCase("Test2", "function() {}"),
            ], {supports: WI.AuditTestBase.Version + 1});

            InspectorTest.expectFalse(group.supported, "Group should not be supported.");
            InspectorTest.expectFalse(group.tests[0].supported, "Test1 should not be supported.");
            InspectorTest.expectFalse(group.tests[1].supported, "Test2 should not be supported.");

            InspectorTest.newline();
            InspectorTest.log("Marking group as supported...");

            group.supports = NaN;
            InspectorTest.expectTrue(group.supported, "Group should be supported.");
            InspectorTest.expectTrue(group.tests[0].supported, "Test1 should be supported.");
            InspectorTest.expectTrue(group.tests[1].supported, "Test2 should be supported.");
        },
    });

    suite.addTestCase({
        name: "AuditTestGroup.Supports.ChangeGroup.UnsupportedTests",
        description: "Check that `supported` properly propagates to tests when `supports` is set on group.",
        async test() {
            let group = new WI.AuditTestGroup("Group", [
                new WI.AuditTestCase("Test1", "function() {}", {supports: WI.AuditTestBase.Version + 1}),
                new WI.AuditTestCase("Test2", "function() {}", {supports: WI.AuditTestBase.Version + 1}),
            ]);

            InspectorTest.expectFalse(group.supported, "Group should not be supported.");
            InspectorTest.expectFalse(group.tests[0].supported, "Test1 should not be supported.");
            InspectorTest.expectFalse(group.tests[1].supported, "Test2 should not be supported.");

            InspectorTest.newline();
            InspectorTest.log("Marking group as supported...");

            group.supports = NaN;
            InspectorTest.expectFalse(group.supported, "Group should not be supported.");
            InspectorTest.expectFalse(group.tests[0].supported, "Test1 should not be supported.");
            InspectorTest.expectFalse(group.tests[1].supported, "Test2 should not be supported.");
        },
    });

    suite.addTestCase({
        name: "AuditTestGroup.Supports.ChangeTests.Supported",
        description: "Check that `supported` properly propagates to group when `supports` is set on tests.",
        async test() {
            let group = new WI.AuditTestGroup("Group", [
                new WI.AuditTestCase("Test1", "function() {}"),
                new WI.AuditTestCase("Test2", "function() {}"),
            ]);

            InspectorTest.expectTrue(group.supported, "Group should be supported.");
            InspectorTest.expectTrue(group.tests[0].supported, "Test1 should be supported.");
            InspectorTest.expectTrue(group.tests[1].supported, "Test2 should be supported.");

            InspectorTest.newline();
            InspectorTest.log("Marking Test1 as unsupported...");

            group.tests[0].supports = WI.AuditTestBase.Version + 1;
            InspectorTest.expectTrue(group.supported, "Group should be supported.");
            InspectorTest.expectFalse(group.tests[0].supported, "Test1 should not be supported.");
            InspectorTest.expectTrue(group.tests[1].supported, "Test2 should be supported.");

            InspectorTest.newline();
            InspectorTest.log("Marking Test2 as unsupported...");

            group.tests[1].supports = WI.AuditTestBase.Version + 1;
            InspectorTest.expectFalse(group.supported, "Group should not be supported.");
            InspectorTest.expectFalse(group.tests[0].supported, "Test1 should not be supported.");
            InspectorTest.expectFalse(group.tests[1].supported, "Test2 should not be supported.");
        },
    });

    suite.addTestCase({
        name: "AuditTestGroup.Supports.ChangeTests.UnsupportedGroup",
        description: "Check that `supported` properly propagates to group when `supports` is set on tests.",
        async test() {
            let group = new WI.AuditTestGroup("Group", [
                new WI.AuditTestCase("Test1", "function() {}"),
                new WI.AuditTestCase("Test2", "function() {}"),
            ], {supports: WI.AuditTestBase.Version + 1});

            InspectorTest.expectFalse(group.supported, "Group should not be supported.");
            InspectorTest.expectFalse(group.tests[0].supported, "Test1 should not be supported.");
            InspectorTest.expectFalse(group.tests[1].supported, "Test2 should not be supported.");

            InspectorTest.newline();
            InspectorTest.log("Marking Test1 as supported...");

            group.tests[0].supports = NaN;
            InspectorTest.expectFalse(group.supported, "Group should not be supported.");
            InspectorTest.expectFalse(group.tests[0].supported, "Test1 should not be supported.");
            InspectorTest.expectFalse(group.tests[1].supported, "Test2 should not be supported.");

            InspectorTest.newline();
            InspectorTest.log("Marking Test2 as supported...");

            group.tests[1].supports = NaN;
            InspectorTest.expectFalse(group.supported, "Group should not be supported.");
            InspectorTest.expectFalse(group.tests[0].supported, "Test1 should not be supported.");
            InspectorTest.expectFalse(group.tests[1].supported, "Test2 should not be supported.");
        },
    });

    suite.addTestCase({
        name: "AuditTestGroup.Supports.ChangeTests.UnsupportedTests",
        description: "Check that `supported` properly propagates to group when `supports` is set on tests.",
        async test() {
            let group = new WI.AuditTestGroup("Group", [
                new WI.AuditTestCase("Test1", "function() {}", {supports: WI.AuditTestBase.Version + 1}),
                new WI.AuditTestCase("Test2", "function() {}", {supports: WI.AuditTestBase.Version + 1}),
            ]);

            InspectorTest.expectFalse(group.supported, "Group should not be supported.");
            InspectorTest.expectFalse(group.tests[0].supported, "Test1 should not be supported.");
            InspectorTest.expectFalse(group.tests[1].supported, "Test2 should not be supported.");

            InspectorTest.newline();
            InspectorTest.log("Marking Test1 as supported...");

            group.tests[0].supports = NaN;
            InspectorTest.expectTrue(group.supported, "Group should be supported.");
            InspectorTest.expectTrue(group.tests[0].supported, "Test1 should be supported.");
            InspectorTest.expectFalse(group.tests[1].supported, "Test2 should not be supported.");

            InspectorTest.newline();
            InspectorTest.log("Marking Test2 as supported...");

            group.tests[1].supports = NaN;
            InspectorTest.expectTrue(group.supported, "Group should be supported.");
            InspectorTest.expectTrue(group.tests[0].supported, "Test1 should be supported.");
            InspectorTest.expectTrue(group.tests[1].supported, "Test2 should be supported.");
        },
    });

    suite.runTestCasesAndFinish();
}
</script>
</head>
<body onload="runTest()">
    <p>Testing the functions of WI.AuditTestGroup.</p>
</body>
</html>