<testcase>
<info>
<keywords>
HTTP
HTTP POST
HTTP CONNECT
proxytunnel
</keywords>
</info>

#
# Server-side
<reply>
<data>
HTTP/1.1 200 OK
Date: Tue, 09 Nov 2010 14:49:00 GMT
Server: test-server/fake swsclose
Content-Type: text/html
Funny-head: yesyes
Content-Length: 9

contents
</data>
<connect>
HTTP/1.1 200 Mighty fine indeed

</connect>
<datacheck>
HTTP/1.1 200 Mighty fine indeed

HTTP/1.1 200 OK
Date: Tue, 09 Nov 2010 14:49:00 GMT
Server: test-server/fake swsclose
Content-Type: text/html
Funny-head: yesyes
Content-Length: 9

contents
</datacheck>
</reply>

#
# Client-side
<client>
<features>
debug
proxy
</features>
<server>
http
http-proxy
</server>
<name>
CONNECT with short sends
</name>
<setenv>
# make the first send cut off after this amount of data
CURL_SMALLREQSEND=8
# make repeated sends small too
CURL_SMALLSENDS=8
</setenv>
<command>
http://test.%TESTNUMBER:%HTTPPORT/we/want/that/page/%TESTNUMBER -p -x %HOSTIP:%PROXYPORT -d "datatopost=ohthatsfunyesyes"
</command>
</client>

#
# Verify data after the test has been "shot"
<verify>
<proxy>
CONNECT test.%TESTNUMBER:%HTTPPORT HTTP/1.1
Host: test.%TESTNUMBER:%HTTPPORT
User-Agent: curl/%VERSION
Proxy-Connection: Keep-Alive

</proxy>
<protocol nonewline="yes">
POST /we/want/that/page/%TESTNUMBER HTTP/1.1
Host: test.%TESTNUMBER:%HTTPPORT
User-Agent: curl/%VERSION
Accept: */*
Content-Length: 27
Content-Type: application/x-www-form-urlencoded

datatopost=ohthatsfunyesyes
</protocol>
</verify>
</testcase>
