def setUp(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])
execparams['DEBUG_LEVEL'] = DEBUG_LEVEL
self.launch(execparams)
#######################################################################
# Verify the basic state of the component
self.assertNotEqual(self.comp, None)
self.assertEqual(self.comp.ref._non_existent(), False)
self.assertEqual(self.comp.ref._is_a("IDL:CF/Resource:1.0"), True)
# Load resources for majority of tests
self.src = sb.DataSource()
self.sink = sb.DataSink()
self.sinkSocket = self.comp
self.sourceSocket = NetworkSource()
self.client = None
self.clients = None
self.server = None
self.servers = None
self.sink2 = None
self.sourceSocket2 = None
def setUp(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])
execparams['DEBUG_LEVEL'] = DEBUG_LEVEL
self.launch(execparams)
#######################################################################
# Verify the basic state of the component
self.assertNotEqual(self.comp, None)
self.assertEqual(self.comp.ref._non_existent(), False)
self.assertEqual(self.comp.ref._is_a("IDL:CF/Resource:1.0"), True)
# Load resources for majority of tests
self.src = sb.DataSource()
self.sink = sb.DataSink()
self.sinkSocket = self.comp
self.sourceSocket = NetworkSource()
self.client = None
self.clients = None
self.server = None
self.servers = None
self.sink2 = None
self.sourceSocket2 = None
def startTests(self, client='CustomSink', portType='octet'):
self.sink2 = sb.DataSink()
self.sourceSocket.setPort(self.PORT)
self.sourceSocket2 = NetworkSource()
self.sourceSocket2.setPort(self.PORT + 1)
if client == 'CustomSink':
self.clients = [self.sinkSocket]
self.servers = [self.sourceSocket, self.sourceSocket2]
else:
self.servers = [self.sinkSocket]
self.clients = [self.sourceSocket, self.sourceSocket2]
sinkSocketName = 'data%s_in' % portType.capitalize()
self.src.connect(self.sinkSocket, sinkSocketName)
self.sourceSocket.connect(self.sink, None, '%sOut' % portType)
self.sourceSocket2.connect(self.sink2, None, '%sOut' % portType)
def startTests(self, client='sinksocket', portType='octet'):
self.sink2 = sb.DataSink()
self.sourceSocket.setPort(self.PORT)
self.sourceSocket2 = NetworkSource()
self.sourceSocket2.setPort(self.PORT+1)
if client == 'sinksocket':
self.clients = [self.sinkSocket]
self.servers = [self.sourceSocket, self.sourceSocket2]
else:
self.servers = [self.sinkSocket]
self.clients = [self.sourceSocket, self.sourceSocket2]
sinkSocketName = 'data%s_in'%portType.capitalize()
self.src.connect(self.sinkSocket, sinkSocketName)
self.sourceSocket.connect(self.sink, None, '%sOut'%portType)
self.sourceSocket2.connect(self.sink2, None, '%sOut'%portType)
class ComponentTests(ossie.utils.testing.ScaComponentTestCase):
"""
Test for all component implementations in sinksocket
"""
PORT = 8645
OCTET_DATA = [range(256)*100]
CHAR_DATA = [range(-128,128)*100]
U_SHORT_DATA = [range(i*16384,(i+1)*16384) for i in xrange(4)]
SHORT_DATA = [range(i*16384,(i+1)*16384) for i in xrange(-2,2)]
U_LONG_DATA = [range(i*2**30,(i+1)*2**30, 500000) for i in xrange(0,4)]
LONG_DATA = [range(i*2**30,(i+1)*2**30, 500000) for i in xrange(-2,2)]
FLOAT_DATA = DOUBLE_DATA = [[float(x) for x in range(i*4096,(i+1)*4096)] for i in xrange(16)]
def testScaBasicBehavior(self):
#######################################################################
# Validate that query returns all expected parameters
# Query of '[]' should return the following set of properties
expectedProps = []
expectedProps.extend(self.getPropertySet(kinds=("configure", "execparam"), modes=("readwrite", "readonly"), includeNil=True))
expectedProps.extend(self.getPropertySet(kinds=("allocate",), action="external", includeNil=True))
props = self.comp.query([])
props = dict((x.id, any.from_any(x.value)) for x in props)
# Query may return more than expected, but not less
for expectedProp in expectedProps:
self.assertEquals(props.has_key(expectedProp.id), True)
#######################################################################
# Verify that all expected ports are available
for port in self.scd.get_componentfeatures().get_ports().get_uses():
port_obj = self.comp.getPort(str(port.get_usesname()))
self.assertNotEqual(port_obj, None)
self.assertEqual(port_obj._non_existent(), False)
self.assertEqual(port_obj._is_a("IDL:CF/Port:1.0"), True)
for port in self.scd.get_componentfeatures().get_ports().get_provides():
port_obj = self.comp.getPort(str(port.get_providesname()))
self.assertNotEqual(port_obj, None)
self.assertEqual(port_obj._non_existent(), False)
self.assertEqual(port_obj._is_a(port.get_repid()), True)
#######################################################################
# Make sure start and stop can be called without throwing exceptions
self.comp.start()
self.comp.stop()
#test a bunch of stuff - vary the start order for client. Vary which one is the client. Vary the data ports as well
def testA(self):
self.runTest(clientFirst=True, client = 'sinksocket', dataPackets=self.OCTET_DATA,portType='octet')
def testB(self):
self.runTest(clientFirst=False, client = 'sinksocket', dataPackets=self.OCTET_DATA,portType='octet')
def testC(self):
self.runTest(clientFirst=True, client = 'sourcesocket', dataPackets=self.OCTET_DATA,portType='octet')
def testD(self):
self.runTest(clientFirst=False, client = 'sourcesocket', dataPackets=self.OCTET_DATA,portType='octet')
def testAChar(self):
self.runTest(clientFirst=True, client = 'sinksocket', dataPackets=self.CHAR_DATA,portType='char')
def testBChar(self):
self.runTest(clientFirst=False, client = 'sinksocket', dataPackets=self.CHAR_DATA,portType='char')
def testCChar(self):
self.runTest(clientFirst=True, client = 'sourcesocket', dataPackets=self.CHAR_DATA,portType='char')
def testDChar(self):
self.runTest(clientFirst=False, client = 'sourcesocket', dataPackets=self.CHAR_DATA,portType='char')
def testAUShort(self):
self.runTest(clientFirst=True, client = 'sinksocket', dataPackets=self.U_SHORT_DATA,portType='ushort')
def testBUShort(self):
self.runTest(clientFirst=False, client = 'sinksocket', dataPackets=self.U_SHORT_DATA,portType='ushort')
def testCUShort(self):
self.runTest(clientFirst=True, client = 'sourcesocket', dataPackets=self.U_SHORT_DATA,portType='ushort')
def testDUShort(self):
self.runTest(clientFirst=False, client = 'sourcesocket', dataPackets=self.U_SHORT_DATA,portType='ushort')
def testAShort(self):
self.runTest(clientFirst=True, client = 'sinksocket', dataPackets=self.SHORT_DATA,portType='short')
def testBShort(self):
self.runTest(clientFirst=False, client = 'sinksocket', dataPackets=self.SHORT_DATA,portType='short')
def testCShort(self):
self.runTest(clientFirst=True, client = 'sourcesocket', dataPackets=self.SHORT_DATA,portType='short')
def testDShort(self):
self.runTest(clientFirst=False, client = 'sourcesocket', dataPackets=self.SHORT_DATA,portType='short')
def testAULong(self):
self.runTest(clientFirst=True, client = 'sinksocket', dataPackets=self.U_LONG_DATA,portType='ulong')
def testBULong(self):
self.runTest(clientFirst=False, client = 'sinksocket', dataPackets=self.U_LONG_DATA,portType='ulong')
def testCULong(self):
self.runTest(clientFirst=True, client = 'sourcesocket', dataPackets=self.U_LONG_DATA,portType='ulong')
def testDULong(self):
self.runTest(clientFirst=False, client = 'sourcesocket', dataPackets=self.U_LONG_DATA,portType='ulong')
def testALong(self):
self.runTest(clientFirst=True, client = 'sinksocket', dataPackets=self.LONG_DATA,portType='long')
def testBLong(self):
self.runTest(clientFirst=False, client = 'sinksocket', dataPackets=self.LONG_DATA,portType='long')
def testCLong(self):
self.runTest(clientFirst=True, client = 'sourcesocket', dataPackets=self.LONG_DATA,portType='long')
def testDLong(self):
self.runTest(clientFirst=False, client = 'sourcesocket', dataPackets=self.LONG_DATA,portType='long')
def testAFloat(self):
self.runTest(clientFirst=True, client = 'sinksocket', dataPackets=self.FLOAT_DATA,portType='float')
def testBFloat(self):
self.runTest(clientFirst=False, client = 'sinksocket', dataPackets=self.FLOAT_DATA,portType='float')
def testCFloat(self):
self.runTest(clientFirst=True, client = 'sourcesocket', dataPackets=self.FLOAT_DATA,portType='float')
def testDFloat(self):
self.runTest(clientFirst=False, client = 'sourcesocket', dataPackets=self.FLOAT_DATA,portType='float')
def testADouble(self):
self.runTest(clientFirst=True, client = 'sinksocket', dataPackets=self.DOUBLE_DATA,portType='double')
def testBDouble(self):
self.runTest(clientFirst=False, client = 'sinksocket', dataPackets=self.DOUBLE_DATA,portType='double')
def testCDouble(self):
self.runTest(clientFirst=True, client = 'sourcesocket', dataPackets=self.DOUBLE_DATA,portType='double')
def testDDouble(self):
self.runTest(clientFirst=False, client = 'sourcesocket', dataPackets=self.DOUBLE_DATA,portType='double')
#test a bunch of stuff. Vary which one is the client. Vary the data ports as well
def testAMultiConnection(self):
self.runMultiConnectionTest(client = 'sinksocket', dataPackets=self.OCTET_DATA,portType='octet')
def testBMultiConnection(self):
self.runMultiConnectionTest(client = 'sourcesocket', dataPackets=self.OCTET_DATA,portType='octet')
def testAMultiConnectionChar(self):
self.runMultiConnectionTest(client = 'sinksocket', dataPackets=self.CHAR_DATA,portType='char')
def testBMultiConnectionChar(self):
self.runMultiConnectionTest(client = 'sourcesocket', dataPackets=self.CHAR_DATA,portType='char')
def testAMultiConnectionUShort(self):
self.runMultiConnectionTest(client = 'sinksocket', dataPackets=self.U_SHORT_DATA,portType='ushort')
def testBMultiConnectionUShort(self):
self.runMultiConnectionTest(client = 'sourcesocket', dataPackets=self.U_SHORT_DATA,portType='ushort')
def testAMultiConnectionShort(self):
self.runMultiConnectionTest(client = 'sinksocket', dataPackets=self.SHORT_DATA,portType='short')
def testBMultiConnectionShort(self):
self.runMultiConnectionTest(client = 'sourcesocket', dataPackets=self.SHORT_DATA,portType='short')
def testAMultiConnectionULong(self):
self.runMultiConnectionTest(client = 'sinksocket', dataPackets=self.U_LONG_DATA,portType='ulong')
def testBMultiConnectionULong(self):
self.runMultiConnectionTest(client = 'sourcesocket', dataPackets=self.U_LONG_DATA,portType='ulong')
def testAMultiConnectionLong(self):
self.runMultiConnectionTest(client = 'sinksocket', dataPackets=self.LONG_DATA,portType='long')
def testBMultiConnectionLong(self):
self.runMultiConnectionTest(client = 'sourcesocket', dataPackets=self.LONG_DATA,portType='long')
def testAMultiConnectionFloat(self):
self.runMultiConnectionTest(client = 'sinksocket', dataPackets=self.FLOAT_DATA,portType='float')
def testBMultiConnectionFloat(self):
self.runMultiConnectionTest(client = 'sourcesocket', dataPackets=self.FLOAT_DATA,portType='float')
def testAMultiConnectionDouble(self):
self.runMultiConnectionTest(client = 'sinksocket', dataPackets=self.DOUBLE_DATA,portType='double')
def testBMultiConnectionDouble(self):
self.runMultiConnectionTest(client = 'sourcesocket', dataPackets=self.DOUBLE_DATA,portType='double')
#Test sending a bunch of little packets
def testLITTLE_PACKETS(self):
print "testLITTLE_PACKETS"
self.runTest(clientFirst=True, client = 'sinksocket', dataPackets=[range(200) for _ in xrange(50000)], maxBytes=256*256, minBytes=0)
def testLITTLE_PACKETS_2(self):
print "testLITTLE_PACKETS_2"
self.runTest(clientFirst=True, client = 'sourcesocket', dataPackets=[range(200) for _ in xrange(50000)], maxBytes=256*256, minBytes=0)
#Test sending two BIG PACKETS
def testBIG_PACKETS(self):
print "testBIG_PACKETS"
self.runTest(clientFirst=True, client = 'sinksocket', dataPackets=[range(200)*25000 for _ in xrange(2)])
def testBIG_PACKETS_2(self):
print "testBIG_PACKETS_2"
self.runTest(clientFirst=True, client = 'sourcesocket', dataPackets=[range(200)*25000 for _ in xrange(2)])
#A bunch of tests for byte swapping
#start with octet port and using various number of bytes for swapping
#flip the bits and show they are equal for the output
def testByteSwap1(self):
TYPE= 'octet'
SWAP = 2
self.runTest(client = 'sourcesocket', dataPackets=[range(0,100)*10], byteSwapSrc=None, byteSwapSink=SWAP,minBytes=1,portType=TYPE)
s = toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f = flip(so,SWAP)
self.assertEqual(s[:len(f)],f)
def testByteSwap2(self):
TYPE= 'octet'
SWAP = 2
self.runTest(client = 'sourcesocket', dataPackets=[range(0,100)*10], byteSwapSrc=SWAP, byteSwapSink=None,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,SWAP)
self.assertEqual(s[:len(f)],f)
def testByteSwap3(self):
TYPE= 'octet'
SWAP = 4
self.runTest(client = 'sourcesocket', dataPackets=[range(0,100)*10], byteSwapSrc=None, byteSwapSink=SWAP,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,SWAP)
self.assertEqual(s[:len(f)],f)
def testByteSwap4(self):
TYPE= 'octet'
SWAP = 4
self.runTest(client = 'sourcesocket', dataPackets=[range(0,100)*10], byteSwapSrc=SWAP, byteSwapSink=None,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,SWAP)
self.assertEqual(s[:len(f)],f)
def testByteSwap5(self):
TYPE= 'octet'
SWAP = 8
self.runTest(client = 'sourcesocket', dataPackets=[range(0,100)*10], byteSwapSrc=None, byteSwapSink=SWAP,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,SWAP)
self.assertEqual(s[:len(f)],f)
def testByteSwap6(self):
TYPE= 'octet'
SWAP=8
self.runTest(client = 'sourcesocket', dataPackets=[range(0,100)*10], byteSwapSrc=SWAP, byteSwapSink=None,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,SWAP)
self.assertEqual(s[:len(f)],f)
def testByteSwap7(self):
TYPE= 'octet'
SWAP=10
self.runTest(client = 'sourcesocket', dataPackets=[range(0,100)*10], byteSwapSrc=None, byteSwapSink=SWAP,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,SWAP)
self.assertEqual(s[:len(f)],f)
def testByteSwap8(self):
TYPE= 'octet'
SWAP = 10
self.runTest(client = 'sourcesocket', dataPackets=[range(0,100)*10], byteSwapSrc=SWAP, byteSwapSink=None,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,SWAP)
self.assertEqual(s[:len(f)],f)
#here are some tests where we swap both ends -
#verify the output is equal
def testByteSwap9(self):
TYPE= 'octet'
SWAP = 10
self.runTest(client = 'sourcesocket', dataPackets=[range(0,100)*10], byteSwapSrc=SWAP, byteSwapSink=SWAP,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
self.assertEqual(s[:len(so)],so)
def testByteSwap10(self):
TYPE= 'octet'
SWAP = 8
self.runTest(client = 'sourcesocket', dataPackets=[range(0,100)*10], byteSwapSrc=SWAP, byteSwapSink=SWAP,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
self.assertEqual(s[:len(so)],so)
def testByteSwap11(self):
TYPE= 'octet'
SWAP = 4
self.runTest(client = 'sourcesocket', dataPackets=[range(0,100)*10], byteSwapSrc=SWAP, byteSwapSink=SWAP,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
self.assertEqual(s[:len(so)],so)
def testByteSwap12(self):
TYPE= 'octet'
SWAP = 2
self.runTest(client = 'sourcesocket', dataPackets=[range(0,100)*10], byteSwapSrc=SWAP, byteSwapSink=SWAP,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
self.assertEqual(s[:len(so)],so)
#here are some tests where we use the swapping defined as the default for each port by settign SWAP to 1
#2 bytes for short & ushort
def testByteSwap13(self):
TYPE= 'short'
SWAP = 1
self.runTest(client = 'sourcesocket', dataPackets=[range(0,100)*10], byteSwapSrc=None, byteSwapSink=SWAP,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,2)
self.assertEqual(s[:len(f)],f)
def testByteSwap14(self):
TYPE= 'short'
SWAP = 1
self.runTest(client = 'sourcesocket', dataPackets=[range(0,100)*10], byteSwapSrc=SWAP, byteSwapSink=None,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,2)
self.assertEqual(s[:len(f)],f)
def testByteSwap15(self):
TYPE= 'ushort'
SWAP = 1
self.runTest(client = 'sourcesocket', dataPackets=[range(0,100)*10], byteSwapSrc=None, byteSwapSink=SWAP,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,2)
self.assertEqual(s[:len(f)],f)
def testByteSwap16(self):
TYPE= 'ushort'
SWAP = 1
self.runTest(client = 'sourcesocket', dataPackets=[range(0,100)*10], byteSwapSrc=SWAP, byteSwapSink=None,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,2)
self.assertEqual(s[:len(f)],f)
#4 bytes for long & ulong, & float
def testByteSwap17(self):
TYPE= 'long'
SWAP = 1
self.runTest(client = 'sourcesocket', dataPackets=[range(0,100)*10], byteSwapSrc=None, byteSwapSink=SWAP,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,4)
self.assertEqual(s[:len(f)],f)
def testByteSwap18(self):
TYPE= 'long'
SWAP = 1
self.runTest(client = 'sourcesocket', dataPackets=[range(0,100)*10], byteSwapSrc=SWAP, byteSwapSink=None,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,4)
self.assertEqual(s[:len(f)],f)
def testByteSwap19(self):
TYPE= 'ulong'
SWAP = 1
self.runTest(client = 'sourcesocket', dataPackets=[range(0,100)*10], byteSwapSrc=None, byteSwapSink=SWAP,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,4)
self.assertEqual(s[:len(f)],f)
def testByteSwap20(self):
TYPE= 'ulong'
SWAP = 1
self.runTest(client = 'sourcesocket', dataPackets=[range(0,100)*10], byteSwapSrc=SWAP, byteSwapSink=None,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,4)
self.assertEqual(s[:len(f)],f)
def testByteSwap21(self):
TYPE= 'float'
SWAP = 1
self.runTest(client = 'sourcesocket', dataPackets=[range(0,100)*10], byteSwapSrc=None, byteSwapSink=SWAP,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,4)
self.assertEqual(s[:len(f)],f)
def testByteSwap22(self):
TYPE= 'float'
SWAP = 1
self.runTest(client = 'sourcesocket', dataPackets=[range(0,100)*10], byteSwapSrc=SWAP, byteSwapSink=None,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,4)
self.assertEqual(s[:len(f)],f)
#8 bytes for double
def testByteSwap23(self):
TYPE= 'double'
SWAP = 1
self.runTest(client = 'sourcesocket', dataPackets=[range(0,100)*10], byteSwapSrc=None, byteSwapSink=SWAP,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,8)
self.assertEqual(s[:len(f)],f)
def testByteSwap24(self):
TYPE= 'double'
SWAP = 1
self.runTest(client = 'sourcesocket', dataPackets=[range(0,100)*10], byteSwapSrc=SWAP, byteSwapSink=None,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,8)
self.assertEqual(s[:len(f)],f)
#Do a test with all the different type of ports using a non-standard byte swapping
def testByteSwap25(self):
TYPE= 'short'
SWAP = 5
self.runTest(client = 'sourcesocket', dataPackets=[range(0,99)]*9, byteSwapSrc=None, byteSwapSink=SWAP,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,SWAP)
self.assertEqual(s[:len(f)],f)
def testByteSwap26(self):
TYPE= 'short'
SWAP = 5
self.runTest(client = 'sourcesocket', dataPackets=[range(0,99)]*9, byteSwapSrc=SWAP, byteSwapSink=None,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,SWAP)
self.assertEqual(s[:len(f)],f)
def testByteSwap27(self):
TYPE= 'ushort'
SWAP = 5
self.runTest(client = 'sourcesocket', dataPackets=[range(0,99)]*9, byteSwapSrc=None, byteSwapSink=SWAP,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,SWAP)
self.assertEqual(s[:len(f)],f)
def testByteSwap28(self):
TYPE= 'ushort'
SWAP = 5
self.runTest(client = 'sourcesocket', dataPackets=[range(0,99)]*9, byteSwapSrc=SWAP, byteSwapSink=None,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,SWAP)
self.assertEqual(s[:len(f)],f)
def testByteSwap29(self):
TYPE= 'long'
SWAP = 5
self.runTest(client = 'sourcesocket', dataPackets=[range(0,99)]*9, byteSwapSrc=None, byteSwapSink=SWAP,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,SWAP)
f= flip(so,SWAP)
self.assertEqual(s[:len(f)],f)
def testByteSwap30(self):
TYPE= 'long'
SWAP = 5
self.runTest(client = 'sourcesocket', dataPackets=[range(0,99)]*9, byteSwapSrc=SWAP, byteSwapSink=None,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,SWAP)
self.assertEqual(s[:len(f)],f)
def testByteSwap31(self):
TYPE= 'ulong'
SWAP = 5
self.runTest(client = 'sourcesocket', dataPackets=[range(0,99)]*9, byteSwapSrc=None, byteSwapSink=SWAP,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,SWAP)
self.assertEqual(s[:len(f)],f)
def testByteSwap32(self):
TYPE= 'ulong'
SWAP = 5
self.runTest(client = 'sourcesocket', dataPackets=[range(0,99)]*9, byteSwapSrc=SWAP, byteSwapSink=None,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,SWAP)
self.assertEqual(s[:len(f)],f)
def testByteSwap33(self):
TYPE= 'float'
SWAP = 5
self.runTest(client = 'sourcesocket', dataPackets=[range(0,99)]*9, byteSwapSrc=None, byteSwapSink=SWAP,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,SWAP)
self.assertEqual(s[:len(f)],f)
def testByteSwap34(self):
TYPE= 'float'
SWAP = 5
self.runTest(client = 'sourcesocket', dataPackets=[range(0,99)]*9, byteSwapSrc=SWAP, byteSwapSink=None,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,SWAP)
self.assertEqual(s[:len(f)],f)
def testByteSwap35(self):
TYPE= 'double'
SWAP = 5
self.runTest(client = 'sourcesocket', dataPackets=[range(0,99)]*9, byteSwapSrc=None, byteSwapSink=SWAP,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,SWAP)
self.assertEqual(s[:len(f)],f)
def testByteSwap36(self):
TYPE= 'double'
SWAP = 5
self.runTest(client = 'sourcesocket', dataPackets=[range(0,99)]*9, byteSwapSrc=SWAP, byteSwapSink=None,minBytes=1,portType=TYPE)
s= toStr(self.input,TYPE)
so = toStr(self.output,TYPE)
f= flip(so,SWAP)
self.assertEqual(s[:len(f)],f)
def runTest(self, clientFirst=True, client = 'sinksocket',dataPackets=[],maxBytes=None,minBytes=None, portType='octet',byteSwapSrc=None, byteSwapSink=None):
self.startTest(client, portType)
if maxBytes!=None:
self.sourceSocket.setMax_bytes(maxBytes)
if minBytes!=None:
self.sourceSocket.setMin_bytes(minBytes)
if clientFirst:
self.configureClient(byteSwapSrc, byteSwapSink)
self.configureServer(byteSwapSrc, byteSwapSink)
else:
self.configureServer(byteSwapSrc, byteSwapSink)
self.configureClient(byteSwapSrc, byteSwapSink)
self.src.start()
self.sink.start()
self.sourceSocket.start()
self.sinkSocket.start()
self.input = []
self.output = []
time.sleep(.1)
for packet in dataPackets:
self.input.extend(packet)
self.src.push(packet, False, "test stream", 1.0)
newdata = self.sink.getData()
if newdata:
if portType == 'octet':
self.output.extend([ord(x) for x in newdata])
else:
self.output.extend(newdata)
time.sleep(.25)
noData = 0
while True:
newdata = self.sink.getData()
if newdata:
noData=0
if portType == 'octet':
self.output.extend([ord(x) for x in newdata])
else:
self.output.extend(newdata)
else:
noData += 1
if noData == 200:
break
time.sleep(.01)
print "self.sourceSocket.bytes_per_sec", self.sourceSocket.bytes_per_sec
print "self.sinkSocket.bytes_per_sec", self.sinkSocket.bytes_per_sec
##
print "self.sinkSocket.total_bytes", self.sinkSocket.total_bytes
print "self.sourceSocket.total_bytes", self.sourceSocket.total_bytes
##
print "len(self.input)", len(self.input), "len(self.output)", len(self.output)
self.assertTrue(len(self.output)> 0)
self.assertTrue(len(self.input)-len(self.output)< self.sourceSocket.max_bytes)
self.assertTrue(len(self.input)>=len(self.output))
if byteSwapSrc == byteSwapSink:
self.assertEquals(self.input[:len(self.output)],self.output)
def runMultiConnectionTest(self, client = 'sinksocket',dataPackets=[],maxBytes=None,minBytes=None, portType='octet',byteSwapSrc=None, byteSwapSink=None):
self.startTests(client, portType)
if maxBytes!=None:
self.sourceSocket.setMax_bytes(maxBytes)
self.sourceSocket2.setMax_bytes(maxBytes)
if minBytes!=None:
self.sourceSocket.setMin_bytes(minBytes)
self.sourceSocket2.setMin_bytes(minBytes)
self.configureClients(byteSwapSrc, byteSwapSink)
self.configureServers(byteSwapSrc, byteSwapSink)
self.src.start()
self.sink.start()
self.sink2.start()
self.sourceSocket.start()
self.sourceSocket2.start()
self.sinkSocket.start()
self.input = []
self.output1 = []
self.output2 = []
time.sleep(.1)
for packet in dataPackets:
self.input.extend(packet)
self.src.push(packet, False, "test stream", 1.0)
newdata1 = self.sink.getData()
if newdata1:
if portType == 'octet':
self.output1.extend([ord(x) for x in newdata1])
else:
self.output1.extend(newdata1)
newdata2 = self.sink2.getData()
if newdata2:
if portType == 'octet':
self.output2.extent([ord(x) for x in newdata2])
else:
self.output2.extend(newdata2)
time.sleep(.25)
noData = 0
while True:
newdata1 = self.sink.getData()
newdata2 = self.sink2.getData()
if not newdata1 and not newdata2:
noData += 1
if noData == 200:
break
time.sleep(.01)
else:
if newdata1:
noData=0
if portType == 'octet':
self.output1.extend([ord(x) for x in newdata1])
else:
self.output1.extend(newdata1)
if newdata2:
noData=0
if portType == 'octet':
self.output2.extend([ord(x) for x in newdata2])
else:
self.output2.extend(newdata2)
print "self.sourceSocket.bytes_per_sec", self.sourceSocket.bytes_per_sec
print "self.sourceSocket2.bytes_per_sec", self.sourceSocket2.bytes_per_sec
print "self.sinkSocket.bytes_per_sec", self.sinkSocket.bytes_per_sec
##
print "self.sinkSocket.total_bytes", self.sinkSocket.total_bytes
print "self.source1Socket.total_bytes", self.sourceSocket.total_bytes
print "self.source1Socket2.total_bytes", self.sourceSocket2.total_bytes
##
print "len(self.input)", len(self.input), "len(self.output1)", len(self.output1), "len(self.output2)", len(self.output2)
self.assertTrue(len(self.output1)> 0)
self.assertTrue(len(self.output2)> 0)
self.assertTrue(len(self.input)-len(self.output1)< self.sourceSocket.max_bytes)
self.assertTrue(len(self.input)-len(self.output2)< self.sourceSocket2.max_bytes)
self.assertTrue(len(self.input)>=len(self.output1))
self.assertTrue(len(self.input)>=len(self.output2))
if byteSwapSrc == byteSwapSink:
self.assertEquals(self.input[:len(self.output1)],self.output1)
self.assertEquals(self.input[:len(self.output2)],self.output2)
def configureClient(self, byteSwapSrc, byteSwapSink):
if self.client == self.sinkSocket:
if byteSwapSink != None:
self.client.Connections = [{'connection_type' : 'client', 'ip_address' : '127.0.0.1', 'ports' : [self.PORT], 'byte_swap' : [byteSwapSink]}]
self.assertTrue(self.client.Connections[0].byte_swap[0] == byteSwapSink)
else:
self.client.Connections = [{'connection_type' : 'client', 'ip_address' : '127.0.0.1', 'ports' : [self.PORT], 'byte_swap' : [0]}]
self.assertTrue(self.client.Connections[0].connection_type == 'client')
self.assertTrue(self.client.Connections[0].ports[0] == self.PORT)
else:
self.client.setConnection_type('client')
self.client.setIp_address("127.0.0.1")
self.client.setPort(self.PORT)
self.assertTrue(self.client.connection_type == 'client')
self.assertTrue(self.client.port == self.PORT)
if byteSwapSrc != None:
self.client.setByte_swap(byteSwapSrc)
self.assertTrue(self.client.byte_swap == byteSwapSrc)
def configureClients(self, byteSwapSrc, byteSwapSink):
if self.clients[0] == self.sinkSocket:
if byteSwapSink != None:
self.clients[0].Connections = [{'connection_type' : 'client', 'ip_address' : '127.0.0.1', 'ports' : [self.PORT, self.PORT+1], 'byte_swap' : [byteSwapSink, byteSwapSink]}]
self.assertTrue(self.clients[0].Connections[0].byte_swap[0] == byteSwapSink)
self.assertTrue(self.clients[0].Connections[0].byte_swap[1] == byteSwapSink)
else:
self.clients[0].Connections = [{'connection_type' : 'client', 'ip_address' : '127.0.0.1', 'ports' : [self.PORT, self.PORT+1], 'byte_swap' : [0, 0]}]
self.assertTrue(self.clients[0].Connections[0].connection_type == 'client')
self.assertTrue(self.clients[0].Connections[0].ports[0] == self.PORT)
self.assertTrue(self.clients[0].Connections[0].ports[1] == self.PORT+1)
else:
self.clients[0].setConnection_type('client')
self.clients[0].setIp_address("127.0.0.1")
self.clients[0].setPort(self.PORT)
self.assertTrue(self.clients[0].connection_type == 'client')
self.assertTrue(self.clients[0].port == self.PORT)
self.clients[1].setConnection_type('client')
self.clients[1].setIp_address("127.0.0.1")
self.clients[1].setPort(self.PORT+1)
self.assertTrue(self.clients[1].connection_type == 'client')
self.assertTrue(self.clients[1].port == self.PORT+1)
if byteSwapSrc != None:
self.clients[0].setByte_swap(byteSwapSrc)
self.assertTrue(self.clients[0].byte_swap == byteSwapSrc)
self.clients[1].setByte_swap(byteSwapSrc)
self.assertTrue(self.clients[1].byte_swap == byteSwapSrc)
def configureServer(self, byteSwapSrc, byteSwapSink):
if self.server == self.sinkSocket:
if byteSwapSink != None:
self.server.Connections = [{'connection_type' : 'server', 'ports' : [self.PORT], 'byte_swap' : [byteSwapSink]}]
self.assertTrue(self.server.Connections[0].byte_swap[0] == byteSwapSink)
else:
self.server.Connections = [{'connection_type' : 'server', 'ports' : [self.PORT], 'byte_swap' : [0]}]
self.assertTrue(self.server.Connections[0].connection_type == 'server')
self.assertTrue(self.server.Connections[0].ports[0] == self.PORT)
else:
self.server.setConnection_type('server')
self.server.setPort(self.PORT)
self.assertTrue(self.server.connection_type=='server')
self.assertTrue(self.server.port==self.PORT)
if byteSwapSrc != None:
self.server.setByte_swap(byteSwapSrc)
self.assertTrue(self.server.byte_swap == byteSwapSrc)
def configureServers(self, byteSwapSrc, byteSwapSink):
if self.servers[0] == self.sinkSocket:
if byteSwapSink != None:
self.servers[0].Connections = [{'connection_type' : 'server', 'ports' : [self.PORT, self.PORT+1], 'byte_swap' : [byteSwapSink, byteSwapSink]}]
self.assertTrue(self.servers[0].Connections[0].byte_swap[0] == byteSwapSink)
self.assertTrue(self.servers[0].Connections[0].byte_swap[1] == byteSwapSink)
else:
self.servers[0].Connections = [{'connection_type' : 'server', 'ports' : [self.PORT, self.PORT+1], 'byte_swap' : [0, 0]}]
self.assertTrue(self.servers[0].Connections[0].connection_type == 'server')
self.assertTrue(self.servers[0].Connections[0].ports[0] == self.PORT)
self.assertTrue(self.servers[0].Connections[0].ports[1] == self.PORT+1)
else:
self.servers[0].setConnection_type('server')
self.servers[0].setPort(self.PORT)
self.assertTrue(self.servers[0].connection_type=='server')
self.assertTrue(self.servers[0].port==self.PORT)
self.servers[1].setConnection_type('server')
self.servers[1].setPort(self.PORT+1)
self.assertTrue(self.servers[1].connection_type=='server')
self.assertTrue(self.servers[1].port==self.PORT+1)
if byteSwapSrc != None:
self.servers[0].setByte_swap(byteSwapSrc)
self.assertTrue(self.servers[0].byte_swap == byteSwapSrc)
self.servers[1].setByte_swap(byteSwapSrc)
self.assertTrue(self.servers[1].byte_swap == byteSwapSrc)
def setUp(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])
execparams['DEBUG_LEVEL'] = DEBUG_LEVEL
self.launch(execparams)
#######################################################################
# Verify the basic state of the component
self.assertNotEqual(self.comp, None)
self.assertEqual(self.comp.ref._non_existent(), False)
self.assertEqual(self.comp.ref._is_a("IDL:CF/Resource:1.0"), True)
# Load resources for majority of tests
self.src = sb.DataSource()
self.sink = sb.DataSink()
self.sinkSocket = self.comp
self.sourceSocket = NetworkSource()
self.client = None
self.clients = None
self.server = None
self.servers = None
self.sink2 = None
self.sourceSocket2 = None
def startTest(self, client='sinksocket', portType='octet'):
if client == 'sinksocket':
self.client = self.sinkSocket
self.server = self.sourceSocket
else:
self.server = self.sinkSocket
self.client = self.sourceSocket
sinkSocketName = 'data%s_in'%portType.capitalize()
self.src.connect(self.sinkSocket, sinkSocketName)
self.sourceSocket.connect(self.sink, None, '%sOut'%portType)
def startTests(self, client='sinksocket', portType='octet'):
self.sink2 = sb.DataSink()
self.sourceSocket.setPort(self.PORT)
self.sourceSocket2 = NetworkSource()
self.sourceSocket2.setPort(self.PORT+1)
if client == 'sinksocket':
self.clients = [self.sinkSocket]
self.servers = [self.sourceSocket, self.sourceSocket2]
else:
self.servers = [self.sinkSocket]
self.clients = [self.sourceSocket, self.sourceSocket2]
sinkSocketName = 'data%s_in'%portType.capitalize()
self.src.connect(self.sinkSocket, sinkSocketName)
self.sourceSocket.connect(self.sink, None, '%sOut'%portType)
self.sourceSocket2.connect(self.sink2, None, '%sOut'%portType)
def tearDown(self):
ossie.utils.testing.ScaComponentTestCase.tearDown(self)
if self.src != None:
self.src.stop()
self.src.releaseObject()
self.src = None
if self.sink != None:
self.sink.stop()
self.sink.releaseObject()
self.sink = None
if self.sink2 != None:
self.sink2.stop()
self.sink2.releaseObject()
self.sink2 = None
if self.sourceSocket != None:
self.sourceSocket.stop()
self.sourceSocket.releaseObject()
self.sourceSocket = None
if self.sourceSocket2 != None:
self.sourceSocket2.stop()
self.sourceSocket2.releaseObject()
self.sourceSocket2 = None
if self.sinkSocket != None:
self.sinkSocket.stop()
self.sinkSocket.releaseObject()
self.sinkSocket = None
self.client = None
self.clients = None
self.server = None
self.servers = None
class ComponentTests(ossie.utils.testing.ScaComponentTestCase):
"""
Test for all component implementations in CustomSink
"""
PORT = 8645
OCTET_DATA = [range(256) * 100]
CHAR_DATA = [range(-128, 128) * 100]
U_SHORT_DATA = [range(i * 16384, (i + 1) * 16384) for i in xrange(4)]
SHORT_DATA = [range(i * 16384, (i + 1) * 16384) for i in xrange(-2, 2)]
U_LONG_DATA = [
range(i * 2**30, (i + 1) * 2**30, 500000) for i in xrange(0, 4)
]
LONG_DATA = [
range(i * 2**30, (i + 1) * 2**30, 500000) for i in xrange(-2, 2)
]
FLOAT_DATA = DOUBLE_DATA = [
[float(x) for x in range(i * 4096, (i + 1) * 4096)] for i in xrange(16)
]
def testScaBasicBehavior(self):
#######################################################################
# Validate that query returns all expected parameters
# Query of '[]' should return the following set of properties
expectedProps = []
expectedProps.extend(
self.getPropertySet(kinds=("configure", "execparam"),
modes=("readwrite", "readonly"),
includeNil=True))
expectedProps.extend(
self.getPropertySet(kinds=("allocate", ),
action="external",
includeNil=True))
props = self.comp.query([])
props = dict((x.id, any.from_any(x.value)) for x in props)
# Query may return more than expected, but not less
for expectedProp in expectedProps:
self.assertEquals(props.has_key(expectedProp.id), True)
#######################################################################
# Verify that all expected ports are available
for port in self.scd.get_componentfeatures().get_ports().get_uses():
port_obj = self.comp.getPort(str(port.get_usesname()))
self.assertNotEqual(port_obj, None)
self.assertEqual(port_obj._non_existent(), False)
self.assertEqual(port_obj._is_a("IDL:CF/Port:1.0"), True)
for port in self.scd.get_componentfeatures().get_ports().get_provides(
):
port_obj = self.comp.getPort(str(port.get_providesname()))
self.assertNotEqual(port_obj, None)
self.assertEqual(port_obj._non_existent(), False)
self.assertEqual(port_obj._is_a(port.get_repid()), True)
#######################################################################
# Make sure start and stop can be called without throwing exceptions
self.comp.start()
self.comp.stop()
#test a bunch of stuff - vary the start order for client. Vary which one is the client. Vary the data ports as well
def testA(self):
self.runTest(clientFirst=True,
client='CustomSink',
dataPackets=self.OCTET_DATA,
portType='octet')
def testB(self):
self.runTest(clientFirst=False,
client='CustomSink',
dataPackets=self.OCTET_DATA,
portType='octet')
def testC(self):
self.runTest(clientFirst=True,
client='CustomSource',
dataPackets=self.OCTET_DATA,
portType='octet')
def testD(self):
self.runTest(clientFirst=False,
client='CustomSource',
dataPackets=self.OCTET_DATA,
portType='octet')
def testAChar(self):
self.runTest(clientFirst=True,
client='CustomSink',
dataPackets=self.CHAR_DATA,
portType='char')
def testBChar(self):
self.runTest(clientFirst=False,
client='CustomSink',
dataPackets=self.CHAR_DATA,
portType='char')
def testCChar(self):
self.runTest(clientFirst=True,
client='CustomSource',
dataPackets=self.CHAR_DATA,
portType='char')
def testDChar(self):
self.runTest(clientFirst=False,
client='CustomSource',
dataPackets=self.CHAR_DATA,
portType='char')
def testAUShort(self):
self.runTest(clientFirst=True,
client='CustomSink',
dataPackets=self.U_SHORT_DATA,
portType='ushort')
def testBUShort(self):
self.runTest(clientFirst=False,
client='CustomSink',
dataPackets=self.U_SHORT_DATA,
portType='ushort')
def testCUShort(self):
self.runTest(clientFirst=True,
client='CustomSource',
dataPackets=self.U_SHORT_DATA,
portType='ushort')
def testDUShort(self):
self.runTest(clientFirst=False,
client='CustomSource',
dataPackets=self.U_SHORT_DATA,
portType='ushort')
def testAShort(self):
self.runTest(clientFirst=True,
client='CustomSink',
dataPackets=self.SHORT_DATA,
portType='short')
def testBShort(self):
self.runTest(clientFirst=False,
client='CustomSink',
dataPackets=self.SHORT_DATA,
portType='short')
def testCShort(self):
self.runTest(clientFirst=True,
client='CustomSource',
dataPackets=self.SHORT_DATA,
portType='short')
def testDShort(self):
self.runTest(clientFirst=False,
client='CustomSource',
dataPackets=self.SHORT_DATA,
portType='short')
def testAULong(self):
self.runTest(clientFirst=True,
client='CustomSink',
dataPackets=self.U_LONG_DATA,
portType='ulong')
def testBULong(self):
self.runTest(clientFirst=False,
client='CustomSink',
dataPackets=self.U_LONG_DATA,
portType='ulong')
def testCULong(self):
self.runTest(clientFirst=True,
client='CustomSource',
dataPackets=self.U_LONG_DATA,
portType='ulong')
def testDULong(self):
self.runTest(clientFirst=False,
client='CustomSource',
dataPackets=self.U_LONG_DATA,
portType='ulong')
def testALong(self):
self.runTest(clientFirst=True,
client='CustomSink',
dataPackets=self.LONG_DATA,
portType='long')
def testBLong(self):
self.runTest(clientFirst=False,
client='CustomSink',
dataPackets=self.LONG_DATA,
portType='long')
def testCLong(self):
self.runTest(clientFirst=True,
client='CustomSource',
dataPackets=self.LONG_DATA,
portType='long')
def testDLong(self):
self.runTest(clientFirst=False,
client='CustomSource',
dataPackets=self.LONG_DATA,
portType='long')
def testAFloat(self):
self.runTest(clientFirst=True,
client='CustomSink',
dataPackets=self.FLOAT_DATA,
portType='float')
def testBFloat(self):
self.runTest(clientFirst=False,
client='CustomSink',
dataPackets=self.FLOAT_DATA,
portType='float')
def testCFloat(self):
self.runTest(clientFirst=True,
client='CustomSource',
dataPackets=self.FLOAT_DATA,
portType='float')
def testDFloat(self):
self.runTest(clientFirst=False,
client='CustomSource',
dataPackets=self.FLOAT_DATA,
portType='float')
def testADouble(self):
self.runTest(clientFirst=True,
client='CustomSink',
dataPackets=self.DOUBLE_DATA,
portType='double')
def testBDouble(self):
self.runTest(clientFirst=False,
client='CustomSink',
dataPackets=self.DOUBLE_DATA,
portType='double')
def testCDouble(self):
self.runTest(clientFirst=True,
client='CustomSource',
dataPackets=self.DOUBLE_DATA,
portType='double')
def testDDouble(self):
self.runTest(clientFirst=False,
client='CustomSource',
dataPackets=self.DOUBLE_DATA,
portType='double')
#test a bunch of stuff. Vary which one is the client. Vary the data ports as well
def testAMultiConnection(self):
self.runMultiConnectionTest(client='CustomSink',
dataPackets=self.OCTET_DATA,
portType='octet')
def testBMultiConnection(self):
self.runMultiConnectionTest(client='CustomSource',
dataPackets=self.OCTET_DATA,
portType='octet')
def testAMultiConnectionChar(self):
self.runMultiConnectionTest(client='CustomSink',
dataPackets=self.CHAR_DATA,
portType='char')
def testBMultiConnectionChar(self):
self.runMultiConnectionTest(client='CustomSource',
dataPackets=self.CHAR_DATA,
portType='char')
def testAMultiConnectionUShort(self):
self.runMultiConnectionTest(client='CustomSink',
dataPackets=self.U_SHORT_DATA,
portType='ushort')
def testBMultiConnectionUShort(self):
self.runMultiConnectionTest(client='CustomSource',
dataPackets=self.U_SHORT_DATA,
portType='ushort')
def testAMultiConnectionShort(self):
self.runMultiConnectionTest(client='CustomSink',
dataPackets=self.SHORT_DATA,
portType='short')
def testBMultiConnectionShort(self):
self.runMultiConnectionTest(client='CustomSource',
dataPackets=self.SHORT_DATA,
portType='short')
def testAMultiConnectionULong(self):
self.runMultiConnectionTest(client='CustomSink',
dataPackets=self.U_LONG_DATA,
portType='ulong')
def testBMultiConnectionULong(self):
self.runMultiConnectionTest(client='CustomSource',
dataPackets=self.U_LONG_DATA,
portType='ulong')
def testAMultiConnectionLong(self):
self.runMultiConnectionTest(client='CustomSink',
dataPackets=self.LONG_DATA,
portType='long')
def testBMultiConnectionLong(self):
self.runMultiConnectionTest(client='CustomSource',
dataPackets=self.LONG_DATA,
portType='long')
def testAMultiConnectionFloat(self):
self.runMultiConnectionTest(client='CustomSink',
dataPackets=self.FLOAT_DATA,
portType='float')
def testBMultiConnectionFloat(self):
self.runMultiConnectionTest(client='CustomSource',
dataPackets=self.FLOAT_DATA,
portType='float')
def testAMultiConnectionDouble(self):
self.runMultiConnectionTest(client='CustomSink',
dataPackets=self.DOUBLE_DATA,
portType='double')
def testBMultiConnectionDouble(self):
self.runMultiConnectionTest(client='CustomSource',
dataPackets=self.DOUBLE_DATA,
portType='double')
#Test sending a bunch of little packets
def testLITTLE_PACKETS(self):
print "testLITTLE_PACKETS"
self.runTest(clientFirst=True,
client='CustomSink',
dataPackets=[range(200) for _ in xrange(50000)],
maxBytes=256 * 256,
minBytes=0)
def testLITTLE_PACKETS_2(self):
print "testLITTLE_PACKETS_2"
self.runTest(clientFirst=True,
client='CustomSource',
dataPackets=[range(200) for _ in xrange(50000)],
maxBytes=256 * 256,
minBytes=0)
#Test sending two BIG PACKETS
def testBIG_PACKETS(self):
print "testBIG_PACKETS"
self.runTest(clientFirst=True,
client='CustomSink',
dataPackets=[range(200) * 25000 for _ in xrange(2)])
def testBIG_PACKETS_2(self):
print "testBIG_PACKETS_2"
self.runTest(clientFirst=True,
client='CustomSource',
dataPackets=[range(200) * 25000 for _ in xrange(2)])
#A bunch of tests for byte swapping
#start with octet port and using various number of bytes for swapping
#flip the bits and show they are equal for the output
def testByteSwap1(self):
TYPE = 'octet'
SWAP = 2
self.runTest(client='CustomSource',
dataPackets=[range(0, 100) * 10],
byteSwapSrc=None,
byteSwapSink=SWAP,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, SWAP)
self.assertEqual(s[:len(f)], f)
def testByteSwap2(self):
TYPE = 'octet'
SWAP = 2
self.runTest(client='CustomSource',
dataPackets=[range(0, 100) * 10],
byteSwapSrc=SWAP,
byteSwapSink=None,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, SWAP)
self.assertEqual(s[:len(f)], f)
def testByteSwap3(self):
TYPE = 'octet'
SWAP = 4
self.runTest(client='CustomSource',
dataPackets=[range(0, 100) * 10],
byteSwapSrc=None,
byteSwapSink=SWAP,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, SWAP)
self.assertEqual(s[:len(f)], f)
def testByteSwap4(self):
TYPE = 'octet'
SWAP = 4
self.runTest(client='CustomSource',
dataPackets=[range(0, 100) * 10],
byteSwapSrc=SWAP,
byteSwapSink=None,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, SWAP)
self.assertEqual(s[:len(f)], f)
def testByteSwap5(self):
TYPE = 'octet'
SWAP = 8
self.runTest(client='CustomSource',
dataPackets=[range(0, 100) * 10],
byteSwapSrc=None,
byteSwapSink=SWAP,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, SWAP)
self.assertEqual(s[:len(f)], f)
def testByteSwap6(self):
TYPE = 'octet'
SWAP = 8
self.runTest(client='CustomSource',
dataPackets=[range(0, 100) * 10],
byteSwapSrc=SWAP,
byteSwapSink=None,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, SWAP)
self.assertEqual(s[:len(f)], f)
def testByteSwap7(self):
TYPE = 'octet'
SWAP = 10
self.runTest(client='CustomSource',
dataPackets=[range(0, 100) * 10],
byteSwapSrc=None,
byteSwapSink=SWAP,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, SWAP)
self.assertEqual(s[:len(f)], f)
def testByteSwap8(self):
TYPE = 'octet'
SWAP = 10
self.runTest(client='CustomSource',
dataPackets=[range(0, 100) * 10],
byteSwapSrc=SWAP,
byteSwapSink=None,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, SWAP)
self.assertEqual(s[:len(f)], f)
#here are some tests where we swap both ends -
#verify the output is equal
def testByteSwap9(self):
TYPE = 'octet'
SWAP = 10
self.runTest(client='CustomSource',
dataPackets=[range(0, 100) * 10],
byteSwapSrc=SWAP,
byteSwapSink=SWAP,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
self.assertEqual(s[:len(so)], so)
def testByteSwap10(self):
TYPE = 'octet'
SWAP = 8
self.runTest(client='CustomSource',
dataPackets=[range(0, 100) * 10],
byteSwapSrc=SWAP,
byteSwapSink=SWAP,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
self.assertEqual(s[:len(so)], so)
def testByteSwap11(self):
TYPE = 'octet'
SWAP = 4
self.runTest(client='CustomSource',
dataPackets=[range(0, 100) * 10],
byteSwapSrc=SWAP,
byteSwapSink=SWAP,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
self.assertEqual(s[:len(so)], so)
def testByteSwap12(self):
TYPE = 'octet'
SWAP = 2
self.runTest(client='CustomSource',
dataPackets=[range(0, 100) * 10],
byteSwapSrc=SWAP,
byteSwapSink=SWAP,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
self.assertEqual(s[:len(so)], so)
#here are some tests where we use the swapping defined as the default for each port by settign SWAP to 1
#2 bytes for short & ushort
def testByteSwap13(self):
TYPE = 'short'
SWAP = 1
self.runTest(client='CustomSource',
dataPackets=[range(0, 100) * 10],
byteSwapSrc=None,
byteSwapSink=SWAP,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, 2)
self.assertEqual(s[:len(f)], f)
def testByteSwap14(self):
TYPE = 'short'
SWAP = 1
self.runTest(client='CustomSource',
dataPackets=[range(0, 100) * 10],
byteSwapSrc=SWAP,
byteSwapSink=None,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, 2)
self.assertEqual(s[:len(f)], f)
def testByteSwap15(self):
TYPE = 'ushort'
SWAP = 1
self.runTest(client='CustomSource',
dataPackets=[range(0, 100) * 10],
byteSwapSrc=None,
byteSwapSink=SWAP,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, 2)
self.assertEqual(s[:len(f)], f)
def testByteSwap16(self):
TYPE = 'ushort'
SWAP = 1
self.runTest(client='CustomSource',
dataPackets=[range(0, 100) * 10],
byteSwapSrc=SWAP,
byteSwapSink=None,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, 2)
self.assertEqual(s[:len(f)], f)
#4 bytes for long & ulong, & float
def testByteSwap17(self):
TYPE = 'long'
SWAP = 1
self.runTest(client='CustomSource',
dataPackets=[range(0, 100) * 10],
byteSwapSrc=None,
byteSwapSink=SWAP,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, 4)
self.assertEqual(s[:len(f)], f)
def testByteSwap18(self):
TYPE = 'long'
SWAP = 1
self.runTest(client='CustomSource',
dataPackets=[range(0, 100) * 10],
byteSwapSrc=SWAP,
byteSwapSink=None,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, 4)
self.assertEqual(s[:len(f)], f)
def testByteSwap19(self):
TYPE = 'ulong'
SWAP = 1
self.runTest(client='CustomSource',
dataPackets=[range(0, 100) * 10],
byteSwapSrc=None,
byteSwapSink=SWAP,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, 4)
self.assertEqual(s[:len(f)], f)
def testByteSwap20(self):
TYPE = 'ulong'
SWAP = 1
self.runTest(client='CustomSource',
dataPackets=[range(0, 100) * 10],
byteSwapSrc=SWAP,
byteSwapSink=None,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, 4)
self.assertEqual(s[:len(f)], f)
def testByteSwap21(self):
TYPE = 'float'
SWAP = 1
self.runTest(client='CustomSource',
dataPackets=[range(0, 100) * 10],
byteSwapSrc=None,
byteSwapSink=SWAP,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, 4)
self.assertEqual(s[:len(f)], f)
def testByteSwap22(self):
TYPE = 'float'
SWAP = 1
self.runTest(client='CustomSource',
dataPackets=[range(0, 100) * 10],
byteSwapSrc=SWAP,
byteSwapSink=None,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, 4)
self.assertEqual(s[:len(f)], f)
#8 bytes for double
def testByteSwap23(self):
TYPE = 'double'
SWAP = 1
self.runTest(client='CustomSource',
dataPackets=[range(0, 100) * 10],
byteSwapSrc=None,
byteSwapSink=SWAP,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, 8)
self.assertEqual(s[:len(f)], f)
def testByteSwap24(self):
TYPE = 'double'
SWAP = 1
self.runTest(client='CustomSource',
dataPackets=[range(0, 100) * 10],
byteSwapSrc=SWAP,
byteSwapSink=None,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, 8)
self.assertEqual(s[:len(f)], f)
#Do a test with all the different type of ports using a non-standard byte swapping
def testByteSwap25(self):
TYPE = 'short'
SWAP = 5
self.runTest(client='CustomSource',
dataPackets=[range(0, 99)] * 9,
byteSwapSrc=None,
byteSwapSink=SWAP,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, SWAP)
self.assertEqual(s[:len(f)], f)
def testByteSwap26(self):
TYPE = 'short'
SWAP = 5
self.runTest(client='CustomSource',
dataPackets=[range(0, 99)] * 9,
byteSwapSrc=SWAP,
byteSwapSink=None,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, SWAP)
self.assertEqual(s[:len(f)], f)
def testByteSwap27(self):
TYPE = 'ushort'
SWAP = 5
self.runTest(client='CustomSource',
dataPackets=[range(0, 99)] * 9,
byteSwapSrc=None,
byteSwapSink=SWAP,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, SWAP)
self.assertEqual(s[:len(f)], f)
def testByteSwap28(self):
TYPE = 'ushort'
SWAP = 5
self.runTest(client='CustomSource',
dataPackets=[range(0, 99)] * 9,
byteSwapSrc=SWAP,
byteSwapSink=None,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, SWAP)
self.assertEqual(s[:len(f)], f)
def testByteSwap29(self):
TYPE = 'long'
SWAP = 5
self.runTest(client='CustomSource',
dataPackets=[range(0, 99)] * 9,
byteSwapSrc=None,
byteSwapSink=SWAP,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, SWAP)
f = flip(so, SWAP)
self.assertEqual(s[:len(f)], f)
def testByteSwap30(self):
TYPE = 'long'
SWAP = 5
self.runTest(client='CustomSource',
dataPackets=[range(0, 99)] * 9,
byteSwapSrc=SWAP,
byteSwapSink=None,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, SWAP)
self.assertEqual(s[:len(f)], f)
def testByteSwap31(self):
TYPE = 'ulong'
SWAP = 5
self.runTest(client='CustomSource',
dataPackets=[range(0, 99)] * 9,
byteSwapSrc=None,
byteSwapSink=SWAP,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, SWAP)
self.assertEqual(s[:len(f)], f)
def testByteSwap32(self):
TYPE = 'ulong'
SWAP = 5
self.runTest(client='CustomSource',
dataPackets=[range(0, 99)] * 9,
byteSwapSrc=SWAP,
byteSwapSink=None,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, SWAP)
self.assertEqual(s[:len(f)], f)
def testByteSwap33(self):
TYPE = 'float'
SWAP = 5
self.runTest(client='CustomSource',
dataPackets=[range(0, 99)] * 9,
byteSwapSrc=None,
byteSwapSink=SWAP,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, SWAP)
self.assertEqual(s[:len(f)], f)
def testByteSwap34(self):
TYPE = 'float'
SWAP = 5
self.runTest(client='CustomSource',
dataPackets=[range(0, 99)] * 9,
byteSwapSrc=SWAP,
byteSwapSink=None,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, SWAP)
self.assertEqual(s[:len(f)], f)
def testByteSwap35(self):
TYPE = 'double'
SWAP = 5
self.runTest(client='CustomSource',
dataPackets=[range(0, 99)] * 9,
byteSwapSrc=None,
byteSwapSink=SWAP,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, SWAP)
self.assertEqual(s[:len(f)], f)
def testByteSwap36(self):
TYPE = 'double'
SWAP = 5
self.runTest(client='CustomSource',
dataPackets=[range(0, 99)] * 9,
byteSwapSrc=SWAP,
byteSwapSink=None,
minBytes=1,
portType=TYPE)
s = toStr(self.input, TYPE)
so = toStr(self.output, TYPE)
f = flip(so, SWAP)
self.assertEqual(s[:len(f)], f)
def runTest(self,
clientFirst=True,
client='CustomSink',
dataPackets=[],
maxBytes=None,
minBytes=None,
portType='octet',
byteSwapSrc=None,
byteSwapSink=None):
self.startTest(client, portType)
if maxBytes != None:
self.sourceSocket.setMax_bytes(maxBytes)
if minBytes != None:
self.sourceSocket.setMin_bytes(minBytes)
if clientFirst:
self.configureClient(byteSwapSrc, byteSwapSink)
self.configureServer(byteSwapSrc, byteSwapSink)
else:
self.configureServer(byteSwapSrc, byteSwapSink)
self.configureClient(byteSwapSrc, byteSwapSink)
self.src.start()
self.sink.start()
self.sourceSocket.start()
self.sinkSocket.start()
self.input = []
self.output = []
time.sleep(.1)
for packet in dataPackets:
self.input.extend(packet)
self.src.push(packet, False, "test stream", 1.0)
newdata = self.sink.getData()
if newdata:
if portType == 'octet':
self.output.extend([ord(x) for x in newdata])
else:
self.output.extend(newdata)
time.sleep(.25)
noData = 0
while True:
newdata = self.sink.getData()
if newdata:
noData = 0
if portType == 'octet':
self.output.extend([ord(x) for x in newdata])
else:
self.output.extend(newdata)
else:
noData += 1
if noData == 200:
break
time.sleep(.01)
print "self.sourceSocket.bytes_per_sec", self.sourceSocket.bytes_per_sec
print "self.sinkSocket.bytes_per_sec", self.sinkSocket.bytes_per_sec
##
print "self.sinkSocket.total_bytes", self.sinkSocket.total_bytes
print "self.sourceSocket.total_bytes", self.sourceSocket.total_bytes
##
print "len(self.input)", len(self.input), "len(self.output)", len(
self.output)
self.assertTrue(len(self.output) > 0)
self.assertTrue(
len(self.input) - len(self.output) < self.sourceSocket.max_bytes)
self.assertTrue(len(self.input) >= len(self.output))
if byteSwapSrc == byteSwapSink:
self.assertEquals(self.input[:len(self.output)], self.output)
def runMultiConnectionTest(self,
client='CustomSink',
dataPackets=[],
maxBytes=None,
minBytes=None,
portType='octet',
byteSwapSrc=None,
byteSwapSink=None):
self.startTests(client, portType)
if maxBytes != None:
self.sourceSocket.setMax_bytes(maxBytes)
self.sourceSocket2.setMax_bytes(maxBytes)
if minBytes != None:
self.sourceSocket.setMin_bytes(minBytes)
self.sourceSocket2.setMin_bytes(minBytes)
self.configureClients(byteSwapSrc, byteSwapSink)
self.configureServers(byteSwapSrc, byteSwapSink)
self.src.start()
self.sink.start()
self.sink2.start()
self.sourceSocket.start()
self.sourceSocket2.start()
self.sinkSocket.start()
self.input = []
self.output1 = []
self.output2 = []
time.sleep(.1)
for packet in dataPackets:
self.input.extend(packet)
self.src.push(packet, False, "test stream", 1.0)
newdata1 = self.sink.getData()
if newdata1:
if portType == 'octet':
self.output1.extend([ord(x) for x in newdata1])
else:
self.output1.extend(newdata1)
newdata2 = self.sink2.getData()
if newdata2:
if portType == 'octet':
self.output2.extent([ord(x) for x in newdata2])
else:
self.output2.extend(newdata2)
time.sleep(.25)
noData = 0
while True:
newdata1 = self.sink.getData()
newdata2 = self.sink2.getData()
if not newdata1 and not newdata2:
noData += 1
if noData == 200:
break
time.sleep(.01)
else:
if newdata1:
noData = 0
if portType == 'octet':
self.output1.extend([ord(x) for x in newdata1])
else:
self.output1.extend(newdata1)
if newdata2:
noData = 0
if portType == 'octet':
self.output2.extend([ord(x) for x in newdata2])
else:
self.output2.extend(newdata2)
print "self.sourceSocket.bytes_per_sec", self.sourceSocket.bytes_per_sec
print "self.sourceSocket2.bytes_per_sec", self.sourceSocket2.bytes_per_sec
print "self.sinkSocket.bytes_per_sec", self.sinkSocket.bytes_per_sec
##
print "self.sinkSocket.total_bytes", self.sinkSocket.total_bytes
print "self.source1Socket.total_bytes", self.sourceSocket.total_bytes
print "self.source1Socket2.total_bytes", self.sourceSocket2.total_bytes
##
print "len(self.input)", len(self.input), "len(self.output1)", len(
self.output1), "len(self.output2)", len(self.output2)
self.assertTrue(len(self.output1) > 0)
self.assertTrue(len(self.output2) > 0)
self.assertTrue(
len(self.input) - len(self.output1) < self.sourceSocket.max_bytes)
self.assertTrue(
len(self.input) - len(self.output2) < self.sourceSocket2.max_bytes)
self.assertTrue(len(self.input) >= len(self.output1))
self.assertTrue(len(self.input) >= len(self.output2))
if byteSwapSrc == byteSwapSink:
self.assertEquals(self.input[:len(self.output1)], self.output1)
self.assertEquals(self.input[:len(self.output2)], self.output2)
def configureClient(self, byteSwapSrc, byteSwapSink):
if self.client == self.sinkSocket:
if byteSwapSink != None:
self.client.Connections = [{
'connection_type': 'client',
'ip_address': '127.0.0.1',
'ports': [self.PORT],
'byte_swap': [byteSwapSink]
}]
self.assertTrue(
self.client.Connections[0].byte_swap[0] == byteSwapSink)
else:
self.client.Connections = [{
'connection_type': 'client',
'ip_address': '127.0.0.1',
'ports': [self.PORT],
'byte_swap': [0]
}]
self.assertTrue(
self.client.Connections[0].connection_type == 'client')
self.assertTrue(self.client.Connections[0].ports[0] == self.PORT)
else:
self.client.setConnection_type('client')
self.client.setIp_address("127.0.0.1")
self.client.setPort(self.PORT)
self.assertTrue(self.client.connection_type == 'client')
self.assertTrue(self.client.port == self.PORT)
if byteSwapSrc != None:
self.client.setByte_swap(byteSwapSrc)
self.assertTrue(self.client.byte_swap == byteSwapSrc)
def configureClients(self, byteSwapSrc, byteSwapSink):
if self.clients[0] == self.sinkSocket:
if byteSwapSink != None:
self.clients[0].Connections = [{
'connection_type':
'client',
'ip_address':
'127.0.0.1',
'ports': [self.PORT, self.PORT + 1],
'byte_swap': [byteSwapSink, byteSwapSink]
}]
self.assertTrue(self.clients[0].Connections[0].byte_swap[0] ==
byteSwapSink)
self.assertTrue(self.clients[0].Connections[0].byte_swap[1] ==
byteSwapSink)
else:
self.clients[0].Connections = [{
'connection_type':
'client',
'ip_address':
'127.0.0.1',
'ports': [self.PORT, self.PORT + 1],
'byte_swap': [0, 0]
}]
self.assertTrue(
self.clients[0].Connections[0].connection_type == 'client')
self.assertTrue(
self.clients[0].Connections[0].ports[0] == self.PORT)
self.assertTrue(
self.clients[0].Connections[0].ports[1] == self.PORT + 1)
else:
self.clients[0].setConnection_type('client')
self.clients[0].setIp_address("127.0.0.1")
self.clients[0].setPort(self.PORT)
self.assertTrue(self.clients[0].connection_type == 'client')
self.assertTrue(self.clients[0].port == self.PORT)
self.clients[1].setConnection_type('client')
self.clients[1].setIp_address("127.0.0.1")
self.clients[1].setPort(self.PORT + 1)
self.assertTrue(self.clients[1].connection_type == 'client')
self.assertTrue(self.clients[1].port == self.PORT + 1)
if byteSwapSrc != None:
self.clients[0].setByte_swap(byteSwapSrc)
self.assertTrue(self.clients[0].byte_swap == byteSwapSrc)
self.clients[1].setByte_swap(byteSwapSrc)
self.assertTrue(self.clients[1].byte_swap == byteSwapSrc)
def configureServer(self, byteSwapSrc, byteSwapSink):
if self.server == self.sinkSocket:
if byteSwapSink != None:
self.server.Connections = [{
'connection_type': 'server',
'ports': [self.PORT],
'byte_swap': [byteSwapSink]
}]
self.assertTrue(
self.server.Connections[0].byte_swap[0] == byteSwapSink)
else:
self.server.Connections = [{
'connection_type': 'server',
'ports': [self.PORT],
'byte_swap': [0]
}]
self.assertTrue(
self.server.Connections[0].connection_type == 'server')
self.assertTrue(self.server.Connections[0].ports[0] == self.PORT)
else:
self.server.setConnection_type('server')
self.server.setPort(self.PORT)
self.assertTrue(self.server.connection_type == 'server')
self.assertTrue(self.server.port == self.PORT)
if byteSwapSrc != None:
self.server.setByte_swap(byteSwapSrc)
self.assertTrue(self.server.byte_swap == byteSwapSrc)
def configureServers(self, byteSwapSrc, byteSwapSink):
if self.servers[0] == self.sinkSocket:
if byteSwapSink != None:
self.servers[0].Connections = [{
'connection_type':
'server',
'ports': [self.PORT, self.PORT + 1],
'byte_swap': [byteSwapSink, byteSwapSink]
}]
self.assertTrue(self.servers[0].Connections[0].byte_swap[0] ==
byteSwapSink)
self.assertTrue(self.servers[0].Connections[0].byte_swap[1] ==
byteSwapSink)
else:
self.servers[0].Connections = [{
'connection_type':
'server',
'ports': [self.PORT, self.PORT + 1],
'byte_swap': [0, 0]
}]
self.assertTrue(
self.servers[0].Connections[0].connection_type == 'server')
self.assertTrue(
self.servers[0].Connections[0].ports[0] == self.PORT)
self.assertTrue(
self.servers[0].Connections[0].ports[1] == self.PORT + 1)
else:
self.servers[0].setConnection_type('server')
self.servers[0].setPort(self.PORT)
self.assertTrue(self.servers[0].connection_type == 'server')
self.assertTrue(self.servers[0].port == self.PORT)
self.servers[1].setConnection_type('server')
self.servers[1].setPort(self.PORT + 1)
self.assertTrue(self.servers[1].connection_type == 'server')
self.assertTrue(self.servers[1].port == self.PORT + 1)
if byteSwapSrc != None:
self.servers[0].setByte_swap(byteSwapSrc)
self.assertTrue(self.servers[0].byte_swap == byteSwapSrc)
self.servers[1].setByte_swap(byteSwapSrc)
self.assertTrue(self.servers[1].byte_swap == byteSwapSrc)
def setUp(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])
execparams['DEBUG_LEVEL'] = DEBUG_LEVEL
self.launch(execparams)
#######################################################################
# Verify the basic state of the component
self.assertNotEqual(self.comp, None)
self.assertEqual(self.comp.ref._non_existent(), False)
self.assertEqual(self.comp.ref._is_a("IDL:CF/Resource:1.0"), True)
# Load resources for majority of tests
self.src = sb.DataSource()
self.sink = sb.DataSink()
self.sinkSocket = self.comp
self.sourceSocket = NetworkSource()
self.client = None
self.clients = None
self.server = None
self.servers = None
self.sink2 = None
self.sourceSocket2 = None
def startTest(self, client='CustomSink', portType='octet'):
if client == 'CustomSink':
self.client = self.sinkSocket
self.server = self.sourceSocket
else:
self.server = self.sinkSocket
self.client = self.sourceSocket
sinkSocketName = 'data%s_in' % portType.capitalize()
self.src.connect(self.sinkSocket, sinkSocketName)
self.sourceSocket.connect(self.sink, None, '%sOut' % portType)
def startTests(self, client='CustomSink', portType='octet'):
self.sink2 = sb.DataSink()
self.sourceSocket.setPort(self.PORT)
self.sourceSocket2 = NetworkSource()
self.sourceSocket2.setPort(self.PORT + 1)
if client == 'CustomSink':
self.clients = [self.sinkSocket]
self.servers = [self.sourceSocket, self.sourceSocket2]
else:
self.servers = [self.sinkSocket]
self.clients = [self.sourceSocket, self.sourceSocket2]
sinkSocketName = 'data%s_in' % portType.capitalize()
self.src.connect(self.sinkSocket, sinkSocketName)
self.sourceSocket.connect(self.sink, None, '%sOut' % portType)
self.sourceSocket2.connect(self.sink2, None, '%sOut' % portType)
def tearDown(self):
ossie.utils.testing.ScaComponentTestCase.tearDown(self)
if self.src != None:
self.src.stop()
self.src.releaseObject()
self.src = None
if self.sink != None:
self.sink.stop()
self.sink.releaseObject()
self.sink = None
if self.sink2 != None:
self.sink2.stop()
self.sink2.releaseObject()
self.sink2 = None
if self.sourceSocket != None:
self.sourceSocket.stop()
self.sourceSocket.releaseObject()
self.sourceSocket = None
if self.sourceSocket2 != None:
self.sourceSocket2.stop()
self.sourceSocket2.releaseObject()
self.sourceSocket2 = None
if self.sinkSocket != None:
self.sinkSocket.stop()
self.sinkSocket.releaseObject()
self.sinkSocket = None
self.client = None
self.clients = None
self.server = None
self.servers = None
