def test_demarshalling_frame_missing_end(self):
"""DeFramer, will not pass on a frame if a chunk is missing out of it"""
X = Framing.DeFramer()
Dummy = Axon.Component.component()
X.link((X, "outbox"), (Dummy, "inbox"))
X.link((X, "signal"), (Dummy, "control"))
X.activate()
X.activate()
originals = []
for i in xrange(1, 10):
original = (i, "a" * i)
originals.append(original)
message = str(Framing.SimpleFrame(*original))
if i == 5:
message = message[:-2]
X._deliver(message, "inbox")
for i in xrange(200):
X.next()
for i in xrange(1, 10):
if i != 5:
# result = X._collect("outbox")
result = Dummy.recv("inbox")
# print result
self.assertEqual(originals[0], result)
del originals[0]
def test_Message_chunkDeChunk_remainsintact(self):
from Kamaelia.Chassis.Pipeline import Pipeline
syncmessage = "XXXXXXXXXXXXXXXXXXXXXXX"
File = open("../../Examples/SimpleGraphicalApps/Ticker/Ulysses").read()
chunks = [File[y:y + 20] for y in xrange(0, len(File), 20)]
chunker = Framing.DataChunker(syncmessage=syncmessage)
dechunker = Framing.DataDeChunker(syncmessage=syncmessage)
system = Pipeline(
chunker,
dechunker,
).activate()
Dummy = Axon.Component.component()
system.link((system, "outbox"), (Dummy, "inbox"))
system.link((system, "signal"), (Dummy, "control"))
for chunk in chunks:
system._deliver(chunk, "inbox")
activeScheduler = system.schedulerClass.run.main()
for _ in xrange(2000):
activeScheduler.next()
resultchunks = []
try:
while 1:
# chunk = system._collect("outbox")
chunk = Dummy.recv("inbox")
resultchunks.append(chunk)
except IndexError:
pass # We collect all items in the outbox
result = "".join(resultchunks)
self.assertEqual(File[:20], result[:20])
def test_marshalling(self):
message = (1, '1')
expect = str(Framing.SimpleFrame(*message))
X = Framing.Framer()
Dummy = Axon.Component.component()
X.link((X, "outbox"), (Dummy, "inbox"))
X.link((X, "signal"), (Dummy, "control"))
X.activate()
X._deliver(message, "inbox")
for i in xrange(
20): # More than sufficient cycles (should be lots less!)
X.next()
# result = X._collect("outbox")
result = Dummy.recv("inbox")
self.assertEqual(expect, result)
def test_DeChunkFullChunk_3(self):
syncmessage = "XXXXXXXXXXXXXXXXXXXXXXX"
message = "1234567890qwertyu\iopa\Ssdfghjklzxcvbnm\n" * 10
message += syncmessage
message += "1234567890qwertyuiopasdfghjklzxcvbnm\n" * 10
chunk = self.makeBasicChunk(message, syncmessage)
X = Framing.DataDeChunker(syncmessage=syncmessage)
Dummy = Axon.Component.component()
X.link((X, "outbox"), (Dummy, "inbox"))
X.link((X, "signal"), (Dummy, "control"))
X.activate()
X._deliver(chunk, "inbox")
for i in xrange(
20): # More than sufficient cycles (should be lots less...)
X.next()
X._deliver("junk", "flush")
for i in xrange(
20): # More than sufficient cycles (should be lots less...)
X.next()
# result = X._collect("outbox")
result = Dummy.recv("inbox")
self.assertEqual(result, message)
def test_makeChunk_oneSync(self):
syncmessage = "XXXXXXXXXXXXXXXXXXXXXXX"
message = "1234567890qwertyuiopasdfghjklzxcvbnm\n" * 10
message += syncmessage
message += "1234567890qwertyuiopasdfghjklzxcvbnm\n" * 10
X = Framing.DataChunker(syncmessage=syncmessage)
Dummy = Axon.Component.component()
X.link((X, "outbox"), (Dummy, "inbox"))
X.link((X, "signal"), (Dummy, "control"))
X.activate()
X._deliver(message, "inbox")
for i in xrange(
20): # More than sufficient cycles (should be lots less!)
X.next()
# result = X._collect("outbox")
result = Dummy.recv("inbox")
result_message = result[len(syncmessage):]
index = result_message.find(syncmessage)
self.assertEqual(
-1, index,
"Should not be able to find the syncmessage in the chunked version"
)
def test_DeChunk_RandomChunk_ManyBlocks(self):
"The dechunker handles taking a chunk that's in many blocks and putting it back together"
syncmessage = "XXXXXXXXXXXXXXXXXXXXXXX"
message = ("".join([str(x) for x in xrange(10, 50)]) + "\n") * 10
chunk = self.makeBasicChunk(message, syncmessage)
X = Framing.DataDeChunker(syncmessage=syncmessage)
Dummy = Axon.Component.component()
X.link((X, "outbox"), (Dummy, "inbox"))
X.link((X, "signal"), (Dummy, "control"))
X.activate()
for block in self.blocks(chunk, blocksize=1):
X._deliver(block, "inbox")
try:
for i in xrange(
2000
): # More than sufficient cycles (should be lots less...)
X.next()
X._deliver("junk", "flush")
for i in xrange(
20
): # More than sufficient cycles (should be lots less...)
X.next()
# result = X._collect("outbox")
result = Dummy.recv("inbox")
except Framing.IncompleteChunk:
self.fail("IncompleteChunk exception should not propogate")
self.assertEqual(result, message)
def test_DeChunk_MultipleChunks_ManyBlocks(self):
"The dechunker handles taking many chunks that are in many blocks and putting it back together"
syncmessage = "XXXXXXXXXXXXXXXXXXXXXXX"
X = Framing.DataDeChunker(syncmessage=syncmessage)
Dummy = Axon.Component.component()
X.link((X, "outbox"), (Dummy, "inbox"))
X.link((X, "signal"), (Dummy, "control"))
X.activate()
for base in xrange(10, 1000, 50):
message = ("".join([str(x)
for x in xrange(base, base + 50)]) + "\n") * 10
chunk = self.makeBasicChunk(message, syncmessage)
for block in self.blocks(chunk, blocksize=1):
X._deliver(block, "inbox")
try:
for i in xrange(
2000
): # Run for a significant time period! (Chunk might be big)
X.next()
X._deliver("junk", "flush")
X.next()
# result = X._collect("outbox")
result = Dummy.recv("inbox")
except Framing.IncompleteChunk:
self.fail("IncompleteChunk exception should not propogate")
self.assertEqual(result, message)
def test_DeChunk_SingleChunk_ManyBlocks(self):
"The dechunker handles taking a chunk that's in many blocks and putting it back together"
syncmessage = "XXXXXXXXXXXXXXXXXXXXXXX"
message = "123\\S\4567\\890qwer\\\tyuiopasdfg\\\\hjklzxcvbnm\n" * 10
message += syncmessage
message += "1234567890q\\Swertyuiopasdfghjklzxcvbnm\n" * 10
chunk = self.makeBasicChunk(message, syncmessage)
X = Framing.DataDeChunker(syncmessage=syncmessage)
Dummy = Axon.Component.component()
X.link((X, "outbox"), (Dummy, "inbox"))
X.link((X, "signal"), (Dummy, "control"))
X.activate()
for block in self.blocks(chunk):
X._deliver(block, "inbox")
try:
for i in xrange(
200
): # More than sufficient cycles (should be lots less...)
X.next()
X._deliver("junk", "flush")
for i in xrange(
20
): # More than sufficient cycles (should be lots less...)
X.next()
# result = X._collect("outbox")
result = Dummy.recv("inbox")
except Framing.IncompleteChunk:
self.fail("IncompleteChunk exception should not propogate")
self.assertEqual(result, message)
def test_tuple2string_string2tuple_roundtrip_2(self):
"SimpleFrame.__str__, Framing.SimpleFrame.fromString - roundtrip for (50,'1111') succeeds"
original = (50, '1111')
Frame = Framing.SimpleFrame(*original)
FrameForWire = str(Frame)
result = Framing.SimpleFrame.fromString(FrameForWire)
self.assertEqual(original, result, "passed through unchanged")
def test_demarshalling_sequence(self):
X = Framing.DeFramer()
Dummy = Axon.Component.component()
X.link((X, "outbox"), (Dummy, "inbox"))
X.link((X, "signal"), (Dummy, "control"))
X.activate()
X.activate()
for i in xrange(100):
original = (i, str(i))
message = str(Framing.SimpleFrame(*original))
X._deliver(message, "inbox")
for i in xrange(
20): # More than sufficient cycles (should be lots less!)
X.next()
# result = X._collect("outbox")
result = Dummy.recv("inbox")
self.assertEqual(original, result)
def test_tuple2string_6(self):
"SimpleFrame.__str__ - Random data of random length as the data part of the tuple succeeds"
import random
length = random.randrange(100, 200)
r = []
for x in xrange(length):
r.append(chr(random.randrange(0, 256)))
data = "".join(r)
Frame = Framing.SimpleFrame(50, data)
result = str(Frame)
self.assertEqual(result, "50 " + str(length) + "\n" + str(data))
def makeBasicChunk(self, message, syncmessage):
X = Framing.DataChunker(syncmessage=syncmessage)
Dummy = Axon.Component.component()
X.link((X, "outbox"), (Dummy, "inbox"))
X.link((X, "signal"), (Dummy, "control"))
X.activate()
X._deliver(message, "inbox")
for i in xrange(
20): # More than sufficient cycles (should be lots less!)
X.next()
# result = X._collect("outbox")
result = Dummy.recv("inbox")
return result
def test_tuple2string_string2tuple_roundtrip_3(self):
"SimpleFrame.__str__, Framing.SimpleFrame.fromString - roundtrip for random data, frame id 50 succeeds"
import random
length = random.randrange(100, 200)
r = []
for x in xrange(length):
r.append(chr(random.randrange(0, 256)))
data = "".join(r)
original = (50, data)
Frame = Framing.SimpleFrame(*original)
FrameForWire = str(Frame)
result = Framing.SimpleFrame.fromString(FrameForWire)
self.assertEqual(original, result, "passed through unchanged")
def test_tuple2string_7(self):
"SimpleFrame.__str__ - Completely random frame"
import random
length = random.randrange(100, 200)
r = []
for x in xrange(length):
r.append(chr(random.randrange(0, 256)))
data = "".join(r)
stamp = random.randrange(0, 200)
Frame = Framing.SimpleFrame(stamp, data)
result = str(Frame)
self.assertEqual(result,
str(stamp) + " " + str(length) + "\n" + str(data))
def test_non_aligned_chunk_blocks(self):
"The dechunker handles taking many chunks that are in many blocks and putting it back together"
syncmessage = "XXXXXXXXXXXXXXXXXXXXXXX"
X = Framing.DataDeChunker(syncmessage=syncmessage)
Dummy = Axon.Component.component()
X.link((X, "outbox"), (Dummy, "inbox"))
X.link((X, "signal"), (Dummy, "control"))
X.activate()
message = ("".join([str(x) for x in xrange(10, 60)]) + "\n") * 10
chunk = self.makeBasicChunk(message, syncmessage)
blockgen = self.blocks(chunk, blocksize=20)
for _ in xrange(5):
blockgen.next() # throw away first 5 blocks of a chunk
for block in blockgen: # This chunk, since it lacks a start should be ignored
X._deliver(block, "inbox")
# The next section assumes by the way the testing happens that the partial
# chunk above sent to the component is ignored - which is the desired
# behaviour we're testing
for base in xrange(10, 1000, 50):
message = ("".join([str(x)
for x in xrange(base, base + 50)]) + "\n") * 10
chunk = self.makeBasicChunk(message, syncmessage)
for block in self.blocks(chunk, blocksize=20):
X._deliver(block, "inbox")
try:
for i in xrange(
2000
): # Run for a significant time period! (Chunk might be big)
X.next()
X._deliver("junk", "flush")
X.next()
# result = X._collect("outbox")
result = Dummy.recv("inbox")
except Framing.IncompleteChunk:
self.fail("IncompleteChunk exception should not propogate")
self.assertEqual(result, message)
def test_makeChunk(self):
message = "1234567890qwertyuiopasdfghjklzxcvbnm\n" * 20
syncmessage = "XXXXXXXXXXXXXXXXXXXXXXX"
X = Framing.DataChunker(syncmessage=syncmessage)
Dummy = Axon.Component.component()
X.link((X, "outbox"), (Dummy, "inbox"))
X.link((X, "signal"), (Dummy, "control"))
X.activate()
X._deliver(message, "inbox")
for i in xrange(
20): # More than sufficient cycles (should be lots less!)
X.next()
# result = X._collect("outbox")
result = Dummy.recv("inbox")
result_start = result[:len(syncmessage)]
result_message = result[len(syncmessage):]
self.assertEqual(message, result_message)
self.assertEqual(syncmessage, result_start)
def test_tuple2string_4(self):
"SimpleFrame.__str__ - (50,'1111') results in '50 4\\n1111'"
Frame = Framing.SimpleFrame(50, '1111')
result = str(Frame)
self.assertEqual(result, '50 4\n1111')
def test_marshalling(self):
X = Framing.Framer()
self.fail("Test Not Implemented")
def test_smokeTest(self):
X = Framing.DeFramer()
X.activate()
def test_tuple2string_2(self):
"SimpleFrame.__str__ - (1,'11') results in '1 2\\n11'"
Frame = Framing.SimpleFrame(1, '11')
result = str(Frame)
self.assertEqual(result, '1 2\n11')
def test_smokeTest(self):
X = Framing.DataChunker()
X.activate()
