class DemodulatorTester(object): """ Set up an environment for testing a demodulator and do some fundamental tests. """ def __init__(self, mode, state=None): # TODO: Refactor things so that we can take the demod ctor rather than a mode string if state is None: state = {} mode_def = lookup_mode(mode) if mode_def is None: raise Exception('No such mode is registered: ' + repr(mode)) # TODO: Tell the simulated device to have no modulators, or have a simpler dummy source for testing, so we don't waste time on setup self.__top = Top(devices={'s1': SimulatedDevice()}) (_, receiver) = self.__top.add_receiver(mode, key='a', state=state) self.__demodulator = receiver.get_demodulator() if not isinstance(self.__demodulator, mode_def.demod_class): raise Exception('Demodulator not of expected class: ' + repr(self.__demodulator)) self.__top.start() # TODO overriding internals def close(self): if self.__top is not None: self.__top.stop() self.__top = None def __enter__(self): state_smoke_test(self.__demodulator) def __exit__(self, exc_type, exc_value, traceback): self.close()
def test_auto_retune(self): # pylint: disable=no-member f1 = 50e6 # avoid 100e6 because that's a default a couple of places dev = simulate.SimulatedDevice(freq=f1, allow_tuning=True) bandwidth = dev.get_rx_driver().get_output_type().get_sample_rate() top = Top(devices={'s1': dev}) (_key, receiver) = top.add_receiver('AM', key='a') # initial state check receiver.set_rec_freq(f1) self.assertEqual(dev.get_freq(), f1) # one "page" up f2 = f1 + bandwidth * 3/4 receiver.set_rec_freq(f2) self.assertEqual(dev.get_freq(), f1 + bandwidth) # must wait for tune_delay, which is 0 for simulated source, or it will look still-valid yield deferLater(the_reactor, 0.1, lambda: None) # one "page" down receiver.set_rec_freq(f1) self.assertEqual(dev.get_freq(), f1) yield deferLater(the_reactor, 0.1, lambda: None) # long hop receiver.set_rec_freq(200e6) self.assertEqual(dev.get_freq(), 200e6)
def __init__(self, devices, audio_config, features): self.__receive_flowgraph = Top(devices=devices, audio_config=audio_config, features=features) # TODO: only one session while we sort out other things self.__session = Session(receive_flowgraph=self.__receive_flowgraph, features=features)
class DemodulatorTester(object): ''' Set up an environment for testing a demodulator and do some fundamental tests. ''' def __init__(self, mode, state=None): # TODO: Refactor things so that we can take the demod ctor rather than a mode string if state is None: state = {} mode_def = lookup_mode(mode) if mode_def is None: raise Exception('No such mode is registered: ' + repr(mode)) # TODO: Tell the simulated device to have no modulators, or have a simpler dummy source for testing, so we don't waste time on setup self.__top = Top(devices={'s1': SimulatedDevice()}) (_, receiver) = self.__top.add_receiver(mode, key='a', state=state) self.__demodulator = receiver.get_demodulator() if not isinstance(self.__demodulator, mode_def.demod_class): raise Exception('Demodulator not of expected class: ' + repr(self.__demodulator)) self.__top.start() # TODO overriding internals def close(self): if self.__top is not None: self.__top.stop() self.__top = None def __enter__(self): state_smoke_test(self.__demodulator) def __exit__(self, exc_type, exc_value, traceback): self.close()
class AppRoot(ExportedState): def __init__(self, devices, audio_config, features): self.__receive_flowgraph = Top( devices=devices, audio_config=audio_config, features=features) # TODO: only one session while we sort out other things self.__session = Session( receive_flowgraph=self.__receive_flowgraph, features=features) @exported_block() def get_receive_flowgraph(self): # TODO needs to go away return self.__receive_flowgraph @exported_block(persists=True) def get_devices(self): """Return all existant devices. This exists only for persistence purposes. """ return self.__receive_flowgraph.get_sources() # TODO: should become something more like 'create new session' def get_session(self): return self.__session def close_all_devices(self): self.__receive_flowgraph.close_all_devices()
def test_add_unknown_mode(self): ''' Specifying an unknown mode should not _fail_. ''' top = Top(devices={'s1': simulate.SimulatedDevice(freq=0)}) (_key, receiver) = top.add_receiver('NONSENSE', key='a') self.assertEqual(receiver.get_mode(), 'AM')
class AppRoot(ExportedState): def __init__(self, devices, audio_config, features): self.__receive_flowgraph = Top(devices=devices, audio_config=audio_config, features=features) # TODO: only one session while we sort out other things self.__session = Session(receive_flowgraph=self.__receive_flowgraph, features=features) @exported_block() def get_receive_flowgraph(self): # TODO needs to go away return self.__receive_flowgraph @exported_block(persists=True) def get_devices(self): """Return all existant devices. This exists only for persistence purposes. """ return self.__receive_flowgraph.get_sources() # TODO: should become something more like 'create new session' def get_session(self): return self.__session def close_all_devices(self): self.__receive_flowgraph.close_all_devices()
def test_auto_retune(self): f1 = 50e6 # avoid 100e6 because that's a default a couple of places dev = simulate.SimulatedDevice(freq=f1, allow_tuning=True) bandwidth = dev.get_rx_driver().get_output_type().get_sample_rate() top = Top(devices={'s1': dev}) (_key, receiver) = top.add_receiver('AM', key='a') # initial state check receiver.set_rec_freq(f1) self.assertEqual(dev.get_freq(), f1) # one "page" up f2 = f1 + bandwidth * 3 / 4 receiver.set_rec_freq(f2) self.assertEqual(dev.get_freq(), f1 + bandwidth) # must wait for tune_delay, which is 0 for simulated source, or it will look still-valid yield deferLater(the_reactor, 0.1, lambda: None) # one "page" down receiver.set_rec_freq(f1) self.assertEqual(dev.get_freq(), f1) yield deferLater(the_reactor, 0.1, lambda: None) # long hop receiver.set_rec_freq(200e6) self.assertEqual(dev.get_freq(), 200e6)
def test_monitor_vfo_change(self): freq1 = 1e6 freq2 = 2e6 dev = simulate.SimulatedDevice(freq=freq1, allow_tuning=True) top = Top(devices={'s1': dev}) self.assertEqual(top.state()['monitor'].get().get_fft_info()[0], freq1) dev.set_freq(freq2) yield deferLater(the_reactor, 0.1, lambda: None) # wait for tune delay self.assertEqual(top.state()['monitor'].get().get_fft_info()[0], freq2)
def test_close(self): l = set() top = Top(devices={'m': Device( rx_driver=ShutdownMockDriver(l, 'rx'), tx_driver=ShutdownMockDriver(l, 'tx'), components={'c': ShutdownMockDriver(l, 'c')})}) top.close_all_devices() # TODO: Add support for closing non-driver components (making this set [rx,tx,c]). self.assertEqual(l, set(['rx', 'tx']))
def test_mono(self): top = Top(devices={'s1': simulate.SimulatedDevice(freq=0)}, stereo=False) queue = gr.msg_queue() (_key, _receiver) = top.add_receiver('AM', key='a') top.set_unpaused(True) # there should be an attempted start top.add_audio_queue(queue, 48000) top.remove_audio_queue(queue)
def test_close(self): l = [] top = Top( devices={ 'm': merge_devices([ simulate.SimulatedDevice(), Device(components={'c': _DeviceShutdownDetector(l)}) ]) }) top.close_all_devices() self.assertEqual(l, ['close'])
def test_close(self): l = set() top = Top( devices={ 'm': Device(rx_driver=ShutdownMockDriver(l, 'rx'), tx_driver=ShutdownMockDriver(l, 'tx'), components={'c': ShutdownMockDriver(l, 'c')}) }) top.close_all_devices() # TODO: Add support for closing non-driver components (making this set [rx,tx,c]). self.assertEqual(l, set(['rx', 'tx']))
def __init__(self, mode, state=None): # TODO: Refactor things so that we can take the demod ctor rather than a mode string if state is None: state = {} mode_def = lookup_mode(mode) if mode_def is None: raise Exception('No such mode is registered: ' + repr(mode)) # TODO: Tell the simulated device to have no modulators, or have a simpler dummy source for testing, so we don't waste time on setup self.__top = Top(devices={'s1': SimulatedDevice()}) (_, receiver) = self.__top.add_receiver(mode, key='a', state=state) self.__demodulator = receiver.get_demodulator() if not isinstance(self.__demodulator, mode_def.demod_class): raise Exception('Demodulator not of expected class: ' + repr(self.__demodulator)) self.__top.start() # TODO overriding internals
def test_receiver_device_default(self): ''' Receiver should default to the monitor device, not other receiver's device. ''' top = Top(devices={ 's1': simulate.SimulatedDevice(), 's2': simulate.SimulatedDevice(), }) (_key, receiver1) = top.add_receiver('AM', key='a') top.set_source_name('s2') receiver1.set_device_name('s1') (_key, receiver2) = top.add_receiver('AM', key='b') self.assertEquals(receiver2.get_device_name(), 's2') self.assertEquals(receiver1.get_device_name(), 's1')
class AppRoot(ExportedState): def __init__(self, **kwargs): # TODO: don't just forward args, do something more sensible, or take as args self.__receive_flowgraph = Top(**kwargs) # TODO: only one session while we sort out other things self.__session = Session(self.__receive_flowgraph) @exported_block() def get_receive_flowgraph(self): return self.__receive_flowgraph # TODO: should become something more like 'create new session' def get_session(self): return self.__session def close_all_devices(self): self.__receive_flowgraph.close_all_devices()
def test_receiver_source_switch(self): ''' Regression test: Switching sources was not updating receiver input frequency. ''' freq1 = 1e6 freq2 = 2e6 top = Top(devices={ 's1': simulate.SimulatedDevice(freq=freq1), 's2': simulate.SimulatedDevice(freq=freq2), }) (_key, receiver) = top.add_receiver('AM', key='a') receiver.set_rec_freq(freq2) receiver.set_device_name('s1') self.assertFalse(receiver.get_is_valid(), 'receiver initially invalid') receiver.set_device_name('s2') self.assertTrue(receiver.get_is_valid(), 'receiver now valid')
def __init__(self, mode, state=None): # TODO: Refactor things so that we can take the demod ctor rather than a mode string # TODO: Tell the simulated device to have no modulators, or have a simpler dummy source for testing, so we don't waste time on setup if state is None: state = {} self.__top = Top(devices={'s1': SimulatedDevice()}) self.__top.add_receiver(mode, key='a', state=state) self.__top.start() # TODO overriding internals
def test_mono(self): top = Top(devices={'s1': simulate.SimulatedDevice(freq=0)}, stereo=False) queue = gr.msg_queue() (_key, _receiver) = top.add_receiver('AM', key='a') top.add_audio_queue(queue, 48000) top.remove_audio_queue(queue)
def test_receiver_source_switch(self): """ Regression test: Switching sources was not updating receiver input frequency. """ freq1 = 1e6 freq2 = 2e6 top = Top( devices={ 's1': simulate.SimulatedDevice(freq=freq1), 's2': simulate.SimulatedDevice(freq=freq2), }) (_key, receiver) = top.add_receiver('AM', key='a') receiver.set_rec_freq(freq2) receiver.set_device_name('s1') self.assertFalse(receiver.get_is_valid(), 'receiver initially invalid') receiver.set_device_name('s2') self.assertTrue(receiver.get_is_valid(), 'receiver now valid')
def __init__(self, devices, audio_config, features): self.__receive_flowgraph = Top( devices=devices, audio_config=audio_config, features=features) # TODO: only one session while we sort out other things self.__session = Session( receive_flowgraph=self.__receive_flowgraph, features=features)
def test_monitor_source_switch(self): freq1 = 1e6 freq2 = 2e6 # TODO: Also test signal type switching (not yet supported by SimulatedDevice) top = Top( devices={ 's1': simulate.SimulatedDevice(freq=freq1), 's2': simulate.SimulatedDevice(freq=freq2), }) top.set_source_name('s1') self.assertEqual(top.state()['monitor'].get().get_fft_info()[0], freq1) top.set_source_name('s2') self.assertEqual(top.state()['monitor'].get().get_fft_info()[0], freq2)
def test_mono(self): top = Top(devices={'s1': simulate.SimulatedDevice(freq=0)}, features={'stereo':False}) queue = gr.msg_queue() (_key, _receiver) = top.add_receiver('AM', key='a') top.add_audio_queue(queue, 48000) top.remove_audio_queue(queue)
def test_monitor_source_switch(self): freq1 = 1e6 freq2 = 2e6 # TODO: Also test signal type switching (not yet supported by SimulatedDevice) top = Top(devices={ 's1': simulate.SimulatedDevice(freq=freq1), 's2': simulate.SimulatedDevice(freq=freq2), }) top.set_source_name('s1') self.assertEqual(top.state()['monitor'].get().get_fft_info()[0], freq1) top.set_source_name('s2') self.assertEqual(top.state()['monitor'].get().get_fft_info()[0], freq2)
class DemodulatorTester(object): ''' Set up an environment for testing a demodulator and do some fundamental tests. ''' def __init__(self, mode, state=None): # TODO: Refactor things so that we can take the demod ctor rather than a mode string # TODO: Tell the simulated device to have no modulators, or have a simpler dummy source for testing, so we don't waste time on setup if state is None: state = {} self.__top = Top(devices={'s1': SimulatedDevice()}) (_, receiver) = self.__top.add_receiver(mode, key='a', state=state) self.__demodulator = receiver.get_demodulator() self.__top.start() # TODO overriding internals def close(self): if self.__top is not None: self.__top.stop() self.__top = None def __enter__(self): state_smoke_test(self.__demodulator) def __exit__(self, exc_type, exc_value, traceback): self.close()
def test_source_switch_update(self): ''' Regression test: Switching sources was not updating receiver input frequency. ''' top = Top(sources={ 's1': simulate.SimulatedSource(freq=0), 's2': simulate.SimulatedSource(freq=1e6), }) top.set_source_name('s1') (_, receiver) = top.add_receiver('AM', key='a') receiver.set_rec_freq(1e6) self.assertFalse(receiver.get_is_valid()) top.set_source_name('s2') self.assertTrue(receiver.get_is_valid())
def test_receiver_device_default(self): """ Receiver should default to the monitor device, not other receiver's device. """ top = Top(devices={ 's1': simulate.SimulatedDevice(), 's2': simulate.SimulatedDevice(), }) (_key, receiver1) = top.add_receiver('AM', key='a') top.set_source_name('s2') receiver1.set_device_name('s1') (_key, receiver2) = top.add_receiver('AM', key='b') self.assertEquals(receiver2.get_device_name(), 's2') self.assertEquals(receiver1.get_device_name(), 's1')
def test_source_switch_update(self): ''' Regression test: Switching sources was not updating receiver input frequency. ''' freq = 1e6 top = Top(devices={ 's1': simulate.SimulatedDevice(freq=0), 's2': simulate.SimulatedDevice(freq=freq), }) top.set_source_name('s1') self.assertEqual(top.monitor.get_fft_info()[0], 0) (_key, receiver) = top.add_receiver('AM', key='a') receiver.set_rec_freq(freq) self.assertFalse(receiver.get_is_valid()) top.set_source_name('s2') # TODO: instead of top.monitor, should go through state interface self.assertEqual(top.monitor.get_fft_info()[0], freq) self.assertTrue(receiver.get_is_valid())
class DemodulatorTester(object): ''' Set up an environment for testing a demodulator. ''' def __init__(self, mode): # TODO: Refactor things so that we can take the demod ctor rather than a mode string # TODO: Tell the simulated device to have no modulators, or have a simpler dummy source for testing, so we don't waste time on setup self.__top = Top(devices={'s1': SimulatedDevice()}) self.__top.add_receiver(mode, key='a') self.__top.start() # TODO overriding internals def close(self): if self.__top is not None: self.__top.stop() self.__top = None def __enter__(self): pass def __exit__(self, exc_type, exc_value, traceback): self.close()
def test_state_smoke(self): state_smoke_test(Top(devices={'s1': simulate.SimulatedDevice()}))
def __init__(self, **kwargs): # TODO: don't just forward args, do something more sensible, or take as args self.__receive_flowgraph = Top(**kwargs) # TODO: only one session while we sort out other things self.__session = Session(self.__receive_flowgraph)
def test_audio_queue_smoke(self): top = Top(devices={'s1': simulate.SimulatedDevice(freq=0)}) queue = gr.msg_queue() top.set_unpaused(True) # there should be an attempted start top.add_audio_queue(queue, 48000) top.remove_audio_queue(queue)
def __init__(self, mode): # TODO: Refactor things so that we can take the demod ctor rather than a mode string # TODO: Tell the simulated device to have no modulators, or have a simpler dummy source for testing, so we don't waste time on setup self.__top = Top(devices={'s1': SimulatedDevice()}) self.__top.add_receiver(mode, key='a') self.__top.start() # TODO overriding internals
def test_audio_queue_smoke(self): top = Top(devices={'s1': simulate.SimulatedDevice(freq=0)}) queue = gr.msg_queue() (_key, _receiver) = top.add_receiver('AM', key='a') top.add_audio_queue(queue, 48000) top.remove_audio_queue(queue)