private static byte[] TEST_FILE_CONTENT;

    private PostWriter postWriter;

        // Create the test file content

        TEST_FILE_CONTENT = new String("foo content &?=01234+56789-\u007c\u2aa1\u266a\u0153\u20a1\u0115\u0364\u00c5\u2052").getBytes("UTF-8");

     * Test method for 'org.apache.jmeter.protocol.http.sampler.PostWriter.sendPostData(URLConnection, HTTPSampler)'

     */

    public void testSendPostData_FileAsBody() throws IOException {

        setupFilepart(sampler, "", temporaryFile, "");

        // Check using default encoding

        postWriter.setHeaders(connection, sampler);

        postWriter.sendPostData(connection, sampler);

        checkContentLength(connection, TEST_FILE_CONTENT.length);        

        checkArraysHaveSameContent(TEST_FILE_CONTENT, connection.getOutputStreamContent());

        connection.disconnect();

        // Check using UTF-8 encoding

        establishConnection();

        sampler.setContentEncoding("UTF-8");

        // File content is sent as binary, so the content encoding should not change the file data

        postWriter.setHeaders(connection, sampler);

        postWriter.sendPostData(connection, sampler);

        checkContentLength(connection, TEST_FILE_CONTENT.length);        

        checkArraysHaveSameContent(TEST_FILE_CONTENT, connection.getOutputStreamContent());

        checkArraysHaveDifferentContent(new String(TEST_FILE_CONTENT).getBytes("UTF-8"), connection.getOutputStreamContent());

        // If we have both file as body, and form data, then only form data will be sent

        setupFormData(sampler);

        establishConnection();

        sampler.setContentEncoding("");

        postWriter.setHeaders(connection, sampler);

        postWriter.sendPostData(connection, sampler);

        checkContentTypeUrlEncoded(connection);

        byte[] expectedUrl = "title=mytitle&description=mydescription".getBytes();

        checkContentLength(connection, expectedUrl.length);

        checkArraysHaveSameContent(expectedUrl, connection.getOutputStreamContent());

    }

    /*

     * Test method for 'org.apache.jmeter.protocol.http.sampler.PostWriter.sendPostData(URLConnection, HTTPSampler)'

     */

    public void testSendFileData_Multipart() throws IOException {

        String fileField = "upload";

        String mimeType = "text/plain";

        File file = temporaryFile;

        byte[] fileContent = TEST_FILE_CONTENT;

        setupFilepart(sampler, fileField, file, mimeType);

        // Test sending data with default encoding

        String contentEncoding = "";

        sampler.setContentEncoding(contentEncoding);        

        postWriter.setHeaders(connection, sampler);

        postWriter.sendPostData(connection, sampler);

        checkContentTypeMultipart(connection, postWriter.getBoundary());

        byte[] expectedFormBody = createExpectedFilepartOutput(postWriter.getBoundary(), fileField, file, mimeType, fileContent, true, true);

        checkContentLength(connection, expectedFormBody.length);

        checkArraysHaveSameContent(expectedFormBody, connection.getOutputStreamContent());

        connection.disconnect();

        // Test sending data as ISO-8859-1

        establishConnection();

        contentEncoding = "ISO-8859-1";

        sampler.setContentEncoding(contentEncoding);        

        postWriter.setHeaders(connection, sampler);

        postWriter.sendPostData(connection, sampler);

        checkContentTypeMultipart(connection, postWriter.getBoundary());

        expectedFormBody = createExpectedFilepartOutput(postWriter.getBoundary(), fileField, file, mimeType, fileContent, true, true);

        checkContentLength(connection, expectedFormBody.length);        

        checkArraysHaveSameContent(expectedFormBody, connection.getOutputStreamContent());

        connection.disconnect();

        // Test sending data as UTF-8

        establishConnection();

        fileField = "some_file_field";

        mimeType = "image/png";

        contentEncoding = "UTF-8";

        sampler.setContentEncoding(contentEncoding);        

        setupFilepart(sampler, fileField, file, mimeType);

        postWriter.setHeaders(connection, sampler);

        postWriter.sendPostData(connection, sampler);

        checkContentTypeMultipart(connection, postWriter.getBoundary());

        expectedFormBody = createExpectedFilepartOutput(postWriter.getBoundary(), fileField, file, mimeType, fileContent, true, true);

        checkContentLength(connection, expectedFormBody.length);        

        checkArraysHaveSameContent(expectedFormBody, connection.getOutputStreamContent());

        connection.disconnect();

    }

    /*

     * Test method for 'org.apache.jmeter.protocol.http.sampler.PostWriter.sendPostData(URLConnection, HTTPSampler)'

     */

    public void testSendFormData_Multipart() throws IOException {

        String titleField = "title";

        String titleValue = "mytitle";

        String descriptionField = "description";

        String descriptionValue = "mydescription";

        setupFormData(sampler, titleValue, descriptionValue);

        // Tell sampler to do multipart, even if we have no files to upload

        sampler.setDoMultipartPost(true);

        // Test sending data with default encoding

        String contentEncoding = "";

        sampler.setContentEncoding(contentEncoding);        

        postWriter.setHeaders(connection, sampler);

        postWriter.sendPostData(connection, sampler);

        checkContentTypeMultipart(connection, postWriter.getBoundary());

        byte[] expectedFormBody = createExpectedFormdataOutput(postWriter.getBoundary(), "iso-8859-1", titleField, titleValue, descriptionField, descriptionValue, true, true);

        System.out.println(new String(expectedFormBody, "UTF-8"));

        System.out.println(new String(connection.getOutputStreamContent(), "UTF-8"));

        checkContentLength(connection, expectedFormBody.length);

        checkArraysHaveSameContent(expectedFormBody, connection.getOutputStreamContent());

        connection.disconnect();

        // Test sending data as ISO-8859-1

        establishConnection();

        contentEncoding = "ISO-8859-1";

        sampler.setContentEncoding(contentEncoding);        

        postWriter.setHeaders(connection, sampler);

        postWriter.sendPostData(connection, sampler);

        checkContentTypeMultipart(connection, postWriter.getBoundary());

        expectedFormBody = createExpectedFormdataOutput(postWriter.getBoundary(), contentEncoding, titleField, titleValue, descriptionField, descriptionValue, true, true);

        checkContentLength(connection, expectedFormBody.length);

        checkArraysHaveSameContent(expectedFormBody, connection.getOutputStreamContent());

        connection.disconnect();

        // Test sending data as ISO-8859-1, with values that need to be urlencoded

        establishConnection();

        titleValue = "mytitle+123 456&yes";

        descriptionValue = "mydescription and some spaces";

        contentEncoding = "ISO-8859-1";

        sampler.setContentEncoding(contentEncoding);        

        setupFormData(sampler, titleValue, descriptionValue);

        postWriter.setHeaders(connection, sampler);

        postWriter.sendPostData(connection, sampler);

        checkContentTypeMultipart(connection, postWriter.getBoundary());

        expectedFormBody = createExpectedFormdataOutput(postWriter.getBoundary(), contentEncoding, titleField, titleValue, descriptionField, descriptionValue, true, true);

        checkContentLength(connection, expectedFormBody.length);

        checkArraysHaveSameContent(expectedFormBody, connection.getOutputStreamContent());

        connection.disconnect();

        // Test sending data as UTF-8

        establishConnection();

        titleValue = "mytitle\u0153\u20a1\u0115\u00c5";

        descriptionValue = "mydescription\u0153\u20a1\u0115\u00c5";

        contentEncoding = "UTF-8";

        sampler.setContentEncoding(contentEncoding);        

        setupFormData(sampler, titleValue, descriptionValue);

        postWriter.setHeaders(connection, sampler);

        postWriter.sendPostData(connection, sampler);

        checkContentTypeMultipart(connection, postWriter.getBoundary());

        expectedFormBody = createExpectedFormdataOutput(postWriter.getBoundary(), contentEncoding, titleField, titleValue, descriptionField, descriptionValue, true, true);

        checkContentLength(connection, expectedFormBody.length);

        checkArraysHaveSameContent(expectedFormBody, connection.getOutputStreamContent());

        connection.disconnect();

        // Test sending data as UTF-8, with values that needs to be urlencoded

        establishConnection();

        titleValue = "mytitle\u0153+\u20a1 \u0115&yes\u00c5";

        descriptionValue = "mydescription \u0153 \u20a1 \u0115 \u00c5";

        contentEncoding = "UTF-8";

        sampler.setContentEncoding(contentEncoding);        

        setupFormData(sampler, titleValue, descriptionValue);

        postWriter.setHeaders(connection, sampler);

        postWriter.sendPostData(connection, sampler);

        checkContentTypeMultipart(connection, postWriter.getBoundary());

        expectedFormBody = createExpectedFormdataOutput(postWriter.getBoundary(), contentEncoding, titleField, titleValue, descriptionField, descriptionValue, true, true);

        checkContentLength(connection, expectedFormBody.length);

        checkArraysHaveSameContent(expectedFormBody, connection.getOutputStreamContent());

        connection.disconnect();

    }

    /*

     * Test method for 'org.apache.jmeter.protocol.http.sampler.PostWriter.sendPostData(URLConnection, HTTPSampler)'

     */

    public void testSendFormData_Urlencoded() throws IOException {

        String titleValue = "mytitle";

        String descriptionValue = "mydescription";

        setupFormData(sampler, titleValue, descriptionValue);

        // Test sending data with default encoding

        String contentEncoding = "";

        sampler.setContentEncoding(contentEncoding);        

        postWriter.setHeaders(connection, sampler);

        postWriter.sendPostData(connection, sampler);

        checkContentTypeUrlEncoded(connection);

        byte[] expectedUrl = "title=mytitle&description=mydescription".getBytes();

        checkContentLength(connection, expectedUrl.length);

        checkArraysHaveSameContent(expectedUrl, connection.getOutputStreamContent());

        connection.disconnect();

        // Test sending data as ISO-8859-1

        establishConnection();

        contentEncoding = "ISO-8859-1";

        sampler.setContentEncoding(contentEncoding);        

        postWriter.setHeaders(connection, sampler);

        postWriter.sendPostData(connection, sampler);

        checkContentTypeUrlEncoded(connection);

        expectedUrl = "title=mytitle&description=mydescription".getBytes("ISO-8859-1");

        checkContentLength(connection, expectedUrl.length);

        checkArraysHaveSameContent(expectedUrl, connection.getOutputStreamContent());

        expectedUrl = "title=mytitle&description=mydescription".getBytes("UTF-8");

        checkContentLength(connection, expectedUrl.length);

        checkArraysHaveSameContent(expectedUrl, connection.getOutputStreamContent());

        connection.disconnect();

        // Test sending data as ISO-8859-1, with values that need to be urlencoded

        establishConnection();

        titleValue = "mytitle+123 456&yes";

        descriptionValue = "mydescription and some spaces";

        contentEncoding = "ISO-8859-1";

        sampler.setContentEncoding(contentEncoding);        

        setupFormData(sampler, titleValue, descriptionValue);

        postWriter.setHeaders(connection, sampler);

        postWriter.sendPostData(connection, sampler);

        checkContentTypeUrlEncoded(connection);

        String expectedString = "title=" + URLEncoder.encode(titleValue, "UTF-8") + "&description=" + URLEncoder.encode(descriptionValue, "UTF-8");

        expectedUrl = expectedString.getBytes("ISO-8859-1");

        checkContentLength(connection, expectedUrl.length);

        checkArraysHaveSameContent(expectedUrl, connection.getOutputStreamContent());

        expectedUrl = expectedString.getBytes("UTF-8");

        checkContentLength(connection, expectedUrl.length);

        checkArraysHaveSameContent(expectedUrl, connection.getOutputStreamContent());

        String unencodedString = "title=" + titleValue + "&description=" + descriptionValue;

        byte[] unexpectedUrl = unencodedString.getBytes("UTF-8");

        checkArraysHaveDifferentContent(unexpectedUrl, connection.getOutputStreamContent());

        connection.disconnect();

        // Test sending data as UTF-8

        establishConnection();

        titleValue = "mytitle\u0153\u20a1\u0115\u00c5";

        descriptionValue = "mydescription\u0153\u20a1\u0115\u00c5";

        contentEncoding = "UTF-8";

        sampler.setContentEncoding(contentEncoding);        

        setupFormData(sampler, titleValue, descriptionValue);

        postWriter.setHeaders(connection, sampler);

        postWriter.sendPostData(connection, sampler);

        checkContentTypeUrlEncoded(connection);

        expectedString = "title=" + URLEncoder.encode(titleValue, "UTF-8") + "&description=" + URLEncoder.encode(descriptionValue, "UTF-8");

        expectedUrl = expectedString.getBytes("UTF-8");

        checkContentLength(connection, expectedUrl.length);

        checkArraysHaveSameContent(expectedUrl, connection.getOutputStreamContent());

        connection.disconnect();

        // Test sending data as UTF-8, with values that needs to be urlencoded

        establishConnection();

        titleValue = "mytitle\u0153+\u20a1 \u0115&yes\u00c5";

        descriptionValue = "mydescription \u0153 \u20a1 \u0115 \u00c5";

        contentEncoding = "UTF-8";

        sampler.setContentEncoding(contentEncoding);        

        setupFormData(sampler, titleValue, descriptionValue);

        postWriter.setHeaders(connection, sampler);

        postWriter.sendPostData(connection, sampler);

        checkContentTypeUrlEncoded(connection);

        expectedString = "title=" + URLEncoder.encode(titleValue, "UTF-8") + "&description=" + URLEncoder.encode(descriptionValue, "UTF-8");

        expectedUrl = expectedString.getBytes("UTF-8");

        checkContentLength(connection, expectedUrl.length);

        checkArraysHaveSameContent(expectedUrl, connection.getOutputStreamContent());

        unencodedString = "title=" + titleValue + "&description=" + descriptionValue;

        unexpectedUrl = unencodedString.getBytes("UTF-8");

        checkArraysHaveDifferentContent(unexpectedUrl, connection.getOutputStreamContent());

        connection.disconnect();

    }

    /*

    private void establishConnection() throws MalformedURLException { 

        connection = new StubURLConnection("http://fake_url/test");

        postWriter = new PostWriter();

    }

        output.write("Content-Transfer-Encoding: 8bit".getBytes(httpEncoding));

        output.write("Content-Disposition: form-data; name=\"".getBytes(httpEncoding));

        output.write(descriptionField.getBytes(httpEncoding));

        output.write("\"".getBytes(httpEncoding));

        output.write(CRLF);

        if(contentEncoding != null) {

            output.write(descriptionValue.getBytes(contentEncoding));

        }

        else {

            output.write(descriptionValue.getBytes());

        }

        output.write(CRLF);

        output.write(DASH_DASH);

        output.write(boundaryString.getBytes(httpEncoding));

        if(lastMultipart) {

            output.write(DASH_DASH);

        }

        output.write(CRLF);

        output.flush();

        output.close();

        return output.toByteArray();

    }

    /**

     * Create the expected file multipart

     * 

     * @param lastMultipart true if this is the last multipart in the request

     */

    private byte[] createExpectedFilepartOutput(

            String boundaryString,

            String fileField,

            File file,

            String mimeType,

            byte[] fileContent,

            boolean firstMultipart,

            boolean lastMultipart) throws IOException {

        // The encoding used for http headers and control information

        final String httpEncoding = "ISO-8859-1";

        final byte[] DASH_DASH = new String("--").getBytes(httpEncoding);

        final ByteArrayOutputStream output = new ByteArrayOutputStream();

        if(firstMultipart) {

            output.write(DASH_DASH);

            output.write(boundaryString.getBytes(httpEncoding));

            output.write(CRLF);

        }

        output.write("Content-Transfer-Encoding: 8bit".getBytes(httpEncoding));

        output.write(CRLF);        

     * Check that the the two byte arrays have identical content

     * 

     * @param expected

     * @param actual

     */

    private void checkArraysHaveSameContent(byte[] expected, byte[] actual) {

        if(expected != null && actual != null) {

            if(expected.length != actual.length) {

                fail("arrays have different length, expected is " + expected.length + ", actual is " + actual.length);

            }

            else {

                for(int i = 0; i < expected.length; i++) {

                    if(expected[i] != actual[i]) {

                        fail("byte at position " + i + " is different, expected is " + expected[i] + ", actual is " + actual[i]);

                    }

                }

            }

        }

        else {

            fail("expected or actual byte arrays were null");

        }

    }

    /**

     * Check that the the two byte arrays different content

     * 

     * @param expected

     * @param actual

     */

    private void checkArraysHaveDifferentContent(byte[] expected, byte[] actual) {

        if(expected != null && actual != null) {

            if(expected.length == actual.length) {

                boolean allSame = true;

                for(int i = 0; i < expected.length; i++) {

                    if(expected[i] != actual[i]) {

                        allSame = false;

                        break;

                    }

                }

                if(allSame) {

                    fail("all bytes were equal");

                }

            }

        }

        else {

            fail("expected or actual byte arrays were null");

        }

    }

    private void checkContentTypeMultipart(HttpURLConnection connection, String boundaryString) {

        assertEquals("multipart/form-data; boundary=" + boundaryString, connection.getRequestProperty("Content-Type"));

    }

    private void checkContentTypeUrlEncoded(HttpURLConnection connection) {

        assertEquals(HTTPSamplerBase.APPLICATION_X_WWW_FORM_URLENCODED, connection.getRequestProperty("Content-Type"));

    }

    private void checkContentLength(HttpURLConnection connection, int length) {

        assertEquals(Integer.toString(length), connection.getRequestProperty("Content-Length"));

    }

    /**

        public byte[] getOutputStreamContent() {

            return output.toByteArray();

        }