<testcase>
<info>
<keywords>
HTTP
HTTP GET
HTTP replaced headers
cookies
httponly
</keywords>
</info>

# Server-side
<reply>
<data>
HTTP/1.0 200 OK swsclose
Date: Tue, 09 Nov 2010 14:49:00 GMT
Content-Type: text/html

boo
</data>
</reply>

# Client-side
<client>
<server>
http
</server>
<name>
HTTP, send cookies when using custom Host:
</name>
<command>
http://%HOSTIP:%HTTPPORT/we/want/%TESTNUMBER http://%HOSTIP:%HTTPPORT/we/want/%TESTNUMBER?hoge=fuga -b %LOGDIR/jar%TESTNUMBER.txt -H "Host: www.host.foo.com"
</command>
<file name="%LOGDIR/jar%TESTNUMBER.txt">
# Netscape HTTP Cookie File
# https://curl.se/docs/http-cookies.html
# This file was generated by libcurl! Edit at your own risk.

#HttpOnly_.foo.com	TRUE	/we/want/	FALSE	22147483647	test	yes
.host.foo.com	TRUE	/we/want/	FALSE	22147483647	test2	yes
.fake.host.foo.com	TRUE	/we/want/	FALSE	22147483647	test4	yes

.foo.com	TRUE	/moo	TRUE	0	test3	maybe
</file>
<features>
cookies
</features>
</client>

# Verify data after the test has been "shot"
<verify>
<protocol>
GET /we/want/%TESTNUMBER HTTP/1.1
Host: www.host.foo.com
User-Agent: curl/%VERSION
Accept: */*
Cookie: test2=yes; test=yes

GET /we/want/%TESTNUMBER?hoge=fuga HTTP/1.1
Host: www.host.foo.com
User-Agent: curl/%VERSION
Accept: */*
Cookie: test2=yes; test=yes

</protocol>
</verify>
</testcase>
