443 lines
12 KiB
Python
443 lines
12 KiB
Python
|
|
||
|
|
# -----------------------------------------------------
|
||
|
|
# test_sam.py: Unit tests for sam.py.
|
||
|
|
# -----------------------------------------------------
|
||
|
|
|
||
|
|
# Make sure we can import i2p
|
||
|
|
import sys; sys.path += ['../../']
|
||
|
|
|
||
|
|
import traceback, time, thread, threading, random, copy
|
||
|
|
from i2p import eep, sam
|
||
|
|
|
||
|
|
def test_passed(s, msg='OK'):
|
||
|
|
"""Notify user that the given unit test passed."""
|
||
|
|
print ' ' + (s + ':').ljust(50) + msg
|
||
|
|
|
||
|
|
def verify_html(s):
|
||
|
|
"""Raise an error if s does not end with </html>"""
|
||
|
|
assert s.strip().lower()[-7:] == '</html>'
|
||
|
|
|
||
|
|
def stream_client(dest):
|
||
|
|
"""Sub-unit test for sam.socket in SOCK_STREAM mode."""
|
||
|
|
S = sam.socket('Alice', sam.SOCK_STREAM)
|
||
|
|
S.connect(dest)
|
||
|
|
S.send('GET / HTTP/1.0\r\n\r\n') # Send request
|
||
|
|
f = S.makefile() # File object
|
||
|
|
|
||
|
|
while True: # Read header
|
||
|
|
line = f.readline().strip() # Read a line
|
||
|
|
if line == '': break # Content begins
|
||
|
|
|
||
|
|
s = f.read() # Get content
|
||
|
|
f.close()
|
||
|
|
S.close()
|
||
|
|
|
||
|
|
def stream_client_test():
|
||
|
|
"""Unit test for sam.socket in SOCK_STREAM mode."""
|
||
|
|
url = 'morph.i2p'
|
||
|
|
stream_client('http://' + url + '/')
|
||
|
|
stream_client(url)
|
||
|
|
stream_client(url + '/')
|
||
|
|
stream_client('http://' + url)
|
||
|
|
stream_client(sam.resolve('http://' + url + '/'))
|
||
|
|
test_passed('sam.socket stream client')
|
||
|
|
|
||
|
|
def packet_test(raw=True):
|
||
|
|
"""Unit test for sam.socket in SOCK_DGRAM or SOCK_RAW modes."""
|
||
|
|
|
||
|
|
try:
|
||
|
|
multithread_wait_time = 500.0
|
||
|
|
may_need_increase = False
|
||
|
|
|
||
|
|
if raw:
|
||
|
|
C = sam.socket('Carola', sam.SOCK_RAW, in_depth=0, out_depth=0)
|
||
|
|
D = sam.socket('Davey', sam.SOCK_RAW, in_depth=0, out_depth=0)
|
||
|
|
else:
|
||
|
|
C = sam.socket('Carol', sam.SOCK_DGRAM,in_depth=0,out_depth=0)
|
||
|
|
D = sam.socket('Dave', sam.SOCK_DGRAM, in_depth=0, out_depth=0)
|
||
|
|
|
||
|
|
global C_recv, D_recv, C_got, D_got, __lock
|
||
|
|
C_recv = [] # Packets C *should* receive
|
||
|
|
D_recv = [] # Packets D *should* receive
|
||
|
|
C_got = [] # Packets C actually got
|
||
|
|
D_got = [] # Packets D actually got
|
||
|
|
|
||
|
|
n = 50 # Create n threads
|
||
|
|
m = 40 # Each thread sends m packets
|
||
|
|
|
||
|
|
global __done_count
|
||
|
|
__done_count = 0
|
||
|
|
__lock = threading.Lock()
|
||
|
|
|
||
|
|
# Use C and D to send and read in many different threads.
|
||
|
|
def f():
|
||
|
|
# This code is run in each separate thread
|
||
|
|
global C_recv, D_recv, C_got, D_got, __lock, __done_count
|
||
|
|
for i in range(m):
|
||
|
|
# Random binary string of length 2-80.
|
||
|
|
index_list = range(random.randrange(2, 80))
|
||
|
|
s = ''.join([chr(random.randrange(256)) for j in index_list])
|
||
|
|
if random.randrange(2) == 0:
|
||
|
|
# Send packet from C to D, and log it.
|
||
|
|
C.sendto(s, 0, D.dest)
|
||
|
|
__lock.acquire()
|
||
|
|
D_recv += [s]
|
||
|
|
__lock.release()
|
||
|
|
else:
|
||
|
|
# Send packet from D to C, and log it.
|
||
|
|
D.sendto(s, 0, C.dest)
|
||
|
|
__lock.acquire()
|
||
|
|
C_recv += [s]
|
||
|
|
__lock.release()
|
||
|
|
time.sleep(0.01*random.uniform(0.0,1.0))
|
||
|
|
# Read any available packets.
|
||
|
|
try: (p, fromaddr) = C.recvfrom(1000, sam.MSG_DONTWAIT)
|
||
|
|
except sam.BlockError: p = None
|
||
|
|
if p != None and not raw: assert fromaddr == D.dest
|
||
|
|
|
||
|
|
__lock.acquire()
|
||
|
|
if p != None: C_got += [p]
|
||
|
|
__lock.release()
|
||
|
|
|
||
|
|
try: (p, fromaddr) = D.recvfrom(1000, sam.MSG_DONTWAIT)
|
||
|
|
except sam.BlockError: p = None
|
||
|
|
if p != None and not raw: assert fromaddr == C.dest
|
||
|
|
|
||
|
|
__lock.acquire()
|
||
|
|
if p != None: D_got += [p]
|
||
|
|
__lock.release()
|
||
|
|
|
||
|
|
__lock.acquire()
|
||
|
|
__done_count += 1
|
||
|
|
__lock.release()
|
||
|
|
|
||
|
|
# Create n threads.
|
||
|
|
for i in range(n):
|
||
|
|
threading.Thread(target=f).start()
|
||
|
|
|
||
|
|
# Wait for them to finish.
|
||
|
|
while __done_count < n: time.sleep(0.01)
|
||
|
|
|
||
|
|
# Read any left-over received packets.
|
||
|
|
end_time = time.clock() + multithread_wait_time
|
||
|
|
while time.clock() < end_time:
|
||
|
|
# Read any available packets.
|
||
|
|
try: (p, fromaddr) = C.recvfrom(1000, sam.MSG_DONTWAIT)
|
||
|
|
except sam.BlockError: p = None
|
||
|
|
if p != None and not raw: assert fromaddr == D.dest
|
||
|
|
|
||
|
|
if p != None: C_got += [p]
|
||
|
|
|
||
|
|
try: (p, fromaddr) = D.recvfrom(1000, sam.MSG_DONTWAIT)
|
||
|
|
except sam.BlockError: p = None
|
||
|
|
if p != None and not raw: assert fromaddr == C.dest
|
||
|
|
|
||
|
|
if p != None: D_got += [p]
|
||
|
|
if len(C_got) == len(C_recv) and len(D_got) == len(D_recv):
|
||
|
|
break
|
||
|
|
|
||
|
|
if time.clock() >= end_time:
|
||
|
|
may_need_increase = True
|
||
|
|
|
||
|
|
C_got.sort()
|
||
|
|
D_got.sort()
|
||
|
|
C_recv.sort()
|
||
|
|
D_recv.sort()
|
||
|
|
|
||
|
|
assert C_got == C_recv
|
||
|
|
assert D_got == D_recv
|
||
|
|
|
||
|
|
C.close()
|
||
|
|
D.close()
|
||
|
|
except:
|
||
|
|
if raw:
|
||
|
|
print 'Unit test failed for sam.socket (SOCK_RAW).'
|
||
|
|
print 'Raw packets are not reliable.'
|
||
|
|
else:
|
||
|
|
print 'Unit test failed for sam.socket (SOCK_DGRAM).'
|
||
|
|
print 'Datagram packets are not reliable.'
|
||
|
|
|
||
|
|
if may_need_increase:
|
||
|
|
print 'Try increasing multithread_wait_time.'
|
||
|
|
|
||
|
|
traceback.print_exc(); sys.exit()
|
||
|
|
|
||
|
|
if raw:
|
||
|
|
test_passed('sam.socket (SOCK_RAW)')
|
||
|
|
else:
|
||
|
|
test_passed('sam.socket (SOCK_RAW)')
|
||
|
|
|
||
|
|
def stream_test():
|
||
|
|
"""Multithreaded unit test for sam.socket (SOCK_STREAM)."""
|
||
|
|
|
||
|
|
try:
|
||
|
|
multithread_wait_time = 200.0
|
||
|
|
may_need_increase = False
|
||
|
|
|
||
|
|
kwargs = {'in_depth':0, 'out_depth':0}
|
||
|
|
C = sam.socket('Carolic', sam.SOCK_STREAM, **kwargs)
|
||
|
|
D = sam.socket('David', sam.SOCK_STREAM, **kwargs)
|
||
|
|
Cout = sam.socket('Carolic', sam.SOCK_STREAM, **kwargs)
|
||
|
|
Dout = sam.socket('David', sam.SOCK_STREAM, **kwargs)
|
||
|
|
|
||
|
|
assert C.dest == Cout.dest
|
||
|
|
assert D.dest == Dout.dest
|
||
|
|
|
||
|
|
C.listen(5)
|
||
|
|
D.listen(5)
|
||
|
|
Cout.connect(D.dest)
|
||
|
|
Dout.connect(C.dest)
|
||
|
|
(Cin, ignoredest) = C.accept()
|
||
|
|
(Din, ignoredest) = D.accept()
|
||
|
|
|
||
|
|
global C_recv, D_recv, C_got, D_got, __lock
|
||
|
|
C_recv = [] # String data C *should* receive
|
||
|
|
D_recv = [] # String data D *should* receive
|
||
|
|
C_got = [] # String data C actually got
|
||
|
|
D_got = [] # String data D actually got
|
||
|
|
|
||
|
|
n = 50 # Create n threads
|
||
|
|
m = 40 # Each thread sends m strings
|
||
|
|
|
||
|
|
global __done_count
|
||
|
|
__done_count = 0
|
||
|
|
__lock = threading.Lock()
|
||
|
|
|
||
|
|
# Use C and D to send and read in many different threads.
|
||
|
|
def f():
|
||
|
|
# This code is run in each separate thread
|
||
|
|
global C_recv, D_recv, C_got, D_got, __lock, __done_count
|
||
|
|
for i in range(m):
|
||
|
|
# Random binary string of length 2-80.
|
||
|
|
index_list = range(random.randrange(2, 80))
|
||
|
|
s = ''.join([chr(random.randrange(256)) for j in index_list])
|
||
|
|
if random.randrange(2) == 0:
|
||
|
|
# Send packet from C to D, and log it.
|
||
|
|
__lock.acquire()
|
||
|
|
Cout.send(s)
|
||
|
|
D_recv += [s]
|
||
|
|
__lock.release()
|
||
|
|
else:
|
||
|
|
# Send packet from D to C, and log it.
|
||
|
|
__lock.acquire()
|
||
|
|
Dout.send(s)
|
||
|
|
C_recv += [s]
|
||
|
|
__lock.release()
|
||
|
|
time.sleep(0.01*random.uniform(0.0,1.0))
|
||
|
|
# Read any available string data, non-blocking.
|
||
|
|
|
||
|
|
__lock.acquire()
|
||
|
|
try: p = Cin.recv(100000, sam.MSG_DONTWAIT)
|
||
|
|
except sam.BlockError: p = None
|
||
|
|
if p != None: C_got += [p]
|
||
|
|
__lock.release()
|
||
|
|
|
||
|
|
__lock.acquire()
|
||
|
|
try: p = Din.recv(100000, sam.MSG_DONTWAIT)
|
||
|
|
except sam.BlockError: p = None
|
||
|
|
if p != None: D_got += [p]
|
||
|
|
__lock.release()
|
||
|
|
|
||
|
|
__lock.acquire()
|
||
|
|
__done_count += 1
|
||
|
|
__lock.release()
|
||
|
|
|
||
|
|
# Create n threads.
|
||
|
|
for i in range(n):
|
||
|
|
threading.Thread(target=f).start()
|
||
|
|
|
||
|
|
# Wait for them to finish.
|
||
|
|
while __done_count < n: time.sleep(0.01)
|
||
|
|
|
||
|
|
# Read any left-over received string data.
|
||
|
|
end_time = time.clock() + multithread_wait_time
|
||
|
|
while time.clock() < end_time:
|
||
|
|
# Read any available string data, non-blocking.
|
||
|
|
try: p = Cin.recv(100000, sam.MSG_DONTWAIT)
|
||
|
|
except sam.BlockError: p = None
|
||
|
|
if p != None: C_got += [p]
|
||
|
|
|
||
|
|
try: p = Din.recv(100000, sam.MSG_DONTWAIT)
|
||
|
|
except sam.BlockError: p = None
|
||
|
|
if p != None: D_got += [p]
|
||
|
|
|
||
|
|
if len(''.join(C_got)) == len(''.join(C_recv)) and \
|
||
|
|
len(''.join(D_got)) == len(''.join(D_recv)):
|
||
|
|
break
|
||
|
|
|
||
|
|
if time.clock() >= end_time:
|
||
|
|
may_need_increase = True
|
||
|
|
|
||
|
|
C_got = ''.join(C_got)
|
||
|
|
D_got = ''.join(D_got)
|
||
|
|
C_recv = ''.join(C_recv)
|
||
|
|
D_recv = ''.join(D_recv)
|
||
|
|
assert C_got == C_recv
|
||
|
|
assert D_got == D_recv
|
||
|
|
|
||
|
|
Cin.close()
|
||
|
|
Din.close()
|
||
|
|
Cout.close()
|
||
|
|
Dout.close()
|
||
|
|
C.close()
|
||
|
|
D.close()
|
||
|
|
except:
|
||
|
|
print 'Unit test failed for sam.socket ' + \
|
||
|
|
'(SOCK_STREAM, multithreaded).'
|
||
|
|
|
||
|
|
if may_need_increase:
|
||
|
|
print 'Try increasing multithread_wait_time.'
|
||
|
|
|
||
|
|
traceback.print_exc(); sys.exit()
|
||
|
|
|
||
|
|
test_passed('sam.socket (SOCK_STREAM, multithreaded)')
|
||
|
|
|
||
|
|
|
||
|
|
def noblock_stream_test():
|
||
|
|
"""Unit test for non-blocking stream commands and listen."""
|
||
|
|
|
||
|
|
serv = sam.socket('Allison',sam.SOCK_STREAM,in_depth=0,out_depth=0)
|
||
|
|
serv.setblocking(False)
|
||
|
|
serv.listen(100)
|
||
|
|
assert serv.gettimeout() == 0.0
|
||
|
|
|
||
|
|
msg_to_client = 'Hi, client!!!!'
|
||
|
|
msg_to_server = 'Hi, server!'
|
||
|
|
|
||
|
|
nconnects = 5
|
||
|
|
|
||
|
|
global server_done, client_count, client_lock
|
||
|
|
server_done = False
|
||
|
|
client_count = 0
|
||
|
|
client_lock = threading.Lock()
|
||
|
|
|
||
|
|
def serv_func(n = nconnects):
|
||
|
|
while True:
|
||
|
|
try:
|
||
|
|
(C, ignoredest) = serv.accept()
|
||
|
|
C.send(msg_to_client)
|
||
|
|
rmsg = C.recv(len(msg_to_server), sam.MSG_WAITALL)
|
||
|
|
if rmsg != msg_to_server:
|
||
|
|
raise ValueError('message should have been: ' +
|
||
|
|
repr(msg_to_server) + ' was: ' + repr(rmsg))
|
||
|
|
C.close()
|
||
|
|
n -= 1
|
||
|
|
if n == 0: break
|
||
|
|
except sam.BlockError:
|
||
|
|
pass
|
||
|
|
time.sleep(0.01)
|
||
|
|
global server_done
|
||
|
|
server_done = True
|
||
|
|
|
||
|
|
def client_func():
|
||
|
|
# FIXME: i2p.sam.NetworkError('TIMEOUT', '') errors are produced
|
||
|
|
# for our streams if we use '' for all clients. Why?
|
||
|
|
C = sam.socket('Bobb', sam.SOCK_STREAM, in_depth=0, out_depth=0)
|
||
|
|
C.setblocking(False)
|
||
|
|
try:
|
||
|
|
C.connect(serv.dest)
|
||
|
|
except sam.BlockError:
|
||
|
|
# One could also use timeout=0.1 and loop
|
||
|
|
(Rlist, Wlist, Elist) = sam.select([C], [C], [C])
|
||
|
|
if len(Elist) > 0:
|
||
|
|
assert Elist[0] == C
|
||
|
|
raise Elist[0].sessobj.err
|
||
|
|
C.send(msg_to_server)
|
||
|
|
C.setblocking(True)
|
||
|
|
rmsg = C.recv(len(msg_to_client), sam.MSG_WAITALL)
|
||
|
|
if rmsg != msg_to_client:
|
||
|
|
raise ValueError('message should have been: ' +
|
||
|
|
repr(msg_to_client) + ' was: ' + repr(rmsg))
|
||
|
|
C.close()
|
||
|
|
global client_count, client_lock
|
||
|
|
|
||
|
|
# Synchronized
|
||
|
|
client_lock.acquire()
|
||
|
|
try: client_count += 1
|
||
|
|
finally: client_lock.release()
|
||
|
|
|
||
|
|
|
||
|
|
thread.start_new_thread(serv_func, ())
|
||
|
|
|
||
|
|
for i in range(nconnects):
|
||
|
|
thread.start_new_thread(client_func, ())
|
||
|
|
|
||
|
|
while True:
|
||
|
|
if server_done and client_count == nconnects: break
|
||
|
|
time.sleep(0.01)
|
||
|
|
|
||
|
|
test_passed('sam.listen (SOCK_STREAM), and non-blocking IO')
|
||
|
|
|
||
|
|
def tunnel_server_demo():
|
||
|
|
"""Demo for TunnelServer."""
|
||
|
|
|
||
|
|
T = sam.TunnelServer('Alisick', 8080, in_depth=0, out_depth=0)
|
||
|
|
|
||
|
|
print 'Server ready at:'
|
||
|
|
print T.dest
|
||
|
|
while True:
|
||
|
|
time.sleep(0.01)
|
||
|
|
|
||
|
|
def tunnel_client_demo():
|
||
|
|
"""Demo for TunnelClient."""
|
||
|
|
|
||
|
|
T = sam.TunnelClient('Alliaha', 8001, 'duck.i2p', \
|
||
|
|
in_depth=0, out_depth=0)
|
||
|
|
|
||
|
|
print 'Serving up duck.i2p at http://127.0.0.1:8001/'
|
||
|
|
while True:
|
||
|
|
time.sleep(0.01)
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
# select, poll
|
||
|
|
# tunnel_client, tunnel_server
|
||
|
|
# noblocking unit tests
|
||
|
|
|
||
|
|
def multi_stream_test(n):
|
||
|
|
"""See if we can have n streams open at once."""
|
||
|
|
server = None
|
||
|
|
client = [None] * n
|
||
|
|
|
||
|
|
server = sam.socket('Aligi',sam.SOCK_STREAM,in_depth=0,out_depth=0)
|
||
|
|
server.listen(n)
|
||
|
|
|
||
|
|
for i in range(n):
|
||
|
|
client[i] = sam.socket('Bobo', sam.SOCK_STREAM, \
|
||
|
|
in_depth=0, out_depth=0)
|
||
|
|
|
||
|
|
for i in range(n):
|
||
|
|
client[i].connect(server.dest)
|
||
|
|
client[i].send('Hi')
|
||
|
|
|
||
|
|
for i in range(n):
|
||
|
|
client[i].close()
|
||
|
|
server.close()
|
||
|
|
|
||
|
|
test_passed(str(n) + ' streams open at once')
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
# Todo: Write unit tests for TunnelServer, TunnelClient.
|
||
|
|
|
||
|
|
def test():
|
||
|
|
print 'Testing:'
|
||
|
|
print "Comment and uncomment tests manually, if they don't finish."
|
||
|
|
|
||
|
|
# noblock_stream_test()
|
||
|
|
# stream_client_test()
|
||
|
|
# packet_test(raw=True)
|
||
|
|
# stream_test()
|
||
|
|
# multi_stream_test(200)
|
||
|
|
|
||
|
|
# Demos (manual unit tests):
|
||
|
|
# tunnel_server_demo()
|
||
|
|
# tunnel_client_demo() # This fails too
|
||
|
|
|
||
|
|
# Note: The datagram unit test fails, apparently due to a bug in I2P
|
||
|
|
# (packet loss).
|
||
|
|
## packet_test(raw=False)
|
||
|
|
|
||
|
|
if __name__ == '__main__':
|
||
|
|
test()
|