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

# Server-side
<reply>
<data nocheck="yes">
HTTP/1.1 200 OK
Server: thebest/1.0
Content-Type: text/plain
Content-Length: 6

first
</data>
<data1 nocheck="yes">
HTTP/1.1 200 OK
Server: thebest/1.0
Content-Type: text/plain
Content-Length: 7

second
</data1>
</reply>

# Client-side
<client>
<server>
http
</server>
 <name>
HTTP --dump-header - with two URLs
 </name>
 <command>
http://%HOSTIP:%HTTPPORT/want/1066 http://%HOSTIP:%HTTPPORT/want/10660001 --dump-header -
</command>
</client>

# Verify data after the test has been "shot"
<verify>
<protocol>
GET /want/1066 HTTP/1.1
Host: %HOSTIP:%HTTPPORT
User-Agent: curl/%VERSION
Accept: */*

GET /want/10660001 HTTP/1.1
Host: %HOSTIP:%HTTPPORT
User-Agent: curl/%VERSION
Accept: */*

</protocol>
<stdout>
HTTP/1.1 200 OK
HTTP/1.1 200 OK
Server: thebest/1.0
Server: thebest/1.0
Content-Type: text/plain
Content-Type: text/plain
Content-Length: 6
Content-Length: 6


first
HTTP/1.1 200 OK
HTTP/1.1 200 OK
Server: thebest/1.0
Server: thebest/1.0
Content-Type: text/plain
Content-Type: text/plain
Content-Length: 7
Content-Length: 7


second
</stdout>
</verify>
</testcase>
