def pushOnePlusPacketsThread(self, firstStreamID, restStreamID, numPacketsToSend): self.dataShortInput.pushPacket([], bulkio_helpers.createCPUTimestamp(), False, firstStreamID) for x in range(numPacketsToSend): self.dataShortInput.pushPacket([], bulkio_helpers.createCPUTimestamp(), False, restStreamID)
def testChangeBlockWithNonEmptyQueue(self): self.utility() numPackets = 6 #set the queueDepth to the number of packets intending to be sent - 1 self.comp.mqd = numPackets - 1 #set the port to not block (this is default behavior s2_sri = BULKIO.StreamSRI(1, 0.0, 0.001, 1, 300, 0.0, 0.001, 1, 1, 's2', False, []) self.dataShortInput.pushSRI(s2_sri) #fill the queue half way self.dataShortInput.pushPacket([1], bulkio_helpers.createCPUTimestamp(), False, 's2') self.dataShortInput.pushPacket([1], bulkio_helpers.createCPUTimestamp(), False, 's2') self.dataShortInput.pushPacket([1], bulkio_helpers.createCPUTimestamp(), False, 's2') #now set the port the be blocking s1_sri = BULKIO.StreamSRI(1, 0.0, 0.001, 1, 300, 0.0, 0.001, 1, 1, 's1', True, []) self.dataShortInput.pushSRI(s1_sri) #should still be able to push 2 more before the queue is full self.dataShortInput.pushPacket([1], bulkio_helpers.createCPUTimestamp(), False, 's2') self.dataShortInput.pushPacket([1], bulkio_helpers.createCPUTimestamp(), False, 's2') #send the last packet in a separate thread #this call should block, not flush t2 = threading.Thread(None, self.pushOnePacketThread, 't2', ('s2', ), {}) t2.setDaemon(True) t2.start() #start the 'quasi' component thread, tell him to receive numPackets t1 = threading.Thread(None, self.getPacketThread, 't1', (numPackets, ), {}) t1.setDaemon(True) t1.start() self.comp.start() t2.join() t1.join() self.comp.stop() #should not have flushed self.assertTrue(not self.queueFlushed) self.assertTrue(self.packetsReceived == numPackets) self.comp.releaseObject()
def testBulkIOTimeStamp(self): ts_start = bulkio_helpers.createCPUTimestamp() self.source = sb.DataSource(startTime=ts_start.twsec + ts_start.tfsec) self.octetConnect() sb.start() fakeData = 1024 * [1] self.source.push(fakeData, EOS=False, streamID=self.id(), sampleRate=1.0, complexData=False, loop=False) rcv = self.getPacket() sdds_header = self.getHeader(rcv) frac_int = sdds_header.timeTag % 4000000000 secs_int = sdds_header.timeTag - frac_int frac_flt = frac_int / 4e9 secs_flt = secs_int / 4e9 ext_flt = 250e-12 * sdds_header.timeTagExt / 4294967296.0 frac_flt += ext_flt now = datetime.datetime.utcnow() first_of_year = datetime.datetime(now.year, 1, 1, tzinfo=UTC()) begin_of_time = datetime.datetime(1970, 1, 1, tzinfo=UTC()) startOfYear = timedelta_total_seconds(first_of_year - begin_of_time) bulkIO_twsec = secs_flt + startOfYear bulkIO_tfsec = frac_flt self.assertEqual(bulkIO_tfsec, ts_start.tfsec, "Expected frac seconds do not match") self.assertEqual(bulkIO_twsec, ts_start.twsec, "Expected whole seconds do not match")
def pushOnePacketThread(self, streamID): self.dataShortInput.pushPacket([], bulkio_helpers.createCPUTimestamp(), False, streamID)
def testEOSBlockReset(self): self.utility() numPackets = 4 #set the queueDepth to the number of packets intending to be sent - 1 self.comp.mqd = numPackets - 1 #send two streamSRI, one for blocking and one to not block, should tell the port to block s1_sri = BULKIO.StreamSRI(1, 0.0, 0.001, 1, 300, 0.0, 0.001, 1, 1, 's1', True, []) s2_sri = BULKIO.StreamSRI(1, 0.0, 0.001, 1, 300, 0.0, 0.001, 1, 1, 's2', False, []) self.dataShortInput.pushSRI(s1_sri) self.dataShortInput.pushSRI(s2_sri) #start the 'quasi' component thread, tell him to receive numPackets*2 t1 = threading.Thread(None, self.getPacketThread, 't1', (numPackets * 2, ), {}) t1.setDaemon(True) t1.start() #fill the queue for x in range(numPackets - 1): self.dataShortInput.pushPacket([], bulkio_helpers.createCPUTimestamp(), False, 's1') #send the last one and the rest of the packets in a separate thread t2 = threading.Thread(None, self.pushOnePlusPacketsThread, 't2', ('s1', 's2', numPackets), {}) t2.setDaemon(True) t2.start() #start the component and let the 'quasi' component thread complete self.comp.start() t2.join() t1.join() #should not have flushed, should have gotten all packets self.assertFalse(self.queueFlushed) self.assertEquals(self.packetsReceived, numPackets * 2) self.comp.stop() #reset packetsReceived to 0 self.packetsReceived = 0 #start another receiver thread t1 = threading.Thread(None, self.getPacketThread, 't1', (numPackets * 2, ), {}) t1.setDaemon(True) t1.start() #send 2 packets, the second one with an EOS which should lift the block #since s1 was calling for the block and s2 wasn't self.comp.start() self.dataShortInput.pushPacket([], bulkio_helpers.createCPUTimestamp(), False, 's1') self.dataShortInput.pushPacket([], bulkio_helpers.createCPUTimestamp(), True, 's1') #wait to see that the EOS has passed through the component #which should reset the block to false while not self.EOSReceived: pass self.comp.stop() #push enough packets in to cause a flush self.dataShortInput.pushPacket([], bulkio_helpers.createCPUTimestamp(), False, 's2') self.dataShortInput.pushPacket([], bulkio_helpers.createCPUTimestamp(), False, 's2') self.dataShortInput.pushPacket([], bulkio_helpers.createCPUTimestamp(), False, 's2') self.dataShortInput.pushPacket([], bulkio_helpers.createCPUTimestamp(), False, 's2') self.comp.start() t1.join() self.comp.stop() #should have received the 2 packets from s1, and the single packet from s2 self.assertTrue(self.queueFlushed) self.assertTrue(self.packetsReceived == 3)
def testSRIChanged(self): ossie.utils.testing.ScaComponentTestCase.setUp(self) ####################################################################### # Launch the component with the default execparams execparams = self.getPropertySet(kinds=("execparam", ), modes=("readwrite", "writeonly"), includeNil=False) execparams = dict([(x.id, any.from_any(x.value)) for x in execparams]) self.launch(execparams) self.comp_obj.initialize() self.comp_obj.start() self.helperShortInput = bulkio_helpers.createBULKIOInputPort( BULKIO__POA.dataShort) self.dataShortInput = self.comp_obj.getPort('dataShortIn') self.dataShortOutput = self.comp_obj.getPort('dataShortOut') self.dataShortOutput.connectPort(self.helperShortInput, 'dataShortOut') shortData = bulkio_helpers.genRandomDataSet(16, True, 1000) s1_sri = BULKIO.StreamSRI(1, 0.0, 0.001, 1, 300, 0.0, 0.001, 1, 1, "s1", False, []) s2_sri = BULKIO.StreamSRI(1, 0.0, 0.001, 1, 200, 0.0, 0.001, 1, 1, "s2", False, []) self.dataShortInput.pushPacket(shortData, bulkio_helpers.createCPUTimestamp(), False, "s1") self.dataShortInput.pushPacket(shortData, bulkio_helpers.createCPUTimestamp(), False, "s2") #pushPacket with no previous pushSRI, should have the correct streamIDs but the flags #should not be set in either getPacket call data, T, EOS, streamID, sri, sriChanged, flushed = self.helperShortInput.getPacket( -1) self.assertEquals(streamID, 's1') self.assertTrue(sriChanged) data, T, EOS, streamID, sri, sriChanged, flushed = self.helperShortInput.getPacket( -1) self.assertEquals(streamID, 's2') self.assertTrue(sriChanged) self.dataShortInput.pushSRI(s1_sri) self.dataShortInput.pushSRI(s2_sri) self.dataShortInput.pushPacket(shortData, bulkio_helpers.createCPUTimestamp(), False, "s1") self.dataShortInput.pushPacket(shortData, bulkio_helpers.createCPUTimestamp(), False, "s2") #pushSRIs followed by pushPackets. The flag should be set in both getPacket #calls and the received SRIs should match the ones sent in data, T, EOS, streamID, sri, sriChanged, flushed = self.helperShortInput.getPacket( -1) self.assertEquals(streamID, 's1') self.assertTrue(bulkio_helpers.compareSRI(sri, s1_sri)) self.assertTrue(sriChanged) data, T, EOS, streamID, sri, sriChanged, flushed = self.helperShortInput.getPacket( -1) self.assertEquals(streamID, 's2') self.assertTrue(bulkio_helpers.compareSRI(sri, s2_sri)) self.assertTrue(sriChanged) s1_sri = BULKIO.StreamSRI(1, 0.0, 0.001, 1, 400, 0.0, 0.001, 1, 1, "s1", False, []) self.dataShortInput.pushSRI(s1_sri) self.dataShortInput.pushPacket(shortData, bulkio_helpers.createCPUTimestamp(), False, "s1") self.dataShortInput.pushPacket(shortData, bulkio_helpers.createCPUTimestamp(), False, "s2") #Changed the SRI for stream s1, and pushed it, did nothing for stream s2. Should see the flag set #in the first getPacket call and the streamID should be s1, also the SRI should match the new one. #The second getPacket call should return streamID s2, flag not set, and the SRI should match the old one data, T, EOS, streamID, sri, sriChanged, flushed = self.helperShortInput.getPacket( -1) self.assertEquals(streamID, 's1') self.assertTrue(bulkio_helpers.compareSRI(sri, s1_sri)) self.assertTrue(sriChanged) data, T, EOS, streamID, sri, sriChanged, flushed = self.helperShortInput.getPacket( -1) self.assertEquals(streamID, 's2') self.assertTrue(bulkio_helpers.compareSRI(sri, s2_sri)) self.assertFalse(sriChanged) #Changed the SRI for stream s2, and pushed it, did nothing for stream s1. Should see the flag set #in the second getPacket call and the streamID should be s2, also the SRI should match the new one. #The first getPacket call should return streamID s1, flag not set, and the SRI should match the old one s2_sri = BULKIO.StreamSRI(1, 0.0, 0.001, 1, 600, 0.0, 0.001, 1, 1, "s2", False, []) self.dataShortInput.pushSRI(s2_sri) self.dataShortInput.pushPacket(shortData, bulkio_helpers.createCPUTimestamp(), False, "s1") self.dataShortInput.pushPacket(shortData, bulkio_helpers.createCPUTimestamp(), False, "s2") data, T, EOS, streamID, sri, sriChanged, flushed = self.helperShortInput.getPacket( -1) self.assertEquals(streamID, 's1') self.assertTrue(bulkio_helpers.compareSRI(sri, s1_sri)) self.assertFalse(sriChanged) data, T, EOS, streamID, sri, sriChanged, flushed = self.helperShortInput.getPacket( -1) self.assertEquals(streamID, 's2') self.assertTrue(bulkio_helpers.compareSRI(sri, s2_sri)) self.assertTrue(sriChanged) #Did nothing to change either stream s1 or stream s2. Should see no changes to SRI, and should not #see the flag set in either getPacket call. The streamIDs should still come back in order self.dataShortInput.pushPacket(shortData, bulkio_helpers.createCPUTimestamp(), False, "s1") self.dataShortInput.pushPacket(shortData, bulkio_helpers.createCPUTimestamp(), False, "s2") data, T, EOS, streamID, sri, sriChanged, flushed = self.helperShortInput.getPacket( -1) self.assertEquals(streamID, 's1') self.assertTrue(bulkio_helpers.compareSRI(sri, s1_sri)) self.assertFalse(sriChanged) data, T, EOS, streamID, sri, sriChanged, flushed = self.helperShortInput.getPacket( -1) self.assertEquals(streamID, 's2') self.assertTrue(bulkio_helpers.compareSRI(sri, s2_sri)) self.assertFalse(sriChanged) #Changed the SRI for stream s2, and pushed it, Then repeated the operation changing the SRI again before #making a pushPacket call for either stream, Should see the flag set in the getPacket call, also the SRI #should match the latest one pushed. s2_sri = BULKIO.StreamSRI(1, 0.0, 0.001, 1, 500, 0.0, 0.001, 1, 1, "s2", False, []) self.dataShortInput.pushSRI(s2_sri) s2_sri = BULKIO.StreamSRI(1, 0.0, 0.001, 1, 700, 0.0, 0.001, 1, 1, "s2", False, []) self.dataShortInput.pushSRI(s2_sri) self.dataShortInput.pushPacket(shortData, bulkio_helpers.createCPUTimestamp(), False, "s2") data, T, EOS, streamID, sri, sriChanged, flushed = self.helperShortInput.getPacket( -1) self.assertEquals(streamID, 's2') self.assertTrue(bulkio_helpers.compareSRI(sri, s2_sri)) self.assertTrue(sriChanged) #Testing that a pushPacket with an EOS flag does not break anything with SRI. The SRI is supposed #to be removed from the list that the port maintains if EOS was received for a particular streamID. #Flags should not be set and SRIs should still come back as the latest ones self.dataShortInput.pushPacket(shortData, bulkio_helpers.createCPUTimestamp(), True, "s1") self.dataShortInput.pushPacket(shortData, bulkio_helpers.createCPUTimestamp(), True, "s2") data, T, EOS, streamID, sri, sriChanged, flushed = self.helperShortInput.getPacket( -1) self.assertEquals(streamID, 's1') self.assertTrue(bulkio_helpers.compareSRI(sri, s1_sri)) self.assertFalse(sriChanged) data, T, EOS, streamID, sri, sriChanged, flushed = self.helperShortInput.getPacket( -1) self.assertEquals(streamID, 's2') self.assertTrue(bulkio_helpers.compareSRI(sri, s2_sri)) self.assertFalse(sriChanged) #This final test looks to see if the same SRI is pushed once before a pushPacket, then again after #the pushPacket, that the sriChanged flag won't be set for the next data set to be returned. A #pushSRI with the exact same SRI that already exists should not cause the flag to be set. The first #getPacket should see new SRI and the flag set, the second one should see the same SRI, no flag set s1_sri = BULKIO.StreamSRI(1, 0.0, 0.001, 1, 300, 0.0, 0.001, 1, 1, "s1", False, []) self.dataShortInput.pushSRI(s1_sri) self.dataShortInput.pushPacket(shortData, bulkio_helpers.createCPUTimestamp(), False, "s1") self.dataShortInput.pushSRI(s1_sri) self.dataShortInput.pushPacket(shortData, bulkio_helpers.createCPUTimestamp(), False, "s1") data, T, EOS, streamID, sri, sriChanged, flushed = self.helperShortInput.getPacket( -1) self.assertEquals(streamID, 's1') self.assertTrue(bulkio_helpers.compareSRI(sri, s1_sri)) self.assertTrue(sriChanged) data, T, EOS, streamID, sri, sriChanged, flushed = self.helperShortInput.getPacket( -1) self.assertEquals(streamID, 's1') self.assertTrue(bulkio_helpers.compareSRI(sri, s1_sri)) self.assertFalse(sriChanged) self.comp_obj.stop() self.comp_obj.releaseObject()
def testMaxQueueDepth(self): shortData = bulkio_helpers.genRandomDataSet(16, True, 100) oldFlushTime = None #try changing it to 10 newmqd = 10 self.comp_obj.configure([ ossie.cf.CF.DataType(id='mqd', value=CORBA.Any(CORBA.TC_short, newmqd)) ]) currmqd = self.comp_obj.query( [ossie.cf.CF.DataType(id=str('mqd'), value=any.to_any(None))])[0].value.value() self.assertEquals(currmqd, newmqd) #push the max + 1 packets, should see a flush on the last packet but not on any other #the reason the packets will be queuing up is because the component has not been started up. for x in range(newmqd + 1): stats = self.dataShortInput._get_statistics() for x in stats.keywords: if x.id == 'timeSinceLastFlush': self.fail("Flush happened before it should have") self.dataShortInput.pushPacket(shortData, bulkio_helpers.createCPUTimestamp(), False, 'stream1') stats = self.dataShortInput._get_statistics() if 'timeSinceLastFlush' not in [y.id for y in stats.keywords]: self.fail("Should have flushed at the max+1 pushPacket") else: for x in stats.keywords: if x.id == 'timeSinceLastFlush': oldFlushTime = x.value.value() break #try setting it again newmqd = 250 self.comp_obj.configure([ ossie.cf.CF.DataType(id='mqd', value=CORBA.Any(CORBA.TC_short, newmqd)) ]) currmqd = self.comp_obj.query( [ossie.cf.CF.DataType(id=str('mqd'), value=any.to_any(None))])[0].value.value() self.assertEquals(int(currmqd), newmqd) #push the max packets (THERE IS ALREADY ONE PACKET IN THE QUEUE #should see a flush on the last packet but not on any other newFlushTime = None for x in range(newmqd): stats = self.dataShortInput._get_statistics() for y in stats.keywords: if y.id == 'timeSinceLastFlush': newFlushTime = y.value.value() self.assertTrue(oldFlushTime <= newFlushTime) oldFlushTime = newFlushTime break self.dataShortInput.pushPacket(shortData, bulkio_helpers.createCPUTimestamp(), False, 'stream1') stats = self.dataShortInput._get_statistics() for x in stats.keywords: if x.id == 'timeSinceLastFlush': newFlushTime = x.value.value() break self.assertTrue(newFlushTime <= oldFlushTime) oldFlushTime = newFlushTime #try making it infinite newmqd = -1 self.comp_obj.configure([ ossie.cf.CF.DataType(id='mqd', value=CORBA.Any(CORBA.TC_short, newmqd)) ]) currmqd = self.comp_obj.query( [ossie.cf.CF.DataType(id=str('mqd'), value=any.to_any(None))])[0].value.value() self.assertEquals(int(currmqd), newmqd) #push 1000 packets, should not see a flush at all newFlushTime = None for x in range(1000): stats = self.dataShortInput._get_statistics() for y in stats.keywords: if y.id == 'timeSinceLastFlush': newFlushTime = y.value.value() self.assertTrue(oldFlushTime <= newFlushTime) oldFlushTime = newFlushTime break self.dataShortInput.pushPacket(shortData, bulkio_helpers.createCPUTimestamp(), False, 'stream1') stats = self.dataShortInput._get_statistics() #set it to blocking, make sure it doesn't break newmqd = 0 self.comp_obj.configure([ ossie.cf.CF.DataType(id='mqd', value=CORBA.Any(CORBA.TC_short, newmqd)) ]) currmqd = self.comp_obj.query( [ossie.cf.CF.DataType(id=str('mqd'), value=any.to_any(None))])[0].value.value() self.assertEquals(int(currmqd), newmqd) #push 100 packets, the pushPacket returns immediately, the queueShould not grow firstaqd = self.dataShortInput._get_statistics().averageQueueDepth nextaqd = None newFlushTime = None for x in range(5): self.dataShortInput.pushPacket(shortData, bulkio_helpers.createCPUTimestamp(), False, 'stream1') nextaqd = self.dataShortInput._get_statistics().averageQueueDepth self.assertEquals(firstaqd, nextaqd)
def testEmptyDataPush(self): self.comp_obj.start() ##################################### # Send empty data on each input port self.dataCharInput.pushPacket('', bulkio_helpers.createCPUTimestamp(), False, "s1") self.dataDoubleInput.pushPacket([], bulkio_helpers.createCPUTimestamp(), False, "s2") self.dataFloatInput.pushPacket([], bulkio_helpers.createCPUTimestamp(), False, "s3") self.dataLongInput.pushPacket([], bulkio_helpers.createCPUTimestamp(), False, "s4") self.dataOctetInput.pushPacket('', bulkio_helpers.createCPUTimestamp(), False, "s5") self.dataShortInput.pushPacket([], bulkio_helpers.createCPUTimestamp(), False, "s6") self.dataUlongInput.pushPacket([], bulkio_helpers.createCPUTimestamp(), False, "s7") self.dataUshortInput.pushPacket([], bulkio_helpers.createCPUTimestamp(), False, "s8") self.dataXMLInput.pushPacket('', False, "s9") self.dataFileInput.pushPacket('', bulkio_helpers.createCPUTimestamp(), False, 's10') self.dataLongLongInput.pushPacket([], bulkio_helpers.createCPUTimestamp(), False, "s11") self.dataUlongLongInput.pushPacket([], bulkio_helpers.createCPUTimestamp(), False, "s12") ########################################## # Receive data from each output port # *** THESE GET PACKETS ARE BLOCKING! *** _charData, T, EOS, streamID, sri, sriChanged, flushed = self.helperCharInput.getPacket( 2) _doubleData, T, EOS, streamID, sri, sriChanged, flushed = self.helperDoubleInput.getPacket( 2) _floatData, T, EOS, streamID, sri, sriChanged, flushed = self.helperFloatInput.getPacket( 2) _longData, T, EOS, streamID, sri, sriChanged, flushed = self.helperLongInput.getPacket( 2) _octetData, T, EOS, streamID, sri, sriChanged, flushed = self.helperOctetInput.getPacket( 2) _shortData, T, EOS, streamID, sri, sriChanged, flushed = self.helperShortInput.getPacket( 2) _uLongData, T, EOS, streamID, sri, sriChanged, flushed = self.helperUlongInput.getPacket( 2) _uShortData, T, EOS, streamID, sri, sriChanged, flushed = self.helperUshortInput.getPacket( 2) _xmlData, T, EOS, streamID, sri, sriChanged, flushed = self.helperXMLInput.getPacket( 2) _fileData, T, EOS, streamID, sri, sriChanged, flushed = self.helperFileInput.getPacket( 2) _longLongData, T, EOS, streamID, sri, sriChanged, flushed = self.helperLongLongInput.getPacket( 2) _uLongLongData, T, EOS, streamID, sri, sriChanged, flushed = self.helperUlongLongInput.getPacket( 2) sentData = ['', [], [], [], '', [], [], [], '', '', [], []] types = [ 'char', 'double', 'float', 'long', 'octet', 'short', 'uLong', 'uLongLong', 'longLong', 'uShort', 'xml', 'file' ] sentData = { 'char': '', 'double': [], 'float': [], 'long': [], 'octet': '', 'short': [], 'uLong': [], 'uShort': [], 'xml': '', 'file': '', 'longLong': [], 'uLongLong': [] } recData = {'char':_charData, 'double':_doubleData, 'float':_floatData, 'long':_longData, 'octet':_octetData, 'short':_shortData,\ 'uLong':_uLongData, 'uShort':_uShortData, 'xml':_xmlData, 'file':_fileData, 'longLong':_longLongData, 'uLongLong':_uLongLongData} for x in types: self.assertNotEquals( None, recData[x], msg="No empty set was recieved for dataType (" + str(x) + ")") ############################################# # Check that data received matches data sent for x in types: self.assertEqual(recData[x], sentData[x]) self.comp_obj.stop()
def testDataPush(self): charData = bulkio_helpers.genRandomDataSet(8, True, 1000) doubleData = bulkio_helpers.genRandomDataSet(64, True, 1000) floatData = bulkio_helpers.genRandomDataSet(32, True, 1000) longData = bulkio_helpers.genRandomDataSet(32, True, 1000) octetData = bulkio_helpers.genRandomDataSet(8, False, 1000) shortData = bulkio_helpers.genRandomDataSet(16, True, 1000) uLongData = bulkio_helpers.genRandomDataSet(32, False, 1000) uLongLongData = bulkio_helpers.genRandomDataSet(32, False, 1000) longLongData = bulkio_helpers.genRandomDataSet(64, True, 1000) uShortData = bulkio_helpers.genRandomDataSet(16, False, 1000) xmlData = '<?xml version="1.0" encoding="ISO-8859-1"?>' fileData = 'SCA:/data/redhawk/myfile' #Format the data sets to be sure they can be used in the pushPacket call formCharData = bulkio_helpers.formatData(charData, self.dataCharInput) formDoubleData = bulkio_helpers.formatData(doubleData, self.dataDoubleInput) formFloatData = bulkio_helpers.formatData(floatData, self.dataFloatInput) formLongData = bulkio_helpers.formatData(longData, self.dataLongInput) formOctetData = bulkio_helpers.formatData(octetData, self.dataOctetInput) formShortData = bulkio_helpers.formatData(shortData, self.dataShortInput) formULongData = bulkio_helpers.formatData(uLongData, self.dataUlongInput) formULongLongData = bulkio_helpers.formatData(uLongLongData, self.dataUlongLongInput) formLongLongData = bulkio_helpers.formatData(longLongData, self.dataLongLongInput) formUShortData = bulkio_helpers.formatData(uShortData, self.dataUshortInput) formXmlData = bulkio_helpers.formatData(xmlData, self.dataXMLInput) formFileData = bulkio_helpers.formatData(fileData, self.dataFileInput) self.comp_obj.start() num_test_runs = 10 for i in range(num_test_runs): ################################ # Send Data on each output port self.dataCharInput.pushPacket(formCharData, bulkio_helpers.createCPUTimestamp(), False, "s1") self.dataDoubleInput.pushPacket( formDoubleData, bulkio_helpers.createCPUTimestamp(), False, "s2") self.dataFloatInput.pushPacket(formFloatData, bulkio_helpers.createCPUTimestamp(), False, "s3") self.dataLongInput.pushPacket(formLongData, bulkio_helpers.createCPUTimestamp(), False, "s4") self.dataOctetInput.pushPacket(formOctetData, bulkio_helpers.createCPUTimestamp(), False, "s5") self.dataShortInput.pushPacket(formShortData, bulkio_helpers.createCPUTimestamp(), False, "s6") self.dataUlongInput.pushPacket(formULongData, bulkio_helpers.createCPUTimestamp(), False, "s7") self.dataUlongLongInput.pushPacket( formULongLongData, bulkio_helpers.createCPUTimestamp(), False, "s8") self.dataLongLongInput.pushPacket( formLongLongData, bulkio_helpers.createCPUTimestamp(), False, "s9") self.dataUshortInput.pushPacket( formUShortData, bulkio_helpers.createCPUTimestamp(), False, "s10") self.dataXMLInput.pushPacket(formXmlData, False, "s11") self.dataFileInput.pushPacket(formFileData, bulkio_helpers.createCPUTimestamp(), False, "s12") ########################################################## # Receive data from each output port # *** THESE GET PACKETS CAN BE SET TO BLOCK OR TIMEOUT *** _charData, T, EOS, streamID, sri, sriChanged, flushed = self.helperCharInput.getPacket( 2) _doubleData, T, EOS, streamID, sri, sriChanged, flushed = self.helperDoubleInput.getPacket( 2) _floatData, T, EOS, streamID, sri, sriChanged, flushed = self.helperFloatInput.getPacket( 2) _longData, T, EOS, streamID, sri, sriChanged, flushed = self.helperLongInput.getPacket( 2) _octetData, T, EOS, streamID, sri, sriChanged, flushed = self.helperOctetInput.getPacket( 2) _shortData, T, EOS, streamID, sri, sriChanged, flushed = self.helperShortInput.getPacket( 2) _uLongData, T, EOS, streamID, sri, sriChanged, flushed = self.helperUlongInput.getPacket( 2) _uLongLongData, T, EOS, streamID, sri, sriChanged, flushed = self.helperUlongLongInput.getPacket( 2) _longLongData, T, EOS, streamID, sri, sriChanged, flushed = self.helperLongLongInput.getPacket( 2) _uShortData, T, EOS, streamID, sri, sriChanged, flushed = self.helperUshortInput.getPacket( 2) _xmlData, T, EOS, streamID, sri, sriChanged, flushed = self.helperXMLInput.getPacket( 2) _fileData, T, EOS, streamID, sri, sriChanged, flushed = self.helperFileInput.getPacket( 2) types = [ 'char', 'double', 'float', 'long', 'octet', 'short', 'uLong', 'uLongLong', 'longLong', 'uShort', 'xml', 'file' ] sentData = {'char':formCharData, 'double':formDoubleData, 'float':formFloatData, 'long':formLongData, 'octet':formOctetData,\ 'short':formShortData, 'uLong':formULongData, 'uShort':formUShortData, 'xml':formXmlData, 'file':formFileData,\ 'longLong':formLongLongData, 'uLongLong':formULongLongData} recData = {'char':_charData, 'double':_doubleData, 'float':_floatData, 'long':_longData, 'octet':_octetData, 'short':_shortData,\ 'uLong':_uLongData, 'uShort':_uShortData, 'xml':_xmlData, 'file':_fileData, 'longLong':_longLongData, 'uLongLong':_uLongLongData} for x in types: self.assertNotEquals( None, recData[x], msg="No data was recieved for dataType (" + str(x) + ")") ############################################# # Check that data received matches data sent for x in types: self.assertEqual(recData[x], sentData[x]) ######################################### # Check restoring the 8 bit data to its # original yields the same results restCharData = bulkio_helpers.restoreData(_charData, '8bit') restOctetData = bulkio_helpers.restoreData(_octetData, 'u8bit') self.assertEquals(restCharData, charData) self.assertEquals(restOctetData, octetData) self.comp_obj.stop()