545 lines
25 KiB
HTML
545 lines
25 KiB
HTML
<!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>
|