def _test(timeout=1, disabled_loggers=None, level=None):
# TODO: Use in separate file to test importing functionality.
from testing import unittest, do_tests, process_events_with_timeout
class Tests(object):
class TestMainWindow(unittest.TestCase):
def setUp(self):
self.finished = False
def tearDown(self):
if self.finished:
process_events_with_timeout(timeout)
def test_main(self):
w = MainWindow()
w.show()
for i in xrange(2):
w.add_router()
w.shake_routers()
#w.send_image_router.send_data(range(100))
self.finished = True
do_tests(Tests, qt=True, disabled_loggers=disabled_loggers, level=level)
def _test(level=None, timeout=1):
# TODO: Use in separate file to test importing functionality.
from testing import unittest, do_tests, process_events_with_timeout
from router_scene_item import RouterItem
from image_transfer_router_scene_item import SendImageRouterItem, \
ReceiveImageRouterItem
class Tests(object):
class TestLinkItem(unittest.TestCase):
def setUp(self):
self.view = QGraphicsView()
self.scene = QGraphicsScene()
self.scene.setSceneRect(-150, -105, 300, 210)
self.scene.addRect(-150, -105, 300 - 1, 210 - 1, QPen(Qt.black))
self.view.setScene(self.scene)
def tearDown(self):
self.view.show()
process_events_with_timeout(timeout)
self.li.terminate()
self.ri1._stop_networking() # TODO
self.ri2._stop_networking() # TODO
def test_main(self):
self.ri1 = RouterItem(1)
self.ri2 = RouterItem(2)
self.scene.addItem(self.ri1)
self.scene.addItem(self.ri2)
self.ri1.setPos(-100, -50)
self.ri2.setPos(100, 50)
self.li = LinkItem(self.ri1, self.ri2, enabled=True)
self.scene.addItem(self.li)
self.finished = True
def test_image_transfer(self):
self.ri1 = SendImageRouterItem(0, 1)
self.ri2 = ReceiveImageRouterItem(1)
self.scene.addItem(self.ri1)
self.scene.addItem(self.ri2)
self.ri1.setPos(-100, -50)
self.ri2.setPos(100, 50)
self.li = LinkItem(self.ri1, self.ri2, enabled=True)
self.scene.addItem(self.li)
self.ri1.send_data(range(100))
self.finished = True
do_tests(Tests, level=level, qt=True)
def _test():
# TODO: Use in separate file to test importing functionality.
from testing import unittest, do_tests
class Tests(object):
class TestConfig(unittest.TestCase):
pass
do_tests(Tests)
def _test():
from testing import unittest, do_tests
class Tests:
class TestTotalOrdering(unittest.TestCase):
def test_main(self):
# TODO
pass
do_tests(Tests)
def _test():
from testing import unittest, do_tests
class Tests:
class TestRecordtypeInheritance(unittest.TestCase):
def setUp(self):
class A(recordtype('A', 'a, b, c')):
def __init__(self, *args, **kwargs):
super(A, self).__init__(*args, **kwargs)
self.A = A
@unittest.expectedFailure
def test_empty_args(self):
a = self.A()
def test_args(self):
a = self.A(1, 2, 3)
def test_kwargs(self):
a = self.A(a=1, b=2, c=3)
class TestRecordtypeInheritanceNested(unittest.TestCase):
def setUp(self):
class NestedClass(object):
class A(recordtype('A', 'a, b, c')):
def __init__(self, *args, **kwargs):
super(NestedClass.A, self).__init__(*args, **kwargs)
self.A = NestedClass.A
@unittest.expectedFailure
def test_empty_args(self):
a = self.A()
def test_args(self):
a = self.A(1, 2, 3)
def test_kwargs(self):
a = self.A(a=1, b=2, c=3)
class TestRecordtypeDetuple(unittest.TestCase):
def test_detuple(self):
A = recordtype('A', 'a, b, c')
a = A(1, 2, 3)
x, y, z = a
self.assertEqual(x, a.a)
self.assertEqual(y, a.b)
self.assertEqual(z, a.c)
do_tests(Tests)
def _test(level=None):
# TODO: Use in separate file to test importing functionality.
from testing import unittest, do_tests
class Tests(object):
class TestRouter(unittest.TestCase):
def test_constructor(self):
name = 1
rr = Router(name)
self.assertEqual(rr.name, name)
self.assertEqual(rr.link_manager.connected_routers(), [])
rr.terminate()
do_tests(Tests, level=level)
def _test():
# TODO: Use in separate file to test importing functionality.
from testing import unittest, do_tests, process_events_with_timeout
class Tests(object):
class TestPalette(unittest.TestCase):
def test_main(self):
p = Palette()
p[10]
def test_deterministic(self):
p1 = Palette()
p2 = Palette()
p1[100]
p2[200]
self.assertEqual(p1[30], p2[30])
def test_test(self):
p1 = Palette()
colors = [(p1[i].red(), p1[i].green(), p1[i].blue())
for i in xrange(10)]
colors.sort()
print "Must be random:", colors
class TestFixedPalette(unittest.TestCase):
def test_main(self):
p = FixedPalette(4)
p[10]
def test_deterministic(self):
p1 = FixedPalette(4)
p2 = FixedPalette(4)
p1[100]
p2[200]
self.assertEqual(p1[30], p2[30])
def test_test(self):
p1 = FixedPalette(4)
colors = [(p1[i].red(), p1[i].green(), p1[i].blue())
for i in xrange(10)]
colors.sort()
print "Must be random:", colors
do_tests(Tests, qt=True)
def _test(level=None):
# TODO: Use in separate file to test importing functionality.
from testing import unittest, do_tests
class Tests(object):
class TestRouterName(unittest.TestCase):
def test_is_valid(self):
self.assertTrue(is_valid(0))
self.assertTrue(is_valid(1))
self.assertTrue(is_valid(2**32 - 1))
self.assertFalse(is_valid(-1))
self.assertFalse(is_valid(-2**32 - 1))
self.assertFalse(is_valid(2**32))
self.assertFalse(is_valid(2**32 + 1))
do_tests(Tests, level=level)
def _test(init_logging=True, level=None, disabled_loggers=None):
# TODO: Use in separate file to test importing functionality.
from testing import unittest, do_tests
from duplex_link import FullDuplexLink, LossFunc
from frame import SimpleFrameTransmitter
from sliding_window import FrameTransmitter
from link_manager import RouterLinkManager
from datagram import DatagramRouter
from service_manager import RouterServiceManager
from routing_table import loopback_routing_table, LocalRoutingTable
class Tests(object):
class TestMain(unittest.TestCase):
def test_main(self):
pass
do_tests(Tests, level=level, disabled_loggers=disabled_loggers)
def _test(timeout=1, disabled_loggers=None, level=None):
# TODO: Use in separate file to test importing functionality.
from testing import unittest, do_tests, process_events_with_timeout
class Tests(object):
class TestMainWindow(unittest.TestCase):
def setUp(self):
self.finished = False
def tearDown(self):
if self.finished:
process_events_with_timeout(timeout)
def test_main(self):
w = TransmissionWidget()
w.show()
self.finished = True
do_tests(Tests, qt=True, disabled_loggers=disabled_loggers, level=level)
def _test(timeout=1):
# TODO: Use in separate file to test importing functionality.
from testing import unittest, do_tests, process_events_with_timeout
import time
from service_manager import Packet
class Tests(object):
class TestRIPPacketItemGUI(unittest.TestCase):
def setUp(self):
self.view = QGraphicsView()
self.scene = QGraphicsScene()
self.scene.setSceneRect(-150, -105, 300, 210)
self.scene.addRect(-150, -105, 300 - 1, 210 - 1, QPen(Qt.black))
self.view.setScene(self.scene)
self.view.scale(10, 10)
self.p = Packet(1, 2, "test", time.time())
self.finished = False
def tearDown(self):
if self.finished:
self.view.show()
process_events_with_timeout(timeout)
def test_main(self):
rpi = RIPPacketItem(self.p)
self.assertEqual(rpi._packet, self.p)
self.scene.addItem(rpi)
self.finished = True
do_tests(Tests, qt=True)
def _test(timeout=1, level=None):
# TODO: Use in separate file to test importing functionality.
from testing import unittest, do_tests, process_events_with_timeout
class Tests(object):
class TestRouterItemGUI(unittest.TestCase):
def setUp(self):
self.view = QGraphicsView()
self.scene = QGraphicsScene()
self.scene.setSceneRect(-150, -105, 300, 210)
self.scene.addRect(-150, -105, 300 - 1, 210 - 1, QPen(Qt.black))
self.view.setScene(self.scene)
self.finished = False
def tearDown(self):
if self.finished:
self.view.show()
process_events_with_timeout(timeout)
def test_main(self):
ri = RouterItem(1)
self.assertEqual(ri.name, 1)
self.scene.addItem(ri)
self.finished = True
def test_change_position(self):
ri = RouterItem(1)
self.scene.addItem(ri)
ri.setPos(50, 50)
self.finished = True
def _test_add_link(self):
ri = RouterItem(1)
link = "dummy"
ri.add_link(link)
self.assertItemsEqual(ri.links, [link])
self.finished = True
def _test_add_link_with_adjustment(self):
ri = RouterItem(1)
class Link(object):
def __init__(self):
self.adjusted = False
def adjust(self):
self.adjusted = True
link = Link()
self.assertFalse(link.adjusted)
ri.add_link(link)
self.assertFalse(link.adjusted)
self.assertItemsEqual(ri.links, [link])
# TODO
# ri.setPos(10, 10)
# self.assertTrue(link.adjusted)
self.finished = True
class TestRouterItem(unittest.TestCase):
def tearDown(self):
process_events_with_timeout(timeout)
def test_start_stop_networking(self):
ri = RouterItem(1)
# self.assertEqual(ri._rip_service, None)
# ri.start_networking()
self.assertNotEqual(ri._rip_service, None)
# ri.stop_networking()
# self.assertEqual(ri._rip_service, None)
class TestRouterItemGUIMoving(unittest.TestCase):
def setUp(self):
self.view = QGraphicsView()
self.scene = QGraphicsScene()
self.scene.setSceneRect(-150, -105, 300, 210)
self.scene.addRect(self.scene.sceneRect(), QPen(Qt.black))
self.view.setScene(self.scene)
self.finished = False
def tearDown(self):
if self.finished:
self.view.show()
self.lastUpdate = time.time()
def update():
t = time.time()
self.ri.advance(t - self.lastUpdate)
self.lastUpdate = t
process_events_with_timeout(timeout, callback=update)
def test_main(self):
self.ri = RouterItem(1)
self.scene.addItem(self.ri)
self.finished = True
do_tests(Tests, qt=True, level=level)
def _test(level=None):
# TODO: Use in separate file to test importing functionality.
from testing import unittest, do_tests
from duplex_link import FullDuplexLink, LossFunc
class Tests(object):
class TestFrame(unittest.TestCase):
def test_frame(self):
id = 13804
data = "Some test data for Frame class (12334567890)."
p = Frame(type=FrameType.data, id=id, is_last=True, data=data)
s = p.serialize()
np = Frame.deserialize(s)
self.assertEqual(p.type, np.type)
self.assertEqual(p.id, np.id)
self.assertEqual(p.data, np.data)
p = Frame(type=FrameType.data, id=id, is_last=True, data="")
s = p.serialize()
np = Frame.deserialize(s)
self.assertEqual(p.type, np.type)
self.assertEqual(p.id, np.id)
self.assertEqual("", np.data)
class TestFrameTransmitterConstructor(unittest.TestCase):
def setUp(self):
self.a, self.b = FullDuplexLink()
self.at = SimpleFrameTransmitter(node=self.a)
self.bt = SimpleFrameTransmitter(node=self.b)
def test_constructor(self):
aft = FrameTransmitter(simple_frame_transmitter=self.at,
debug_src=1, debug_dest=2)
bft = FrameTransmitter(simple_frame_transmitter=self.bt,
debug_src=2, debug_dest=1)
aft.terminate()
bft.terminate()
@unittest.expectedFailure
def test_terminate(self):
aft = FrameTransmitter(simple_frame_transmitter=self.at)
aft.terminate()
aft.terminate()
class TestFrameTransmitter(unittest.TestCase):
def setUp(self):
self.a, self.b = FullDuplexLink()
self.at = SimpleFrameTransmitter(node=self.a)
self.bt = SimpleFrameTransmitter(node=self.b)
self.aft = FrameTransmitter(simple_frame_transmitter=self.at,
debug_src=1, debug_dest=2)
self.bft = FrameTransmitter(simple_frame_transmitter=self.bt,
debug_src=2, debug_dest=1)
def tearDown(self):
self.aft.terminate()
self.bft.terminate()
def test_transmit(self):
text = "Test!"
self.aft.send(text)
self.assertEqual(self.bft.receive(), text)
self.assertEqual(self.bft.receive(block=False), None)
text2 = "".join(map(chr, xrange(256)))
self.bft.send(text2)
self.assertEqual(self.aft.receive(), text2)
self.assertEqual(self.aft.receive(block=False), None)
text3 = "test"
self.bft.send(text3)
text_a = text2
text_b = "".join(reversed(text2))
self.aft.send(text_a)
self.aft.send(text_b)
self.assertEqual(self.aft.receive(), text3)
self.assertEqual(self.bft.receive(), text_a)
self.assertEqual(self.bft.receive(), text_b)
text4 = text2 * 10
self.aft.send(text4)
self.assertEqual(self.bft.receive(), text4)
self.assertEqual(self.aft.receive(block=False), None)
self.assertEqual(self.bft.receive(block=False), None)
def test_enabled(self):
self.assertTrue(self.aft.enabled)
text = "Test!"
self.aft.send(text)
self.assertEqual(self.bft.receive(), text)
self.aft.enabled = False
self.assertFalse(self.aft.enabled)
self.aft.send(text)
self.assertEqual(self.bft.receive(block=False), None)
self.aft.enabled = True
self.aft.send(text)
self.assertEqual(self.bft.receive(block=False), None)
self.aft.send(text)
self.aft.enabled = False
self.assertFalse(self.aft.enabled)
self.aft.enabled = True
self.assertEqual(self.bft.receive(block=False), None)
class TestFrameTransmitterWithLosses(unittest.TestCase):
def setUp(self):
self.a, self.b = FullDuplexLink(
loss_func=LossFunc(0.001, 0.001, 0.001))
self.at = SimpleFrameTransmitter(node=self.a)
self.bt = SimpleFrameTransmitter(node=self.b)
self.aft = FrameTransmitter(simple_frame_transmitter=self.at,
debug_src=1, debug_dest=2)
self.bft = FrameTransmitter(simple_frame_transmitter=self.bt,
debug_src=2, debug_dest=1)
def tearDown(self):
self.aft.terminate()
self.bft.terminate()
def test_transmit_with_losses(self):
text = "Test!"
self.aft.send(text)
self.assertEqual(self.bft.receive(), text)
self.assertEqual(self.bft.receive(block=False), None)
text2 = "".join(map(chr, xrange(256)))
self.bft.send(text2)
self.assertEqual(self.aft.receive(), text2)
self.assertEqual(self.aft.receive(block=False), None)
text3 = "test"
self.bft.send(text3)
text_a = text2
text_b = "".join(reversed(text2))
self.aft.send(text_a)
self.aft.send(text_b)
self.assertEqual(self.aft.receive(), text3)
self.assertEqual(self.bft.receive(), text_a)
self.assertEqual(self.bft.receive(), text_b)
#text4 = text2 * 10
#self.aft.send(text4)
#self.assertEqual(self.bft.receive(), text4)
self.assertEqual(self.aft.receive(block=False), None)
self.assertEqual(self.bft.receive(block=False), None)
class TestExperiment(unittest.TestCase):
def test_main(self):
time_, sent = experiment(100, 100, ["data"], loss_prob=None)
# TODO: Assume that computer is not very slow.
self.assertLess(time_, 5.0)
self.assertEqual(sent, 2)
time_, sent = experiment(100, 100, ["data", "another"],
loss_prob=None)
# TODO: Assume that computer is not very slow.
self.assertLess(time_, 5.0)
self.assertEqual(sent, 4)
do_tests(Tests, level=level)
def _test(level=None):
# TODO: Use in separate file to test importing functionality.
from testing import unittest, do_tests
from duplex_link import FullDuplexLink, LossFunc
from frame import SimpleFrameTransmitter
from sliding_window import FrameTransmitter
from link_manager import RouterLinkManager
from routing_table import loopback_routing_table, LocalRoutingTable
from datagram import DatagramRouter
class Tests(object):
class TestPacket(unittest.TestCase):
def test_main(self):
t = time.time()
p1 = Packet( 1, 2, "3", 4, t)
p2 = Packet(src=1, dest=2, data="3", delivered_from=4, time=t)
self.assertEqual(p1, p2)
self.assertEqual(p1.src, 1)
self.assertEqual(p1.dest, 2)
self.assertEqual(p1.data, "3")
self.assertEqual(p1.time, t)
d1 = packet_to_datagram(p1, 30)
self.assertEqual(d1,
datagram(30, p1.src, p1.dest, p1.data +
struct.pack("d", t)))
d1_type, p1_ = datagram_to_packet(d1, 4)
self.assertEqual(d1_type, d1.type)
self.assertEqual(p1_, p1)
self.assertEqual(p1_.time, p1.time)
class Test_ServiceInfo(unittest.TestCase):
def test_main(self):
sm = RouterServiceManager.ServiceInfo(0, 1, 2)
self.assertEqual(sm.name, 0)
self.assertEqual(sm.receive_queue, 1)
self.assertEqual(sm.send_queue, 2)
class TestRouterServiceManagerBasic(unittest.TestCase):
def setUp(self):
self.lm1 = RouterLinkManager()
self.dt1 = DatagramRouter(
router_name=1,
link_manager=self.lm1)
def test_constructor(self):
sm = RouterServiceManager(self.dt1)
sm.terminate()
def test_main(self):
sm = RouterServiceManager(self.dt1)
s10 = sm.register_service(10)
sm.terminate()
def tearDown(self):
self.dt1.terminate()
class TestRouterServiceManager1(unittest.TestCase):
def setUp(self):
self.lm1 = RouterLinkManager()
self.dt1 = DatagramRouter(
router_name=1,
link_manager=self.lm1)
self.sm1 = RouterServiceManager(self.dt1)
def test_send_receive_data(self):
self.s30 = self.sm1.register_service(30)
text = "Some text text."
self.s30.send_data(1, text)
self.assertEqual(self.s30.receive_data(), (1, text))
self.assertEqual(self.s30.receive_data(False), None)
def test_main(self):
s10 = self.sm1.register_service(10)
s15 = self.sm1.register_service(15)
unreach_p10 = Packet(1, 2, "unreachable test (10)", 1)
s10.send(unreach_p10)
p10_1 = Packet(1, 1, "test (10)", 1)
s10.send(p10_1)
self.assertEqual(s10.receive(), p10_1)
self.assertEqual(s10.receive(block=False), None)
p15_1 = Packet(1, 1, "test (15)", 1)
p10_2 = Packet(1, 1, "test 2 (10)", 1)
s10.send(p10_1)
s15.send(p15_1)
s10.send(p10_2)
self.assertEqual(s15.receive(), p15_1)
self.assertEqual(s15.receive(block=False), None)
self.assertEqual(s10.receive(), p10_1)
self.assertEqual(s10.receive(), p10_2)
self.assertEqual(s10.receive(block=False), None)
text = "".join(map(chr, xrange(256)))
p15_2 = Packet(1, 1, text * 10, 1)
s15.send(p15_2)
s10.send(p10_1)
self.assertEqual(s10.receive(), p10_1)
self.assertEqual(s15.receive(), p15_2)
def tearDown(self):
self.sm1.terminate()
self.dt1.terminate()
class TestRouterServiceManager2(unittest.TestCase):
def setUp(self):
l1, l2 = FullDuplexLink()
sft1 = SimpleFrameTransmitter(node=l1)
sft2 = SimpleFrameTransmitter(node=l2)
self.ft1 = FrameTransmitter(simple_frame_transmitter=sft1,
debug_src=1, debug_dest=2)
self.ft2 = FrameTransmitter(simple_frame_transmitter=sft2,
debug_src=2, debug_dest=1)
rlm1 = RouterLinkManager()
rlm2 = RouterLinkManager()
self.dr1 = DatagramRouter(
router_name=1,
link_manager=rlm1,
routing_table=LocalRoutingTable(1, rlm1))
self.dr2 = DatagramRouter(
router_name=2,
link_manager=rlm2,
routing_table=LocalRoutingTable(2, rlm2))
rlm1.add_link(2, self.ft1)
rlm2.add_link(1, self.ft2)
self.sm1 = RouterServiceManager(self.dr1)
self.sm2 = RouterServiceManager(self.dr2)
self.s1_100 = self.sm1.register_service(100)
self.s2_100 = self.sm2.register_service(100)
def _test_transmit(self):
s1_77 = self.sm1.register_service(77)
s2_77 = self.sm2.register_service(77)
d12 = Packet(1, 2, "test")
s1_77.send(d12)
self.assertEqual(s2_77.receive(), d12)
s2_77.send(d12)
self.assertEqual(s2_77.receive(), d12)
s1_33 = self.sm1.register_service(33)
s2_33 = self.sm2.register_service(33)
d21 = Packet(2, 1, "test 2")
s2_33.send(d21)
self.assertEqual(s1_33.receive(), d21)
s1_33.send(d21)
self.assertEqual(s1_33.receive(), d21)
text = "".join(map(chr, xrange(256)))
d_big = Packet(1, 2, text * 5)
s1_33.send(d_big)
self.assertEqual(s2_33.receive(), d_big)
d12_2 = Packet(1, 2, "test 2")
d12_3 = Packet(1, 2, "test 3")
s1_33.send(d12)
s1_33.send(d12_2)
self.assertEqual(s2_33.receive(), d12)
s1_77.send(d12_3)
self.assertEqual(s2_77.receive(), d12_3)
self.assertEqual(s2_33.receive(), d12_2)
def test_time(self):
data = "test"
self.s1_100.send_data(2, data)
p = self.s2_100.receive()
self.assertEqual(p.data, data)
# TODO: Assume computer is not slow.
self.assertLess(p.time, 5.0)
self.assertGreaterEqual(p.time, 0)
def tearDown(self):
self.sm1.terminate()
self.sm2.terminate()
self.dr1.terminate()
self.dr2.terminate()
self.ft1.terminate()
self.ft2.terminate()
class _TestRouterServiceManager2WithLosses(unittest.TestCase):
def setUp(self):
l1, l2 = FullDuplexLink(loss_func=LossFunc(0.001, 0.001, 0.001))
sft1 = SimpleFrameTransmitter(node=l1)
sft2 = SimpleFrameTransmitter(node=l2)
self.ft1 = FrameTransmitter(simple_frame_transmitter=sft1,
debug_src=1, debug_dest=2)
self.ft2 = FrameTransmitter(simple_frame_transmitter=sft2,
debug_src=2, debug_dest=1)
rlm1 = RouterLinkManager()
rlm2 = RouterLinkManager()
self.dr1 = DatagramRouter(
router_name=1,
link_manager=rlm1,
routing_table=LocalRoutingTable(1, rlm1))
self.dr2 = DatagramRouter(
router_name=2,
link_manager=rlm2,
routing_table=LocalRoutingTable(2, rlm2))
rlm1.add_link(2, self.ft1)
rlm2.add_link(1, self.ft2)
self.sm1 = RouterServiceManager(self.dr1)
self.sm2 = RouterServiceManager(self.dr2)
def test_transmit(self):
s1_77 = self.sm1.register_service(77)
s2_77 = self.sm2.register_service(77)
d12 = Packet(1, 2, "test")
s1_77.send(d12)
self.assertEqual(s2_77.receive(), d12)
s2_77.send(d12)
self.assertEqual(s2_77.receive(), d12)
s1_33 = self.sm1.register_service(33)
s2_33 = self.sm2.register_service(33)
d21 = Packet(2, 1, "test 2")
s2_33.send(d21)
self.assertEqual(s1_33.receive(), d21)
s1_33.send(d21)
self.assertEqual(s1_33.receive(), d21)
text = "".join(map(chr, xrange(256)))
d_big = Packet(1, 2, text * 5)
s1_33.send(d_big)
self.assertEqual(s2_33.receive(), d_big)
d12_2 = Packet(1, 2, "test 2")
d12_3 = Packet(1, 2, "test 3")
s1_33.send(d12)
s1_33.send(d12_2)
self.assertEqual(s2_33.receive(), d12)
s1_77.send(d12_3)
self.assertEqual(s2_77.receive(), d12_3)
self.assertEqual(s2_33.receive(), d12_2)
def tearDown(self):
self.sm1.terminate()
self.sm2.terminate()
self.dr1.terminate()
self.dr2.terminate()
self.ft1.terminate()
self.ft2.terminate()
do_tests(Tests, level=level)
def _test(init_logging=True, level=None, disabled_loggers=None):
# TODO: Use in separate file to test importing functionality.
from testing import unittest, do_tests
from duplex_link import FullDuplexLink, LossFunc
from frame import SimpleFrameTransmitter
from sliding_window import FrameTransmitter
from link_manager import RouterLinkManager
from datagram import DatagramRouter
from service_manager import RouterServiceManager
from routing_table import loopback_routing_table, LocalRoutingTable
class Tests(object):
class TestRIPData(unittest.TestCase):
def test_main(self):
distances = [(1, 1), (2, 2)]
rd = RIPData(distances)
self.assertEqual(rd.distances, distances)
raw_rd = rd.serialize()
new_rd = RIPData.deserialize(raw_rd)
self.assertEqual(rd, new_rd)
self.assertEqual(new_rd.distances, distances)
class TestRIPServiceBasic(unittest.TestCase):
def setUp(self):
self.lm1 = RouterLinkManager()
self.dt1 = DatagramRouter(
router_name=1,
link_manager=self.lm1)
self.sm1 = RouterServiceManager(self.dt1)
self.rip_st1 = self.sm1.register_service(RIPService.protocol)
def test_constructor(self):
rs1 = RIPService(1, self.lm1, self.rip_st1)
rs1.terminate()
def test_main(self):
rs1 = RIPService(1, self.lm1, self.rip_st1)
self.assertEqual(rs1.dynamic_routing_table().next_router(1), 1)
self.assertEqual(rs1.dynamic_routing_table().next_router(2),
None)
rs1.terminate()
def tearDown(self):
self.sm1.terminate()
self.dt1.terminate()
class TestRIPService1(unittest.TestCase):
def setUp(self):
self.lm1 = RouterLinkManager()
self.dt1 = DatagramRouter(
router_name=1,
link_manager=self.lm1)
self.sm1 = RouterServiceManager(self.dt1)
self.rip_st1 = self.sm1.register_service(RIPService.protocol)
self.rs1 = RIPService(1, self.lm1, self.rip_st1,
update_period=0.3, inf_timeout=0.6, remove_timeout=1)
def test_dynamic_routing(self):
self.dt1.set_routing_table(self.rs1.dynamic_routing_table())
time.sleep(5)
def test_dynamic_routing_transfer(self):
self.dt1.set_routing_table(self.rs1.dynamic_routing_table())
#time.sleep(0.5)
s10 = self.sm1.register_service(10)
s15 = self.sm1.register_service(15)
unreach_p10 = Packet(1, 2, "unreachable test (10)")
s10.send(unreach_p10)
p10_1 = Packet(1, 1, "test (10)")
s10.send(p10_1)
self.assertEqual(s10.receive(), p10_1)
self.assertEqual(s10.receive(block=False), None)
p15_1 = Packet(1, 1, "test (15)")
p10_2 = Packet(1, 1, "test 2 (10)")
s10.send(p10_1)
s15.send(p15_1)
s10.send(p10_2)
self.assertEqual(s15.receive(), p15_1)
self.assertEqual(s15.receive(block=False), None)
self.assertEqual(s10.receive(), p10_1)
self.assertEqual(s10.receive(), p10_2)
self.assertEqual(s10.receive(block=False), None)
text = "".join(map(chr, xrange(256)))
p15_2 = Packet(1, 1, text * 10)
s15.send(p15_2)
s10.send(p10_1)
self.assertEqual(s10.receive(), p10_1)
self.assertEqual(s15.receive(), p15_2)
def tearDown(self):
self.rs1.terminate()
self.sm1.terminate()
self.dt1.terminate()
class TestRIPService2(unittest.TestCase):
def setUp(self):
l1, l2 = FullDuplexLink()
sft1 = SimpleFrameTransmitter(node=l1)
sft2 = SimpleFrameTransmitter(node=l2)
self.ft1 = FrameTransmitter(simple_frame_transmitter=sft1,
debug_src=1, debug_dest=2)
self.ft2 = FrameTransmitter(simple_frame_transmitter=sft2,
debug_src=2, debug_dest=1)
rlm1 = RouterLinkManager()
rlm2 = RouterLinkManager()
self.dr1 = DatagramRouter(
router_name=1,
link_manager=rlm1,
routing_table=LocalRoutingTable(1, rlm1))
self.dr2 = DatagramRouter(
router_name=2,
link_manager=rlm2,
routing_table=LocalRoutingTable(2, rlm2))
rlm1.add_link(2, self.ft1)
rlm2.add_link(1, self.ft2)
self.sm1 = RouterServiceManager(self.dr1)
self.sm2 = RouterServiceManager(self.dr2)
self.rip_st1 = self.sm1.register_service(RIPService.protocol)
self.rip_st2 = self.sm2.register_service(RIPService.protocol)
self.rs1 = RIPService(1, rlm1, self.rip_st1,
update_period=0.5, inf_timeout=0.9, remove_timeout=1.6)
self.rs2 = RIPService(2, rlm2, self.rip_st2,
update_period=0.5, inf_timeout=0.9, remove_timeout=1.6)
self.dr1.set_routing_table(self.rs1.dynamic_routing_table())
self.dr2.set_routing_table(self.rs2.dynamic_routing_table())
def test_transmit(self):
s1_77 = self.sm1.register_service(77)
s2_77 = self.sm2.register_service(77)
d12 = Packet(1, 2, "test")
s1_77.send(d12)
self.assertEqual(s2_77.receive(), d12)
s2_77.send(d12)
self.assertEqual(s2_77.receive(), d12)
s1_33 = self.sm1.register_service(33)
s2_33 = self.sm2.register_service(33)
d21 = Packet(2, 1, "test 2")
s2_33.send(d21)
self.assertEqual(s1_33.receive(), d21)
s1_33.send(d21)
self.assertEqual(s1_33.receive(), d21)
text = "".join(map(chr, xrange(256)))
d_big = Packet(1, 2, text * 5)
s1_33.send(d_big)
self.assertEqual(s2_33.receive(), d_big)
d12_2 = Packet(1, 2, "test 2")
d12_3 = Packet(1, 2, "test 3")
s1_33.send(d12)
s1_33.send(d12_2)
self.assertEqual(s2_33.receive(), d12)
s1_77.send(d12_3)
self.assertEqual(s2_77.receive(), d12_3)
self.assertEqual(s2_33.receive(), d12_2)
def tearDown(self):
self.rs1.terminate()
self.rs2.terminate()
self.sm1.terminate()
self.sm2.terminate()
self.dr1.terminate()
self.dr2.terminate()
self.ft1.terminate()
self.ft2.terminate()
class TestRIPService2WithLosses(TestRIPService2):
def setUp(self):
l1, l2 = FullDuplexLink(
loss_func=LossFunc(0.0008, 0.0008, 0.0008))
sft1 = SimpleFrameTransmitter(node=l1)
sft2 = SimpleFrameTransmitter(node=l2)
self.ft1 = FrameTransmitter(simple_frame_transmitter=sft1,
debug_src=1, debug_dest=2)
self.ft2 = FrameTransmitter(simple_frame_transmitter=sft2,
debug_src=2, debug_dest=1)
rlm1 = RouterLinkManager()
rlm2 = RouterLinkManager()
self.dr1 = DatagramRouter(
router_name=1,
link_manager=rlm1,
routing_table=LocalRoutingTable(1, rlm1))
self.dr2 = DatagramRouter(
router_name=2,
link_manager=rlm2,
routing_table=LocalRoutingTable(2, rlm2))
rlm1.add_link(2, self.ft1)
rlm2.add_link(1, self.ft2)
self.sm1 = RouterServiceManager(self.dr1)
self.sm2 = RouterServiceManager(self.dr2)
self.rip_st1 = self.sm1.register_service(RIPService.protocol)
self.rip_st2 = self.sm2.register_service(RIPService.protocol)
self.rs1 = RIPService(1, rlm1, self.rip_st1,
update_period=0.5, inf_timeout=0.9, remove_timeout=1.6)
self.rs2 = RIPService(2, rlm2, self.rip_st2,
update_period=0.5, inf_timeout=0.9, remove_timeout=1.6)
self.dr1.set_routing_table(self.rs1.dynamic_routing_table())
self.dr2.set_routing_table(self.rs2.dynamic_routing_table())
do_tests(Tests, level=level, disabled_loggers=disabled_loggers)
def _test(level=None):
# TODO: Use in separate file to test importing functionality.
from testing import unittest, do_tests
from duplex_link import FullDuplexLink, LossFunc
from frame import SimpleFrameTransmitter
from link_manager import RouterLinkManager
from routing_table import loopback_routing_table, LocalRoutingTable
class Tests(object):
class TestDatagram(unittest.TestCase):
def test_datagram(self):
id = 13804
data = "Some test data for Datagram class (12334567890)."
p = Datagram(type=12, src=100, dest=200, data=data)
s = p.serialize()
np = Datagram.deserialize(s)
self.assertEqual(p.type, np.type)
self.assertEqual(p.src, np.src)
self.assertEqual(p.dest, np.dest)
self.assertEqual(p.data, np.data)
p = Datagram(type=12, src=100, dest=200, data="")
s = p.serialize()
np = Datagram.deserialize(s)
self.assertEqual(p.type, np.type)
self.assertEqual(p.src, np.src)
self.assertEqual(p.dest, np.dest)
self.assertEqual("", np.data)
def test_datagram_func(self):
d = datagram(1, 2, 3, "test")
self.assertEqual(d.type, 1)
self.assertEqual(d.src, 2)
self.assertEqual(d.dest, 3)
self.assertEqual(d.data, "test")
class TestDatagramRouterBasic(unittest.TestCase):
def test_basic(self):
lm = RouterLinkManager()
dt10 = DatagramRouter(
router_name=10,
link_manager=lm)
dt10.terminate()
class TestDatagramRouter1(unittest.TestCase):
def setUp(self):
self.lm1 = RouterLinkManager()
self.dt1 = DatagramRouter(
router_name=1,
link_manager=self.lm1)
def test_set_routing_table(self):
self.dt1.set_routing_table(loopback_routing_table(1))
self.dt1.set_routing_table(LocalRoutingTable(1, self.lm1))
def test_name(self):
self.assertEqual(self.dt1.name, 1)
def test_transmit(self):
self.dt1.send(datagram(1, 1, 2, "unreachable test"))
self.assertEqual(self.dt1.receive(block=False)[1], None)
self.dt1.send(datagram(13, 1, 1, "test"))
d = self.dt1.receive()[1]
self.assertEqual(d.type, 13)
self.assertEqual(d.src, 1)
self.assertEqual(d.dest, 1)
self.assertEqual(d.data, "test")
self.dt1.send(datagram(14, 1, 1, "test 1"))
self.dt1.send(datagram(15, 1, 1, "test 2"))
d = self.dt1.receive()[1]
self.assertEqual(d.type, 14)
self.assertEqual(d.src, 1)
self.assertEqual(d.dest, 1)
self.assertEqual(d.data, "test 1")
d = self.dt1.receive()[1]
self.assertEqual(d.type, 15)
self.assertEqual(d.src, 1)
self.assertEqual(d.dest, 1)
self.assertEqual(d.data, "test 2")
def tearDown(self):
self.dt1.terminate()
class TestDatagramRouter2(unittest.TestCase):
def setUp(self):
l1, l2 = FullDuplexLink()
sft1 = SimpleFrameTransmitter(node=l1)
sft2 = SimpleFrameTransmitter(node=l2)
self.ft1 = FrameTransmitter(simple_frame_transmitter=sft1,
debug_src=1, debug_dest=2)
self.ft2 = FrameTransmitter(simple_frame_transmitter=sft2,
debug_src=2, debug_dest=1)
rlm1 = RouterLinkManager()
rlm2 = RouterLinkManager()
self.dr1 = DatagramRouter(
router_name=1,
link_manager=rlm1,
routing_table=LocalRoutingTable(1, rlm1))
self.dr2 = DatagramRouter(
router_name=2,
link_manager=rlm2,
routing_table=LocalRoutingTable(2, rlm2))
rlm1.add_link(2, self.ft1)
rlm2.add_link(1, self.ft2)
def test_transmit(self):
d12 = datagram(12, 1, 2, "test")
self.dr1.send(d12)
self.assertEqual(self.dr2.receive()[1], d12)
self.dr2.send(d12)
self.assertEqual(self.dr2.receive()[1], d12)
d21 = datagram(13, 2, 1, "test 2")
self.dr2.send(d21)
self.assertEqual(self.dr1.receive()[1], d21)
self.dr1.send(d21)
self.assertEqual(self.dr1.receive()[1], d21)
text = "".join(map(chr, xrange(256)))
d_big = datagram(130, 1, 2, text * 5)
self.dr1.send(d_big)
self.assertEqual(self.dr2.receive()[1], d_big)
d12_2 = datagram(14, 1, 2, "test 2")
d12_3 = datagram(14, 1, 2, "test 3")
self.dr1.send(d12)
self.dr1.send(d12_2)
self.assertEqual(self.dr2.receive()[1], d12)
self.dr1.send(d12_3)
self.assertEqual(self.dr2.receive()[1], d12_2)
self.assertEqual(self.dr2.receive()[1], d12_3)
def test_invalid_datagram(self):
self.ft1.send("raw test!")
self.assertEqual(self.dr2.receive(block=False)[1], None)
d12 = datagram(12, 1, 2, "test")
self.dr1.send(d12)
self.assertEqual(self.dr2.receive()[1], d12)
def tearDown(self):
self.dr1.terminate()
self.dr2.terminate()
self.ft1.terminate()
self.ft2.terminate()
class TestDatagramRouter2WithLosses(unittest.TestCase):
def setUp(self):
l1, l2 = FullDuplexLink(loss_func=LossFunc(0.001, 0.001, 0.001))
sft1 = SimpleFrameTransmitter(node=l1)
sft2 = SimpleFrameTransmitter(node=l2)
self.ft1 = FrameTransmitter(simple_frame_transmitter=sft1,
debug_src=1, debug_dest=2)
self.ft2 = FrameTransmitter(simple_frame_transmitter=sft2,
debug_src=2, debug_dest=1)
rlm1 = RouterLinkManager()
rlm2 = RouterLinkManager()
self.dr1 = DatagramRouter(
router_name=1,
link_manager=rlm1,
routing_table=LocalRoutingTable(1, rlm1))
self.dr2 = DatagramRouter(
router_name=2,
link_manager=rlm2,
routing_table=LocalRoutingTable(2, rlm2))
rlm1.add_link(2, self.ft1)
rlm2.add_link(1, self.ft2)
def test_transmit(self):
d12 = datagram(12, 1, 2, "test")
self.dr1.send(d12)
self.assertEqual(self.dr2.receive()[1], d12)
self.dr2.send(d12)
self.assertEqual(self.dr2.receive()[1], d12)
d21 = datagram(13, 2, 1, "test 2")
self.dr2.send(d21)
self.assertEqual(self.dr1.receive()[1], d21)
self.dr1.send(d21)
self.assertEqual(self.dr1.receive()[1], d21)
text = "".join(map(chr, xrange(256)))
d_big = datagram(130, 1, 2, text * 3)
self.dr1.send(d_big)
self.assertEqual(self.dr2.receive()[1], d_big)
d12_2 = datagram(14, 1, 2, "test 2")
d12_3 = datagram(14, 1, 2, "test 3")
self.dr1.send(d12)
self.dr1.send(d12_2)
self.assertEqual(self.dr2.receive()[1], d12)
self.dr1.send(d12_3)
self.assertEqual(self.dr2.receive()[1], d12_2)
self.assertEqual(self.dr2.receive()[1], d12_3)
def tearDown(self):
self.dr1.terminate()
self.dr2.terminate()
self.ft1.terminate()
self.ft2.terminate()
do_tests(Tests, level=level)
def _test(level=None, timeout=None):
# TODO: Use in separate file to test importing functionality.
from testing import unittest, do_tests, process_events_with_timeout
from duplex_link import FullDuplexLink, LossFunc
from sliding_window import SimpleFrameTransmitter
from service_manager import packet_to_datagram
class Tests(object):
class TestControllableFrameTransmitterConstructor(unittest.TestCase):
def setUp(self):
self.a, self.b = FullDuplexLink()
self.at = SimpleFrameTransmitter(node=self.a)
self.bt = SimpleFrameTransmitter(node=self.b)
def tearDown(self):
process_events_with_timeout(timeout)
def test_constructor(self):
aft = ControllableFrameTransmitter(
src_name=1, dest_name=2,
simple_frame_transmitter=self.at,
debug_src=1, debug_dest=2)
bft = ControllableFrameTransmitter(
src_name=2, dest_name=1,
simple_frame_transmitter=self.bt,
debug_src=2, debug_dest=1)
aft.terminate()
bft.terminate()
class TestControllableFrameTransmitter(unittest.TestCase):
def setUp(self):
self.a, self.b = FullDuplexLink()
self.at = SimpleFrameTransmitter(node=self.a)
self.bt = SimpleFrameTransmitter(node=self.b)
self.aft = ControllableFrameTransmitter(
src_name=1, dest_name=2,
simple_frame_transmitter=self.at,
debug_src=1, debug_dest=2)
self.bft = ControllableFrameTransmitter(
src_name=2, dest_name=1,
simple_frame_transmitter=self.bt,
debug_src=2, debug_dest=1)
def tearDown(self):
self.aft.terminate()
self.bft.terminate()
def test_transmission(self):
text = "Test!"
self.aft.send(text)
self.assertEqual(self.bft.receive(), text)
self.assertEqual(self.bft.receive(block=False), None)
text2 = "".join(map(chr, xrange(256)))
self.bft.send(text2)
self.assertEqual(self.aft.receive(), text2)
self.assertEqual(self.aft.receive(block=False), None)
text3 = "test"
self.bft.send(text3)
text_a = text2
text_b = "".join(reversed(text2))
self.aft.send(text_a)
self.aft.send(text_b)
self.assertEqual(self.aft.receive(), text3)
self.assertEqual(self.bft.receive(), text_a)
self.assertEqual(self.bft.receive(), text_b)
text4 = text2 * 10
self.aft.send(text4)
self.assertEqual(self.bft.receive(), text4)
self.assertEqual(self.aft.receive(block=False), None)
self.assertEqual(self.bft.receive(block=False), None)
def test_packet_transmission(self):
packet = Packet(1, 2, "test", 1)
datagram = packet_to_datagram(packet, 100)
self.aft.send(datagram.serialize())
self.assertEqual(self.bft.receive(), datagram.serialize())
self.assertEqual(self.bft.receive(block=False), None)
# TODO: Test signals.
do_tests(Tests, level=level, qt=True)
def _test(self, tst):
return testing.do_tests(tst, self.name, self.sdir, self.logfile)
def _test(self, tst):
return testing.do_tests(tst, self.name, self.sdir, self.logfile)
