Exemplo n.º 1
0
    def test_001(self):
        src_data = ( 1,  2,  3,  4,  5,  6,  7,  8,  9,  10)
        trg_data = (-1, -1,  1,  1, -1, -1,  1,  1, -1,  -1)
        src = blocks.vector_source_i(src_data)
        trg = blocks.vector_source_s(trg_data)
        op  = blocks.burst_tagger(gr.sizeof_int)
        snk = blocks.tagged_file_sink(gr.sizeof_int, 1)
        self.tb.connect(src, (op,0))
        self.tb.connect(trg, (op,1))
        self.tb.connect(op, snk)
        self.tb.run()

        # Tagged file sink gets 2 burst tags at index 2 and index 5.
        # Creates two new files, each with two integers in them from
        # src_data at these indexes (3,4) and (7,8).
        file0 = "file{0}_0_2.00000000.dat".format(snk.unique_id())
        file1 = "file{0}_1_6.00000000.dat".format(snk.unique_id())

        # Open the files and read in the data, then remove the files
        # to clean up the directory.
        outfile0 = file(file0, 'rb')
	outfile1 = file(file1, 'rb')
	data0 = outfile0.read(8)
	data1 = outfile1.read(8)
        outfile0.close()
        outfile1.close()
	os.remove(file0)
	os.remove(file1)

        # Convert the 8 bytes from the files into a tuple of 2 ints.
        idata0 = struct.unpack('ii', data0)
        idata1 = struct.unpack('ii', data1)

        self.assertEqual(idata0, (3, 4))
        self.assertEqual(idata1, (7, 8))
Exemplo n.º 2
0
 def test_001(self):
     # Just run some data through and make sure it doesn't puke.
     src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
     src = blocks.vector_source_i(src_data)
     op = blocks.tag_debug(gr.sizeof_int, "tag QA")
     self.tb.connect(src, op)
     self.tb.run()
     x = op.current_tags()
Exemplo n.º 3
0
 def test_001(self):
     # Just run some data through and make sure it doesn't puke.
     src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
     src = blocks.vector_source_i(src_data)
     op = blocks.tag_debug(gr.sizeof_int, "tag QA")
     self.tb.connect(src, op)
     self.tb.run()
     x = op.current_tags()
Exemplo n.º 4
0
 def help_ii(self, src_data, exp_data, op):
     for s in zip(range(len(src_data)), src_data):
         src = blocks.vector_source_i(s[1])
         self.tb.connect(src, (op, s[0]))
     dst = blocks.vector_sink_i()
     self.tb.connect(op, dst)
     self.tb.run()
     result_data = dst.data()
     self.assertEqual(exp_data, result_data)
Exemplo n.º 5
0
 def test_and_const_ii (self):
     src_data =        (1,  2,  3,  0x5004,   0x1150)
     expected_result = (0,  2,  2,  0x5000,   0x1100)
     src = blocks.vector_source_i(src_data)
     op = blocks.and_const_ii (0x55AA)
     dst = blocks.vector_sink_i()
     self.tb.connect(src, op, dst)
     self.tb.run()
     self.assertEqual(dst.data(), expected_result)
Exemplo n.º 6
0
 def help_ii (self, src_data, exp_data, op):
     for s in zip (range (len (src_data)), src_data):
         src = blocks.vector_source_i (s[1])
         self.tb.connect (src, (op, s[0]))
     dst = blocks.vector_sink_i ()
     self.tb.connect (op, dst)
     self.tb.run ()
     result_data = dst.data ()
     self.assertEqual (exp_data, result_data)
Exemplo n.º 7
0
 def test_int_to_float_identity(self):
     src_data = (1, 2, 3, 4, 5)
     expected_data = (1.0, 2.0, 3.0, 4.0, 5.0)
     src = blocks.vector_source_i(src_data)
     op = blocks.int_to_float()
     dst = blocks.vector_sink_f()
     self.tb.connect(src, op, dst)
     self.tb.run()
     self.assertFloatTuplesAlmostEqual(expected_data, dst.data())
Exemplo n.º 8
0
 def test_int_to_float_identity(self):
     src_data = (1, 2, 3, 4, 5)
     expected_data = (1.0, 2.0, 3.0, 4.0, 5.0)
     src = blocks.vector_source_i(src_data)
     op = blocks.int_to_float()
     dst = blocks.vector_sink_f()
     self.tb.connect(src, op, dst)
     self.tb.run()
     self.assertFloatTuplesAlmostEqual(expected_data, dst.data())
Exemplo n.º 9
0
 def test_int_to_float_scale(self):
     src_data = (1, 2, 3, 4, 5)
     expected_data = (0.2, 0.4, 0.6, 0.8, 1.0)
     src = blocks.vector_source_i(src_data)
     op = blocks.int_to_float(1, 5)
     dst = blocks.vector_sink_f()
     self.tb.connect(src, op, dst)
     self.tb.run()
     self.assertFloatTuplesAlmostEqual(expected_data, dst.data())
Exemplo n.º 10
0
 def test_and_const_ii(self):
     src_data = (1, 2, 3, 0x5004, 0x1150)
     expected_result = (0, 2, 2, 0x5000, 0x1100)
     src = blocks.vector_source_i(src_data)
     op = blocks.and_const_ii(0x55AA)
     dst = blocks.vector_sink_i()
     self.tb.connect(src, op, dst)
     self.tb.run()
     self.assertEqual(dst.data(), expected_result)
Exemplo n.º 11
0
    def help_const_ii(self, src_data, exp_data, op):
	src = blocks.vector_source_i(src_data)
	srcv = blocks.stream_to_vector(gr.sizeof_int, len(src_data))
	rhs = blocks.vector_to_stream(gr.sizeof_int, len(src_data))
        dst = blocks.vector_sink_i()
        self.tb.connect(src, srcv, op, rhs, dst)
        self.tb.run()
        result_data = dst.data()
        self.assertEqual(exp_data, result_data)
Exemplo n.º 12
0
    def test_001_ii(self):
	src_data = (1, 2, 3, 4, 5, 6)
	dst_data = (6, 15)
	src = blocks.vector_source_i(src_data)
	itg = blocks.integrate_ii(3)
	dst = blocks.vector_sink_i()
	self.tb.connect(src, itg, dst)
	self.tb.run()
	self.assertEqual(dst_data, dst.data())
Exemplo n.º 13
0
 def test_int_to_float_scale(self):
     src_data = (1, 2, 3, 4, 5)
     expected_data = (0.2, 0.4, 0.6, 0.8, 1.0)
     src = blocks.vector_source_i(src_data)
     op = blocks.int_to_float(1, 5)
     dst = blocks.vector_sink_f()
     self.tb.connect(src, op, dst)
     self.tb.run()
     self.assertFloatTuplesAlmostEqual(expected_data, dst.data())
Exemplo n.º 14
0
 def test_skip_all(self):
     skip_cnt = len(self.src_data)
     expected_result = tuple(self.src_data[skip_cnt:])
     src1 = blocks.vector_source_i(self.src_data)
     op = blocks.skiphead(gr.sizeof_int, skip_cnt)
     dst1 = blocks.vector_sink_i()
     self.tb.connect(src1, op, dst1)
     self.tb.run()
     dst_data = dst1.data()
     self.assertEqual(expected_result, dst_data)
Exemplo n.º 15
0
 def test_skip_all(self):
     skip_cnt = len(self.src_data)
     expected_result = tuple(self.src_data[skip_cnt:])
     src1 = blocks.vector_source_i(self.src_data)
     op = blocks.skiphead(gr.sizeof_int, skip_cnt)
     dst1 = blocks.vector_sink_i()
     self.tb.connect(src1, op, dst1)
     self.tb.run()
     dst_data = dst1.data()
     self.assertEqual(expected_result, dst_data)
Exemplo n.º 16
0
 def test_head(self):
     src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
     expected_result = (1, 2, 3, 4)
     src1 = blocks.vector_source_i(src_data)
     op = blocks.head(gr.sizeof_int, 4)
     dst1 = blocks.vector_sink_i()
     self.tb.connect(src1, op)
     self.tb.connect(op, dst1)
     self.tb.run()
     dst_data = dst1.data()
     self.assertEqual(expected_result, dst_data)
Exemplo n.º 17
0
 def test_head(self):
     src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
     expected_result = (1, 2, 3, 4)
     src1 = blocks.vector_source_i(src_data)
     op = blocks.head(gr.sizeof_int, 4)
     dst1 = blocks.vector_sink_i()
     self.tb.connect(src1, op)
     self.tb.connect(op, dst1)
     self.tb.run()
     dst_data = dst1.data()
     self.assertEqual(expected_result, dst_data)
Exemplo n.º 18
0
    def help_ii(self, size, src_data, exp_data, op):
        for s in zip(range (len (src_data)), src_data):
            src = blocks.vector_source_i(s[1])
	    srcv = blocks.stream_to_vector(gr.sizeof_int, size)
	    self.tb.connect(src, srcv)
            self.tb.connect(srcv, (op, s[0]))
	rhs = blocks.vector_to_stream(gr.sizeof_int, size)
        dst = blocks.vector_sink_i()
        self.tb.connect(op, rhs, dst)
        self.tb.run()
        result_data = dst.data()
        self.assertEqual(exp_data, result_data)
Exemplo n.º 19
0
    def test_002(self):

        src_data = [1,2,3,4]
        expected_result = [16777216, 33554432, 50331648, 67108864];

        src = blocks.vector_source_i(src_data)
        op = blocks.endian_swap(4)
        dst = blocks.vector_sink_i()

        self.tb.connect(src, op, dst)
        self.tb.run()
        result_data = list(dst.data())
    
        self.assertEqual(expected_result, result_data)
Exemplo n.º 20
0
    def test_if_004(self):
        const = [-3, -1, 1, 3]
        src_data = (0, 1, 2, 3, 3, 2, 1, 0)
        expected_result = (-3, -1, 1, 3, 3, 1, -1, -3)

        src = blocks.vector_source_i(src_data)
        op = digital.chunks_to_symbols_if(const)

        dst = blocks.vector_sink_f()
        self.tb.connect(src, op)
        self.tb.connect(op, dst)
        self.tb.run()

        actual_result = dst.data()
        self.assertEqual(expected_result, actual_result)
Exemplo n.º 21
0
    def test_ic_003(self):
        const = [1 + 0j, 0 + 1j, -1 + 0j, 0 - 1j]
        src_data = (0, 1, 2, 3, 3, 2, 1, 0)
        expected_result = (1 + 0j, 0 + 1j, -1 + 0j, 0 - 1j, 0 - 1j, -1 + 0j,
                           0 + 1j, 1 + 0j)

        src = blocks.vector_source_i(src_data)
        op = digital.chunks_to_symbols_ic(const)

        dst = blocks.vector_sink_c()
        self.tb.connect(src, op)
        self.tb.connect(op, dst)
        self.tb.run()

        actual_result = dst.data()
        self.assertEqual(expected_result, actual_result)
Exemplo n.º 22
0
    def test_if_004(self):
        const = [-3, -1, 1, 3]
        src_data = (0, 1, 2, 3, 3, 2, 1, 0)
        expected_result = (-3, -1, 1, 3,
                            3, 1, -1, -3)

        src = blocks.vector_source_i(src_data)
        op = digital.chunks_to_symbols_if(const)

        dst = blocks.vector_sink_f()
        self.tb.connect(src, op)
        self.tb.connect(op, dst)
        self.tb.run()

        actual_result = dst.data()
        self.assertEqual(expected_result, actual_result)
Exemplo n.º 23
0
    def test_ic_003(self):
        const = [ 1+0j, 0+1j,
                 -1+0j, 0-1j]
        src_data = (0, 1, 2, 3, 3, 2, 1, 0)
        expected_result = (1+0j, 0+1j, -1+0j, 0-1j,
                           0-1j, -1+0j, 0+1j, 1+0j)

        src = blocks.vector_source_i(src_data)
        op = digital.chunks_to_symbols_ic(const)

        dst = blocks.vector_sink_c()
        self.tb.connect(src, op)
        self.tb.connect(op, dst)
        self.tb.run()

        actual_result = dst.data()
        self.assertEqual(expected_result, actual_result)
Exemplo n.º 24
0
    def test_201b(self):
        random.seed(0)
        src_data = []
        for i in xrange(100):
            src_data.append((random.randint(-2**31, 2**31 - 1)))
        src_data = tuple(src_data)
        expected_results = src_data
        src = blocks.vector_source_i(tuple(src_data), False)
        op1 = blocks.packed_to_unpacked_ii(8, gr.GR_LSB_FIRST)
        op2 = blocks.unpacked_to_packed_ii(8, gr.GR_LSB_FIRST)
        dst = blocks.vector_sink_i()

        self.tb.connect(src, op1, op2)
        self.tb.connect(op2, dst)
        self.tb.run()

        self.assertEqual(expected_results, dst.data())
Exemplo n.º 25
0
    def test_201b(self):
        random.seed(0)
        src_data = []
        for i in xrange(100):
            src_data.append((random.randint(-2**31,2**31-1)))
        src_data = tuple(src_data)
        expected_results = src_data
        src = blocks.vector_source_i(tuple(src_data), False)
        op1 = blocks.packed_to_unpacked_ii(8, gr.GR_LSB_FIRST)
        op2 = blocks.unpacked_to_packed_ii(8, gr.GR_LSB_FIRST)
        dst = blocks.vector_sink_i()

        self.tb.connect(src, op1, op2)
        self.tb.connect(op2, dst)
        self.tb.run()

        self.assertEqual(expected_results, dst.data())
Exemplo n.º 26
0
    def test_02(self):
        tb = self.tb

        data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

        expected_result = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,
                           0, 0, 0, 0)

        src = blocks.vector_source_i(data, False)
        regen = blocks.peak_detector_ib()
        dst = blocks.vector_sink_b()

        tb.connect(src, regen)
        tb.connect(regen, dst)
        tb.run()

        dst_data = dst.data()

        self.assertEqual(expected_result, dst_data)
Exemplo n.º 27
0
    def test_02(self):
        tb = self.tb

        data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
                9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

        expected_result = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
                           0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

        src = blocks.vector_source_i(data, False)
        regen = blocks.peak_detector_ib()
        dst = blocks.vector_sink_b()

        tb.connect(src, regen)
        tb.connect(regen, dst)
        tb.run()

        dst_data = dst.data()

        self.assertEqual(expected_result, dst_data)
Exemplo n.º 28
0
    def test_002(self):

        # Test streams_to_stream (using stream_to_streams).

        n = 8
        src_len = n * 8
        src_data = tuple(range(src_len))
        expected_results = src_data

        src = blocks.vector_source_i(src_data)
        op1 = blocks.stream_to_streams(gr.sizeof_int, n)
        op2 = blocks.streams_to_stream(gr.sizeof_int, n)
        dst = blocks.vector_sink_i()

        self.tb.connect(src, op1)
        for i in range(n):
            self.tb.connect((op1, i), (op2, i))
        self.tb.connect(op2, dst)

        self.tb.run()
        self.assertEqual(expected_results, dst.data())
Exemplo n.º 29
0
    def test_002(self):

        # Test streams_to_stream (using stream_to_streams).

        n = 8
        src_len = n * 8
        src_data = tuple(range(src_len))
        expected_results = src_data

        src = blocks.vector_source_i(src_data)
        op1 = blocks.stream_to_streams(gr.sizeof_int, n)
        op2 = blocks.streams_to_stream(gr.sizeof_int, n)
        dst = blocks.vector_sink_i()

        self.tb.connect(src, op1)
        for i in range(n):
            self.tb.connect((op1, i), (op2, i))
        self.tb.connect(op2, dst)

        self.tb.run()
        self.assertEqual(expected_results, dst.data())
Exemplo n.º 30
0
    def test_001(self):
        src_data = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
        trg_data = (-1, -1, 1, 1, -1, -1, 1, 1, -1, -1)
        src = blocks.vector_source_i(src_data)
        trg = blocks.vector_source_s(trg_data)
        op = blocks.burst_tagger(gr.sizeof_int)
        snk = blocks.tag_debug(gr.sizeof_int, "burst tagger QA")
        self.tb.connect(src, (op, 0))
        self.tb.connect(trg, (op, 1))
        self.tb.connect(op, snk)
        self.tb.run()

        x = snk.current_tags()
        self.assertEqual(2, x[0].offset)
        self.assertEqual(4, x[1].offset)
        self.assertEqual(6, x[2].offset)
        self.assertEqual(8, x[3].offset)

        self.assertEqual(True, pmt.to_bool(x[0].value))
        self.assertEqual(False, pmt.to_bool(x[1].value))
        self.assertEqual(True, pmt.to_bool(x[2].value))
        self.assertEqual(False, pmt.to_bool(x[3].value))
Exemplo n.º 31
0
    def test_001(self):
        src_data  = ( 1,  2,  3,  4,  5,  6,  7,  8,  9,  10)
        trg_data = (-1, -1,  1,  1, -1, -1,  1,  1, -1,  -1)
        src = blocks.vector_source_i(src_data)
        trg = blocks.vector_source_s(trg_data)
        op  = blocks.burst_tagger(gr.sizeof_int)
        snk = blocks.tag_debug(gr.sizeof_int, "burst tagger QA")
        self.tb.connect(src, (op,0))
        self.tb.connect(trg, (op,1))
        self.tb.connect(op, snk)
        self.tb.run()
        
        x = snk.current_tags()
        self.assertEqual(2, x[0].offset)
        self.assertEqual(4, x[1].offset)
        self.assertEqual(6, x[2].offset)
        self.assertEqual(8, x[3].offset)

        self.assertEqual(True,  pmt.to_bool(x[0].value))
        self.assertEqual(False, pmt.to_bool(x[1].value))
        self.assertEqual(True,  pmt.to_bool(x[2].value))
        self.assertEqual(False, pmt.to_bool(x[3].value))
Exemplo n.º 32
0
    def test_001(self):
        """
        Test stream_to_streams.
        """
        n = 8
        src_len = n * 8
        src_data = range(src_len)

        expected_results = calc_expected_result(src_data, n)
        #print "expected results: ", expected_results
        src = blocks.vector_source_i(src_data)
        op = blocks.stream_to_streams(gr.sizeof_int, n)
        self.tb.connect(src, op)

        dsts = []
        for i in range(n):
            dst = blocks.vector_sink_i()
            self.tb.connect((op, i), (dst, 0))
            dsts.append(dst)

        self.tb.run()

        for d in range(n):
            self.assertEqual(expected_results[d], dsts[d].data())
Exemplo n.º 33
0
    def test_001(self):
        """
        Test stream_to_streams.
        """
        n = 8
        src_len = n * 8
        src_data = range(src_len)

        expected_results = calc_expected_result(src_data, n)
        #print "expected results: ", expected_results
        src = blocks.vector_source_i(src_data)
        op = blocks.stream_to_streams(gr.sizeof_int, n)
        self.tb.connect(src, op)

        dsts = []
        for i in range(n):
            dst = blocks.vector_sink_i()
            self.tb.connect((op, i), (dst, 0))
            dsts.append(dst)

        self.tb.run()

        for d in range(n):
            self.assertEqual(expected_results[d], dsts[d].data())