<html>
<head>
<title>Test for bug 19079</title>
</head>
<body>
<p>This is a test for https://bugs.webkit.org/show_bug.cgi?id=19079, it send the submissions
character encoding in hidden _charset_ field.
</p>
<p>
This should submit _charset_=iso8559-1.  Note that this _charset_ input has a value before it submits, which is overwritten. IE6 submits windows1252, because all pages are evidently Unicode in IE6.  The point is that it submits the charset we're using, not what exactly it submits.</p>

<form name="testForm" action="resources/char-encoding-in-hidden-charset-field.php" method="post">
<input type=hidden name="_charset_" value="This value should change">
<input type=submit>
</form>

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

document.testForm.submit();
</script>

</body>
</html> 
