def setUp(self):
"""Set up the unit test - this is run before every method that starts with test
"""
ossie.utils.testing.ScaComponentTestCase.setUp(self)
self.src = sb.DataSource()
self.soft = sb.DataSink()
self.bits = sb.DataSink()
self.phase = sb.DataSink()
#setup my components
self.setupComponent()
self.comp.start()
self.src.start()
self.soft.start()
self.bits.start()
#do the connections
self.src.connect(self.comp)
self.comp.connect(self.soft, usesPortName='softDecision_dataFloat_out')
self.comp.connect(self.bits, usesPortName='bits_dataShort_out')
self.comp.connect(self.phase, usesPortName='phase_dataFloat_out')
def setUp(self):
"""Set up the unit test - this is run before every method that starts with test.
"""
ossie.utils.testing.ScaComponentTestCase.setUp(self)
#######################################################################
# Launch and initialize the component with the default execparam/property values,
# and set debug level
print ' * Note:'
print ' * During this unit test, SinkVITA49 will warn about using a built-in table'
print ' * for leap seconds if no leap seconds file is found at the indicated location.'
self.launch(execparams={"DEBUG_LEVEL": DEBUG_LEVEL})
#######################################################################
# Set up data input/output and tracking variables
self.dataSource = sb.DataSource()
self.dataSource.connect(self.comp, 'dataShort_in')
self.inVitaPort = bulkio.InVITA49Port("dataVITA49_in")
self.inVitaPort.setNewAttachDetachListener(self)
self.attaches = 0
self.detaches = 0
def testEosPush(self):
self.octetConnect()
short_source = sb.DataSource()
short_source.connect(self.comp, usesPortName='shortOut')
sb.start()
goodData1 = 1024 * [1]
goodData2 = 1024 * [3]
self.source.push(goodData1,
EOS=False,
streamID=self.id(),
sampleRate=1.0,
complexData=False,
loop=False)
self.assertEqual(
goodData1, list(struct.unpack('1024B',
self.getPacket()[-1024:])))
# Push an empty packet with EOS
self.source.push([],
EOS=True,
streamID=self.id(),
sampleRate=1.0,
complexData=False,
loop=False)
# Push a new stream with new stream ID
self.source.push(goodData2,
EOS=False,
streamID="New Stream",
sampleRate=1.0,
complexData=False,
loop=False)
self.assertEqual(
goodData2, list(struct.unpack('1024B',
self.getPacket()[-1024:])))
def setUp(self):
"""Set up the unit test - this is run before every method that starts with test
"""
ossie.utils.testing.ScaComponentTestCase.setUp(self)
self.src = sb.DataSource()
self.sinkAM = sb.DataSink()
self.sinkPM = sb.DataSink()
self.sinkFM = sb.DataSink()
#start all my components
self.startComponent()
props = {
'freqDeviation': 10.0,
'phaseDeviation': 20.0,
'squelch': -2000.0
}
self.comp.configure(props_from_dict(props))
self.comp.start()
self.src.start()
self.sinkAM.start()
self.sinkPM.start()
self.sinkFM.start()
def _testConnectionFail(self, format, data):
uses_name = 'data%sOut' % format
provides_name = 'data%sIn' % format
source = sb.DataSource()
source.connect(self.comp1, providesPortName=provides_name)
self.comp1.connect(self.comp2, usesPortName=uses_name)
sink = sb.DataSink()
self.comp1.connect(sink, usesPortName=uses_name)
sb.start()
os.kill(self.comp2._pid, 9)
while self.comp2._process.isAlive():
time.sleep(0.1)
source.push(data, EOS=False, streamID='test_connection_fail')
for ii in xrange(9):
source.push(data, EOS=False)
source.push(data, EOS=True)
sink.getData(eos_block=True)
def _test_FileSink(self, format):
filename = self._tempfileName('sink_%s' % format)
complexData = format.startswith('C')
typecode = format[1]
dataFormat, dataType = self.TYPEMAP[typecode]
indata = [dataType(x) for x in xrange(16)]
source = sb.DataSource(dataFormat=dataFormat)
sink = sb.FileSink(filename, midasFile=True)
source.connect(sink)
sb.start()
source.push(indata, complexData=complexData, EOS=True)
sink.waitForEOS()
hdr, outdata = bluefile.read(filename)
self.assertEqual(hdr['format'], format)
if complexData:
if dataFormat in ('double', 'float'):
outdata = list(self._flatten(outdata))
else:
outdata = outdata.flatten()
self.assertTrue(numpy.array_equal(indata, outdata), msg="Format '%s' %s != %s" % (format, indata, outdata))
def testFlush(self):
"""
Test the standard flush behavior.
"""
self.utility()
numPackets = 4
# Set the queue depth to the number of packets intending to be sent - 1
self.comp.mqd = numPackets - 1
# Create a non-blocking source
source = sb.DataSource(blocking=False)
source.connect(self.comp)
# Create a sink for the output
sink = sb.DataSink()
self.comp.connect(sink)
# Send numPackets without starting the component, should generate a flush
for x in range(numPackets):
source.push([x])
source.start()
source.push([], EOS=True)
# Ensure all packets are pushed before starting component
source.waitAllPacketsSent()
# Start the component and let the stream complete
self.comp.start()
sink.start()
data = sink.getData(eos_block=True)
self.assertEqual(len(data), 1)
source.stop()
sink.stop()
self.comp.stop()
def setUp(self):
"""Set up the unit test - this is run before every method that starts with test
"""
ossie.utils.testing.ScaComponentTestCase.setUp(self)
self.src = sb.DataSource()
self.sink = sb.DataSink()
#setup my components
self.setupComponent()
self.setProps(alpha=.9,
eps=1e-4,
avgPower=100,
minPower=1e10,
maxPower=-1e10,
enabled=True)
self.comp.start()
self.src.start()
self.sink.start()
#do the connections
self.src.connect(self.comp)
self.comp.connect(self.sink, 'floatIn')
def _test_FileSinkOctet(self, format):
filename = self._tempfileName('sink_octet_' + format.lower())
source = sb.DataSource(dataFormat='octet')
sink = sb.FileSink(filename, midasFile=True)
source.connect(sink)
sb.start()
# Push a 256-element ramp (the maximum range of octet)
indata = range(256)
isComplex = bool(format[0] == 'C')
source.push(indata, complexData=isComplex, EOS=True)
sink.waitForEOS()
# Check the BLUE file format matches
hdr, data = bluefile.read(filename)
self.assertEqual(format, hdr['format'])
# Have to "cast" the data to unsigned 8-bit, since 'B' is a signed type
# (as are all BLUE formats), and flattening the array re-interleaves
# complex data
outdata = data.view(numpy.uint8).reshape(-1)
self.assertTrue(numpy.array_equal(indata, outdata),
msg="Format '%s' %s != %s" % (format, indata, outdata))
#
# This file is part of REDHAWK bulkioInterfaces.
#
# REDHAWK bulkioInterfaces is free software: you can redistribute it and/or modify it under
# the terms of the GNU Lesser General Public License as published by the Free
# Software Foundation, either version 3 of the License, or (at your option) any
# later version.
#
# REDHAWK bulkioInterfaces is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
# details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see http://www.gnu.org/licenses/.
#
import sys
from ossie.utils import sb
dsource = sb.DataSource()
dsink = sb.DataSink()
test_comp = sb.Component('CPP_Ports')
data = range(100)
dsource.connect(test_comp, providesPortName='dataShortIn')
test_comp.connect(dsink,
providesPortName='shortIn',
usesPortName='dataShortOut')
sb.start()
dsource.push(data, EOS=True)
dest_data = dsink.getData(eos_block=True)
def testMultipleStreamsDifferentPort(self):
self.octetConnect()
short_source = sb.DataSource()
short_source.connect(self.comp, usesPortName='shortOut')
sink = sb.DataSinkSDDS()
ad_cb = SddsAttachDetachCB()
sink.registerAttachCallback(ad_cb.attach_cb)
sink.registerDetachCallback(ad_cb.detach_cb)
self.comp.connect(sink)
sb.start()
goodData1 = 1024 * [1]
deckedData = 512 * [2]
goodData2 = 512 * [3]
# No data pushed, no attaches or detaches
self.assertEqual(len(ad_cb.get_attach()), 0,
"Should not have received any attaches")
# Push one good packet and confirm it was received
self.source.push(goodData1,
EOS=False,
streamID=self.id(),
sampleRate=1.0,
complexData=False,
loop=False)
self.assertEqual(
goodData1, list(struct.unpack('1024B',
self.getPacket()[-1024:])))
# Since we pushed, we should get an attach, no detach
self.assertEqual(len(ad_cb.get_attach()), 1,
"Should have received 1 attach total")
# Push a new stream, it should get decked, and disabled, confirm we receive no data and still have only a single attach
short_source.push(deckedData,
EOS=False,
streamID="Decked Stream",
sampleRate=1.0,
complexData=False,
loop=False)
self.assertEqual(
len(self.getPacket()), 0,
"Should not have passed on new stream, stream already active")
self.assertEqual(len(ad_cb.get_attach()), 1,
"Should have received 1 attach total")
# Push an EOS which should cause a detach, the decked stream to become active and the goodData pushed and us to have another attach called.
self.source.push(goodData1,
EOS=True,
streamID=self.id(),
sampleRate=1.0,
complexData=False,
loop=False)
self.assertEqual(
goodData1, list(struct.unpack('1024B',
self.getPacket()[-1024:])))
time.sleep(2)
self.assertEqual(len(ad_cb.get_attach()), 2,
"Should have received 2 attach total")
# Push decked data and EOS It.
short_source.push(deckedData,
EOS=True,
streamID="Decked Stream",
sampleRate=1.0,
complexData=False,
loop=False)
self.assertEqual(
deckedData, list(struct.unpack('!512H',
self.getPacket()[-1024:])))
# Send a new stream, which means a new attach
short_source.push(goodData2,
EOS=False,
streamID="New Stream",
sampleRate=1.0,
complexData=False,
loop=False)
self.assertEqual(
goodData2, list(struct.unpack('!512H',
self.getPacket()[-1024:])))
self.assertEqual(len(ad_cb.get_attach()), 3,
"Should have received 3 attach total")
# Tear stuff down, confirm we get the final detach
sb.release()
self.assertEqual(len(ad_cb.get_attach()), 3,
"Should have received 3 attach total")
self.assertEqual(len(ad_cb.get_detach()), 3,
"Should have received 3 detach total")
#
# You should have received a copy of the GNU Lesser General Public License along with this
# program. If not, see http://www.gnu.org/licenses/.
#
from ossie.utils import sb
from ossie.properties import props_from_dict
import ossie.properties
print ossie.properties.__file__
import math
from math import cos
import time
c = sb.Component('../fcalc.spd.xml')
src1 = sb.DataSource()
src2 = sb.DataSource()
sink = sb.DataSink()
src1.connect(c, 'a')
src2.connect(c, 'b')
c.connect(sink, 'floatIn')
c.equation = "math.sin(3*a)+cos(5*b)"
print c.query([])
sb.start()
data1 = [float(x) for x in xrange(1024)]
data2 = [float(x) for x in xrange(-512, 0)]
data3 = [float(x) for x in xrange(0, 512)]
src1.push(data1)
#f.write('\n\n')
f.write('*********************************\n')
f.write('********** Unit Test 5 **********\n')
f.write('*********************************\n\n')
# This unit test relies on rhSourceVITA49 component for end-to-end testing
if "rh.SourceVITA49" not in sb.catalog():
print "ERROR - cannot run tests without rh.SourceVITA49. Install in $SDRROOT and try again."
sys.exit(1)
f.write('********** Creating components and connections **********\n')
sink = sb.launch('../SinkVITA49.spd.xml', execparams={"DEBUG_LEVEL": 0})
source = sb.launch('rh.SourceVITA49', execparams={"DEBUG_LEVEL": 0})
#push data into the sink NIC
inputS = sb.DataSource()
outputS = sb.DataSink()
sink.connect(source, providesPortName='dataVITA49_in')
inputS.connect(sink, providesPortName='dataShort_in')
source.connect(outputS, providesPortName='shortIn')
f.write('***** Source Configuration *****\n')
source.interface = ethernet_device
f.write('source.interface = "em1"\n')
source.attachment_override.enabled = False
f.write('source.attachment_override.enabled = True\n')
source.attachment_override.ip_address = ip_address
f.write('source.attachment_override.ip_address = ip_address\n')
source.attachment_override.port = network_port
f.write('source.attachment_override.port = 29465')
# for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this program. If not, see http://www.gnu.org/licenses/.
#
import time
from ossie.utils import sb
print '*****************************************'
print '**** Differenetial Decoder Unit Test ****'
print '*****************************************'
print '\n********* Creating Components ***********'
#Use sb helpers for producing and receiving data from component
src = sb.DataSource()
sink = sb.DataSink()
decoder = sb.launch('DifferentialDecoder', execparams={'DEBUG_LEVEL': 5})
print '\n********* Creating Connections **********'
#Make connections
src.connect(decoder)
decoder.connect(sink)
print 'Connections Created'
print '\n*********** Starting Sandbox ************'
#Start sandbox env
sb.start()
print 'Components Started'
print '\n*********** Generating Data *************'
def main():
f = open('unit_test.log', 'w')
display(f, "*********************************")
display(f, "******** BPSK Unit Test *********")
display(f, "*********************************")
# Launch the component and the input sources and output sink
display(f, "\n******* Creating Component ******")
test_component = sb.launch('../BPSK.spd.xml',
execparams={'DEBUG_LEVEL': 5})
clockSource = sb.DataSource()
dataSource = sb.DataSource()
dataSink = sb.DataSink()
# Connect the output of the clock source and the data source
# to the inputs of the BPSK. Connect the output of the BPSK
# to the input of the data sink
display(f, "\n****** Creating Connections *****")
clockSource.connect(test_component, providesPortName='clockFloat_in')
dataSource.connect(test_component, providesPortName='dataFloat_in')
test_component.connect(dataSink, providesPortName='shortIn')
display(f, "Connections created")
display(f, "\n******** Generating Data ********")
# Generate a simple sine wave for use as the clock and the
# data
convenient_time_data = linspace(0, 48 * pi, 2400)
clock = sin(convenient_time_data).tolist()
display(f, "Single Packet Case...")
# Use 24 bits to generate a BPSK modulated signal
single_packet_data = [
0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1
]
single_packet_keyed_data = []
i = 0
for j in single_packet_data:
for k in range(i, i + 100):
if j == 1:
single_packet_keyed_data.append(clock[k])
else:
single_packet_keyed_data.append(-clock[k])
i += 100
display(f, "Two Packet Case...")
# Use a 16 bit packet and an 8 bit packet to generate two
# BPSK modulated signals using the same clock
two_packet_data1 = [0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1]
two_packet_data2 = [0, 1, 0, 1, 0, 1, 1, 1]
two_packet_keyed_data1 = []
two_packet_keyed_data2 = []
i = 0
for j in two_packet_data1:
for k in range(i, i + 100):
if j == 1:
two_packet_keyed_data1.append(clock[k])
else:
two_packet_keyed_data1.append(-clock[k])
i += 100
for j in two_packet_data2:
for k in range(i, i + 100):
if j == 1:
two_packet_keyed_data2.append(clock[k])
else:
two_packet_keyed_data2.append(-clock[k])
i += 100
display(f, "Two Packets, Unaligned Case...")
# Reuse the one packet from above, but send it as two
# that aren't lined up on the period boundary
two_packet_unaligned_keyed_data1 = []
two_packet_unaligned_keyed_data2 = []
i = 0
for j in single_packet_data[:14]:
for k in range(i, i + 100):
if j == 1:
two_packet_unaligned_keyed_data1.append(clock[k])
else:
two_packet_unaligned_keyed_data1.append(-clock[k])
i += 100
for k in range(i, i + 100):
# Put the first 27 samples into the first packet and the next
# 73 into the second packet
if k < (i + 27):
if single_packet_data[14] == 1:
two_packet_unaligned_keyed_data1.append(clock[k])
else:
two_packet_unaligned_keyed_data1.append(-clock[k])
else:
if single_packet_data[14] == 1:
two_packet_unaligned_keyed_data2.append(clock[k])
else:
two_packet_unaligned_keyed_data2.append(-clock[k])
i += 100
for j in single_packet_data[15:]:
for k in range(i, i + 100):
if j == 1:
two_packet_unaligned_keyed_data2.append(clock[k])
else:
two_packet_unaligned_keyed_data2.append(-clock[k])
i += 100
display(f, "\n******* Starting Components ******")
sb.start()
display(f, "Component started")
display(f, "** Testing Single Packet Case **")
# For now, the only accepted output rate of the BPSK is
# 1187.5 bps. Since 100 samples of the clock represents
# a period, this will force the output to be one bit per
# period
clockSource.push(clock, False, 'Test', (100 * 1187.5), False, [], None)
dataSource.push(single_packet_keyed_data, False, 'Test', (100 * 1187.5),
False, [], None)
time.sleep(1)
received_data = dataSink.getData()
passed_test_1 = True
test_1_message = ""
displayList(f, "Received Data: ", received_data)
displayList(f, "Original Data: ", single_packet_data)
# Make sure that the received data and original data
# are of the same length and that they match
if len(received_data) == len(single_packet_data):
for i in range(0, len(received_data)):
if received_data[i] != single_packet_data[i]:
passed_test_1 = False
test_1_message = "received_data[" + str(
i) + "] != original_data[" + str(i) + "]"
break
else:
passed_test_1 = False
test_1_message = "len(received_data) != len(original_data)"
#******************************************************
display(f, "\n*** Testing Two Packet Case ****")
clockSource.push(clock[:len(two_packet_keyed_data1)], False, 'Test',
(100 * 1187.5), False, [], None)
dataSource.push(two_packet_keyed_data1, False, 'Test', (100 * 1187.5),
False, [], None)
time.sleep(1)
received_data = dataSink.getData()
clockSource.push(clock[len(two_packet_keyed_data1):], False, 'Test',
(100 * 1187.5), False, [], None)
dataSource.push(two_packet_keyed_data2, False, 'Test', (100 * 1187.5),
False, [], None)
time.sleep(1)
received_data += dataSink.getData()
passed_test_2 = True
test_2_message = ""
displayList(f, "Received Data: ", received_data)
displayList(f, "Original Data1: ", two_packet_data1)
displayList(f, "Original Data2: ", two_packet_data2)
# Make sure that the received data and original data
# are of the same length and that they match
if len(received_data) == (len(two_packet_data1) + len(two_packet_data2)):
for i in range(0, len(received_data)):
if i < len(two_packet_data1):
if received_data[i] != two_packet_data1[i]:
passed_test_2 = False
test_2_message = "received_data[" + str(
i) + "] != original_data1[" + str(i) + "]"
break
else:
if received_data[i] != two_packet_data2[i -
len(two_packet_data1)]:
passed_test_2 = False
test_2_message = "received_data[" + str(
i) + "] != original_data2[" + str(
i - len(two_packet_data1)) + "]"
else:
passed_test_2 = False
test_2_message = "len(received_data) != len(original_data1) + len(original_data2)"
#******************************************************
display(f, "\n** Testing Two Packet, Unaligned Case **")
clockSource.push(clock[:len(two_packet_unaligned_keyed_data1)], False,
'Test', (100 * 1187.5), False, [], None)
dataSource.push(two_packet_unaligned_keyed_data1, False, 'Test',
(100 * 1187.5), False, [], None)
time.sleep(1)
received_data = dataSink.getData()
clockSource.push(clock[len(two_packet_unaligned_keyed_data1):], False,
'Test', (100 * 1187.5), False, [], None)
dataSource.push(two_packet_unaligned_keyed_data2, False, 'Test',
(100 * 1187.5), False, [], None)
time.sleep(1)
received_data += dataSink.getData()
passed_test_3 = True
test_3_message = ""
displayList(f, "Received Data: ", received_data)
displayList(f, "Original Data: ", single_packet_data)
# Make sure that the received data and original data
# are of the same length and that they match
if len(received_data) == len(single_packet_data):
for i in range(0, len(received_data)):
if received_data[i] != single_packet_data[i]:
passed_test_3 = False
test_3_message = "received_data[" + str(
i) + "] != original_data[" + str(i) + "]"
break
else:
passed_test_3 = False
test_3_message = "len(received_data) != len(original_data1) + len(original_data2)"
display(f, "\n******* Stopping Components ******")
sb.stop()
display(f, "Components stopped")
# Display the results of the unit test
if passed_test_1:
display(
f, "\nSingle Packet Test ...................." +
u'\u2714'.encode('utf8'))
else:
display(
f, "\nSingle Packet Test ...................." +
u'\u2718'.encode('utf8') + '\t' + test_1_message)
if passed_test_2:
display(
f, "Two Packet Test ......................." +
u'\u2714'.encode('utf8'))
else:
display(
f, "Two Packet Test ......................." +
u'\u2718'.encode('utf8') + '\t' + test_2_message)
if passed_test_3:
display(
f, "Two Packet, Unaligned Test ............" +
u'\u2714'.encode('utf8'))
else:
display(
f, "Two Packet, Unaligned Test ............" +
u'\u2718'.encode('utf8') + '\t' + test_3_message)
display(f, '\n')
display(f, "Unit Test Complete")
f.close()
def test_bpsk_decode(self):
nbits = 6000
samples_per_symbol = 4
# Generate random bit sequence and convert to BPSK symbols
bits_in = [random.randint(0, 1) for x in range(nbits)]
samples_in = symbols_to_samples(bits_to_symbols(bits_in),
samples_per_symbol)
# Add Gaussian noise and a slow rotation to the symbols
sig_in = apply_rotation(add_noise(samples_in, 0.10), 0.01)
# Convert from a list of complex pairs to a single list of floats
sig_in = expand_complex(sig_in)
source = sb.DataSource()
sink = sb.DataSink()
# FLL
fll_ntaps = 55
freq_recov = sb.Component(
'../components/fll_band_edge_cc_4o/fll_band_edge_cc_4o.spd.xml',
execparams=execparams)
freq_recov.samples_per_symbol = samples_per_symbol
freq_recov.rolloff = 0.35
freq_recov.filter_size = fll_ntaps
freq_recov.bandwidth = 2.0 * math.pi / 100.0
# Timing recovery
nfilts = 32
time_recov = sb.Component(
'../components/pfb_clock_sync_ccf_4o/pfb_clock_sync_ccf_4o.spd.xml',
execparams=execparams)
time_recov.sps = samples_per_symbol
time_recov.loop_bw = 2 * math.pi / 100.0
# Note: taps are hard-coded
time_recov.taps = list(bpsk_taps.taps)
time_recov.filter_size = nfilts
time_recov.init_phase = nfilts / 2
time_recov.max_rate_deviation = 1.5
time_recov.osps = 1
# BPSK symbol decode
receiver = sb.Component(
'../components/psk_demod_cb/psk_demod_cb.spd.xml',
execparams=execparams)
receiver.constellation = 1
receiver.loop_bw = 2 * math.pi / 100.0
receiver.fmin = -0.25
receiver.fmax = 0.25
# Connect components
source.connect(freq_recov)
freq_recov.connect(time_recov, usesPortName='data_complex_out')
time_recov.connect(receiver, usesPortName='data_complex_out')
receiver.connect(sink)
# Push data through components, waiting for completion
sb.start()
source.push(sig_in, EOS=True, complexData=True)
sym_out = sink.getData(eos_block=True)
sb.stop()
# The symbol is equivalent to the bit value; unpack from a char to
# a number.
bits_out = map(lambda x: struct.unpack('b', x)[0], sym_out)
# The output data is delayed by 34 samples
delay = 34
# Verify that our delayed output data matches the input
bit_errors = 0
for ii in range(len(bits_out) - delay):
if bits_out[ii + delay] != bits_in[ii]:
bit_errors += 1
self.failUnless(bit_errors == 0, '%d bit errors' % (bit_errors, ))
def pushDataAndCheck(self,
inputData=range(100),
expectedOutput=range(100),
pause=PAUSE,
streamID='defaultStreamID',
sampleRate=1.0,
complexData=False,
SRIKeywords=[],
usesPortName="vectorOut0",
providesPortName="vectorIn0"):
dataFormat = "double"
source = sb.DataSource(dataFormat=dataFormat)
sink = sb.DataSink()
# connect source -> compoennt -> sink
source.connect(self.comp,
usesPortName=source.supportedPorts[dataFormat]
["portDict"]["Port Name"],
providesPortName=providesPortName)
self.comp.connect(sink,
usesPortName=usesPortName,
providesPortName=sink.supportedPorts[dataFormat]
["portDict"]["Port Name"])
# Start all
source.start()
self.comp.start()
sink.start()
source.push(inputData,
EOS=True,
streamID=streamID,
sampleRate=sampleRate,
complexData=complexData,
SRIKeywords=SRIKeywords)
# Give the component some time to process the data
time.sleep(pause)
retData = sink.getData()
self.assertEquals(retData, expectedOutput)
# SRI tests
retSri = sink.sri()
self.assertEquals(sink.eos(), True)
self.assertEquals(retSri.streamID, streamID)
# sample rate is checked via Xdelta
self.assertEquals(retSri.xdelta, 1. / sampleRate)
self.assertEquals(retSri.mode, complexData)
# SRI keywords
if len(SRIKeywords) != len(retSri.keywords):
self.fail(
"Incorrect number of SRI keywords returned by component.")
for expectedKeyword in SRIKeywords:
found = False
for retKeyword in retSri.keywords:
if retKeyword.id == expectedKeyword._name:
self.assertEquals(str(retKeyword.value),
str(any.to_any(expectedKeyword._value)))
found = True
break
if not found:
self.fail("SRI keyword not found: " + expectedKeyword.id)
display(
f,
'******************** Unit Test 1 - Lowpass - Real Data ********************\n'
)
display(
f,
'***************************************************************************\n\n'
)
#------------------------------------------------
# Create components and connections
#------------------------------------------------
display(f, '* Creating Components and Connections\n')
filt = sb.launch('../FilterDecimate.spd.xml', execparams={"DEBUG_LEVEL": 3})
inputS = sb.DataSource(bytesPerPush=64)
outputS = sb.DataSink()
inputS.connect(filt, providesPortName='dataFloat_in')
filt.connect(outputS, providesPortName='floatIn')
#------------------------------------------------
# Start Components
#------------------------------------------------
display(f, '* Starting Component\n\n')
sb.start()
case = 0
for ii in lowpass_cases:
case += 1
passed_count += 1
display(f, '*** TEST CASE ' + str(passed_count) + ' ***\n')
