<testcase>
<info>
<keywords>
HTTP
HTTP POST
Expect: 100-continue
</keywords>
</info>

#
# Server-side
<reply>
<data nocheck="yes">
HTTP/1.1 404 NOOOOOOOOO
Date: Tue, 09 Nov 2010 14:49:00 GMT
Server: test-server/fake
Content-Length: 6
Content-Type: text/html

-foo-
</data>

<data1>
HTTP/1.1 404 NEITHER
Date: Tue, 09 Nov 2010 14:49:00 GMT
Server: test-server/fake
Content-Length: 6
Content-Type: text/html

-foo-
</data1>

# We use skip to make the test server never read the full payload off
# the socket and instead return the response at once. In actuality, the
# long --expect100-timeout means that it will never get a chance to read this.
<servercmd>
skip: 100
</servercmd>
</reply>

#
# Client-side
<client>
# 100 x 'x'
<file name="%LOGDIR/file%TESTNUMBER">
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
</file>
<server>
http
</server>
<name>
HTTP POST forced expect 100-continue with a 404
</name>
 <command option="no-output">
-d @%LOGDIR/file%TESTNUMBER http://%HOSTIP:%HTTPPORT/%TESTNUMBER http://%HOSTIP:%HTTPPORT/%TESTNUMBER0001 -H "Expect: 100-continue" --expect100-timeout 99
</command>
</client>

#
# Verify data after the test has been "shot"
<verify>
<stdout>
HTTP/1.1 404 NOOOOOOOOO
Date: Tue, 09 Nov 2010 14:49:00 GMT
Server: test-server/fake
Content-Length: 6
Content-Type: text/html

-foo-
HTTP/1.1 404 NEITHER
Date: Tue, 09 Nov 2010 14:49:00 GMT
Server: test-server/fake
Content-Length: 6
Content-Type: text/html

-foo-
</stdout>
<protocol>
POST /%TESTNUMBER HTTP/1.1
Host: %HOSTIP:%HTTPPORT
User-Agent: curl/%VERSION
Accept: */*
Expect: 100-continue
Content-Length: 100
Content-Type: application/x-www-form-urlencoded

POST /%TESTNUMBER0001 HTTP/1.1
Host: %HOSTIP:%HTTPPORT
User-Agent: curl/%VERSION
Accept: */*
Expect: 100-continue
Content-Length: 100
Content-Type: application/x-www-form-urlencoded

</protocol>
</verify>
</testcase>
