<testcase>
# Server-side
<reply>
</reply>

# Client-side
<client>
<server>
ftp
</server>
 <name>
FTP with multiple uploads
 </name>
 <command>
-T log/upload149 ftp://%HOSTIP:%FTPPORT/dir1/149 -T log/upload149 ftp://%HOSTIP:%FTPPORT/dir2/149
</command>
<file name="log/upload149">
send away this contents
</file>
</client>

# Verify data after the test has been "shot"
<verify>
# Strip all valid kinds of PORT and EPRT that curl can send
<strip>
^PORT \d{1,3},\d{1,3},\d{1,3},\d{1,3},\d{1,3},\d{1,3}
^EPRT \|1\|\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\|\d{1,5}\|
</strip>
<protocol>
USER anonymous
PASS ftp@example.com
PWD
CWD dir1
EPSV
TYPE I
STOR 149
CWD /
CWD dir2
EPSV
STOR 149
QUIT
</protocol>
<file name="log/upload149">
send away this contents
</file>
</verify>
</testcase>
