git.gag.com Git - debian/gnuradio/blob - gnuradio-core/src/python/gnuradio/gr/qa_packed_to_unpacked.py

   1 #!/usr/bin/env python
   2 #
   3 # Copyright 2005,2007 Free Software Foundation, Inc.
   4 #
   5 # This file is part of GNU Radio
   6 #
   7 # GNU Radio is free software; you can redistribute it and/or modify
   8 # it under the terms of the GNU General Public License as published by
   9 # the Free Software Foundation; either version 3, or (at your option)
  10 # any later version.
  11 #
  12 # GNU Radio is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 # GNU General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU General Public License
  18 # along with GNU Radio; see the file COPYING.  If not, write to
  19 # the Free Software Foundation, Inc., 51 Franklin Street,
  20 # Boston, MA 02110-1301, USA.
  21 #
  22
  23 from gnuradio import gr, gr_unittest
  24 import random
  25
  26 class test_packing(gr_unittest.TestCase):
  27
  28     def setUp(self):
  29         self.tb = gr.top_block ()
  30
  31     def tearDown(self):
  32         self.tb = None
  33
  34     def test_001(self):
  35         """
  36         Test stream_to_streams.
  37         """
  38         src_data = (0x80,)
  39         expected_results = (1,0,0,0,0,0,0,0)
  40         src = gr.vector_source_b(src_data,False)
  41         op = gr.packed_to_unpacked_bb(1, gr.GR_MSB_FIRST)
  42         self.tb.connect(src, op)
  43
  44         dst = gr.vector_sink_b()
  45         self.tb.connect(op, dst)
  46
  47         self.tb.run()
  48
  49         self.assertEqual(expected_results, dst.data())
  50
  51     def test_002(self):
  52         """
  53         Test stream_to_streams.
  54         """
  55         src_data = (0x80,)
  56         expected_results = (0,0,0,0,0,0,0, 1)
  57         src = gr.vector_source_b(src_data,False)
  58         op = gr.packed_to_unpacked_bb(1, gr.GR_LSB_FIRST)
  59         self.tb.connect(src, op)
  60
  61         dst = gr.vector_sink_b()
  62         self.tb.connect(op, dst)
  63
  64         self.tb.run()
  65
  66         self.assertEqual(expected_results, dst.data())
  67
  68     def test_003(self):
  69         """
  70         Test stream_to_streams.
  71         """
  72         src_data = (0x11,)
  73         expected_results = (4, 2)
  74         src = gr.vector_source_b(src_data,False)
  75         op = gr.packed_to_unpacked_bb(3, gr.GR_LSB_FIRST)
  76         self.tb.connect(src, op)
  77
  78         dst = gr.vector_sink_b()
  79         self.tb.connect(op, dst)
  80
  81         self.tb.run()
  82
  83         self.assertEqual(expected_results, dst.data())
  84
  85     def test_004(self):
  86         """
  87         Test stream_to_streams.
  88         """
  89         src_data = (0x11,)
  90         expected_results = (0, 4)
  91         src = gr.vector_source_b(src_data,False)
  92         op = gr.packed_to_unpacked_bb(3, gr.GR_MSB_FIRST)
  93         self.tb.connect(src, op)
  94
  95         dst = gr.vector_sink_b()
  96         self.tb.connect(op, dst)
  97
  98         self.tb.run()
  99
 100         self.assertEqual(expected_results, dst.data())
 101
 102     def test_005(self):
 103         """
 104         Test stream_to_streams.
 105         """
 106         src_data = (1,0,0,0,0,0,1,0,0,1,0,1,1,0,1,0)
 107         expected_results =  (0x82,0x5a)
 108         src = gr.vector_source_b(src_data,False)
 109         op = gr.unpacked_to_packed_bb(1, gr.GR_MSB_FIRST)
 110         self.tb.connect(src, op)
 111
 112         dst = gr.vector_sink_b()
 113         self.tb.connect(op, dst)
 114
 115         self.tb.run()
 116
 117         self.assertEqual(expected_results, dst.data())
 118
 119     def test_006(self):
 120         """
 121         Test stream_to_streams.
 122         """
 123         src_data = (0,1,0,0,0,0,0,1,0,1,0,1,1,0,1,0)
 124         expected_results =  (0x82,0x5a)
 125         src = gr.vector_source_b(src_data,False)
 126         op = gr.unpacked_to_packed_bb(1, gr.GR_LSB_FIRST)
 127         self.tb.connect(src, op)
 128
 129         dst = gr.vector_sink_b()
 130         self.tb.connect(op, dst)
 131
 132         self.tb.run()
 133
 134         self.assertEqual(expected_results, dst.data())
 135
 136
 137     def test_007(self):
 138         """
 139         Test stream_to_streams.
 140         """
 141         src_data = (4, 2, 0,0,0)
 142         expected_results = (0x11,)
 143         src = gr.vector_source_b(src_data,False)
 144         op = gr.unpacked_to_packed_bb(3, gr.GR_LSB_FIRST)
 145         self.tb.connect(src, op)
 146
 147         dst = gr.vector_sink_b()
 148         self.tb.connect(op, dst)
 149
 150         self.tb.run()
 151
 152         self.assertEqual(expected_results, dst.data())
 153
 154     def test_008(self):
 155         """
 156         Test stream_to_streams.
 157         """
 158         src_data = (0, 4, 2,0,0)
 159         expected_results = (0x11,)
 160         src = gr.vector_source_b(src_data,False)
 161         op = gr.unpacked_to_packed_bb(3, gr.GR_MSB_FIRST)
 162         self.tb.connect(src, op)
 163
 164         dst = gr.vector_sink_b()
 165         self.tb.connect(op, dst)
 166
 167         self.tb.run()
 168
 169         self.assertEqual(expected_results, dst.data())
 170
 171     def test_009(self):
 172         """
 173         Test stream_to_streams.
 174         """
 175
 176         random.seed(0)
 177         src_data = []
 178         for i in xrange(202):
 179             src_data.append((random.randint(0,255)))
 180         src_data = tuple(src_data)
 181         expected_results = src_data
 182
 183         src = gr.vector_source_b(tuple(src_data),False)
 184         op1 = gr.packed_to_unpacked_bb(3, gr.GR_MSB_FIRST)
 185         op2 = gr.unpacked_to_packed_bb(3, gr.GR_MSB_FIRST)
 186         self.tb.connect(src, op1, op2)
 187
 188         dst = gr.vector_sink_b()
 189         self.tb.connect(op2, dst)
 190
 191         self.tb.run()
 192
 193         self.assertEqual(expected_results[0:201], dst.data())
 194
 195     def test_010(self):
 196         """
 197         Test stream_to_streams.
 198         """
 199
 200         random.seed(0)
 201         src_data = []
 202         for i in xrange(56):
 203             src_data.append((random.randint(0,255)))
 204         src_data = tuple(src_data)
 205         expected_results = src_data
 206         src = gr.vector_source_b(tuple(src_data),False)
 207         op1 = gr.packed_to_unpacked_bb(7, gr.GR_MSB_FIRST)
 208         op2 = gr.unpacked_to_packed_bb(7, gr.GR_MSB_FIRST)
 209         self.tb.connect(src, op1, op2)
 210         dst = gr.vector_sink_b()
 211         self.tb.connect(op2, dst)
 212
 213         self.tb.run()
 214         self.assertEqual(expected_results[0:201], dst.data())
 215
 216     def test_011(self):
 217         """
 218         Test stream_to_streams.
 219         """
 220
 221         random.seed(0)
 222         src_data = []
 223         for i in xrange(56):
 224             src_data.append((random.randint(0,255)))
 225         src_data = tuple(src_data)
 226         expected_results = src_data
 227         src = gr.vector_source_b(tuple(src_data),False)
 228         op1 = gr.packed_to_unpacked_bb(7, gr.GR_LSB_FIRST)
 229         op2 = gr.unpacked_to_packed_bb(7, gr.GR_LSB_FIRST)
 230         self.tb.connect(src, op1, op2)
 231         dst = gr.vector_sink_b()
 232         self.tb.connect(op2, dst)
 233
 234         self.tb.run()
 235         self.assertEqual(expected_results[0:201], dst.data())
 236
 237
 238     # tests on shorts
 239
 240     def test_100a(self):
 241         """
 242         test short version
 243         """
 244         random.seed(0)
 245         src_data = []
 246         for i in xrange(100):
 247             src_data.append((random.randint(-2**15,2**15-1)))
 248         src_data = tuple(src_data)
 249         expected_results = src_data
 250         src = gr.vector_source_s(tuple(src_data),False)
 251         op1 = gr.packed_to_unpacked_ss(1, gr.GR_MSB_FIRST)
 252         op2 = gr.unpacked_to_packed_ss(1, gr.GR_MSB_FIRST)
 253         self.tb.connect(src, op1, op2)
 254         dst = gr.vector_sink_s()
 255         self.tb.connect(op2, dst)
 256
 257         self.tb.run()
 258         self.assertEqual(expected_results, dst.data())
 259
 260     def test_100b(self):
 261         """
 262         test short version
 263         """
 264         random.seed(0)
 265         src_data = []
 266         for i in xrange(100):
 267             src_data.append((random.randint(-2**15,2**15-1)))
 268         src_data = tuple(src_data)
 269         expected_results = src_data
 270         src = gr.vector_source_s(tuple(src_data),False)
 271         op1 = gr.packed_to_unpacked_ss(1, gr.GR_LSB_FIRST)
 272         op2 = gr.unpacked_to_packed_ss(1, gr.GR_LSB_FIRST)
 273         self.tb.connect(src, op1, op2)
 274         dst = gr.vector_sink_s()
 275         self.tb.connect(op2, dst)
 276
 277         self.tb.run()
 278         self.assertEqual(expected_results, dst.data())
 279
 280     def test_101a(self):
 281         """
 282         test short version
 283         """
 284         random.seed(0)
 285         src_data = []
 286         for i in xrange(100):
 287             src_data.append((random.randint(-2**15,2**15-1)))
 288         src_data = tuple(src_data)
 289         expected_results = src_data
 290         src = gr.vector_source_s(tuple(src_data),False)
 291         op1 = gr.packed_to_unpacked_ss(8, gr.GR_MSB_FIRST)
 292         op2 = gr.unpacked_to_packed_ss(8, gr.GR_MSB_FIRST)
 293         self.tb.connect(src, op1, op2)
 294         dst = gr.vector_sink_s()
 295         self.tb.connect(op2, dst)
 296
 297         self.tb.run()
 298         self.assertEqual(expected_results, dst.data())
 299
 300     def test_101b(self):
 301         """
 302         test short version
 303         """
 304         random.seed(0)
 305         src_data = []
 306         for i in xrange(100):
 307             src_data.append((random.randint(-2**15,2**15-1)))
 308         src_data = tuple(src_data)
 309         expected_results = src_data
 310         src = gr.vector_source_s(tuple(src_data),False)
 311         op1 = gr.packed_to_unpacked_ss(8, gr.GR_LSB_FIRST)
 312         op2 = gr.unpacked_to_packed_ss(8, gr.GR_LSB_FIRST)
 313         self.tb.connect(src, op1, op2)
 314         dst = gr.vector_sink_s()
 315         self.tb.connect(op2, dst)
 316
 317         self.tb.run()
 318         self.assertEqual(expected_results, dst.data())
 319
 320     # tests on ints
 321
 322     def test_200a(self):
 323         """
 324         test int version
 325         """
 326         random.seed(0)
 327         src_data = []
 328         for i in xrange(100):
 329             src_data.append((random.randint(-2**31,2**31-1)))
 330         src_data = tuple(src_data)
 331         expected_results = src_data
 332         src = gr.vector_source_i(tuple(src_data),False)
 333         op1 = gr.packed_to_unpacked_ii(1, gr.GR_MSB_FIRST)
 334         op2 = gr.unpacked_to_packed_ii(1, gr.GR_MSB_FIRST)
 335         self.tb.connect(src, op1, op2)
 336         dst = gr.vector_sink_i()
 337         self.tb.connect(op2, dst)
 338
 339         self.tb.run()
 340         self.assertEqual(expected_results, dst.data())
 341
 342     def test_200b(self):
 343         """
 344         test int version
 345         """
 346         random.seed(0)
 347         src_data = []
 348         for i in xrange(100):
 349             src_data.append((random.randint(-2**31,2**31-1)))
 350         src_data = tuple(src_data)
 351         expected_results = src_data
 352         src = gr.vector_source_i(tuple(src_data),False)
 353         op1 = gr.packed_to_unpacked_ii(1, gr.GR_LSB_FIRST)
 354         op2 = gr.unpacked_to_packed_ii(1, gr.GR_LSB_FIRST)
 355         self.tb.connect(src, op1, op2)
 356         dst = gr.vector_sink_i()
 357         self.tb.connect(op2, dst)
 358
 359         self.tb.run()
 360         self.assertEqual(expected_results, dst.data())
 361
 362     def test_201a(self):
 363         """
 364         test int version
 365         """
 366         random.seed(0)
 367         src_data = []
 368         for i in xrange(100):
 369             src_data.append((random.randint(-2**31,2**31-1)))
 370         src_data = tuple(src_data)
 371         expected_results = src_data
 372         src = gr.vector_source_i(tuple(src_data),False)
 373         op1 = gr.packed_to_unpacked_ii(8, gr.GR_MSB_FIRST)
 374         op2 = gr.unpacked_to_packed_ii(8, gr.GR_MSB_FIRST)
 375         self.tb.connect(src, op1, op2)
 376         dst = gr.vector_sink_i()
 377         self.tb.connect(op2, dst)
 378
 379         self.tb.run()
 380         self.assertEqual(expected_results, dst.data())
 381
 382     def test_201b(self):
 383         """
 384         test int version
 385         """
 386         random.seed(0)
 387         src_data = []
 388         for i in xrange(100):
 389             src_data.append((random.randint(-2**31,2**31-1)))
 390         src_data = tuple(src_data)
 391         expected_results = src_data
 392         src = gr.vector_source_i(tuple(src_data),False)
 393         op1 = gr.packed_to_unpacked_ii(8, gr.GR_LSB_FIRST)
 394         op2 = gr.unpacked_to_packed_ii(8, gr.GR_LSB_FIRST)
 395         self.tb.connect(src, op1, op2)
 396         dst = gr.vector_sink_i()
 397         self.tb.connect(op2, dst)
 398
 399         self.tb.run()
 400         self.assertEqual(expected_results, dst.data())
 401
 402
 403 if __name__ == '__main__':
 404    gr_unittest.main ()
 405