def set_up(self):
self.queue = RetransmissionQueue()
self.snd_una = self.DEFAULT_SEQ
self.snd_nxt = self.snd_una + 2 * len(self.DEFAULT_DATA)
packet1 = self.packet_builder.build(seq=self.DEFAULT_SEQ,
payload=self.DEFAULT_DATA)
packet2 = self.packet_builder.build(seq=self.DEFAULT_SEQ+\
len(self.DEFAULT_DATA),
payload=self.DEFAULT_DATA)
self.packets = [packet1, packet2]
def set_up(self):
self.queue = RetransmissionQueue()
self.snd_una = self.DEFAULT_SEQ
self.snd_nxt = self.snd_una + 2 * len(self.DEFAULT_DATA)
packet1 = self.packet_builder.build(seq=self.DEFAULT_SEQ, payload=self.DEFAULT_DATA)
packet2 = self.packet_builder.build(seq=self.DEFAULT_SEQ + len(self.DEFAULT_DATA), payload=self.DEFAULT_DATA)
self.packets = [packet1, packet2]
class RetransmissionQueueTest(PTCTestCase):
DEFAULT_SEQ = 10000
DEFAULT_DATA = 'data' * 50
def set_up(self):
self.queue = RetransmissionQueue()
self.snd_una = self.DEFAULT_SEQ
self.snd_nxt = self.snd_una + 2 * len(self.DEFAULT_DATA)
packet1 = self.packet_builder.build(seq=self.DEFAULT_SEQ,
payload=self.DEFAULT_DATA)
packet2 = self.packet_builder.build(seq=self.DEFAULT_SEQ+\
len(self.DEFAULT_DATA),
payload=self.DEFAULT_DATA)
self.packets = [packet1, packet2]
def get_packet_for_seqs(self, seq_lo, seq_hi):
if seq_hi < seq_lo:
seq_hi = MAX_SEQ + seq_hi
payload = 'x' * int(seq_hi - seq_lo + 1)
packet = self.packet_builder.build(seq=seq_lo, payload=payload)
return packet
def test_nothing_to_retransmit_if_timeout_has_not_expired(self):
time_to_wait = RETRANSMISSION_TIMEOUT / 2
packet = self.packets[0]
self.queue.put(packet)
time.sleep(time_to_wait)
self.queue.tick()
packets_to_retransmit = self.queue.get_packets_to_retransmit()
self.assertEquals(0, len(packets_to_retransmit))
def test_packets_ready_to_retransmit_after_timeout(self):
time_to_wait = RETRANSMISSION_TIMEOUT
packet1, packet2 = self.packets
self.queue.put(packet1)
self.queue.put(packet2)
time.sleep(time_to_wait)
self.queue.tick()
packets_to_retransmit = self.queue.get_packets_to_retransmit()
self.assertEquals(2, len(packets_to_retransmit))
to_retransmit1, to_retransmit2 = packets_to_retransmit
self.assertEquals(packet1.get_seq_number(),
to_retransmit1.get_seq_number())
self.assertEquals(packet2.get_seq_number(),
to_retransmit2.get_seq_number())
def test_acknowledged_packet_should_not_be_retransmited(self):
time_to_wait = RETRANSMISSION_TIMEOUT
packet1, packet2 = self.packets
ack_number = self.DEFAULT_SEQ + len(self.DEFAULT_DATA) + 5
ack_packet = self.packet_builder.build(flags=[ACKFlag], ack=ack_number)
self.queue.put(packet1)
self.queue.put(packet2)
self.queue.remove_acknowledged_by(ack_packet, self.snd_una,
self.snd_nxt)
time.sleep(time_to_wait)
self.queue.tick()
packets_to_retransmit = self.queue.get_packets_to_retransmit()
self.assertEquals(1, len(packets_to_retransmit))
to_retransmit = packets_to_retransmit[0]
self.assertEquals(packet2.get_seq_number(),
to_retransmit.get_seq_number())
def test_packet_not_removed_from_queue_when_partially_acked(self):
time_to_wait = RETRANSMISSION_TIMEOUT
ack_number = self.DEFAULT_SEQ + len(self.DEFAULT_DATA) - 10
ack_packet = self.packet_builder.build(flags=[ACKFlag], ack=ack_number)
packet = self.packets[0]
self.queue.put(packet)
self.queue.remove_acknowledged_by(ack_packet, self.snd_una,
self.snd_nxt)
time.sleep(time_to_wait)
self.queue.tick()
packets_to_retransmit = self.queue.get_packets_to_retransmit()
self.assertEquals(1, len(packets_to_retransmit))
packet = packets_to_retransmit[0]
self.assertEquals(packet.get_seq_number(), packet.get_seq_number())
def test_ack_covers_packet_without_wraparound(self):
# Caso 1: snd_una < seq_lo < seq_hi < ack < snd_nxt
# Debería dar verdadero.
snd_una = SequenceNumber(75)
snd_nxt = snd_una + 20
seq_lo = SequenceNumber(80)
seq_hi = SequenceNumber(85)
ack = SequenceNumber(90)
packet = self.get_packet_for_seqs(seq_lo, seq_hi)
result = self.queue.ack_covers_packet(ack, packet, snd_una, snd_nxt)
self.assertTrue(result)
# Caso 2: snd_una < ack < seq_lo < seq_hi < snd_nxt
# Debería dar falso.
ack = seq_lo - 1
snd_una = ack - 1
result = self.queue.ack_covers_packet(ack, packet, snd_una, snd_nxt)
self.assertFalse(result)
# Caso 3: snd_una < seq_lo < ack < seq_hi < snd_nxt
# Debería dar falso.
ack = seq_hi - 1
snd_una = seq_lo - 1
result = self.queue.ack_covers_packet(ack, packet, snd_una, snd_nxt)
self.assertFalse(result)
def test_ack_covers_packet_with_wraparound(self):
# Caso 1: seq_hi < ack < snd_nxt < snd_una < seq_lo
# Debería dar verdadero.
seq_hi = SequenceNumber(10)
ack = seq_hi + 5
snd_nxt = ack + 1
snd_una = snd_nxt + 10
seq_lo = SequenceNumber(MAX_SEQ - 10)
packet = self.get_packet_for_seqs(seq_lo, seq_hi)
result = self.queue.ack_covers_packet(ack, packet, snd_una, snd_nxt)
self.assertTrue(result)
# Caso 2: ack < seq_hi < snd_nxt < snd_una < seq_lo
# Debería dar falso.
ack = seq_hi - 1
snd_nxt = seq_hi + 1
result = self.queue.ack_covers_packet(ack, packet, snd_una, snd_nxt)
self.assertFalse(result)
# Caso 3: seq_hi < snd_nxt < snd_una < seq_lo < ack
# Debería dar falso.
ack = seq_lo + 1
result = self.queue.ack_covers_packet(ack, packet, snd_una, snd_nxt)
self.assertFalse(result)
# Caso 4: seq_hi < snd_nxt < snd_una < ack < seq_lo
# Debería dar falso.
ack = seq_lo - 1
result = self.queue.ack_covers_packet(ack, packet, snd_una, snd_nxt)
self.assertFalse(result)
class RetransmissionQueueTest(PTCTestCase):
DEFAULT_SEQ = 10000
DEFAULT_DATA = 'data' * 50
def set_up(self):
self.queue = RetransmissionQueue()
self.snd_una = self.DEFAULT_SEQ
self.snd_nxt = self.snd_una + 2*len(self.DEFAULT_DATA)
packet1 = self.packet_builder.build(seq=self.DEFAULT_SEQ,
payload=self.DEFAULT_DATA)
packet2 = self.packet_builder.build(seq=self.DEFAULT_SEQ+\
len(self.DEFAULT_DATA),
payload=self.DEFAULT_DATA)
self.packets = [packet1, packet2]
def get_packet_for_seqs(self, seq_lo, seq_hi):
if seq_hi < seq_lo:
seq_hi = MAX_SEQ + seq_hi
payload = 'x' * int(seq_hi - seq_lo + 1)
packet = self.packet_builder.build(seq=seq_lo,
payload=payload)
return packet
def test_empty_queue(self):
self.assertTrue(self.queue.empty())
self.queue.put(self.packets[0])
self.assertFalse(self.queue.empty())
def test_queue_head(self):
self.assertRaises(RuntimeError, self.queue.head)
self.queue.put(self.packets[0])
self.queue.put(self.packets[1])
head = self.queue.head()
expected_seq = self.packets[0].get_seq_number()
self.assertEquals(expected_seq, head.get_seq_number())
def test_acked_packet_removed_from_queue(self):
self.queue.put(self.packets[0])
self.queue.put(self.packets[1])
expected_seq, target_ack = self.packets[0].get_seq_interval()
ack_packet = self.packet_builder.build(flags=[ACKFlag],
ack=target_ack + 10)
packets = self.queue.remove_acknowledged_by(ack_packet, self.snd_una,
self.snd_nxt)
self.assertEquals(1, len(packets))
self.assertEquals(expected_seq, packets[0].get_seq_number())
def test_partially_acked_packet_not_removed_from_queue(self):
self.queue.put(self.packets[0])
expected_seq = self.packets[0].get_seq_number()
ack_packet = self.packet_builder.build(flags=[ACKFlag],
ack=expected_seq + 10)
packets = self.queue.remove_acknowledged_by(ack_packet, self.snd_una,
self.snd_nxt)
self.assertEquals(0, len(packets))
def test_ack_covers_packet_without_wraparound(self):
# Case 1: snd_una < seq_lo < seq_hi < ack < snd_nxt
# Should be true.
snd_una = SequenceNumber(75)
snd_nxt = snd_una + 20
seq_lo = SequenceNumber(80)
seq_hi = SequenceNumber(85)
ack = SequenceNumber(90)
packet = self.get_packet_for_seqs(seq_lo, seq_hi)
result = self.queue.ack_covers_packet(ack, packet, snd_una, snd_nxt)
self.assertTrue(result)
# Case 2: snd_una < ack < seq_lo < seq_hi < snd_nxt
# Should be false.
ack = seq_lo - 1
snd_una = ack - 1
result = self.queue.ack_covers_packet(ack, packet, snd_una, snd_nxt)
self.assertFalse(result)
# Case 3: snd_una < seq_lo < ack < seq_hi < snd_nxt
# Should be false.
ack = seq_hi - 1
snd_una = seq_lo - 1
result = self.queue.ack_covers_packet(ack, packet, snd_una, snd_nxt)
self.assertFalse(result)
def test_ack_covers_packet_with_wraparound(self):
# Case 1: seq_hi < ack < snd_nxt < snd_una < seq_lo
# Should be true.
seq_hi = SequenceNumber(10)
ack = seq_hi + 5
snd_nxt = ack + 1
snd_una = snd_nxt + 10
seq_lo = SequenceNumber(MAX_SEQ - 10)
packet = self.get_packet_for_seqs(seq_lo, seq_hi)
result = self.queue.ack_covers_packet(ack, packet, snd_una, snd_nxt)
self.assertTrue(result)
# Case 2: ack < seq_hi < snd_nxt < snd_una < seq_lo
# Should be false.
ack = seq_hi - 1
snd_nxt = seq_hi + 1
result = self.queue.ack_covers_packet(ack, packet, snd_una, snd_nxt)
self.assertFalse(result)
# Case 3: seq_hi < snd_nxt < snd_una < seq_lo < ack
# Should be false.
ack = seq_lo + 1
result = self.queue.ack_covers_packet(ack, packet, snd_una, snd_nxt)
self.assertFalse(result)
# Case 4: seq_hi < snd_nxt < snd_una < ack < seq_lo
# Should be false.
ack = seq_lo - 1
result = self.queue.ack_covers_packet(ack, packet, snd_una, snd_nxt)
self.assertFalse(result)
class RetransmissionQueueTest(PTCTestCase):
DEFAULT_SEQ = 10000
DEFAULT_DATA = "data" * 50
def set_up(self):
self.queue = RetransmissionQueue()
self.snd_una = self.DEFAULT_SEQ
self.snd_nxt = self.snd_una + 2 * len(self.DEFAULT_DATA)
packet1 = self.packet_builder.build(seq=self.DEFAULT_SEQ, payload=self.DEFAULT_DATA)
packet2 = self.packet_builder.build(seq=self.DEFAULT_SEQ + len(self.DEFAULT_DATA), payload=self.DEFAULT_DATA)
self.packets = [packet1, packet2]
def get_packet_for_seqs(self, seq_lo, seq_hi):
if seq_hi < seq_lo:
seq_hi = MAX_SEQ + seq_hi
payload = "x" * int(seq_hi - seq_lo + 1)
packet = self.packet_builder.build(seq=seq_lo, payload=payload)
return packet
def test_nothing_to_retransmit_if_timeout_has_not_expired(self):
time_to_wait = RETRANSMISSION_TIMEOUT / 2
packet = self.packets[0]
self.queue.put(packet)
time.sleep(time_to_wait)
self.queue.tick()
packets_to_retransmit = self.queue.get_packets_to_retransmit()
self.assertEquals(0, len(packets_to_retransmit))
def test_packets_ready_to_retransmit_after_timeout(self):
time_to_wait = RETRANSMISSION_TIMEOUT
packet1, packet2 = self.packets
self.queue.put(packet1)
self.queue.put(packet2)
time.sleep(time_to_wait)
self.queue.tick()
packets_to_retransmit = self.queue.get_packets_to_retransmit()
self.assertEquals(2, len(packets_to_retransmit))
to_retransmit1, to_retransmit2 = packets_to_retransmit
self.assertEquals(packet1.get_seq_number(), to_retransmit1.get_seq_number())
self.assertEquals(packet2.get_seq_number(), to_retransmit2.get_seq_number())
def test_acknowledged_packet_should_not_be_retransmited(self):
time_to_wait = RETRANSMISSION_TIMEOUT
packet1, packet2 = self.packets
ack_number = self.DEFAULT_SEQ + len(self.DEFAULT_DATA) + 5
ack_packet = self.packet_builder.build(flags=[ACKFlag], ack=ack_number)
self.queue.put(packet1)
self.queue.put(packet2)
self.queue.remove_acknowledged_by(ack_packet, self.snd_una, self.snd_nxt)
time.sleep(time_to_wait)
self.queue.tick()
packets_to_retransmit = self.queue.get_packets_to_retransmit()
self.assertEquals(1, len(packets_to_retransmit))
to_retransmit = packets_to_retransmit[0]
self.assertEquals(packet2.get_seq_number(), to_retransmit.get_seq_number())
def test_packet_not_removed_from_queue_when_partially_acked(self):
time_to_wait = RETRANSMISSION_TIMEOUT
ack_number = self.DEFAULT_SEQ + len(self.DEFAULT_DATA) - 10
ack_packet = self.packet_builder.build(flags=[ACKFlag], ack=ack_number)
packet = self.packets[0]
self.queue.put(packet)
self.queue.remove_acknowledged_by(ack_packet, self.snd_una, self.snd_nxt)
time.sleep(time_to_wait)
self.queue.tick()
packets_to_retransmit = self.queue.get_packets_to_retransmit()
self.assertEquals(1, len(packets_to_retransmit))
packet = packets_to_retransmit[0]
self.assertEquals(packet.get_seq_number(), packet.get_seq_number())
def test_ack_covers_packet_without_wraparound(self):
# Caso 1: snd_una < seq_lo < seq_hi < ack < snd_nxt
# Debería dar verdadero.
snd_una = SequenceNumber(75)
snd_nxt = snd_una + 20
seq_lo = SequenceNumber(80)
seq_hi = SequenceNumber(85)
ack = SequenceNumber(90)
packet = self.get_packet_for_seqs(seq_lo, seq_hi)
result = self.queue.ack_covers_packet(ack, packet, snd_una, snd_nxt)
self.assertTrue(result)
# Caso 2: snd_una < ack < seq_lo < seq_hi < snd_nxt
# Debería dar falso.
ack = seq_lo - 1
snd_una = ack - 1
result = self.queue.ack_covers_packet(ack, packet, snd_una, snd_nxt)
self.assertFalse(result)
# Caso 3: snd_una < seq_lo < ack < seq_hi < snd_nxt
# Debería dar falso.
ack = seq_hi - 1
snd_una = seq_lo - 1
result = self.queue.ack_covers_packet(ack, packet, snd_una, snd_nxt)
self.assertFalse(result)
def test_ack_covers_packet_with_wraparound(self):
# Caso 1: seq_hi < ack < snd_nxt < snd_una < seq_lo
# Debería dar verdadero.
seq_hi = SequenceNumber(10)
ack = seq_hi + 5
snd_nxt = ack + 1
snd_una = snd_nxt + 10
seq_lo = SequenceNumber(MAX_SEQ - 10)
packet = self.get_packet_for_seqs(seq_lo, seq_hi)
result = self.queue.ack_covers_packet(ack, packet, snd_una, snd_nxt)
self.assertTrue(result)
# Caso 2: ack < seq_hi < snd_nxt < snd_una < seq_lo
# Debería dar falso.
ack = seq_hi - 1
snd_nxt = seq_hi + 1
result = self.queue.ack_covers_packet(ack, packet, snd_una, snd_nxt)
self.assertFalse(result)
# Caso 3: seq_hi < snd_nxt < snd_una < seq_lo < ack
# Debería dar falso.
ack = seq_lo + 1
result = self.queue.ack_covers_packet(ack, packet, snd_una, snd_nxt)
self.assertFalse(result)
# Caso 4: seq_hi < snd_nxt < snd_una < ack < seq_lo
# Debería dar falso.
ack = seq_lo - 1
result = self.queue.ack_covers_packet(ack, packet, snd_una, snd_nxt)
self.assertFalse(result)
class RetransmissionQueueTest(PTCTestCase):
DEFAULT_SEQ = 10000
DEFAULT_DATA = 'data' * 50
def set_up(self):
self.queue = RetransmissionQueue()
self.snd_una = self.DEFAULT_SEQ
self.snd_nxt = self.snd_una + 2 * len(self.DEFAULT_DATA)
packet1 = self.packet_builder.build(seq=self.DEFAULT_SEQ,
payload=self.DEFAULT_DATA)
packet2 = self.packet_builder.build(seq=self.DEFAULT_SEQ+\
len(self.DEFAULT_DATA),
payload=self.DEFAULT_DATA)
self.packets = [packet1, packet2]
def get_packet_for_seqs(self, seq_lo, seq_hi):
if seq_hi < seq_lo:
seq_hi = MAX_SEQ + seq_hi
payload = 'x' * int(seq_hi - seq_lo + 1)
packet = self.packet_builder.build(seq=seq_lo, payload=payload)
return packet
def test_empty_queue(self):
self.assertTrue(self.queue.empty())
self.queue.put(self.packets[0])
self.assertFalse(self.queue.empty())
def test_queue_head(self):
self.assertRaises(RuntimeError, self.queue.head)
self.queue.put(self.packets[0])
self.queue.put(self.packets[1])
head = self.queue.head()
expected_seq = self.packets[0].get_seq_number()
self.assertEquals(expected_seq, head.get_seq_number())
def test_acked_packet_removed_from_queue(self):
self.queue.put(self.packets[0])
self.queue.put(self.packets[1])
expected_seq, target_ack = self.packets[0].get_seq_interval()
ack_packet = self.packet_builder.build(flags=[ACKFlag],
ack=target_ack + 10)
packets = self.queue.remove_acknowledged_by(ack_packet, self.snd_una,
self.snd_nxt)
self.assertEquals(1, len(packets))
self.assertEquals(expected_seq, packets[0].get_seq_number())
def test_partially_acked_packet_not_removed_from_queue(self):
self.queue.put(self.packets[0])
expected_seq = self.packets[0].get_seq_number()
ack_packet = self.packet_builder.build(flags=[ACKFlag],
ack=expected_seq + 10)
packets = self.queue.remove_acknowledged_by(ack_packet, self.snd_una,
self.snd_nxt)
self.assertEquals(0, len(packets))
def test_ack_covers_packet_without_wraparound(self):
# Caso 1: snd_una < seq_lo < seq_hi < ack < snd_nxt
# Debería dar verdadero.
snd_una = SequenceNumber(75)
snd_nxt = snd_una + 20
seq_lo = SequenceNumber(80)
seq_hi = SequenceNumber(85)
ack = SequenceNumber(90)
packet = self.get_packet_for_seqs(seq_lo, seq_hi)
result = self.queue.ack_covers_packet(ack, packet, snd_una, snd_nxt)
self.assertTrue(result)
# Caso 2: snd_una < ack < seq_lo < seq_hi < snd_nxt
# Debería dar falso.
ack = seq_lo - 1
snd_una = ack - 1
result = self.queue.ack_covers_packet(ack, packet, snd_una, snd_nxt)
self.assertFalse(result)
# Caso 3: snd_una < seq_lo < ack < seq_hi < snd_nxt
# Debería dar falso.
ack = seq_hi - 1
snd_una = seq_lo - 1
result = self.queue.ack_covers_packet(ack, packet, snd_una, snd_nxt)
self.assertFalse(result)
def test_ack_covers_packet_with_wraparound(self):
# Caso 1: seq_hi < ack < snd_nxt < snd_una < seq_lo
# Debería dar verdadero.
seq_hi = SequenceNumber(10)
ack = seq_hi + 5
snd_nxt = ack + 1
snd_una = snd_nxt + 10
seq_lo = SequenceNumber(MAX_SEQ - 10)
packet = self.get_packet_for_seqs(seq_lo, seq_hi)
result = self.queue.ack_covers_packet(ack, packet, snd_una, snd_nxt)
self.assertTrue(result)
# Caso 2: ack < seq_hi < snd_nxt < snd_una < seq_lo
# Debería dar falso.
ack = seq_hi - 1
snd_nxt = seq_hi + 1
result = self.queue.ack_covers_packet(ack, packet, snd_una, snd_nxt)
self.assertFalse(result)
# Caso 3: seq_hi < snd_nxt < snd_una < seq_lo < ack
# Debería dar falso.
ack = seq_lo + 1
result = self.queue.ack_covers_packet(ack, packet, snd_una, snd_nxt)
self.assertFalse(result)
# Caso 4: seq_hi < snd_nxt < snd_una < ack < seq_lo
# Debería dar falso.
ack = seq_lo - 1
result = self.queue.ack_covers_packet(ack, packet, snd_una, snd_nxt)
self.assertFalse(result)
