<testcase>
<info>
<keywords>
HTTP
HTTP GET
Content-Range
Resume
followlocation
</keywords>
</info>

# Server-side
<reply>
<data>
HTTP/1.1 301 OK swsbounce
Location: /%TESTNUMBER
Content-Length: 3

OK
</data>
<data1>
HTTP/1.1 200 OK 
Connection: close
Content-Length: 15
Content-Range: bytes 50-

Actual content
</data1>

<datacheck>
HTTP/1.1 301 OK swsbounce
Location: /%TESTNUMBER
Content-Length: 3

HTTP/1.1 200 OK 
Connection: close
Content-Length: 15
Content-Range: bytes 50-

Actual content
</datacheck>

</reply>

# Client-side
<client>
<server>
http
</server>
<name>
HTTP GET with resume and redirect
</name>
<command>
http://%HOSTIP:%HTTPPORT/%TESTNUMBER -C 50 -L
</command>
</client>

# Verify data after the test has been "shot"
<verify>
<protocol>
GET /%TESTNUMBER HTTP/1.1
Host: %HOSTIP:%HTTPPORT
Range: bytes=50-
User-Agent: curl/%VERSION
Accept: */*

GET /%TESTNUMBER HTTP/1.1
Host: %HOSTIP:%HTTPPORT
Range: bytes=50-
User-Agent: curl/%VERSION
Accept: */*

</protocol>
</verify>
</testcase>
