class qa_threshold_to_message (gr_unittest.TestCase): def setUp (self): self.tb = gr.top_block () self.pdf = Pdf_class(self.id().split(".")[1]) def tearDown (self): self.tb = None self.pdf.finalize_pdf() def test_001_t (self): """test_001_t: without repetition""" print('do you see me?') data_src = (-1, 1, -1, 1, 1, -1, -1, 1, -1, 1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, -1, 1, -1, 1, -1, 1, -1, 1, 1, -1, -1, 1, 1, -1) expected_data = (0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1) data_out = test_spl(self, data_src) plot(self, data_out, data_src) self.assertAlmostEqual(data_out, expected_data) print ("- Data correctly encoded.") if __name__ == '__main__': suite = gr_unittest.TestLoader().loadTestsFromTestCase(qa_threshold_to_message) runner = runner.HTMLTestRunner(output='../TestResults', template='DEFAULT_TEMPLATE_3') runner.run(suite) #gr_unittest.TestProgram()
class qa_fixed_point_math (gr_unittest.TestCase): def setUp (self): self.tb = gr.top_block () def tearDown (self): self.tb = None def test_001_t (self): """test_001_t: fractional""" src_data = np.arange(-2, 2, 0.01) expected_result = (-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0,-1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -1.0, -0.9375, -0.9375, -0.9375, -0.9375, -0.9375, -0.9375, -0.875, -0.875, -0.875, -0.875, -0.875, -0.875, -0.8125, -0.8125, -0.8125, -0.8125, -0.8125, -0.8125, -0.75, -0.75, -0.75, -0.75, -0.75, -0.75, -0.75, -0.6875, -0.6875, -0.6875, -0.6875, -0.6875, -0.6875, -0.625, -0.625, -0.625, -0.625, -0.625, -0.625, -0.5625, -0.5625, -0.5625, -0.5625, -0.5625, -0.5625, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.5, -0.4375, -0.4375, -0.4375, -0.4375, -0.4375, -0.4375, -0.375, -0.375, -0.375, -0.375, -0.375, -0.375, -0.3125, -0.3125, -0.3125, -0.3125, -0.3125, -0.3125, -0.25, -0.25, -0.25, -0.25, -0.25, -0.25, -0.25, -0.1875, -0.1875, -0.1875, -0.1875, -0.1875, -0.1875, -0.125, -0.125, -0.125, -0.125, -0.125, -0.125, -0.0625, -0.0625, -0.0625, -0.0625, -0.0625, -0.0625, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0625, 0.0625, 0.0625, 0.0625, 0.0625, 0.0625, 0.125, 0.125, 0.125, 0.125, 0.125, 0.125, 0.1875, 0.1875, 0.1875, 0.1875, 0.1875, 0.1875, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.3125, 0.3125, 0.3125, 0.3125, 0.3125, 0.3125, 0.375, 0.375, 0.375, 0.375, 0.375, 0.375, 0.4375, 0.4375, 0.4375, 0.4375, 0.4375, 0.4375, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.5625, 0.625, 0.625, 0.625, 0.625, 0.625, 0.625, 0.6875, 0.6875, 0.6875, 0.6875, 0.6875, 0.6875, 0.75, 0.75, 0.75, 0.75, 0.75, 0.75, 0.75, 0.8125, 0.8125, 0.8125, 0.8125, 0.8125, 0.8125, 0.875, 0.875, 0.875, 0.875, 0.875, 0.875, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375,0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375, 0.9375) src = blocks.vector_source_f(src_data) dst = blocks.vector_sink_f() fixed_point_math_conv = flaress.fixed_point_math_ff(1, 1, 4) self.tb.connect(src, fixed_point_math_conv, dst) self.tb.run() result_data = dst.data() # print result_data self.assertEqual(expected_result, result_data) if __name__ == '__main__': suite = gr_unittest.TestLoader().loadTestsFromTestCase(qa_fixed_point_math) runner = runner.HTMLTestRunner(output='../TestResults',template='DEFAULT_TEMPLATE_1') runner.run(suite) gr_unittest.TestProgram()
"""test_002_t: precision test""" param = namedtuple('param', 'samp_rate items N min_value max_value') param.N = 4 param.samp_rate = 4096 * 4 param.items = param.samp_rate / 2 param.max_value = 2 * math.pi param.min_value = -2 * math.pi print_parameters(param) data_pc = test_ramp(self, param) plot(self,data_pc) src_slope = (param.max_value - param.min_value) / param.items pc_min_step, pc_slope = check_integer_phase(data_pc.out, param.N , param.items) precision = math.pow(2,(- (param.N - 1))) * math.pi self.assertGreaterEqual(pc_min_step, precision) self.assertAlmostEqual(pc_slope, src_slope, 5) print ("-Output Slope : %f rad/s;" % (pc_slope * param.samp_rate)) print ("-Output Min step : %f rad." % pc_min_step) if __name__ == '__main__': suite = gr_unittest.TestLoader().loadTestsFromTestCase(qa_phase_converter) runner = runner.HTMLTestRunner(output='Results', template='DEFAULT_TEMPLATE_3') runner.run(suite) #gr_unittest.TestProgram()
) param.f_central = 0 param.bw = 1000 param.average = False param.cutoff = 1000 param.samp_rate = 4096 * 8 param.items = param.samp_rate param.freq = 0 param.threshold = 10 param.noise = 1 param.fft_size = 4096 param.decimation = 1 print_parameters(param) data_sine = test_sine(self, param) self.assertGreaterEqual(len(data_sine.src), len(data_sine.out)) self.assertGreater(len(data_sine.out), 0) self.assertGreaterEqual(len(data_sine.tags), 1) if __name__ == '__main__': suite = gr_unittest.TestLoader().loadTestsFromTestCase( qa_signal_search_fft_v) runner = runner.HTMLTestRunner(output='Results', template='DEFAULT_TEMPLATE_2') runner.run(suite) #gr_unittest.TestProgram()
result_data = dst.data() # print result_data self.assertEqual(expected_result, result_data) def test_002_t(self): """test_002_t: long input""" src_data = np.arange(-10, 10, 1) expected_result = (-8, -8, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 7, 7) src = flaress.vector_source_int64(src_data) dst = flaress.vector_sink_int64() integer_point_math_conv = flaress.integer_math_ll(1, 4) self.tb.connect(src, integer_point_math_conv, dst) self.tb.run() result_data = dst.data() # print result_data self.assertEqual(expected_result, result_data) if __name__ == '__main__': suite = gr_unittest.TestLoader().loadTestsFromTestCase(qa_integer_math) runner = runner.HTMLTestRunner(output='Results', template='DEFAULT_TEMPLATE_1') runner.run(suite) gr_unittest.TestProgram()
result_data = dst.data() self.assertEqual(expected_result, result_data) 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) if __name__ == '__main__': suite = gr_unittest.TestLoader().loadTestsFromTestCase(qa_add_const_xx) runner = runner.HTMLTestRunner(output='../TestResults', template='DEFAULT_TEMPLATE_1') runner.run(suite) #gr_unittest.TestProgram()
throttle = blocks.throttle(gr.sizeof_float*1, samp_rate,True) head = blocks.head(gr.sizeof_float, int (items)) # throttle.set_max_noutput_items (samp_rate) # throttle.set_min_noutput_items (samp_rate) tb.connect(src, throttle) tb.connect(throttle, head) tb.connect(head, debug) _probe_func_thread.start() tb.run() data = debug.data() self.assertEqual(len(data), 2) self.assertLessEqual(data[0], samp_rate * 2) self.assertGreaterEqual(data[0], samp_rate) self.assertLessEqual(data[1], samp_rate * 3) self.assertGreaterEqual(data[1], samp_rate * 2) print ("-Set function received at the moment: %f s." % (data[0] * (1.0 / samp_rate))) print ("-Set function received at the moment: %f s." % (data[1] * (1.0 / samp_rate))) if __name__ == '__main__': suite = gr_unittest.TestLoader().loadTestsFromTestCase(qa_debug_func_probe) runner = runner.HTMLTestRunner(output='../TestResults',template='DEFAULT_TEMPLATE_1') runner.run(suite) gr_unittest.TestProgram()
print_parameters(param) data_pe, data_fft = test_accumulator_gain(self, param) plot(self, data_pe) plot_fft(self, data_fft) phase = check_phase( data_pe.out[1:]) #to consider the delay of gain phase accumulator #check frequency self.assertAlmostEqual(((param.freq * param.downlink / param.uplink) * (2 * math.pi) / param.samp_rate), np.mean(phase)) print "-Frequency measured= %f Hz;" % (np.mean(phase) / (2 * math.pi) * param.samp_rate) #check phase error self.assertAlmostEqual(np.var(phase), 0) print "-No phase jump found." if __name__ == '__main__': suite = gr_unittest.TestLoader().loadTestsFromTestCase( qa_coherent_phase_modulator) runner = runner.HTMLTestRunner(output='Results', template='DEFAULT_TEMPLATE_2') runner.run(suite) # gr_unittest.TestProgram()
def test_002_double_2(self): """test_002_double_2: multiply 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.multiply_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) if __name__ == '__main__': suite = gr_unittest.TestLoader().loadTestsFromTestCase( qa_multiply_const_xx) runner = runner.HTMLTestRunner(output='../TestResults', template='DEFAULT_TEMPLATE_1') runner.run(suite) gr_unittest.TestProgram()
stdout = p.communicate()[0] log.debug(stdout) # Should fail only on the last iteration of the loop try: self.assertEqual(stdout.count("Got event code underflow message."), 1, "TX underflows could not be requested async") except AssertionError, e: self.failures.append(str(e)) pass finally: timer.cancel() if __name__ == '__main__': crimson_test_suite = gr_unittest.TestSuite() # Flag for test development IS_DEV = False if IS_DEV: # Runs only the specified test in isolation crimson_test_suite.addTest(qa_crimson_loopback('test_000_t')) else: crimson_test_suite = gr_unittest.TestLoader().loadTestsFromTestCase(qa_crimson_loopback) print "Test results availible in test_results.log" #gr_unittest.TextTestRunner(verbosity=2).run(crimson_test_suite) gr_unittest.TextTestRunner().run(crimson_test_suite)
"""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) if __name__ == '__main__': suite = gr_unittest.TestLoader().loadTestsFromTestCase(qa_divide_xx) runner = runner.HTMLTestRunner(output='Results', template='DEFAULT_TEMPLATE_1') runner.run(suite) gr_unittest.TestProgram()
self.tb.connect(src, conv, dst) self.tb.run() result_data = dst.data() self.assertEqual(expected_result, result_data) def test_005(self): """test_005: set_repeat""" src_data = [int(x) for x in range(16)] src_data_int = [int(x) for x in range(16)] expected_result = tuple(src_data_int) src = blocks.vector_source_i(src_data, True) dst = flaress.vector_sink_int64() src.set_repeat(False) conv = flaress.int_to_int64() self.tb.connect(src, conv, dst) # will timeout if set_repeat does not work self.tb.run() result_data = dst.data() self.assertEqual(expected_result, result_data) if __name__ == '__main__': suite = gr_unittest.TestLoader().loadTestsFromTestCase(qa_int_to_int64) runner = runner.HTMLTestRunner(output='Results', template='DEFAULT_TEMPLATE_1') runner.run(suite) gr_unittest.TestProgram()
conv = flaress.float_to_int64() self.tb.connect(src, conv, dst) self.tb.run() result_data = dst.data() self.assertEqual(expected_result, result_data) def test_005(self): """test_005: set_repeat""" src_data = [float(x) for x in range(16)] expected_result = tuple(src_data) src = blocks.vector_source_f(src_data, True) dst = flaress.vector_sink_int64() src.set_repeat(False) conv = flaress.float_to_int64() self.tb.connect(src, conv, dst) # will timeout if set_repeat does not work self.tb.run() result_data = dst.data() self.assertEqual(expected_result, result_data) if __name__ == '__main__': suite = gr_unittest.TestLoader().loadTestsFromTestCase(qa_float_to_double) runner = runner.HTMLTestRunner(output='../TestResults', template='DEFAULT_TEMPLATE_1') runner.run(suite) gr_unittest.TestProgram()
adder = blocks.add_vcc(1) tb.connect(src, (adder, 1)) tb.connect(noise, (adder, 0)) tb.connect(src, bpf_signal) tb.connect(bpf_signal, dst_src) tb.connect(noise, bpf_noise) tb.connect(bpf_noise, dst_noise) tb.connect(adder, head1) tb.connect(head1, snr) tb.connect(snr, dst_out) tb.run() data_src = dst_src.data() data_noise = dst_noise.data() # data_input = dst_input.data() data_out = dst_out.data() print("SNR evaluated variance:", 10 * math.log10(np.var(data_src) / np.var(data_noise))) print("SNR estimated:", np.mean(data_out)) if __name__ == '__main__': suite = gr_unittest.TestLoader().loadTestsFromTestCase(qa_snr_estimator) runner = runner.HTMLTestRunner(output='Results', template='DEFAULT_TEMPLATE_2') runner.run(suite) #gr_unittest.TestProgram()
print_parameters(param) time_error_measure = 0.05 error = 0.05 data_sine = test_sine(self, param) data_transient = transient_evaluation(self, data_sine, param, error, time_error_measure) self.assertLessEqual(data_transient.settling_time, 100) self.assertGreaterEqual(data_transient.settling_time, 10) self.assertEqual(data_transient.stable_start, True) self.assertLessEqual(data_transient.error_percentage_mean_start, (error + param.noise) * 100) self.assertLessEqual(data_transient.error_percentage_mean_end, (error + param.noise) * 100) print("-Settling time: %.3f ms" % data_transient.settling_time) print("-Output error after swing: %.3f%%" % data_transient.error_percentage_mean_start) print("-Output error before swing: %.3f%%" % data_transient.error_percentage_mean_end) if __name__ == '__main__': suite = gr_unittest.TestLoader().loadTestsFromTestCase(qa_agc) runner = runner.HTMLTestRunner(output='../TestResults', template='DEFAULT_TEMPLATE_3') runner.run(suite) #gr_unittest.TestProgram()
print( "-Set function received at the moment (of the simulation): %.2f s;" % (switch[0] * (1.0 / param.samp_rate))) #check the value after reset self.assertEqual(data_gain.src[switch[0]], data_gain.out[switch[0]]) #check slope src_min_step, src_slope = check_integer_phase(data_gain.src, param.N, 10) gain_min_step, gain_slope = check_integer_phase( data_gain.out, param.N, 10) tar = (param.downlink * 1.0 / param.uplink) #turn around ratio self.assertAlmostEqual((tar * src_slope), gain_slope, 2) self.assertAlmostEqual((tar * src_min_step), gain_min_step, 2) print("-Input Slope : %f rad/s;" % (src_slope * param.samp_rate)) print("-Input Min step : %f rad;" % src_min_step) print("-Turn Around Ration : %f;" % tar) print("-Output Slope : %f rad/s;" % (gain_slope * param.samp_rate)) print("-Output Min step : %f rad." % gain_min_step) if __name__ == '__main__': suite = gr_unittest.TestLoader().loadTestsFromTestCase( qa_gain_phase_accumulator) runner = runner.HTMLTestRunner(output='Results', template='DEFAULT_TEMPLATE_3') runner.run(suite) #gr_unittest.TestProgram()
param.t1, param.t2, param.samp_rate) print("Coefficents: ") print((loop_filter_3rd_order)) reference = (4.542760205688479, 0.013480000495910645, 1.0000000447034852e-05) self.assertEqual(loop_filter_3rd_order, reference) def test_003_t (self): """test_003_t: test 3rd order coefficient generation with unstable time constants""" param = namedtuple('param', 'order samp_rate natural_freq t1 t2') param.order = "3rd" param.samp_rate = 200000 param.natural_freq = 10 param.t1 = 0.01 param.t2 = 0.00674 to_print = "/pr!Order: %s<br> Sample Rate: %d<br> Natural Frequency: %.0f Hz<br> Time constant 1: %.3f s<br> Time constant 2: %.3f s<br>/pr!" \ %(param.order, param.samp_rate, param.natural_freq, param.t1, param.t2) print (to_print) self.assertRaises(RuntimeError, ecss.loop_filter.coefficients3rdorder, param.natural_freq, param.t1, param.t2, param.samp_rate) print("RuntimeError raised") if __name__ == '__main__': suite = gr_unittest.TestLoader().loadTestsFromTestCase(qa_loop_filter) runner = runner.HTMLTestRunner(output='../TestResults', template='DEFAULT_TEMPLATE_3') runner.run(suite) #gr_unittest.TestProgram()
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_007(self): """test_007: set_repeat""" src_data = [int(x) for x in range(16)] expected_result = tuple(src_data) src = flaress.vector_source_int64(src_data, True) dst = flaress.vector_sink_int64() 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) if __name__ == '__main__': suite = gr_unittest.TestLoader().loadTestsFromTestCase( qa_vector_sink_source_int64) runner = runner.HTMLTestRunner(output='../TestResults', template='DEFAULT_TEMPLATE_1') runner.run(suite) gr_unittest.TestProgram()
blocks_file_source_0 = blocks.file_source( gr.sizeof_float * 1, os.path.join(srcdir, "test_files", "phase_error_PLL_datasw150kHz_swr32kHz-s_tc4kbps_mi"), False) blocks_file_source_0.set_begin_tag(pmt.PMT_NIL) dst_output = blocks.vector_sink_f() ################################################## # Connections ################################################## tb.connect((blocks_file_source_0, 0), (blocks_throttle_0, 0)) tb.connect((blocks_throttle_0, 0), (dst_output, 0)) self.tb.run() data.phase_output = dst_output.data() data.time = np.linspace(0, (len(data.phase_output) * 1.0 / samp_rate), len(data.phase_output), endpoint=False) plot(self, data) if __name__ == '__main__': suite = gr_unittest.TestLoader().loadTestsFromTestCase(qa_demodulator) runner = runner.HTMLTestRunner(output='Results', template='DEFAULT_TEMPLATE_3') runner.run(suite) #gr_unittest.TestProgram()
head = blocks.head(flaress.sizeof_long, 100) dst = flaress.null_sink(flaress.sizeof_long) self.tb.connect(src, head, dst) self.tb.run() def test_006(self): """test_006: with Float64 (Double)""" src = flaress.null_source(gr.sizeof_double) head = blocks.head(gr.sizeof_double, 100) dst = flaress.null_sink(gr.sizeof_double) self.tb.connect(src, head, dst) self.tb.run() def test_007(self): """test_007: with Complex""" src = flaress.null_source(gr.sizeof_gr_complex) head = blocks.head(gr.sizeof_gr_complex, 100) dst = flaress.null_sink(gr.sizeof_gr_complex) self.tb.connect(src, head, dst) self.tb.run() if __name__ == '__main__': suite = gr_unittest.TestLoader().loadTestsFromTestCase(qa_null_source_sink) runner = runner.HTMLTestRunner(output='Results', template='DEFAULT_TEMPLATE_1') runner.run(suite) gr_unittest.TestProgram()
step_phase = 3.0 frequency = step_phase * samp_rate / (2 * math.pi) # Blocks sine_debug_0 = sine_debug() dst_out = blocks.vector_sink_f() head = blocks.head(gr.sizeof_gr_complex, items) sig_source = analog.sig_source_c(samp_rate, analog.GR_COS_WAVE, frequency, 1, 0) # Connections tb.connect(sig_source, head) tb.connect(head, sine_debug_0) tb.connect(sine_debug_0, dst_out) self.tb.run() result_data = dst_out.data() self.assertAlmostEqual(np.mean(result_data), step_phase, 4) self.assertAlmostEqual(np.var(result_data), 0, 3) print(np.mean(result_data), np.var(result_data)) if __name__ == '__main__': suite = gr_unittest.TestLoader().loadTestsFromTestCase(qa_sine_debug) runner = runner.HTMLTestRunner(output='Results', template='DEFAULT_TEMPLATE_1') runner.run(suite) gr_unittest.TestProgram()
tb.connect((blocks_complex_to_arg_0, 0), (dst_output, 0)) self.tb.run() data_tar.phase_source = dst_source.data() data_tar.phase_output = dst_output.data() data_tar.tar = dst_tar.data() data_tar.time = np.linspace( 0, (len(data_tar.phase_output) * 1.0 / samp_rate), len(data_tar.phase_output), endpoint=False) print(len(data_tar.phase_output), len(data_tar.phase_source)) # for i in range(len(data_tar.phase_output)): # if data_tar.phase_output[i] != 0: # print i # break plot(self, data_tar) # self.assertAlmostEqual(np.mean(data_tar.tar[127000:]), (240.0/221.0),6) # self.assertAlmostEqual(np.var(data_tar.tar[127000:]), 0.0) if __name__ == '__main__': suite = gr_unittest.TestLoader().loadTestsFromTestCase(qa_validation_test) runner = runner.HTMLTestRunner(output='Results', template='DEFAULT_TEMPLATE_3') runner.run(suite) #gr_unittest.TestProgram()
self.assertFloatTuplesAlmostEqual(data_out, expected_data) print ("- Data correctly encoded.") def test_006_t (self): """test_006_t: square wave with data""" param = namedtuple('param', 'data_src bit_rate samp_rate sine freq_sub') param.bit_rate = 1024 param.samp_rate = 4096 * 32 param.sine = False param.freq_sub = 256 param.data_src = (0,0,1,0,0,0,1,0,1,0,1,1,1,1,1,0,0,0,0,1,0,1) expected_data = (-1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1) print_parameters(param) data_out = test_nrlz(self, param) plot(self, data_out, param.data_src) self.assertFloatTuplesAlmostEqual(data_out, expected_data) print ("- Data correctly encoded.") if __name__ == '__main__': suite = gr_unittest.TestLoader().loadTestsFromTestCase(qa_nrzl_encoder_subcarrier) runner = runner.HTMLTestRunner(output='Results', template='DEFAULT_TEMPLATE_3') runner.run(suite) # gr_unittest.TestProgram()
'samp_rate items frequency amplitude offset magnitude phase origin' ) param.samp_rate = 2048 param.items = param.samp_rate param.frequency = 50.0 param.amplitude = 1.0 param.offset = 0.0 param.magnitude = 10.0 param.phase = -10.0 param.origin = "TX" print_parameters(param) data = test_imbalance(self, param) all_images = plot(self, data) print_all_images(all_images) # i,j = np.unravel_index(data.corr.argmax(), data.corr.shape) #get the index of the maximum value of correlation # # self.assertAlmostEqual(param.step / (2 * math.pi), data_fft.carrier) # print "Time shifting= %.3f ms;" %(data.time_corr[i]*1000) if __name__ == '__main__': suite = gr_unittest.TestLoader().loadTestsFromTestCase(qa_iqbal_gen) runner = runner.HTMLTestRunner(output='Results', template='DEFAULT_TEMPLATE_3') runner.run(suite) #gr_unittest.TestProgram()
def setUp(self): self.tb = gr.top_block() self.pdf = Pdf_class(self.id().split(".")[1]) def tearDown(self): self.tb = None self.pdf.finalize_pdf() def test_001_t(self): """test_001_t: without repetition""" data_src = (-1, 1, -1, 1, 1, -1, -1, 1, -1, 1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1, -1, 1, -1, 1, -1, 1, -1, 1, 1, -1, -1, 1, 1, -1) expected_data = (0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1) data_out = test_spl(self, data_src) plot(self, data_out, data_src) self.assertAlmostEqual(data_out, expected_data) print "- Data correctly encoded." if __name__ == '__main__': suite = gr_unittest.TestLoader().loadTestsFromTestCase(qa_spl_decoder) runner = runner.HTMLTestRunner(output='Results', template='DEFAULT_TEMPLATE_1') runner.run(suite) #gr_unittest.TestProgram()
sig_source1 = blocks.vector_source_c(src_data, repeat=False, tags=src_tags1) # Connections tb.connect(sig_source0, (flaress_selector, 0)) tb.connect(sig_source1, (flaress_selector, 1)) tb.connect(flaress_selector, dst_out) self.tb.run() result_data = dst_out.data() result_tags = dst_out.tags() self.assertFloatTuplesAlmostEqual(expected_result, result_data) self.assertEqual(len(result_tags), 4) self.assertTrue(compare_tags(expected_tags[0], result_tags[0])) self.assertTrue(compare_tags(expected_tags[1], result_tags[1])) self.assertTrue(compare_tags(expected_tags[2], result_tags[2])) self.assertTrue(compare_tags(expected_tags[3], result_tags[3])) print("- Tag received properly") if __name__ == '__main__': suite = gr_unittest.TestLoader().loadTestsFromTestCase(qa_selector) runner = runner.HTMLTestRunner(output='Results', template='DEFAULT_TEMPLATE_2') runner.run(suite) #gr_unittest.TestProgram()