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)
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)
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)
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)
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)
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)
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)
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)
