class AbsTests(unittest.TestCase): '''Test the absolute actor''' def setUp(self): ''' Unit test setup code ''' self.q_in = Channel() self.q_out = Channel() def test_positive_integers(self): '''Test a simple positive integer signal. ''' inp = [Event(value=i, tag=i) for i in xrange(0, 100, 1)] expected_outputs = inp[:] abs = Abs(self.q_in, self.q_out) abs.start() [self.q_in.put(val) for val in inp] self.q_in.put(LastEvent()) abs.join() for expected_output in expected_outputs: out = self.q_out.get() self.assertEquals(out.value, expected_output.value) self.assertEquals(out.tag, expected_output.tag) self.assertTrue(self.q_out.get().last)
class Ct2DtTests(unittest.TestCase): '''Test the Ct2Dt actor''' def setUp(self): ''' Unit test setup code ''' self.q_in = Channel("CT") self.q_out = Channel("DT") def test_simple_ramp(self): '''Convert a simple ramp signal''' inp = [Event(value=i, tag=i / 10.0) for i in xrange(0, 100, 1)] expected_outputs = [ Event(value=i * 2, tag=i) for i in xrange(0, 50, 1) ] sampler = Ct2Dt(self.q_in, self.q_out, 5) sampler.start() [self.q_in.put(val) for val in inp] self.q_in.put(LastEvent()) sampler.join() for expected_output in expected_outputs: out = self.q_out.get() self.assertAlmostEquals(out.value, expected_output.value) self.assertEquals(out.tag, expected_output.tag)
class Ct2DtTests(unittest.TestCase): '''Test the Ct2Dt actor''' def setUp(self): ''' Unit test setup code ''' self.q_in = Channel("CT") self.q_out = Channel("DT") def test_simple_ramp(self): '''Convert a simple ramp signal''' inp = [Event(value=i, tag=i/10.0) for i in xrange(0, 100, 1)] expected_outputs = [Event(value=i*2, tag=i) for i in xrange(0, 50, 1)] sampler = Ct2Dt(self.q_in, self.q_out, 5) sampler.start() [self.q_in.put(val) for val in inp] self.q_in.put(LastEvent()) sampler.join() for expected_output in expected_outputs: out = self.q_out.get() self.assertAlmostEquals(out.value, expected_output.value) self.assertEquals(out.tag, expected_output.tag)
class DecimatorTests(unittest.TestCase): '''Test the decimation actor''' def setUp(self): ''' Unit test setup code ''' self.q_in = Channel() self.q_out = Channel() def test_basic_integer_tags(self): '''Test halving the frequency we sample a simple integer signal. Create a discrete time signal with a 1hz frequency down-sample to 0.5hz by a factor 2 reduction ''' inp = [Event(value=1, tag=i) for i in xrange(0, 100, 1)] expected_outputs = [Event(value=1, tag=i) for i in xrange(0, 100, 2)] down_sampler = Decimator(self.q_in, self.q_out, 2) down_sampler.start() [self.q_in.put(val) for val in inp] self.q_in.put(LastEvent()) down_sampler.join() for expected_output in expected_outputs: out = self.q_out.get() self.assertEquals(out.value, expected_output.value) self.assertEquals(out.tag, expected_output.tag) self.assertTrue(self.q_out.get().last)
class AbsTests( unittest.TestCase ): '''Test the absolute actor''' def setUp( self ): ''' Unit test setup code ''' self.q_in = Channel() self.q_out = Channel() def test_positive_integers( self ): '''Test a simple positive integer signal. ''' inp = [Event(value=i, tag=i) for i in xrange( 0, 100, 1 )] expected_outputs = inp[:] abs = Abs( self.q_in, self.q_out ) abs.start() [self.q_in.put( val ) for val in inp] self.q_in.put( LastEvent() ) abs.join() for expected_output in expected_outputs: out = self.q_out.get() self.assertEquals( out.value, expected_output.value ) self.assertEquals( out.tag, expected_output.tag ) self.assertTrue( self.q_out.get().last )
def test_different_rate(self): '''Test that integration of a simple positive constant signal doesn't change with samplerate. ''' from scipy import arange inp_1 = [Event(value = 10, tag = i) for i in arange(0, 10, 1)] inp_2 = [Event(value = 10, tag = i) for i in arange(0, 10, 0.1)] expected_output_values_1 = [10 * i for i in arange(0, 10, 1)] expected_output_values_2 = [10 * i for i in arange(0, 10, 0.1)] for Block in [CTIntegratorForwardEuler]: q_in1, q_out1, q_in2, q_out2 = Channel(), Channel(), Channel(), Channel() block1 = Block(q_in1, q_out1) block2 = Block(q_in2, q_out2) block1.start(); block2.start() [q_in1.put(val) for val in inp_1] [q_in2.put(val) for val in inp_2] q_in1.put(LastEvent()); q_in2.put(LastEvent()) block1.join(); block2.join() out = [] for expected_output in expected_output_values_1: out.append(q_out1.get()) out = [item.value for item in out] self.assertEquals(len(out), len(expected_output_values_1)) #[self.assertEquals(out[i], expected_output[i]) for i, _ in enumerate(expected_output_values_1)] self.assertTrue(q_out1.get().last) for expected_output in expected_output_values_2: out = q_out2.get() self.assertAlmostEquals(out.value, expected_output) self.assertTrue(q_out2.get().last)
def test_alternating_merge(self): ''' Test merging two channels with out-of-sync tags. ''' q_in_1 = Channel() q_in_2 = Channel() q_out = Channel() input1 = [Event(value=1, tag=2.0*i) for i in xrange(100)] + [LastEvent()] input2 = [Event(value=2, tag=2.0*i + 1.0) for i in xrange(100)] + [LastEvent()] merge = Merge([q_in_1, q_in_2], q_out) merge.start() for val in input1: q_in_1.put(val) for val in input2: q_in_2.put(val) merge.join() for i in xrange(99): self.assertEquals(q_out.get().value, 1) self.assertEquals(q_out.get().value, 2) # The termination event from channel 1 will cause the # last value event from channel 2 to be lost self.assertEquals(q_out.get().value, 1) self.assertTrue(q_out.get().last) self.assertTrue(q_out.get().last)
class QuantizerTests(unittest.TestCase): '''Test the quantizer actor''' def setUp(self): ''' Unit test setup code ''' self.q_in = Channel("CT") self.q_out = Channel("CT") def test_ramp_quantization(self): ''' Test quantizing a simple ramp signal. ''' inp = [Event(i, i) for i in xrange(-20, 21, 1)] quantizer = Quantizer(self.q_in, self.q_out, 2) expected_outputs = [Event(i, i if i%2==0 else i-1) for i in xrange(-20, 21, 1)] quantizer.start() [self.q_in.put(val) for val in inp] self.q_in.put(LastEvent()) quantizer.join() for expected_output in expected_outputs: out = self.q_out.get() self.assertEquals(out.value, expected_output.value) self.assertEquals(out.tag, expected_output.tag) self.assertTrue(self.q_out.get().last)
class EventFilterTests(unittest.TestCase): '''Test the event-filter actor''' def setUp(self): ''' Unit test setup code ''' self.q_in = Channel("CT") self.q_out = Channel("DE") def test_ramp_event_detection(self): ''' Test event detection on a simple ramp signal. ''' inp = [Event(i/3, i/3) for i in xrange(-60, 63, 1)] ef = EventFilter(self.q_in, self.q_out, 2) expected_outputs = [Event(i, i) for i in xrange(-20, 21, 2)] ef.start() [self.q_in.put(val) for val in inp] self.q_in.put(LastEvent()) ef.join() for expected_output in expected_outputs: out = self.q_out.get() self.assertEquals(out.tag, expected_output.tag) self.assertEquals(out.value, expected_output.value) self.assertTrue(self.q_out.get().last)
class QuantizerTests(unittest.TestCase): '''Test the quantizer actor''' def setUp(self): ''' Unit test setup code ''' self.q_in = Channel("CT") self.q_out = Channel("CT") def test_ramp_quantization(self): ''' Test quantizing a simple ramp signal. ''' inp = [Event(i, i) for i in xrange(-20, 21, 1)] quantizer = Quantizer(self.q_in, self.q_out, 2) expected_outputs = [ Event(i, i if i % 2 == 0 else i - 1) for i in xrange(-20, 21, 1) ] quantizer.start() [self.q_in.put(val) for val in inp] self.q_in.put(LastEvent()) quantizer.join() for expected_output in expected_outputs: out = self.q_out.get() self.assertEquals(out.value, expected_output.value) self.assertEquals(out.tag, expected_output.tag) self.assertTrue(self.q_out.get().last)
class BundleTests(unittest.TestCase): def setUp(self): self.q_in = Channel() self.q_out = Channel() self.q_out2 = Channel() self.input = [Event(value=1, tag=i) for i in xrange(100)] def tearDown(self): del self.q_in del self.q_out def test_bundle_full_signal(self): '''Test sending a basic integer tagged signal all at once''' bundle_size = 1000 #expected_output = [Event(value=1, tag=i + delay) for i in xrange(100)] block = Bundle(self.q_in, self.q_out, bundle_size) block.start() [self.q_in.put(i) for i in self.input + [LastEvent()]] block.join() actual_output = self.q_out.get() self.assertEqual(actual_output.size, 100) self.assertTrue(self.q_out.get().last) def test_bundle_partial_signal(self): '''Test sending a basic integer tagged signal in sections''' bundle_size = 40 #expected_output = [Event(value=1, tag=i + delay) for i in xrange(100)] block = Bundle(self.q_in, self.q_out, bundle_size) block.start() [self.q_in.put(i) for i in self.input + [LastEvent()]] block.join() actual_output = self.q_out.get() self.assertEqual(actual_output.size, bundle_size) actual_output = self.q_out.get() self.assertEqual(actual_output.size, bundle_size) actual_output = self.q_out.get() self.assertEqual(actual_output.size, 20) self.assertTrue(self.q_out.get().last) def test_unbundle(self): '''Test the unbundler and the bundler''' bundler = Bundle(self.q_in, self.q_out) unbundler = Unbundle(self.q_out, self.q_out2) [block.start() for block in [bundler, unbundler]] [self.q_in.put(i) for i in self.input + [LastEvent()]] [block.join() for block in [bundler, unbundler]] [self.assertEquals(self.q_out2.get(), i) for i in self.input] self.assertTrue(self.q_out2.get().last)
class DelayTests(unittest.TestCase): def setUp(self): self.q_in = Channel() self.q_out = Channel() def tearDown(self): del self.q_in del self.q_out def test_basic_delay(self): '''Test delaying a basic integer tagged signal by 1''' delay = 2 input1 = [Event(value=1, tag=i) for i in xrange(100)] expected_output = [Event(value=1, tag=i + delay) for i in xrange(100)] block = Delay(self.q_in, self.q_out, delay) block.start() [self.q_in.put(i) for i in input1 + [LastEvent()]] block.join() actual_output = [self.q_out.get() for i in xrange(100)] [ self.assertEquals(actual_output[i], expected_output[i]) for i in xrange(100) ] self.assertTrue(self.q_out.get().last) def test_complex_delay(self): '''Test delaying a CT signal''' delay = 11.5 # Delay by this amount simulation_time = 120 # seconds to simulate resolution = 10.0 # samples per second (10hz) tags = linspace(0, simulation_time, simulation_time / resolution) values = arange(len(tags)) data_in = [ Event(value=values[i], tag=tags[i]) for i in xrange(len(tags)) ] expected_output = [ Event(value=values[i], tag=tags[i] + delay) for i in xrange(len(tags)) ] block = Delay(self.q_in, self.q_out, delay) block.start() [self.q_in.put(i) for i in data_in + [LastEvent()]] block.join() actual_output = [self.q_out.get() for i in xrange(len(tags))] [ self.assertEquals(actual_output[i], expected_output[i]) for i in xrange(len(tags)) ] self.assertTrue(self.q_out.get().last)
def test_ct_summer_with_different_rates(self): ''' Test adding two channels where one is operates at a different rate than the other. The sum should appear at the fastest rate, with values that assume constant-interpolation between events in the slower channel. ''' DELAY = 2 q_in_1 = Channel('CT') q_in_2 = Channel('CT') q_out = Channel('CT') input1 = [Event(value=i, tag=i) for i in xrange(1,100)] input2 = [Event(value=2*i, tag=2*i) for i in xrange(1,50)] summer = Summer([q_in_1, q_in_2], q_out) summer.start() for val in input1: q_in_1.put(val) for val in input2: q_in_2.put(val) q_in_1.put(LastEvent()) q_in_2.put(LastEvent()) summer.join() self.assertEquals(q_out.get()['value'], 1.0) for i in xrange(2, 98, 2): self.assertEquals(q_out.get()['value'], i + i) self.assertEquals(q_out.get()['value'], i + i + 1) self.assertEquals(q_out.get()['value'], 196) self.assertTrue(q_out.get().last)
def test_delayed_summer2(self): ''' Test adding two channels where one is delayed by an arbitrary time step difference. Summer is set up to discard incomplete sets ''' DELAY = 2 q_in_1 = Channel('DT') q_in_2 = Channel('DT') q_out = Channel('DT') input1 = [Event(value=1, tag=i) for i in xrange(100)] input2 = [Event(value=2, tag=i + DELAY) for i in xrange(100)] summer = DTSummer([q_in_1, q_in_2], q_out, True) summer.start() for val in input1: q_in_1.put(val) for val in input2: q_in_2.put(val) q_in_1.put(LastEvent()) q_in_2.put(LastEvent()) summer.join() for i in xrange(DELAY, 100): self.assertEquals(q_out.get()['value'], 3) self.assertTrue(q_out.get().last)
def test_delayed_summer3(self): ''' Test adding two channels where one is delayed by ONE time step difference Summer is set up to SUM incomplete sets ''' q_in_1 = Channel('DT') q_in_2 = Channel('DT') q_out = Channel('DT') input1 = [Event(value=1, tag=i) for i in xrange(100)] # First tag is 0, last tag is 99. input2 = [Event(value=2, tag=i + 1) for i in xrange(100)] # First tag is 1, last tag is 100. summer = DTSummer([q_in_1, q_in_2], q_out, False) summer.start() for val in input1: q_in_1.put(val) for val in input2: q_in_2.put(val) q_in_1.put(LastEvent()) q_in_2.put(LastEvent()) summer.join() # First value should be 1, next 99 should be 3, last should be 2. data = q_out.get() self.assertEquals(data['value'], 1) self.assertEquals(data['tag'], 0) for i in xrange(1, 100): data = q_out.get() self.assertEquals(data['value'], 3) self.assertEquals(data['tag'], i) data = q_out.get() # lastly the channel should contain a terminal event self.assertTrue(q_out.get().last)
def test_ct_summer_with_different_rates(self): ''' Test adding two channels where one is operates at a different rate than the other. The sum should appear at the fastest rate, with values that assume constant-interpolation between events in the slower channel. ''' DELAY = 2 q_in_1 = Channel('CT') q_in_2 = Channel('CT') q_out = Channel('CT') input1 = [Event(value=i, tag=i) for i in xrange(1, 100)] input2 = [Event(value=2 * i, tag=2 * i) for i in xrange(1, 50)] summer = Summer([q_in_1, q_in_2], q_out) summer.start() for val in input1: q_in_1.put(val) for val in input2: q_in_2.put(val) q_in_1.put(LastEvent()) q_in_2.put(LastEvent()) summer.join() self.assertEquals(q_out.get()['value'], 1.0) for i in xrange(2, 98, 2): self.assertEquals(q_out.get()['value'], i + i) self.assertEquals(q_out.get()['value'], i + i + 1) self.assertEquals(q_out.get()['value'], 196) self.assertTrue(q_out.get().last)
class BundleDerivativeTests(unittest.TestCase): def setUp(self): ''' Unit test setup code ''' self.q_in = Channel() self.q_out = Channel() self.q_out2 = Channel() def test_first_order_diff(self): '''Test a first order diff''' input_values = [0, 1, 2, 3, 3, 3, 3, 1] outs = [1, 1, 1, 0, 0, 0, -2] self.input = [Event(value=input_values[i], tag=i) for i in xrange(len(input_values))] bundler = Bundle(self.q_in, self.q_out) diffblock = BundleDerivative(self.q_out, self.q_out2, threshold=50) [self.q_in.put(i) for i in self.input + [LastEvent()]] [block.start() for block in [bundler, diffblock]] [block.join() for block in [bundler, diffblock]] outputs = self.q_out2.get() self.assertNotEqual(outputs, None) [self.assertEquals(outs[i], outputs['Value'][i]) for i in xrange(len(outs))] self.assertTrue(self.q_out2.get().last)
def test_interleaving_merge(self): ''' Test merging two channels that have different numbers of events, and don't simply alternate their tags. ''' q_in_1 = Channel() q_in_2 = Channel() q_out = Channel() input1 = [Event(value=1, tag=2.0*i) for i in xrange(3)] + [LastEvent()] input2 = [Event(value=2, tag=0.5*i) for i in xrange(11)] + [LastEvent()] merge = Merge([q_in_1, q_in_2], q_out) merge.start() for val in input1: q_in_1.put(val) for val in input2: q_in_2.put(val) merge.join() self.assertEquals(q_out.head().tag, 0.0) self.assertEquals(q_out.get().value, 1) # 0 self.assertEquals(q_out.head().tag, 0.0) self.assertEquals(q_out.get().value, 2) # 0 self.assertEquals(q_out.head().tag, 0.5) self.assertEquals(q_out.get().value, 2) # 0.5 self.assertEquals(q_out.head().tag, 1.0) self.assertEquals(q_out.get().value, 2) # 1.0 self.assertEquals(q_out.head().tag, 1.5) self.assertEquals(q_out.get().value, 2) # 1.5 self.assertEquals(q_out.head().tag, 2.0) self.assertEquals(q_out.get().value, 1) self.assertEquals(q_out.head().tag, 2.0) self.assertEquals(q_out.get().value, 2) self.assertEquals(q_out.head().tag, 2.5) self.assertEquals(q_out.get().value, 2) self.assertEquals(q_out.head().tag, 3.0) self.assertEquals(q_out.get().value, 2) self.assertEquals(q_out.head().tag, 3.5) self.assertEquals(q_out.get().value, 2) self.assertEquals(q_out.head().tag, 4.0) self.assertEquals(q_out.get().value, 1) self.assertEquals(q_out.head().tag, 4.0) self.assertEquals(q_out.get().value, 2) self.assertTrue(q_out.get().last) self.assertTrue(q_out.get().last)
class DelayTests(unittest.TestCase): def setUp(self): self.q_in = Channel() self.q_out = Channel() def tearDown(self): del self.q_in del self.q_out def test_basic_delay(self): '''Test delaying a basic integer tagged signal by 1''' delay = 2 input1 = [Event(value=1, tag=i) for i in xrange(100)] expected_output = [Event(value=1, tag=i + delay) for i in xrange(100)] block = Delay(self.q_in, self.q_out, delay) block.start() [self.q_in.put(i) for i in input1 + [LastEvent()]] block.join() actual_output = [self.q_out.get() for i in xrange(100)] [self.assertEquals(actual_output[i], expected_output[i]) for i in xrange(100)] self.assertTrue(self.q_out.get().last) def test_complex_delay(self): '''Test delaying a CT signal''' delay = 11.5 # Delay by this amount simulation_time = 120 # seconds to simulate resolution = 10.0 # samples per second (10hz) tags = linspace(0, simulation_time, simulation_time / resolution) values = arange(len(tags)) data_in = [Event(value = values[i], tag = tags[i]) for i in xrange(len(tags))] expected_output = [Event(value = values[i], tag = tags[i] + delay) for i in xrange(len(tags))] block = Delay(self.q_in, self.q_out, delay) block.start() [self.q_in.put(i) for i in data_in + [LastEvent()]] block.join() actual_output = [self.q_out.get() for i in xrange(len(tags))] [self.assertEquals(actual_output[i], expected_output[i]) for i in xrange(len(tags))] self.assertTrue(self.q_out.get().last)
def test_basic_proportional(self): '''Test doubling a channel.''' q_in = Channel() q_out = Channel() inp = [Event(value=1, tag=i) for i in xrange(100)] expected_output = [Event(value=2, tag=i) for i in xrange(100)] doubler = Proportional(q_in, q_out) doubler.start() [q_in.put(val) for val in inp] q_in.put(LastEvent()) doubler.join() for i in xrange(100): out = q_out.get() self.assertEquals(out.value, expected_output[i].value) self.assertEquals(out.tag, expected_output[i].tag) self.assertTrue(q_out.get().last)
class ElsePassThroughTests(unittest.TestCase): '''Test the IF-Else actor''' def setUp(self): '''General set up that will be used in all tests''' self.data_in = Channel() self.alt_data_in = Channel() self.bool_in = Channel() self.output = Channel() # Some fake boolean data self.every_second_point = [True, False] * 50 # some fake pass through data, and add it to the channel self.data = range(100) self.data_alt = 10 * self.data [ self.alt_data_in.put(Event(tag=i, value=self.data_alt[i])) for i in range(100) ] [self.data_in.put(Event(tag=i, value=i)) for i in range(100)] self.data_in.put(LastEvent()) self.alt_data_in.put(LastEvent()) # create the block self.block = PassThrough(self.bool_in, self.data_in, self.output, else_data_input=self.alt_data_in) def test_every_second_alternative(self): '''Test merging with if - else actor. half the values come from one channel, and half from the other''' [ self.bool_in.put(Event(tag=i, value=self.every_second_point[i])) for i in self.data ] self.bool_in.put(LastEvent()) self.block.start() self.block.join() for i in self.data: output = self.output.get(True) self.assertEquals(output.tag, i) if i % 2 == 0: self.assertEquals(output.value, i) else: self.assertEquals(output.value, self.data_alt[i]) self.assertTrue(self.output.get().last)
def test_simple_merge(self): '''Test merging two channels of complete pairs together''' q_in_1 = Channel() q_in_2 = Channel() q_out = Channel() input1 = [Event(value=1, tag=i) for i in xrange(100)] + [LastEvent()] input2 = [Event(value=2, tag=i) for i in xrange(100)] + [LastEvent()] merge = Merge([q_in_1, q_in_2], q_out) merge.start() for val in input1: q_in_1.put(val) for val in input2: q_in_2.put(val) merge.join() for i in xrange(100): self.assertEquals(q_out.get().value, 1) self.assertEquals(q_out.get().value, 2) self.assertTrue(q_out.get().last)
def test_text_writer(self): tfile = tempfile.NamedTemporaryFile() filename = tfile.name output = Channel() writer = TextWriter(output, filename) [output.put(e) for e in [Event(value=i ** 3, tag=i) for i in xrange(100)] + [LastEvent()]] writer.start() writer.join() for i, line in enumerate(tfile): self.assertEquals('%s, %s' % (str(i), str(i**3)), line.strip())
class BundlePlotTests( unittest.TestCase ): def setUp( self ): self.q_in = Channel() self.q_out = Channel() self.q_out2 = Channel() self.input = [Event(value=1, tag=i) for i in xrange( 100 )] self.title = "test plot" self.url = os.path.join(os.getcwd() , self.title) + ".png" def tearDown( self ): del self.q_in del self.q_out try: os.remove(self.url) except OSError: pass def test_getting_bundle_data( self ): '''Test bundling a signal and getting the data back''' block = Bundle( self.q_in, self.q_out ) block.start() [self.q_in.put( i ) for i in self.input + [LastEvent()]] block.join() bundled_data = self.q_out.get() self.assertEqual( len( bundled_data ), 100 ) self.assertEqual( type( bundled_data ), numpy.ndarray ) values = bundled_data["Value"] self.assertTrue( all( values == 1 ) ) tags = bundled_data["Tag"] [self.assertEquals( tags[i] , i ) for i in xrange( 100 ) ] def test_plotting( self ): bundler = Bundle( self.q_in, self.q_out ) bundlingPlotter = BundlePlotter( self.q_out, self.title ) [block.start() for block in [bundler, bundlingPlotter]] [self.q_in.put( i ) for i in self.input + [LastEvent()]] [block.join() for block in [bundler, bundlingPlotter]] self.assertTrue(os.path.exists(self.url))
class SinkTests(unittest.TestCase): '''Test the sink actor''' def setUp(self): ''' Unit test setup code ''' self.q_in = Channel() def test_sink(self): '''Test that sink runs. ''' inp = [Event(i, i) for i in xrange(0, 100, 1)] try: sink = Sink(self.q_in) sink.start() [self.q_in.put(val) for val in inp] self.q_in.put(LastEvent()) sink.join() except: self.fail("Sink failed to run without exception.")
class BundlePlotTests(unittest.TestCase): def setUp(self): self.q_in = Channel() self.q_out = Channel() self.q_out2 = Channel() self.input = [Event(value=1, tag=i) for i in xrange(100)] self.title = "test plot" self.url = os.path.join(os.getcwd(), self.title) + ".png" def tearDown(self): del self.q_in del self.q_out try: os.remove(self.url) except OSError: pass def test_getting_bundle_data(self): '''Test bundling a signal and getting the data back''' block = Bundle(self.q_in, self.q_out) block.start() [self.q_in.put(i) for i in self.input + [LastEvent()]] block.join() bundled_data = self.q_out.get() self.assertEqual(len(bundled_data), 100) self.assertEqual(type(bundled_data), numpy.ndarray) values = bundled_data["Value"] self.assertTrue(all(values == 1)) tags = bundled_data["Tag"] [self.assertEquals(tags[i], i) for i in xrange(100)] def test_plotting(self): bundler = Bundle(self.q_in, self.q_out) bundlingPlotter = BundlePlotter(self.q_out, self.title) [block.start() for block in [bundler, bundlingPlotter]] [self.q_in.put(i) for i in self.input + [LastEvent()]] [block.join() for block in [bundler, bundlingPlotter]] self.assertTrue(os.path.exists(self.url))
class SinkTests(unittest.TestCase): '''Test the sink actor''' def setUp(self): ''' Unit test setup code ''' self.q_in = Channel() def test_sink(self): '''Test that sink runs. ''' inp = [Event(i,i) for i in xrange(0, 100, 1)] try: sink = Sink(self.q_in) sink.start() [self.q_in.put(val) for val in inp] self.q_in.put(LastEvent()) sink.join() except: self.fail("Sink failed to run without exception.")
def test_basic_split(self): '''Test getting two for the price of one - cloning a channel''' q_in = Channel() q_out1 = Channel() q_out2 = Channel() inp = Event(value=15, tag=1) cloneQ = Split(q_in, [q_out1, q_out2]) cloneQ.start() q_in.put(inp) q_in.put(LastEvent()) cloneQ.join() out1 = q_out1.get() self.assertEquals(out1.value, inp.value) self.assertEquals(out1.tag, inp.tag) self.assertTrue(q_out1.get().last) out2 = q_out2.get() self.assertEquals(out2.value, inp.value) self.assertEquals(out2.tag, inp.tag) self.assertTrue(q_out2.get().last)
class FileIOTests(unittest.TestCase): '''Test the FileIO Actors''' def setUp(self): self.chan = Channel() self.signal = [Event(value=i ** 3, tag=i) for i in xrange(100)] + [LastEvent()] [self.chan.put(val) for val in self.signal] self.f = tempfile.NamedTemporaryFile()#delete=False) def tearDown(self): self.f.close() def test_file_write(self): '''Test that we can save data''' fileWriter = Writer(self.chan, self.f.name) # Run the file writer and save the output to a temp file fileWriter.start() fileWriter.join() # Check that the channel is empty... self.assertRaises(Channel.Empty, lambda: self.chan.get(block=False)) # TODO check the data (load with numpy) def test_file_read(self): '''Test that we can retrieve data''' # Using self.f here, even with delete set to false, doesn't seem to # work. So we need to manually create a temp file. fileName = tempfile.gettempdir() + '/numpy_test_data.npy' fileWriter = Writer(self.chan, fileName) fileWriter.start() fileWriter.join() fileReader = Reader(output_channel=self.chan, file_name=fileName) fileReader.start() fileReader.join() for expected in self.signal: if not expected.last: received = self.chan.get() self.assertEqual(received.tag, expected.tag) self.assertEqual(received.value, expected.value) self.assertTrue(expected.last) os.remove(fileName) # clean up
def test_signed_summer(self): '''Test subtracting one channel from another''' q_in_1 = Channel('DT') q_in_2 = Channel('DT') q_out = Channel('DT') input1 = [Event(value=1, tag=i) for i in xrange(100)] input2 = [Event(value=2, tag=i) for i in xrange(100)] summer = Summer([q_in_1, (q_in_2, '-')], q_out) summer.start() for val in input1: q_in_1.put(val) for val in input2: q_in_2.put(val) q_in_1.put(LastEvent()) q_in_2.put(LastEvent()) summer.join() for i in xrange(100): self.assertEquals(q_out.get()['value'], -1) self.assertTrue(q_out.get().last)
def test_basic_summer(self): '''Test adding two channels of complete pairs together''' q_in_1 = Channel('DT') q_in_2 = Channel('DT') q_out = Channel('DT') input1 = [Event(value=1, tag=i) for i in xrange(100)] input2 = [Event(value=2, tag=i) for i in xrange(100)] summer = Summer([q_in_1, q_in_2], q_out) summer.start() for val in input1: q_in_1.put(val) for val in input2: q_in_2.put(val) q_in_1.put(LastEvent()) q_in_2.put(LastEvent()) summer.join() for i in xrange(100): self.assertEquals(q_out.get()['value'], 3) self.assertTrue(q_out.get().last)
class DTIntegratorTests(unittest.TestCase): '''Test the integrator actors''' def setUp(self): ''' Unit test setup code ''' self.q_in = Channel('DT') self.q_out = Channel('DT') def test_backward_euler(self): '''Test backward Euler integration of a simple positive integer signal. ''' inp = [Event(value=i, tag=i) for i in xrange(0, 10, 1)] expected_output_values = [sum(range(i)) for i in xrange(1, 11)] block = DTIntegratorBackwardEuler(self.q_in, self.q_out) block.start() [self.q_in.put(val) for val in inp] self.q_in.put(LastEvent()) block.join() for expected_output in expected_output_values: out = self.q_out.get() self.assertEquals(out.value, expected_output) self.assertTrue(self.q_out.get().last) def test_forward_euler(self): '''Test forward Euler integration of a simple positive integer signal. ''' inp = [Event(value=i, tag=i) for i in xrange(0, 10, 1)] expected_output_values = [sum(range(i)) for i in xrange(0, 10)] block = DTIntegratorForwardEuler(self.q_in, self.q_out) block.start() [self.q_in.put(val) for val in inp] self.q_in.put(LastEvent()) block.join() for expected_output in expected_output_values: out = self.q_out.get() self.assertEquals(out.value, expected_output) self.assertTrue(self.q_out.get().last) def test_trapezoidal(self): '''Test trapezoidal integration of a simple positive integer signal. ''' inp = [Event(value=i, tag=i) for i in xrange(0, 10, 1)] x_avgs = [0.5 * (x + (x - 1)) for x in xrange(1, 11, 1)] expected_output_values = [sum(x_avgs[:i]) for i in range(10)] block = DTIntegratorTrapezoidal(self.q_in, self.q_out) block.start() [self.q_in.put(val) for val in inp] self.q_in.put(LastEvent()) block.join() for expected_output in expected_output_values: out = self.q_out.get() self.assertEquals(out.value, expected_output) self.assertTrue(self.q_out.get().last)
class CTIntegratorTests(unittest.TestCase): '''Test the integrator actors''' def setUp(self): ''' Unit test setup code ''' self.q_in = Channel() self.q_out = Channel() def test_forward_euler(self): '''Test forward Euler integration of a simple positive integer signal. ''' inp = [Event(value = i, tag = i) for i in xrange(0, 10, 1)] expected_output_values = [sum(range(i)) for i in xrange(1, 11)] block = CTIntegratorForwardEuler(self.q_in, self.q_out) block.start() [self.q_in.put(val) for val in inp] self.q_in.put(LastEvent()) block.join() for expected_output in expected_output_values: out = self.q_out.get() self.assertEquals(out.value, expected_output) self.assertTrue(self.q_out.get().last) def test_different_rate(self): '''Test that integration of a simple positive constant signal doesn't change with samplerate. ''' from scipy import arange inp_1 = [Event(value = 10, tag = i) for i in arange(0, 10, 1)] inp_2 = [Event(value = 10, tag = i) for i in arange(0, 10, 0.1)] expected_output_values_1 = [10 * i for i in arange(0, 10, 1)] expected_output_values_2 = [10 * i for i in arange(0, 10, 0.1)] for Block in [CTIntegratorForwardEuler]: q_in1, q_out1, q_in2, q_out2 = Channel(), Channel(), Channel(), Channel() block1 = Block(q_in1, q_out1) block2 = Block(q_in2, q_out2) block1.start(); block2.start() [q_in1.put(val) for val in inp_1] [q_in2.put(val) for val in inp_2] q_in1.put(LastEvent()); q_in2.put(LastEvent()) block1.join(); block2.join() out = [] for expected_output in expected_output_values_1: out.append(q_out1.get()) out = [item.value for item in out] self.assertEquals(len(out), len(expected_output_values_1)) #[self.assertEquals(out[i], expected_output[i]) for i, _ in enumerate(expected_output_values_1)] self.assertTrue(q_out1.get().last) for expected_output in expected_output_values_2: out = q_out2.get() self.assertAlmostEquals(out.value, expected_output) self.assertTrue(q_out2.get().last)
class CTintegratorQSTests(unittest.TestCase): '''Test the integrator actor''' def setUp(self): ''' Unit test setup code ''' self.q_in = Channel() self.q_out = Channel() def test_simple_integration(self): ''' Test a simple integration of xdot = -x. ''' # Note that here instead of actually closing the loop around the # integrator we're simply feeding in a sequence of values corresponding # to the function f(x) = -x, and then later checking that the outputs we # get match the inputs we fed in. This allows the testing to be done # without relying on other actors. intags = [ 0.0, 0.0500000000000000, 0.1611111111111, 0.28611111111111, 0.42896825396825566, 0.59563492063492, 0.79563492063492, 1.04563492063492, 1.37896825396825, 1.878968253968261, 2.878968253968262 ] invals = [ -1, -0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, 0.0 ] inputs = [ Event(value=val, tag=tag) for (val, tag) in zip(invals, intags) ] expected_output_tags = [ 0.0, 0.0500000000000000, 0.1611111111111, 0.28611111111111, 0.42896825396825566, 0.59563492063492, 0.79563492063492, 1.04563492063492, 1.37896825396825, 1.878968253968261, 2.878968253968262, 10.0 ] expected_output_values = [ 1, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 0.0, 0.1 ] expected_outputs = [ Event(value=val, tag=tag) for (val, tag) in zip(expected_output_values, expected_output_tags) ] # k has been set to make maxstep 10.0 block = CTIntegratorQS1(self.q_in, self.q_out, init=1.0, delta=0.1, maxstep=10.0, algebraic_loop=True) SisoCTTestHelper(self, block, inputs, expected_outputs) def test_simple_integration_2(self): ''' Test two simultaneous integrations. Testing using same values as above, but also clones output for second integration. ''' from scipysim.actors.signal import Split # Note that here instead of actually closing the loop around the # integrator we're simply feeding in a sequence of values corresponding # to the function f(x) = -x, and then later checking that the outputs we # get match the inputs we fed in. This allows the testing to be done # without relying on other actors. intags = [ 0.0, 0.0500000000000000, 0.1611111111111, 0.28611111111111, 0.42896825396825566, 0.59563492063492, 0.79563492063492, 1.04563492063492, 1.37896825396825, 1.878968253968261, 2.878968253968262 ] invals = [ -1, -0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, 0.0 ] inputs = [ Event(value=val, tag=tag) for (val, tag) in zip(invals, intags) ] expected_output_tags = [ 0.0, 0.0500000000000000, 0.1611111111111, 0.28611111111111, 0.42896825396825566, 0.59563492063492, 0.79563492063492, 1.04563492063492, 1.37896825396825, 1.878968253968261, 2.878968253968262, 10.0 ] expected_output_values = [ 1, 0.9, 0.8, 0.7, 0.6, 0.5, 0.4, 0.3, 0.2, 0.1, 0.0, 0.1 ] expected_outputs = [ Event(value=val, tag=tag) for (val, tag) in zip(expected_output_values, expected_output_tags) ] q1, q2, q3 = Channel(), Channel(), Channel() blocks = [ CTIntegratorQS1(self.q_in, self.q_out, init=1.0, delta=0.1, maxstep=10.0, algebraic_loop=True), Split(self.q_out, [q1, q2]), CTIntegratorQS1(q1, q3, init=1.0, delta=0.1, maxstep=10.0, algebraic_loop=True) ] [self.q_in.put(val) for val in inputs + [LastEvent()]] [b.start() for b in blocks] [b.join() for b in blocks] for expected_output in expected_outputs: out = q2.get() self.assertAlmostEqual(out.value, expected_output.value, 4) self.assertAlmostEqual(out.tag, expected_output.tag, 4) self.assertTrue(q2.get().last)
class SamplerTests(unittest.TestCase): '''Test the sampling actor''' def setUp(self): ''' Unit test setup code ''' self.q_in = Channel("DT") self.q_out = Channel("DT") def test_basic_integer_tags(self): '''Test halving the frequency we sample a simple integer signal. Create a discrete time signal with a 1hz frequency and down-sample to 0.5hz ''' inp = [Event(value=1, tag=i) for i in xrange(0, 100, 1)] expected_outputs = [Event(value=1, tag=i) for i in xrange(0, 100, 2)] down_sampler = Sampler(self.q_in, self.q_out, 0.5) down_sampler.start() [self.q_in.put(val) for val in inp] self.q_in.put(LastEvent()) down_sampler.join() for expected_output in expected_outputs: out = self.q_out.get() self.assertEquals(out.value, expected_output.value) self.assertEquals(out.tag, expected_output.tag) self.assertTrue(self.q_out.get().last) def test_compatible_signals(self): '''Test reducing the frequency of a more complicated signal. Create a signal of 120 seconds, with 10 samples per second. (10hz) Down-sample this to a 2hz signal. ''' simulation_time = 120 # seconds to simulate resolution = 10.0 # samples per second (10hz) desired_resolution = 2 # what we want out - (2hz) # Create tags for a signal from 0 to 120 seconds. # length = number of seconds * ( samples per second + 1) freq = simulation_time * resolution tags = linspace(0, simulation_time, (freq) + 1) # Create 120 seconds of a discrete time signal with a 10hz frequency inp = [Event(value=1, tag=i) for i in tags] step = resolution / desired_resolution expected_output = [Event(value=1, tag=i) for i in tags[::step]] down_sampler = Sampler(self.q_in, self.q_out, desired_resolution) down_sampler.start() [self.q_in.put(val) for val in inp] self.q_in.put(LastEvent()) down_sampler.join() for expected_output_element in expected_output: out = self.q_out.get() self.assertEquals(out.value, expected_output_element.value) self.assertEquals(out.tag, expected_output_element.tag) self.assertTrue(self.q_out.get().last) def test_incompatible_signals(self): '''Test reducing the frequency by non integer factor. First create a signal of 120 seconds, with 10 samples per second. Down-sample this to a 8hz signal. ''' simulation_time = 120 # seconds to simulate resolution = 10.0 # samples per second (10hz) desired_resolution = 8 # what we want out - (8hz) # Create tags for a signal from 0 to 120 seconds. # length = number of seconds * ( samples per second + 1) freq = simulation_time * resolution tags = linspace(0, simulation_time, (freq) + 1) # Create 120 seconds of a discrete time signal with a 10hz frequency inp = [Event(value=1, tag=i) for i in tags] down_sampler = Sampler(self.q_in, self.q_out, desired_resolution) down_sampler.start() [self.q_in.put(val) for val in inp] self.q_in.put(LastEvent()) down_sampler.join() out = self.q_out.get() # @todo: NEED TO WORK OUT HOW WE WANT TO DO THIS... #self.assertEquals(type(out), InvalidSimulationInput) self.assertTrue(self.q_out.get().last)
class SamplerTests(unittest.TestCase): '''Test the sampling actor''' def setUp(self): ''' Unit test setup code ''' self.q_in = Channel("DT") self.q_out = Channel("DT") def test_basic_integer_tags(self): '''Test halving the frequency we sample a simple integer signal. Create a discrete time signal with a 1hz frequency and down-sample to 0.5hz ''' inp = [Event(value=1, tag=i) for i in xrange(0, 100, 1)] expected_outputs = [Event(value=1, tag=i) for i in xrange(0, 100, 2)] down_sampler = Sampler(self.q_in, self.q_out, 0.5) down_sampler.start() [self.q_in.put(val) for val in inp] self.q_in.put(LastEvent()) down_sampler.join() for expected_output in expected_outputs: out = self.q_out.get() self.assertEquals(out.value, expected_output.value) self.assertEquals(out.tag, expected_output.tag) self.assertTrue(self.q_out.get().last) def test_compatible_signals(self): '''Test reducing the frequency of a more complicated signal. Create a signal of 120 seconds, with 10 samples per second. (10hz) Down-sample this to a 2hz signal. ''' simulation_time = 120 # seconds to simulate resolution = 10.0 # samples per second (10hz) desired_resolution = 2 # what we want out - (2hz) # Create tags for a signal from 0 to 120 seconds. # length = number of seconds * ( samples per second + 1) freq = simulation_time * resolution tags = linspace(0, simulation_time , (freq) + 1) # Create 120 seconds of a discrete time signal with a 10hz frequency inp = [Event(value=1, tag=i) for i in tags] step = resolution / desired_resolution expected_output = [ Event(value=1, tag=i) for i in tags[::step]] down_sampler = Sampler(self.q_in, self.q_out, desired_resolution) down_sampler.start() [self.q_in.put(val) for val in inp] self.q_in.put(LastEvent()) down_sampler.join() for expected_output_element in expected_output: out = self.q_out.get() self.assertEquals(out.value, expected_output_element.value) self.assertEquals(out.tag, expected_output_element.tag) self.assertTrue(self.q_out.get().last) def test_incompatible_signals(self): '''Test reducing the frequency by non integer factor. First create a signal of 120 seconds, with 10 samples per second. Down-sample this to a 8hz signal. ''' simulation_time = 120 # seconds to simulate resolution = 10.0 # samples per second (10hz) desired_resolution = 8 # what we want out - (8hz) # Create tags for a signal from 0 to 120 seconds. # length = number of seconds * ( samples per second + 1) freq = simulation_time * resolution tags = linspace(0, simulation_time , (freq) + 1) # Create 120 seconds of a discrete time signal with a 10hz frequency inp = [Event(value=1, tag=i) for i in tags] down_sampler = Sampler(self.q_in, self.q_out, desired_resolution) down_sampler.start() [self.q_in.put(val) for val in inp] self.q_in.put(LastEvent()) down_sampler.join() out = self.q_out.get() # @todo: NEED TO WORK OUT HOW WE WANT TO DO THIS... #self.assertEquals(type(out), InvalidSimulationInput) self.assertTrue(self.q_out.get().last)
class PassThroughTests(unittest.TestCase): '''Test the IF actor''' def setUp(self): '''General set up that will be used in all tests''' self.data_in = Channel() self.bool_in = Channel() self.output = Channel() # Some fake boolean data self.every_second_point = [True, False] * 50 self.no_points = [False] * 100 # some fake pass through data, and add it to the channel self.data = range(100) [self.data_in.put(Event(tag=i, value=i)) for i in range(100)] self.data_in.put(LastEvent()) # create the block self.block = PassThrough(self.bool_in, self.data_in, self.output) def test_all_points(self): '''Test that it passes through every point when given True control signal''' every_point = [True] * 100 [ self.bool_in.put(Event(tag=i, value=every_point[i])) for i in self.data ] self.bool_in.put(LastEvent()) self.block.start() self.block.join() [self.assertEquals(self.output.get().tag, i) for i in self.data] self.assertTrue(self.output.get().last) def test_every_second_point(self): '''Test every second point is passed through and that the rest is discarded ''' [ self.bool_in.put(Event(tag=i, value=self.every_second_point[i])) for i in self.data ] self.bool_in.put(LastEvent()) self.block.start() self.block.join() [ self.assertEquals(self.output.get().tag, i) for i in self.data if i % 2 == 0 ] self.assertTrue(self.output.get().last) def test_no_points(self): '''Test that no points get passed through for an all False signal''' [ self.bool_in.put(Event(tag=i, value=self.no_points[i])) for i in self.data ] self.bool_in.put(LastEvent()) self.block.start() self.block.join() self.assertTrue(self.output.get().last)