<testcase>
#based off test 707 after bug report #1218
<info>
<keywords>
FTP
PASV
RETR
SOCKS5
</keywords>
</info>
#
# Server-side
<reply>
<data>
silly content
</data>
</reply>

#
# Client-side
<client>
<features>
proxy
</features>
<server>
ftp
socks5
</server>
<name>
FTP fetch with --proxy set to socks5://
</name>
<command>
ftp://%HOSTIP:%FTPPORT/%TESTNUMBER --proxy socks5://%HOSTIP:%SOCKSPORT
</command>
</client>

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