def test_003_crc_equal_unpacked(self):
""" Test unpacked operation with packed operation
"""
data = range(35)
src = blocks.vector_source_b(data)
unpack1 = blocks.repack_bits_bb(8, 1, self.tsb_key, False,
gr.GR_LSB_FIRST)
unpack2 = blocks.repack_bits_bb(8, 1, self.tsb_key, False,
gr.GR_LSB_FIRST)
crc_unpacked = digital.crc32_bb(False, self.tsb_key, False)
crc_packed = digital.crc32_bb(False, self.tsb_key, True)
sink1 = blocks.tsb_vector_sink_b(tsb_key=self.tsb_key)
sink2 = blocks.tsb_vector_sink_b(tsb_key=self.tsb_key)
self.tb.connect(
src,
blocks.stream_to_tagged_stream(gr.sizeof_char, 1, len(data),
self.tsb_key), crc_packed, unpack1,
sink1)
self.tb.connect(
src,
blocks.stream_to_tagged_stream(gr.sizeof_char, 1, len(data),
self.tsb_key), unpack2,
crc_unpacked, sink2)
self.tb.run()
self.assertEqual(sink1.data(), sink2.data())
def test_0010_tag_propagation(self):
""" Make sure tags on the CRC aren't lost. """
# Data with precalculated CRC
data = (0, 0, 0, 0, 0, 0, 0, 0,
1, 0, 0, 0, 0, 0, 0, 0,
0, 1, 0, 0, 0, 0, 0, 0,
1, 1, 0, 0, 0, 0, 0, 0,
0, 0, 1, 0, 0, 0, 0, 0,
1, 0, 1, 0, 0, 0, 0, 0,
0, 1, 1, 0, 0, 0, 0, 0,
1, 1, 1, 0, 0, 0, 0, 0,
0, 0, 0, 1, 0, 0, 0, 0,
0, 1, 0, 0, 0, 0, 0, 0,
1, 1, 0, 0, 0, 0, 1, 0,
1, 0, 0, 0, 0, 1, 1, 1,
0, 0, 1, 1, 1, 1, 0, 1)
testtag = gr.tag_t()
testtag.offset = len(data) - 1
testtag.key = pmt.string_to_symbol('tag1')
testtag.value = pmt.from_long(0)
src = blocks.vector_source_b(data, False, 1, (testtag, ))
crc_check = digital.crc32_bb(True, self.tsb_key, False)
sink = blocks.tsb_vector_sink_b(tsb_key=self.tsb_key)
self.tb.connect(src,
blocks.stream_to_tagged_stream(
gr.sizeof_char, 1, len(data), self.tsb_key),
crc_check, sink)
self.tb.run()
self.assertEqual([len(data) - 33, ], [
tag.offset for tag in sink.tags()
if pmt.symbol_to_string(tag.key) == 'tag1'
])
def test_0010_tag_propagation (self):
""" Make sure tags on the CRC aren't lost. """
# Data with precalculated CRC
data = (
0, 1, 2, 3, 4, 5, 6, 7, 8,
0, 1, 0, 0, 0, 0, 0, 0,
1, 1, 0, 0, 0, 0, 1, 0,
1, 0, 0, 0, 0, 1, 1, 1,
0, 0, 1, 1, 1, 1, 0, 1
) # 2, 67, 225, 188
testtag = gr.tag_t()
testtag.offset = len(data)-1
testtag.key = pmt.string_to_symbol('tag1')
testtag.value = pmt.from_long(0)
src = blocks.vector_source_b(data, False, 1, (testtag,))
crc_check = digital.crc32_bb(True, self.tsb_key, False)
sink = blocks.tsb_vector_sink_b(tsb_key=self.tsb_key)
self.tb.connect(
src,
blocks.stream_to_tagged_stream(gr.sizeof_char, 1, len(data), self.tsb_key),
crc_check,
sink
)
self.tb.run()
self.assertEqual([len(data)-33,], [tag.offset for tag in sink.tags() if pmt.symbol_to_string(tag.key) == 'tag1'])
def test_with_reset(self):
input1 = (10, 0, 1, 2)
#input1= [0, 0, 0, 0, 1, 0, 1, 0]
#input2 = [ 0, 0, 0, 0, 0, 0, 0, 0]
#input3 = [ 0, 0, 0, 0, 0, 0, 0, 1]
#input4 = [0, 0, 0, 0, 0, 0, 1, 0]
output1 = (245, 225, 28, 152)
#output1 = [1, 1, 1, 1, 0, 1, 0, 1]
#output2 = [1, 1, 1, 0, 0, 0, 0, 1]
#output3 = [0, 0, 0, 1, 1, 1, 0, 0]
#output4 = [1, 0, 0, 1, 1, 0, 0, 0]
src = blocks.vector_source_b(input1)
src.set_max_noutput_items(2)
src.set_min_output_buffer(2)
src.set_max_output_buffer(2)
src_tagged = blocks.stream_to_tagged_stream(gr.sizeof_char, 1,
len(input1), self.tsb_key)
src_tagged.set_max_noutput_items(2)
src_tagged.set_min_output_buffer(2)
src_tagged.set_max_output_buffer(2)
pn9 = pn9_whitening(True)
dst = blocks.tsb_vector_sink_b(tsb_key=self.tsb_key)
self.tb.connect(src, src_tagged, pn9, dst)
self.tb.run()
self.assertEquals(dst.data()[0], output1)
def test_1(self):
packets0 = (
(0, 1, 2), (5, 6), (10,), (14, 15, 16,)
)
packets1 = (
(3, 4), (7, 8, 9), (11, 12, 13), (17,)
)
expected = ((0, 1, 2, 3, 4), (5, 6, 7, 8, 9), (10, 11, 12, 13), (14, 15, 16, 17))
data0, tags0 = self.setup_data_tags(packets0)
data1, tags1 = self.setup_data_tags(packets1)
tags0.append(make_tag('spam', 42, 4))
tags1.append(make_tag('eggs', 23, 3))
src0 = blocks.vector_source_b(data0, tags=tags0)
src1 = blocks.vector_source_b(data1, tags=tags1)
tagged_stream_mux = blocks.tagged_stream_mux(gr.sizeof_char, self.tsb_key)
snk = blocks.tsb_vector_sink_b(tsb_key=self.tsb_key)
self.tb.connect(src0, (tagged_stream_mux, 0))
self.tb.connect(src1, (tagged_stream_mux, 1))
self.tb.connect(tagged_stream_mux, snk)
self.tb.run()
# Check
self.assertEqual(expected, snk.data())
tags = [gr.tag_to_python(x) for x in snk.tags()]
tags = sorted([(x.offset, x.key, x.value) for x in tags])
tags_expected = [
(6, 'spam', 42),
(8, 'eggs', 23),
]
self.assertEqual(tags, tags_expected)
def test_1(self):
packets0 = ((0, 1, 2), (5, 6), (10, ), (
14,
15,
16,
))
packets1 = ((3, 4), (7, 8, 9), (11, 12, 13), (17, ))
expected = ((0, 1, 2, 3, 4), (5, 6, 7, 8, 9), (10, 11, 12, 13),
(14, 15, 16, 17))
data0, tags0 = self.setup_data_tags(packets0)
data1, tags1 = self.setup_data_tags(packets1)
tags0.append(make_tag('spam', 42, 4))
tags1.append(make_tag('eggs', 23, 3))
src0 = blocks.vector_source_b(data0, tags=tags0)
src1 = blocks.vector_source_b(data1, tags=tags1)
tagged_stream_mux = blocks.tagged_stream_mux(gr.sizeof_char,
self.tsb_key)
snk = blocks.tsb_vector_sink_b(tsb_key=self.tsb_key)
self.tb.connect(src0, (tagged_stream_mux, 0))
self.tb.connect(src1, (tagged_stream_mux, 1))
self.tb.connect(tagged_stream_mux, snk)
self.tb.run()
# Check
self.assertEqual(expected, snk.data())
tags = [gr.tag_to_python(x) for x in snk.tags()]
tags = sorted([(x.offset, x.key, x.value) for x in tags])
tags_expected = [
(6, 'spam', 42),
(8, 'eggs', 23),
]
self.assertEqual(tags, tags_expected)
def test_001_t(self):
len_tag_key = "header_len"
debug_tag_key = "test"
payload_key = "packet_size"
own_id = 4
maxS = 3
header_one = [20]
header_two = [17]
header_three = [132]
header_four = [20, 20]
header_five = [20]
header_six = [20]
src_data = header_one + header_two + header_three + header_four
src_data = src_data + header_five + header_six
src_tags = make_tags(len_tag_key, debug_tag_key, payload_key)
#blocks
src = blocks.vector_source_b(src_data, repeat=False, tags=src_tags)
parser = ownHeader.parse_short_bb(len_tag_key, payload_key, own_id,
maxS)
dest = blocks.tsb_vector_sink_b(1, len_tag_key)
#connection
self.tb.connect(src, parser, dest)
self.tb.run()
# retrieve data
dest_data = dest.data()
dest_tags = dest.tags()
#testing
#receiver data
self.assertEqual(len(dest_data), 6)
self.assertEqual(dest_data, ((1, ), (0, ), (0, ), (0, ), (1, ), (1, )))
#tags
tags = [gr.tag_to_python(x) for x in dest_tags]
self.assertEqual(len(tags), 4)
zero = []
four = []
five = []
rest = []
for tag in tags:
if tag.offset == 0:
zero.append(tag)
elif tag.offset == 4:
four.append(tag)
elif tag.offset == 5:
five.append(tag)
else:
rest.appned(tag)
self.assertEqual(len(rest), 0)
self.assertEqual(len(zero), 1)
self.assertEqual(len(four), 2)
self.assertEqual(len(five), 1)
self.assertEqual(zero[0].value, 1)
for tag in four:
if tag.key == debug_tag_key:
self.assertEqual(tag.value, 400)
elif tag.key == payload_key:
self.assertEqual(tag.value, 1)
else:
self.assertEqual(False, True)
self.assertEqual(five[0].value, 1)
def test_002_t(self):
# FORTH & BACK
input1 = (49, 50, 51, 52, 53, 54, 55, 56, 57) # Unicode 1-9
input1_tagger = blocks.stream_to_tagged_stream(gr.sizeof_char, 1, len(input1), self.tsb_key)
src = blocks.vector_source_b(input1)
crc = crc_tagged_stream(False, self.tsb_key)
crc_check = crc_tagged_stream(True, self.tsb_key)
dst = blocks.tsb_vector_sink_b(tsb_key=self.tsb_key)
self.tb.connect(src, input1_tagger, crc, crc_check, dst)
self.tb.run()
self.assertEquals(dst.data()[0], input1)
def test_001_t(self):
len_tag_key = "packet_len"
receiver_key = 'recv_id'
pay_len_key = "pay_len"
debug_key = "test"
tag_debug = gr.tag_t()
tag_debug.key = pmt.intern(debug_key)
tag_debug.value = pmt.from_long(400)
tag_debug.offset = 2
tag1 = gr.tag_t()
tag1.key = pmt.intern(len_tag_key)
tag1.value = pmt.from_long(2)
tag1.offset = 0
tag2 = gr.tag_t()
tag2.key = pmt.intern(len_tag_key)
tag2.value = pmt.from_long(2)
tag2.offset = 2
tag1r = gr.tag_t()
tag1r.key = pmt.intern(receiver_key)
tag1r.value = pmt.from_long(3)
tag1r.offset = 0
tag2r = gr.tag_t()
tag2r.key = pmt.intern(receiver_key)
tag2r.value = pmt.from_long(3)
tag2r.offset = 2
tag1l = gr.tag_t()
tag1l.key = pmt.intern(pay_len_key)
tag1l.value = pmt.from_long(2)
tag1l.offset = 0
tag2l = gr.tag_t()
tag2l.key = pmt.intern(pay_len_key)
tag2l.value = pmt.from_long(2)
tag2l.offset = 2
packet1 = [10, 10]
packet2 = [10, 20]
src_data = packet1 + packet2
src_tags = tuple([tag_debug, tag1, tag2, tag1l, tag1r, tag2l, tag2r])
#blocks
source = blocks.vector_source_b(src_data, repeat=False, tags=src_tags)
dest = blocks.tsb_vector_sink_b(tsb_key="packet_len")
gen = ownHeader.generate_short_bb(len_tag_key, pay_len_key,
receiver_key)
#connections
self.tb.connect(source, gen, dest)
self.tb.run()
#retrieve fdata
dest_data = dest.data()
dest_tags = dest.tags()
# check data
self.assertEqual(len(dest_data), 2)
self.assertEqual(dest_data[0], (35, ))
self.assertEqual(dest_data[1], (35, ))
self.assertEqual(len(dest_tags), 0)
def test_001_t (self):
# ADDING CRC
input1 = (49, 50, 51, 52, 53, 54, 55, 56, 57) # Unicode 1-9
input1_tagger = blocks.stream_to_tagged_stream(gr.sizeof_char, 1, len(input1), self.tsb_key)
src = blocks.vector_source_b(input1)
crc = crc_tagged_stream(False, self.tsb_key)
dst = blocks.tsb_vector_sink_b(tsb_key = self.tsb_key)
output1 = (49, 50, 51, 52, 53, 54, 55, 56, 57, 177, 41) #unicode 0x29B1
self.tb.connect(src, input1_tagger, crc, dst)
self.tb.run ()
self.assertEquals(dst.data()[0], output1)
def test_001_t(self):
src_data = [193 for x in range(12)]
src_tags = make_tags(0)
source = blocks.vector_source_b(src_data, repeat=False, tags=src_tags)
dest = blocks.tsb_vector_sink_b(tsb_key="packet_len")
header = ownHeader.generate_header_bb("packet_len")
self.tb.connect(source, header, dest)
self.tb.run()
result_data = dest.data()[0]
self.assertEqual(len(result_data), 6)
self.assertEqual(result_data, tuple([1, 1, 1, 0, 0, 0]))
def test_001_crc_len(self):
""" Make sure the output of a CRC set is 4 bytes longer than the input. """
data = list(range(16))
src = blocks.vector_source_b(data)
crc = digital.crc32_bb(False, self.tsb_key)
sink = blocks.tsb_vector_sink_b(tsb_key=self.tsb_key)
self.tb.connect(
src,
blocks.stream_to_tagged_stream(gr.sizeof_char, 1,
len(data), self.tsb_key), crc, sink)
self.tb.run()
# Check that the packets before crc_check are 4 bytes longer that the input.
self.assertEqual(len(data) + 4, len(sink.data()[0]))
def test_002_crc_equal_unpacked (self):
""" Test unpacked operation with packed operation
"""
data = (0, 1, 2, 3, 4, 5, 6, 7, 8)
src = blocks.vector_source_b(data)
unpack1 = blocks.repack_bits_bb(8, 1, self.tsb_key, False, gr.GR_LSB_FIRST)
unpack2 = blocks.repack_bits_bb(8, 1, self.tsb_key, False, gr.GR_LSB_FIRST)
crc_unpacked = digital.crc32_bb(False, self.tsb_key, False)
crc_packed = digital.crc32_bb(False, self.tsb_key, True)
sink1 = blocks.tsb_vector_sink_b(tsb_key=self.tsb_key)
sink2 = blocks.tsb_vector_sink_b(tsb_key=self.tsb_key)
self.tb.connect(src,
blocks.stream_to_tagged_stream(
gr.sizeof_char, 1, len(data), self.tsb_key),
crc_packed, unpack1, sink1)
self.tb.connect(src,
blocks.stream_to_tagged_stream(
gr.sizeof_char, 1, len(data), self.tsb_key),
unpack2, crc_unpacked, sink2)
self.tb.run()
self.assertEqual(sink1.data(), sink2.data())
def test_001_crc_len(self):
""" Make sure the output of a CRC set is 4 bytes longer than the input. """
data = list(range(16))
src = blocks.vector_source_b(data)
crc = digital.crc32_bb(False, self.tsb_key)
sink = blocks.tsb_vector_sink_b(tsb_key=self.tsb_key)
self.tb.connect(
src,
blocks.stream_to_tagged_stream(gr.sizeof_char, 1,
len(data), self.tsb_key), crc, sink)
self.tb.run()
# Check that the packets before crc_check are 4 bytes longer that the input.
self.assertEqual(len(data) + 4, len(sink.data()[0]))
def test_002_crc_equal(self):
""" Go through CRC set / CRC check and make sure the output
is the same as the input. """
data = (0, 1, 2, 3, 4, 5, 6, 7, 8)
src = blocks.vector_source_b(data)
crc = digital.crc32_bb(False, self.tsb_key)
crc_check = digital.crc32_bb(True, self.tsb_key)
sink = blocks.tsb_vector_sink_b(tsb_key=self.tsb_key)
self.tb.connect(src,
blocks.stream_to_tagged_stream(
gr.sizeof_char, 1, len(data), self.tsb_key), crc,
crc_check, sink)
self.tb.run()
# Check that the packets after crc_check are the same as input.
self.assertEqual(data, sink.data()[0])
def test_009_fail(self):
""" Corrupt the data and make sure it fails CRC test. """
data = (0, 1, 2, 3, 4, 5, 6, 7)
src = blocks.vector_source_b(data)
crc = digital.crc32_bb(False, self.tsb_key, False)
crc_check = digital.crc32_bb(True, self.tsb_key, False)
corruptor = blocks.add_const_bb(1)
sink = blocks.tsb_vector_sink_b(tsb_key=self.tsb_key)
self.tb.connect(src,
blocks.stream_to_tagged_stream(
gr.sizeof_char, 1, len(data), self.tsb_key), crc,
corruptor, crc_check, sink)
self.tb.run()
# crc_check will drop invalid packets
self.assertEqual(len(sink.data()), 0)
def test_004_fail(self):
""" Corrupt the data and make sure it fails CRC test. """
data = [0, 1, 2, 3, 4, 5, 6, 7]
src = blocks.vector_source_b(data)
crc = digital.crc32_bb(False, self.tsb_key)
crc_check = digital.crc32_bb(True, self.tsb_key)
corruptor = blocks.add_const_bb(1)
sink = blocks.tsb_vector_sink_b(tsb_key=self.tsb_key)
self.tb.connect(src,
blocks.stream_to_tagged_stream(
gr.sizeof_char, 1, len(data), self.tsb_key), crc,
corruptor, crc_check, sink)
self.tb.run()
# crc_check will drop invalid packets
self.assertEqual(len(sink.data()), 0)
def test_002_crc_equal(self):
""" Go through CRC set / CRC check and make sure the output
is the same as the input. """
data = [0, 1, 2, 3, 4, 5, 6, 7, 8]
src = blocks.vector_source_b(data)
crc = digital.crc32_bb(False, self.tsb_key)
crc_check = digital.crc32_bb(True, self.tsb_key)
sink = blocks.tsb_vector_sink_b(tsb_key=self.tsb_key)
self.tb.connect(src,
blocks.stream_to_tagged_stream(
gr.sizeof_char, 1, len(data), self.tsb_key), crc,
crc_check, sink)
self.tb.run()
# Check that the packets after crc_check are the same as input.
self.assertEqual(data, sink.data()[0])
def test_005_three_with_tags_trailing(self):
""" 3 -> 8, trailing bits """
src_data = (0b101, ) + (0b111, ) * 4 + (0b001, )
expected_data = (0b11111101, 0b11111111)
k = 3
l = 8
src = blocks.vector_source_b(src_data, False, 1)
repack = blocks.repack_bits_bb(k, l, self.tsb_key, True)
sink = blocks.tsb_vector_sink_b(tsb_key=self.tsb_key)
self.tb.connect(
src,
blocks.stream_to_tagged_stream(gr.sizeof_char, 1, len(src_data),
self.tsb_key), repack, sink)
self.tb.run()
self.assertEqual(len(sink.data()), 1)
self.assertEqual(sink.data()[0], expected_data)
def test_001_t (self):
src_data = [180 for x in range(13)]
src_data2 = [193 for x in range(13)]
src_tags = make_tags(0) + make_tags(13)
source = blocks.vector_source_b(src_data,repeat = False, tags = src_tags)
dest = blocks.tsb_vector_sink_b(tsb_key="packet_l")
header = ownHeader.append_header_bb("packet_l")
tagger = blocks.stream_to_tagged_stream(gr.sizeof_char,1, len(src_data), "packet_l")
self.tb.connect(source,tagger,header)
self.tb.connect(header,dest)
self.tb.run ()
result_data = dest.data()
result_tags = dest.tags()
self.assertEqual(len(result_data[0]),len(src_data)+6)
self.assertEqual(result_data[0], tuple([1,1,1,0,0,0] + src_data))
def test_003_crc_correct_lentag (self):
tag_name = "length"
pack_len = 8
packets = range(pack_len*2)
tag1 = gr.tag_t()
tag1.offset = 0
tag1.key = pmt.string_to_symbol(tag_name)
tag1.value = pmt.from_long(pack_len)
tag2 = gr.tag_t()
tag2.offset = pack_len
tag2.key = pmt.string_to_symbol(tag_name)
tag2.value = pmt.from_long(pack_len)
testtag1 = gr.tag_t()
testtag1.offset = 1
testtag1.key = pmt.string_to_symbol("tag1")
testtag1.value = pmt.from_long(0)
testtag2 = gr.tag_t()
testtag2.offset = pack_len
testtag2.key = pmt.string_to_symbol("tag2")
testtag2.value = pmt.from_long(0)
testtag3 = gr.tag_t()
testtag3.offset = len(packets)-1
testtag3.key = pmt.string_to_symbol("tag3")
testtag3.value = pmt.from_long(0)
src = blocks.vector_source_b(packets, False, 1, (testtag1, testtag2, testtag3))
crc = digital.crc32_bb(False, self.tsb_key)
sink = blocks.tsb_vector_sink_b(tsb_key=self.tsb_key)
self.tb.connect(
src,
blocks.stream_to_tagged_stream(gr.sizeof_char, 1, pack_len, self.tsb_key),
crc,
sink
)
self.tb.run()
self.assertEqual(len(sink.data()), 2)
self.assertEqual(len(sink.data()[0]), (pack_len+4))
self.assertEqual(len(sink.data()[1]), (pack_len+4))
correct_offsets = {'tag1': 1, 'tag2': 12, 'tag3': 19}
tags_found = {'tag1': False, 'tag2': False, 'tag3': False}
for tag in sink.tags():
key = pmt.symbol_to_string(tag.key)
if key in correct_offsets.keys():
tags_found[key] = True
self.assertEqual(correct_offsets[key], tag.offset)
self.assertTrue(all(tags_found.values()))
def test_005_three_with_tags_trailing (self):
""" 3 -> 8, trailing bits """
src_data = (0b101,) + (0b111,) * 4 + (0b001,)
expected_data = (0b11111101, 0b11111111)
k = 3
l = 8
src = blocks.vector_source_b(src_data, False, 1)
repack = blocks.repack_bits_bb(k, l, self.tsb_key, True)
sink = blocks.tsb_vector_sink_b(tsb_key=self.tsb_key)
self.tb.connect(
src,
blocks.stream_to_tagged_stream(gr.sizeof_char, 1, len(src_data), self.tsb_key),
repack,
sink
)
self.tb.run ()
self.assertEqual(len(sink.data()), 1)
self.assertEqual(sink.data()[0], expected_data)
def test_004_three_with_tags (self):
""" 8 -> 3 """
src_data = [0b11111101, 0b11111111]
expected_data = [0b101,] + [0b111,] * 4 + [0b001,]
k = 8
l = 3
src = blocks.vector_source_b(src_data, False, 1)
repack = blocks.repack_bits_bb(k, l, self.tsb_key)
sink = blocks.tsb_vector_sink_b(tsb_key=self.tsb_key)
self.tb.connect(
src,
blocks.stream_to_tagged_stream(gr.sizeof_char, 1, len(src_data), self.tsb_key),
repack,
sink
)
self.tb.run ()
self.assertEqual(len(sink.data()), 1)
self.assertEqual(sink.data()[0], expected_data)
def test_003_crc_correct_lentag(self):
tag_name = "length"
pack_len = 8
packets = list(range(pack_len*2))
tag1 = gr.tag_t()
tag1.offset = 0
tag1.key = pmt.string_to_symbol(tag_name)
tag1.value = pmt.from_long(pack_len)
tag2 = gr.tag_t()
tag2.offset = pack_len
tag2.key = pmt.string_to_symbol(tag_name)
tag2.value = pmt.from_long(pack_len)
testtag1 = gr.tag_t()
testtag1.offset = 1
testtag1.key = pmt.string_to_symbol("tag1")
testtag1.value = pmt.from_long(0)
testtag2 = gr.tag_t()
testtag2.offset = pack_len
testtag2.key = pmt.string_to_symbol("tag2")
testtag2.value = pmt.from_long(0)
testtag3 = gr.tag_t()
testtag3.offset = len(packets) - 1
testtag3.key = pmt.string_to_symbol("tag3")
testtag3.value = pmt.from_long(0)
src = blocks.vector_source_b(packets, False, 1,
(testtag1, testtag2, testtag3))
crc = digital.crc32_bb(False, self.tsb_key)
sink = blocks.tsb_vector_sink_b(tsb_key=self.tsb_key)
self.tb.connect(src,
blocks.stream_to_tagged_stream(
gr.sizeof_char, 1, pack_len, self.tsb_key), crc,
sink)
self.tb.run()
self.assertEqual(len(sink.data()), 2)
self.assertEqual(len(sink.data()[0]), (pack_len + 4))
self.assertEqual(len(sink.data()[1]), (pack_len + 4))
correct_offsets = {'tag1': 1, 'tag2': 12, 'tag3': 19}
tags_found = {'tag1': False, 'tag2': False, 'tag3': False}
for tag in sink.tags():
key = pmt.symbol_to_string(tag.key)
if key in list(correct_offsets.keys()):
tags_found[key] = True
self.assertEqual(correct_offsets[key], tag.offset)
self.assertTrue(all(tags_found.values()))
def test_001_t (self):
len_tag_key = "packet_len"
len_frame_tag_key = "frame_length"
maxS = 3
ownID = 2
maxPad = 1
header_one = [2,0,1,2,0,0]
header_two = [100,1,1,2,0,0] #too long
header_three = [1,2,1,3,0,0] #wrong receiver
header_four = [1,0,1,2,10,0] #too much padding
src_data = header_one + header_two + header_three + header_four
src_tags = make_tags(len_tag_key, len_frame_tag_key)
src = blocks.vector_source_b(src_data, repeat = False, tags = src_tags)
parser = ownHeader.parse_header_bb(len_tag_key,len_frame_tag_key, maxS, ownID, maxPad)
dest = blocks.tsb_vector_sink_b(1,len_tag_key)
self.tb.connect(src,parser,dest)
self.tb.run ()
dest_data = dest.data()
dest_tags = dest.tags()
self.assertEqual(len(dest_data),4)
self.assertEqual(dest_data, ((1,),(0,),(0,),(0,),))
tags = [gr.tag_to_python(x) for x in dest_tags]
self.assertEqual(len(tags),6)
zero = []
one = []
two = []
three = []
for tag in tags:
if tag.offset ==0:
zero.append(tag)
elif tag.offset ==1:
one.append(tag)
elif tag.offset == 2:
two.append(tag)
else :
three.append(tag)
self.assertEqual(len(zero),6)
def test_001_t(self):
input1 = (10, 0, 1, 2)
#input1= [0, 0, 0, 0, 1, 0, 1, 0]
#input2 = [ 0, 0, 0, 0, 0, 0, 0, 0]
#input3 = [ 0, 0, 0, 0, 0, 0, 0, 1]
#input4 = [0, 0, 0, 0, 0, 0, 1, 0]
output1 = (245, 225, 28, 152)
#output1 = [1, 1, 1, 1, 0, 1, 0, 1]
#output2 = [1, 1, 1, 0, 0, 0, 0, 1]
#output3 = [0, 0, 0, 1, 1, 1, 0, 0]
#output4 = [1, 0, 0, 1, 1, 0, 0, 0]
src = blocks.vector_source_b(input1)
src_tagged = blocks.stream_to_tagged_stream(gr.sizeof_char, 1,
len(input1), self.tsb_key)
pn9 = pn9_whitening(False)
dst = blocks.tsb_vector_sink_b(tsb_key=self.tsb_key)
self.tb.connect(src, src_tagged, pn9, dst)
self.tb.run()
self.assertEquals(dst.data()[0], output1)
