<!DOCTYPE html>
<html>

<head>
    <!-- Programmatically converted from a WebKit Reftest, please forgive resulting idiosyncracies.-->
    <meta http-equiv="Content-Security-Policy" content="script-src 'self' 'unsafe-inline'; connect-src 'self';">
    <title>eval-blocked-and-sends-report</title>
    <script src="/resources/testharness.js"></script>
    <script src="/resources/testharnessreport.js"></script>
    <script src='../support/logTest.sub.js?logs=["PASS: eval() blocked.","violated-directive=script-src"]'></script>
    <script src="../support/alertAssert.sub.js?alerts=[]"></script>
</head>

<body>
    <script>
        window.addEventListener('securitypolicyviolation', function(e) {
            log("violated-directive=" + e.violatedDirective);
        });

        try {
            eval("alert_assert('FAIL')");
        } catch (e) {
            log('PASS: eval() blocked.');
        }

    </script>
    <div id="log"></div>
</body>

</html>
