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

# Server-side
# This particular response is an exact excerpt from an actual Apache
# server when asked for a 0-10,12-15 range (except gt/lt changed to {}
# to avoid XML escaping problems).
<reply>
<data>
HTTP/1.1 206 Partial Content swsclose
Date: Sat, 24 Apr 2004 09:24:49 GMT
Server: Apache/1.3.29 (Unix) mod_throttle/3.1.2 PHP/4.3.4 mod_fastcgi/2.4.0
Last-Modified: Tue, 23 Mar 2004 08:23:14 GMT
ETag: "53814a-ec5-405ff3f2"
Accept-Ranges: bytes
Content-Length: 187
Content-Type: multipart/byteranges; boundary=408a326132c

--408a326132c
Content-type: text/html
Content-range: bytes 0-10/3781

{html}
{hea

--408a326132c
Content-type: text/html
Content-range: bytes 12-15/3781

}
{t

--408a326132c--
</data>
</reply>

# Client-side
<client>
<server>
http
</server>
 <name>
HTTP range with multiple ranges
 </name>
 <command>
http://%HOSTIP:%HTTPPORT/want/164 -r 0-10,12-15
</command>
</client>

# Verify data after the test has been "shot"
<verify>
<strip>
^User-Agent:.*
</strip>
<protocol>
GET /want/164 HTTP/1.1
Range: bytes=0-10,12-15
Host: %HOSTIP:%HTTPPORT
Accept: */*

</protocol>
</verify>
</testcase>
