# Server-side
<reply>
<data>
HTTP/1.1 200 OK
Date: Thu, 09 Nov 2010 14:49:00 GMT
Server: test-server/fake
Content-Type: text/html
Funny-head: yesyes
Set-Cookie: test=yes; domain=foo.com; expires=Tue Feb 1 11:56:27 MET 2007
Set-Cookie: test2=yes; domain=host.foo.com; expires=Tue Feb 1 11:56:27 MET 2007
Set-Cookie: test3=maybe; domain=foo.com; path=/moo; secure
Set-Cookie: test4=no; domain=nope.foo.com; path=/moo; secure
Set-Cookie: test5=name; domain=anything.com; path=/ ; secure
Content-Length: 4

boo
</data>
</reply>

# Client-side
<client>
<server>
http
</server>
 <name>
HTTP with various cookies and custom Host:
 </name>
 <command>
http://%HOSTIP:%HOSTPORT/we/want/61 -c log/jar61.txt -H "Host: www.host.foo.com"
</command>
</client>

# Verify data after the test has been "shot"
<verify>
<strip>
^User-Agent:.*
</strip>
<protocol>
GET /we/want/61 HTTP/1.1
Pragma: no-cache
Accept: image/gif, image/x-xbitmap, image/jpeg, image/pjpeg, */*
Host: www.host.foo.com

</protocol>
<file name="log/jar61.txt">
# Netscape HTTP Cookie File
# http://www.netscape.com/newsref/std/cookie_spec.html
# This file was generated by libcurl! Edit at your own risk.

.foo.com	TRUE	/we/want/	FALSE	1170327387	test	yes
.host.foo.com	TRUE	/we/want/	FALSE	1170327387	test2	yes
.foo.com	TRUE	/moo	TRUE	0	test3	maybe
</file>
</verify>
