<testcase>
<info>
<keywords>
HTTP
HTTP POST
CURLOPT_KEEP_SENDING_ON_ERROR
</keywords>
</info>

# Server-side
<reply>
<servercmd>
auth_required
</servercmd>
<data nocheck="yes">
HTTP/1.1 401 Authorization Required
Date: Thu, 09 Nov 2010 14:49:00 GMT
Server: test-server/fake
Content-Length: 15

Early Response
</data>
</reply>
# Client-side
<client>
<server>
http
</server>
<tool>
lib1533
</tool>
<name>
HTTP with CURLOPT_KEEP_SENDING_ON_ERROR and an early error response
</name>
<command>
http://%HOSTIP:%HTTPPORT/1533
</command>
</client>

# Verify data after the test has been "shot"
# TEST_ERR_SUCCESS is errorcode 120
<verify>
<errorcode>
120
</errorcode>
<protocol nonewline="yes">
POST /1533 HTTP/1.1
Host: %HOSTIP:%HTTPPORT
Accept: */*
Content-Length: 3
Content-Type: application/x-www-form-urlencoded

POST /1533 HTTP/1.1
Host: %HOSTIP:%HTTPPORT
Accept: */*
Content-Length: 3
Content-Type: application/x-www-form-urlencoded

POST /1533 HTTP/1.1
Host: %HOSTIP:%HTTPPORT
Accept: */*
Content-Length: 3
Content-Type: application/x-www-form-urlencoded

aaaPOST /1533 HTTP/1.1
Host: %HOSTIP:%HTTPPORT
Accept: */*
Content-Length: 3
Content-Type: application/x-www-form-urlencoded

aaa
</protocol>
</verify>
</testcase>
