<testcase>
<info>
<keywords>
HTTP
HTTP GET
HTTP Basic auth
HTTP proxy
HTTP proxy Basic auth
</keywords>
</info>

#
# Server-side
<reply>
<data>
HTTP/1.1 200 OK
Date: Thu, 09 Nov 2010 14:49:00 GMT
Server: test-server/fake swsclose
Content-Type: text/html
Funny-head: yesyes
Content-Length: 9

contents
</data>
</reply>

#
# Client-side
<client>
<server>
http
</server>
 <name>
HTTP over proxy with site and proxy authentication
 </name>
 <command>
http://%HOSTIP:%HTTPPORT/we/want/that/page/85 -x %HOSTIP:%HTTPPORT --user iam:myself --proxy-user testing:this
</command>
</client>

#
# Verify data after the test has been "shot"
<verify>
<strip>
^User-Agent:.*
</strip>
<protocol>
GET http://%HOSTIP:%HTTPPORT/we/want/that/page/85 HTTP/1.1
Proxy-Authorization: Basic dGVzdGluZzp0aGlz
Authorization: Basic aWFtOm15c2VsZg==
User-Agent: curl/7.10.7-pre2 (i686-pc-linux-gnu) libcurl/7.10.7-pre2 OpenSSL/0.9.7a zlib/1.1.3
Host: %HOSTIP:%HTTPPORT
Accept: */*
Proxy-Connection: Keep-Alive

</protocol>
</verify>
</testcase>
