def test_003_double_3(self):
"""test_003_double_3: multiply double version with 3 inputs"""
src_data1 = [float(x) for x in range(16)]
src_data2 = [float(x) for x in range(16)]
src_data3 = [float(x) for x in range(16)]
expected_result_temp = []
for i in range(0, len(src_data1)):
expected_result_temp.append(src_data1[i] * src_data2[i] *
src_data3[i])
expected_result = tuple(expected_result_temp)
src1 = flaress.vector_source_double(src_data1)
src2 = flaress.vector_source_double(src_data2)
src3 = flaress.vector_source_double(src_data3)
dst = flaress.vector_sink_double()
op = flaress.multiply_double(1)
self.tb.connect(src1, (op, 0))
self.tb.connect(src2, (op, 1))
self.tb.connect(src3, (op, 2))
self.tb.connect(op, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(expected_result, result_data)
def test_005(self):
"""test_005: that repeat works (with tagged streams)"""
length = 16
src_data = [float(x) for x in range(length)]
expected_result = tuple(src_data + src_data)
src_tags = tuple([make_tag('key', 'val', 0, 'src')])
expected_tags = tuple([
make_tag('key', 'val', 0, 'src'),
make_tag('key', 'val', length, 'src')
])
src = flaress.vector_source_double(src_data,
repeat=True,
tags=src_tags)
head = blocks.head(gr.sizeof_double, 2 * length)
dst = flaress.vector_sink_double()
self.tb.connect(src, head, dst)
self.tb.run()
result_data = dst.data()
result_tags = dst.tags()
self.assertEqual(expected_result, result_data)
self.assertEqual(len(result_tags), 2)
self.assertTrue(compare_tags(expected_tags[0], result_tags[0]))
self.assertTrue(compare_tags(expected_tags[1], result_tags[1]))
def test_003(self):
"""test_003: that we can only make vectors (the I/O type) if the input vector has sufficient size"""
src_data = [float(x) for x in range(16)]
expected_result = tuple(src_data)
self.assertRaises(
RuntimeError,
lambda: flaress.vector_source_double(src_data, False, 3))
def test_002(self):
"""test_002: vectors (the gnuradio vector I/O type)"""
src_data = [float(x) for x in range(16)]
expected_result = tuple(src_data)
src = flaress.vector_source_double(src_data, False, 2)
dst = flaress.vector_sink_double(2)
self.tb.connect(src, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(expected_result, result_data)
def test_001(self):
"""test_001: that sink has data set in source for the simplest case"""
src_data = [float(x) for x in range(16)]
expected_result = tuple(src_data)
src = flaress.vector_source_double(src_data)
dst = flaress.vector_sink_double()
self.tb.connect(src, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(expected_result, result_data)
def test_006(self):
"""test_006: set_data"""
src_data = [float(x) for x in range(16)]
expected_result = tuple(src_data)
src = flaress.vector_source_double((3,1,4))
dst = flaress.vector_sink_double()
src.set_data(src_data)
self.tb.connect(src, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(expected_result, result_data)
def test_002_double_2(self):
"""test_002_double_2: divide double version with 2 inputs"""
src_data1 = [float(x) for x in range(1, 16)]
src_data2 = [float(x) for x in range(1, 16)]
expected_result_temp = []
for i in range(0, len(src_data1)):
expected_result_temp.append(src_data1[i] / src_data2[i])
expected_result = tuple(expected_result_temp)
src1 = flaress.vector_source_double(src_data1)
src2 = flaress.vector_source_double(src_data2)
dst = flaress.vector_sink_double()
op = flaress.divide_double(1)
self.tb.connect(src1, (op, 0))
self.tb.connect(src2, (op, 1))
self.tb.connect(op, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(expected_result, result_data)
def test_007(self):
"""test_007: set_repeat"""
src_data = [float(x) for x in range(16)]
expected_result = tuple(src_data)
src = flaress.vector_source_double(src_data, True)
dst = flaress.vector_sink_double()
src.set_repeat(False)
self.tb.connect(src, dst)
# will timeout if set_repeat does not work
self.tb.run()
result_data = dst.data()
self.assertEqual(expected_result, result_data)
def test_004(self):
"""test_004: sending and receiving tagged streams"""
src_data = [float(x) for x in range(16)]
expected_result = tuple(src_data)
src_tags = tuple([make_tag('key', 'val', 0, 'src')])
expected_tags = src_tags[:]
src = flaress.vector_source_double(src_data, repeat=False, tags=src_tags)
dst = flaress.vector_sink_double()
self.tb.connect(src, dst)
self.tb.run()
result_data = dst.data()
result_tags = dst.tags()
self.assertEqual(expected_result, result_data)
self.assertEqual(len(result_tags), 1)
self.assertTrue(compare_tags(expected_tags[0], result_tags[0]))
def test_002_double_2 (self):
"""test_002_double_2: add const double version with 2 inputs"""
src_data1 = [float(x) for x in range(16)]
expected_result_temp = []
const = 10
for i in range(0, len(src_data1)):
expected_result_temp.append(const + src_data1[i])
expected_result = tuple(expected_result_temp)
src1 = flaress.vector_source_double(src_data1)
dst = flaress.vector_sink_double()
op = flaress.add_const_double(const, 1)
self.tb.connect(src1, (op, 0))
self.tb.connect(op, dst)
self.tb.run()
result_data = dst.data()
self.assertEqual(expected_result, result_data)
