<script>
if (window.testRunner) {
    testRunner.dumpAsText();
    testRunner.waitUntilDone();
}

function finish()
{
    if (location.search.length == 0)
        document.getElementById("console").innerHTML = "PASS: cross-site assignment of location.search not allowed";
    else
        document.getElementById("console").innerHTML = "FAIL: cross-site assignment of location.search was allowed!";

    if (window.testRunner)
        testRunner.notifyDone();
}
</script>

<body onload="finish()">

<script>
if (location.search == 0) {
    document.write('<iframe src="http://localhost:8000/security/resources/xss-DENIED-assign-location-search-attacker.html"></iframe>');
}
</script>

<div id="console"></div>
</body>
</html>
