<testcase>
<info>
<keywords>
HTTP
GLOBAL DNS CACHE
</keywords>
</info>

# Server-side
<reply>
<data1>
HTTP/1.1 200 OK
Date: Thu, 09 Nov 2010 14:49:00 GMT
Server: test-server/fake
Content-Length: 47

file contents should appear once for each file
</data1>
<data2>
HTTP/1.1 200 OK
Date: Thu, 09 Nov 2010 14:49:00 GMT
Server: test-server/fake
Content-Length: 47

file contents should appear once for each file
</data2>
<data3>
HTTP/1.1 200 OK
Date: Thu, 09 Nov 2010 14:49:00 GMT
Server: test-server/fake
Content-Length: 47

file contents should appear once for each file
</data3>
<data4>
HTTP/1.1 200 OK
Date: Thu, 09 Nov 2010 14:49:00 GMT
Server: test-server/fake
Content-Length: 47

file contents should appear once for each file
</data4>
</reply>

# Client-side
<client>
<server>
http
</server>
<tool>
lib1512
</tool>
 <name>
GLOBAL CACHE test over two easy performs
 </name>
 <command>
http://%HOSTIP:%HTTPPORT/path/1512 %HOSTIP %HTTPPORT
</command>
</client>

# Verify data after the test has been "shot"
<verify>
<protocol>
GET /path/15120001 HTTP/1.1
Host: %HOSTIP:%HTTPPORT
Accept: */*

GET /path/15120002 HTTP/1.1
Host: %HOSTIP:%HTTPPORT
Accept: */*

</protocol>
<strip>
^Host:.*
</strip>
<stripfile>
$_ = '' if (($_ !~ /left intact/) && ($_ !~ /Closing connection/))
</stripfile>
</verify>
</testcase>
