<testcase>
<info>
<keywords>
FTP
EPSV
RETR
--remote-time
</keywords>
</info>
# Server-side
<reply>
<data>
file data
</data>
<mdtm>
213 20090213233130
</mdtm>
</reply>

# Client-side
<client>
<server>
ftp
</server>
<name>
FTP with --remote-time
</name>
<command>
ftp://%HOSTIP:%FTPPORT/%TESTNUMBER --remote-time
</command>
# Verify the mtime of the file. The mtime is specifically chosen to be an even
# number so that it can be represented exactly on a FAT filesystem.
<postcheck>
perl -e 'exit((stat("%LOGDIR/curl%TESTNUMBER.out"))[9] != 1234567890)'
</postcheck>
</client>

# Verify data after the test has been "shot"
<verify>
<protocol>
USER anonymous
PASS ftp@example.com
PWD
MDTM %TESTNUMBER
EPSV
TYPE I
SIZE %TESTNUMBER
RETR %TESTNUMBER
QUIT
</protocol>
</verify>
</testcase>
