<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<style>
.unused {
    color: green;
}
</style>
<script>
JSON = {};
</script>
<script src="../../http/tests/inspector/inspector-test.js"></script>
<script src="audits-test.js"></script>

<!-- These scripts are needed to result in a violation of the max JS resource count from the same domain -->
<script src="resources/audits-script1.js"></script>
<link rel="stylesheet" href="resources/audits-style1.css" type="text/css">
<script src="resources/audits-script2.js"></script>
<script>
var test = function()
{
    InspectorTest.reloadPage(step1);

    function step1()
    {
        WebInspector.AuditRuleResult.resourceDomain = function() {
            return "[domain]";
        };

        var launcherView = WebInspector.panels.audits._launcherView;
        launcherView._selectAllClicked(true);
        launcherView._auditPresentStateElement.checked = true;
        launcherView._launchButtonClicked();

        InspectorTest.runAfterPendingDispatches(step2);
    }

    function step2()
    {
        InspectorTest.collectAuditResults();
        InspectorTest.completeTest();
    }
}
</script>
</head>

<body onload="runTest()">
Tests audit rules on a page without images.
<style>
.violation { color: red; }
</style>
<link rel="stylesheet" href="resources/audits-style1.css" type="text/css">
</body>
</html>
