<testcase>
<info>
<keywords>
HTTP
HTTP GET
HTTP/1.0
DELAY
</keywords>
</info>

# Server-side
<reply>
<data nocheck="yes">
HTTP/1.0 200 OK
Date: Tue, 09 Nov 2010 14:49:00 GMT
Content-Length: 9
Connection: Keep-Alive

surprise
</data>
<data1>
HTTP/1.0 200 OK swsclose
Date: Tue, 09 Nov 2010 14:49:00 GMT
Connection: close

surprise2
</data1>

<postcmd>
wait 1
</postcmd>
</reply>

# Client-side
<client>
<server>
http
</server>
<name>
HTTP downgrade to HTTP/1.0 on second request
</name>
<command>
http://%HOSTIP:%HTTPPORT/want/%TESTNUMBER http://%HOSTIP:%HTTPPORT/wantmore/%TESTNUMBER0001
</command>
</client>

# Verify data after the test has been "shot"
<verify>
<stdout>
HTTP/1.0 200 OK
Date: Tue, 09 Nov 2010 14:49:00 GMT
Content-Length: 9
Connection: Keep-Alive

surprise
HTTP/1.0 200 OK swsclose
Date: Tue, 09 Nov 2010 14:49:00 GMT
Connection: close

surprise2
</stdout>

<protocol>
GET /want/%TESTNUMBER HTTP/1.1
Host: %HOSTIP:%HTTPPORT
User-Agent: curl/%VERSION
Accept: */*

GET /wantmore/%TESTNUMBER0001 HTTP/1.0
Host: %HOSTIP:%HTTPPORT
User-Agent: curl/%VERSION
Accept: */*

</protocol>
</verify>
</testcase>
