<!DOCTYPE html>
<html>
<head>
<meta http-equiv="Content-Security-Policy" content="form-action 127.0.0.1:8000">
<script>
  if (window.testRunner) {
    testRunner.dumpAsText();
    testRunner.waitUntilDone();
    testRunner.clearBackForwardList();
    testRunner.dumpBackForwardList();
  }
  window.addEventListener('load', function() {
    setTimeout(function () {
      testRunner.notifyDone();
    }, 1000);
    document.getElementById('submit').click();
  });
</script>
</head>
<body>
  <form
    action="/resources/redirection-response.php?host=localhost:8000&status=302&target=/navigation/resources/form-target.pl"
    id='theform'
    method='post'>
    <input type='text' name='fieldname' value='fieldvalue'>
    <input type='submit' id='submit' value='submit'>
  </form>

  <p>
    Tests that blocking form actions works with the 'get' method and redirects.
    If this test passes, you will see a console error, and will not see a page
    indicating a form was POSTed.
  </p>
</body>
</html>
