def testNavSetter(self):
input_parent = self.nav_port_sample()
input_parent_2 = self.nav_port_sample()
input_port_1 = InNavDataPort("input_1", input_parent)
output_port = OutNavDataPort("output")
self.assertEquals(input_parent.get_source_id(), "original")
_time = BULKIO.PrecisionUTCTime(1, 1, 1.0, 1.0, 1.0)
_positioninfo = FRONTEND.PositionInfo(False, 'DATUM_WGS84', 0.0, 0.0,
0.0)
_cartesianpos = FRONTEND.CartesianPositionInfo(False, 'DATUM_WGS84',
0.0, 0.0, 0.0)
_velocityinfo = FRONTEND.VelocityInfo(False, 'DATUM_WGS84', '', 0.0,
0.0, 0.0)
_accelerationinfo = FRONTEND.AccelerationInfo(False, 'DATUM_WGS84', '',
0.0, 0.0, 0.0)
_attitudeinfo = FRONTEND.AttitudeInfo(False, 0.0, 0.0, 0.0)
navpacket = FRONTEND.NavigationPacket('', '', _positioninfo,
_cartesianpos, _velocityinfo,
_accelerationinfo, _attitudeinfo,
_time, [])
navpacket.source_id = "newvalue"
output_port._set_nav_packet(navpacket)
self.assertEquals(input_parent.get_source_id(), "original")
self.assertRaises(PortCallError, output_port._set_nav_packet,
navpacket, "hello")
output_port.connectPort(input_port_1._this(), "hello")
output_port._set_nav_packet(navpacket)
self.assertEquals(input_parent.get_source_id(), "newvalue")
navpacket.source_id = "newvalue_2"
output_port._set_nav_packet(navpacket, "hello")
self.assertEquals(input_parent.get_source_id(), "newvalue_2")
self.assertRaises(PortCallError, output_port._set_nav_packet,
navpacket, "foo")
navpacket.source_id = "newvalue_3"
input_port_2 = InNavDataPort("input_2", input_parent_2)
output_port.connectPort(input_port_2._this(), "foo")
output_port._set_nav_packet(navpacket)
self.assertEquals(input_parent.get_source_id(), "newvalue_3")
self.assertEquals(input_parent_2.get_source_id(), "newvalue_3")
navpacket.source_id = "newvalue_4"
output_port._set_nav_packet(navpacket, "hello")
self.assertEquals(input_parent.get_source_id(), "newvalue_4")
self.assertEquals(input_parent_2.get_source_id(), "newvalue_3")
self.assertRaises(PortCallError, output_port._set_nav_packet,
navpacket, "something")
output_port.disconnectPort("hello")
def get_nav_packet(self, port_name):
_time = BULKIO.PrecisionUTCTime(1, 1, 1.0, 1.0, 1.0)
_positioninfo = FRONTEND.PositionInfo(False, 'DATUM_WGS84', 0.0, 0.0,
0.0)
_cartesianpos = FRONTEND.CartesianPositionInfo(False, 'DATUM_WGS84',
0.0, 0.0, 0.0)
_velocityinfo = FRONTEND.VelocityInfo(False, 'DATUM_WGS84', '', 0.0,
0.0, 0.0)
_accelerationinfo = FRONTEND.AccelerationInfo(False, 'DATUM_WGS84', '',
0.0, 0.0, 0.0)
_attitudeinfo = FRONTEND.AttitudeInfo(False, 0.0, 0.0, 0.0)
_navpacket = FRONTEND.NavigationPacket('', '', _positioninfo,
_cartesianpos, _velocityinfo,
_accelerationinfo,
_attitudeinfo, _time, [])
return _navpacket
def testBasicBehavior(self):
self.assertEquals(self.got_logmsg, False)
#######################################################################
# Make sure start and stop can be called without throwing exceptions
exc_src = sb.launch('./build/fei_exception_through/tests/fei_exc_src/fei_exc_src.spd.xml')
self.comp.connect(exc_src,usesPortName='DigitalTuner_out')
self.comp.connect(exc_src,usesPortName='RFInfo_out')
self.comp.connect(exc_src,usesPortName='GPS_out')
self.comp.connect(exc_src,usesPortName='NavData_out')
self.comp.connect(exc_src,usesPortName='RFSource_out')
for port in self.comp.ports:
if port.name == 'DigitalTuner_in':
DigitalTuner_in = port
if port.name == 'RFInfo_in':
RFInfo_in = port
if port.name == 'GPS_in':
GPS_in = port
if port.name == 'NavData_in':
NavData_in = port
if port.name == 'RFSource_in':
RFSource_in = port
_time = BULKIO.PrecisionUTCTime(1,1,1.0,1.0,1.0)
_gpsinfo = FRONTEND.GPSInfo('','','',1L,1L,1L,1.0,1.0,1.0,1.0,1,1.0,'',_time,[])
_positioninfo = FRONTEND.PositionInfo(False,'DATUM_WGS84',0.0,0.0,0.0)
_gpstimepos = FRONTEND.GpsTimePos(_positioninfo,_time)
_cartesianpos=FRONTEND.CartesianPositionInfo(False,'DATUM_WGS84',0.0,0.0,0.0)
_velocityinfo=FRONTEND.VelocityInfo(False,'DATUM_WGS84','',0.0,0.0,0.0)
_accelerationinfo=FRONTEND.AccelerationInfo(False,'DATUM_WGS84','',0.0,0.0,0.0)
_attitudeinfo=FRONTEND.AttitudeInfo(False,0.0,0.0,0.0)
_navpacket=FRONTEND.NavigationPacket('','',_positioninfo,_cartesianpos,_velocityinfo,_accelerationinfo,_attitudeinfo,_time,[])
_antennainfo=FRONTEND.AntennaInfo('','','','')
_freqrange=FRONTEND.FreqRange(0,0,[])
_feedinfo=FRONTEND.FeedInfo('','',_freqrange)
_sensorinfo=FRONTEND.SensorInfo('','','',_antennainfo,_feedinfo)
_rfcapabilities=FRONTEND.RFCapabilities(_freqrange,_freqrange)
_rfinfopkt=FRONTEND.RFInfoPkt('',0.0,0.0,0.0,False,_sensorinfo,[],_rfcapabilities,[])
_strat = FRONTEND.ScanningTuner.ScanStrategy(FRONTEND.ScanningTuner.DISCRETE_SCAN, FRONTEND.ScanningTuner.ScanModeDefinition(discrete_freq_list=[]), FRONTEND.ScanningTuner.TIME_BASED, 0.1)
DigitalTuner_in.ref.getScanStatus('hello')
DigitalTuner_in.ref.setScanStartTime('hello', _time)
DigitalTuner_in.ref.setScanStrategy('hello', _strat)
DigitalTuner_in.ref.getTunerType('hello')
DigitalTuner_in.ref.getTunerDeviceControl('hello')
DigitalTuner_in.ref.getTunerGroupId('hello')
DigitalTuner_in.ref.getTunerRfFlowId('hello')
DigitalTuner_in.ref.setTunerCenterFrequency('hello', 1.0)
DigitalTuner_in.ref.getTunerCenterFrequency('hello')
DigitalTuner_in.ref.setTunerBandwidth('hello', 1.0)
DigitalTuner_in.ref.getTunerBandwidth('hello')
DigitalTuner_in.ref.setTunerAgcEnable('hello', True)
DigitalTuner_in.ref.getTunerAgcEnable('hello')
DigitalTuner_in.ref.setTunerGain('hello', 1.0)
DigitalTuner_in.ref.getTunerGain('hello')
DigitalTuner_in.ref.setTunerReferenceSource('hello', 1L)
DigitalTuner_in.ref.getTunerReferenceSource('hello')
DigitalTuner_in.ref.setTunerEnable('hello', True)
DigitalTuner_in.ref.getTunerEnable('hello')
DigitalTuner_in.ref.setTunerOutputSampleRate('hello', 1.0)
DigitalTuner_in.ref.getTunerOutputSampleRate('hello')
GPS_in.ref._get_gps_info()
GPS_in.ref._set_gps_info(_gpsinfo)
GPS_in.ref._get_gps_time_pos()
GPS_in.ref._set_gps_time_pos(_gpstimepos)
NavData_in.ref._get_nav_packet()
NavData_in.ref._set_nav_packet(_navpacket)
RFInfo_in.ref._get_rf_flow_id()
RFInfo_in.ref._set_rf_flow_id('rf_flow')
RFInfo_in.ref._get_rfinfo_pkt()
RFInfo_in.ref._set_rfinfo_pkt(_rfinfopkt)
os.killpg(exc_src._pid, 9)
while True:
try:
os.kill(exc_src._pid, 0)
time.sleep(0.1)
except:
break
exception = (CORBA.COMM_FAILURE, CORBA.TRANSIENT)
self.assertRaises(exception, DigitalTuner_in.ref.getScanStatus, 'hello')
self.assertRaises(exception, DigitalTuner_in.ref.setScanStartTime, 'hello', _time)
self.assertRaises(exception, DigitalTuner_in.ref.setScanStrategy, 'hello', _strat)
self.assertRaises(exception, DigitalTuner_in.ref.getTunerType, 'hello')
self.assertRaises(exception, DigitalTuner_in.ref.getTunerDeviceControl, 'hello')
self.assertRaises(exception, DigitalTuner_in.ref.getTunerGroupId, 'hello')
self.assertRaises(exception, DigitalTuner_in.ref.getTunerRfFlowId, 'hello')
self.assertRaises(exception, DigitalTuner_in.ref.setTunerCenterFrequency, 'hello', 1.0)
self.assertRaises(exception, DigitalTuner_in.ref.getTunerCenterFrequency, 'hello')
self.assertRaises(exception, DigitalTuner_in.ref.setTunerBandwidth, 'hello', 1.0)
self.assertRaises(exception, DigitalTuner_in.ref.getTunerBandwidth, 'hello')
self.assertRaises(exception, DigitalTuner_in.ref.setTunerAgcEnable, 'hello', True)
self.assertRaises(exception, DigitalTuner_in.ref.getTunerAgcEnable, 'hello')
self.assertRaises(exception, DigitalTuner_in.ref.setTunerGain, 'hello', 1.0)
self.assertRaises(exception, DigitalTuner_in.ref.getTunerGain, 'hello')
self.assertRaises(exception, DigitalTuner_in.ref.setTunerReferenceSource, 'hello', 1L)
self.assertRaises(exception, DigitalTuner_in.ref.getTunerReferenceSource, 'hello')
self.assertRaises(exception, DigitalTuner_in.ref.setTunerEnable, 'hello', True)
self.assertRaises(exception, DigitalTuner_in.ref.getTunerEnable, 'hello')
self.assertRaises(exception, DigitalTuner_in.ref.setTunerOutputSampleRate, 'hello', 1.0)
self.assertRaises(exception, DigitalTuner_in.ref.getTunerOutputSampleRate, 'hello')
self.assertRaises(exception, GPS_in.ref._get_gps_info)
self.assertRaises(exception, GPS_in.ref._set_gps_info, _gpsinfo)
self.assertRaises(exception, GPS_in.ref._get_gps_time_pos)
self.assertRaises(exception, GPS_in.ref._set_gps_time_pos, _gpstimepos)
self.assertRaises(exception, NavData_in.ref._get_nav_packet)
self.assertRaises(exception, NavData_in.ref._set_nav_packet, _navpacket)
self.assertRaises(exception, RFInfo_in.ref._get_rf_flow_id)
self.assertRaises(exception, RFInfo_in.ref._set_rf_flow_id, 'rf_flow')
self.assertRaises(exception, RFInfo_in.ref._get_rfinfo_pkt)
self.assertRaises(exception, RFInfo_in.ref._set_rfinfo_pkt, _rfinfopkt)
def testBasicBehavior(self):
#######################################################################
# Make sure start and stop can be called without throwing exceptions
self.comp.start()
self.comp.stop()
gps_port = self.comp.getPort('gps_in')
tuner_port = self.comp.getPort('tuner_in')
navdata_port = self.comp.getPort('navdata_in')
rfsource_port = self.comp.getPort('rfsource_in')
rfinfo_port = self.comp.getPort('rfinfo_in')
allocation_id = "hello"
rightnow = bulkio.timestamp.now()
# tuner
self.assertRaises(FRONTEND.NotSupportedException,
tuner_port.getTunerType, "hello")
self.assertRaises(FRONTEND.NotSupportedException,
tuner_port.getTunerDeviceControl, "hello")
self.assertRaises(FRONTEND.NotSupportedException,
tuner_port.getTunerGroupId, "hello")
self.assertRaises(FRONTEND.NotSupportedException,
tuner_port.getTunerRfFlowId, "hello")
self.assertRaises(FRONTEND.NotSupportedException,
tuner_port.setTunerCenterFrequency, "hello", 1.0)
self.assertRaises(FRONTEND.NotSupportedException,
tuner_port.getTunerCenterFrequency, "hello")
self.assertRaises(FRONTEND.NotSupportedException,
tuner_port.setTunerBandwidth, "hello", 1.0)
self.assertRaises(FRONTEND.NotSupportedException,
tuner_port.getTunerBandwidth, "hello")
self.assertRaises(FRONTEND.NotSupportedException,
tuner_port.setTunerAgcEnable, "hello", True)
self.assertRaises(FRONTEND.NotSupportedException,
tuner_port.getTunerAgcEnable, "hello")
self.assertRaises(FRONTEND.NotSupportedException,
tuner_port.setTunerGain, "hello", 1.0)
self.assertRaises(FRONTEND.NotSupportedException,
tuner_port.getTunerGain, "hello")
self.assertRaises(FRONTEND.NotSupportedException,
tuner_port.setTunerReferenceSource, "hello", 1L)
self.assertRaises(FRONTEND.NotSupportedException,
tuner_port.getTunerReferenceSource, "hello")
self.assertRaises(FRONTEND.NotSupportedException,
tuner_port.setTunerEnable, "hello", True)
self.assertRaises(FRONTEND.NotSupportedException,
tuner_port.getTunerEnable, "hello")
self.assertRaises(FRONTEND.NotSupportedException,
tuner_port.setTunerOutputSampleRate, "hello", 1.0)
self.assertRaises(FRONTEND.NotSupportedException,
tuner_port.getTunerOutputSampleRate, "hello")
self.assertRaises(FRONTEND.NotSupportedException,
tuner_port.getScanStatus, "hello")
self.assertRaises(FRONTEND.NotSupportedException,
tuner_port.setScanStartTime, "hello", rightnow)
_scan_strategy = FRONTEND.ScanningTuner.ScanStrategy(
FRONTEND.ScanningTuner.MANUAL_SCAN,
FRONTEND.ScanningTuner.ScanModeDefinition(center_frequency=1.0),
FRONTEND.ScanningTuner.TIME_BASED, 0.0)
self.assertRaises(FRONTEND.NotSupportedException,
tuner_port.setScanStrategy, "hello", _scan_strategy)
# gps
_gpsinfo = FRONTEND.GPSInfo('', '', '', 1L, 1L, 1L, 1.0, 1.0, 1.0, 1.0,
1, 1.0, '', rightnow, [])
self.assertEquals(gps_port._get_gps_info().status_message, '')
gps_port._set_gps_info(_gpsinfo)
self.assertEquals(gps_port._get_gps_time_pos().position.datum,
'DATUM_WGS84')
_positioninfo = FRONTEND.PositionInfo(False, 'DATUM_WGS84', 0.0, 0.0,
0.0)
_gpstimepos = FRONTEND.GpsTimePos(_positioninfo, rightnow)
gps_port._set_gps_time_pos(_gpstimepos)
# navdata
_cartesianpos = FRONTEND.CartesianPositionInfo(False, 'DATUM_WGS84',
0.0, 0.0, 0.0)
_velocityinfo = FRONTEND.VelocityInfo(False, 'DATUM_WGS84', '', 0.0,
0.0, 0.0)
_accelerationinfo = FRONTEND.AccelerationInfo(False, 'DATUM_WGS84', '',
0.0, 0.0, 0.0)
_attitudeinfo = FRONTEND.AttitudeInfo(False, 0.0, 0.0, 0.0)
_navpacket = FRONTEND.NavigationPacket('', '', _positioninfo,
_cartesianpos, _velocityinfo,
_accelerationinfo,
_attitudeinfo, rightnow, [])
navdata_port._set_nav_packet(_navpacket)
new_navpacket = navdata_port._get_nav_packet()
self.assertEquals(new_navpacket.position.datum, 'DATUM_WGS84')
# rfinfo
self.assertEquals(rfinfo_port._get_rf_flow_id(), '')
rfinfo_port._set_rf_flow_id('hello')
self.assertEquals(rfinfo_port._get_rfinfo_pkt().rf_flow_id, '')
_antennainfo = FRONTEND.AntennaInfo('', '', '', '')
_freqrange = FRONTEND.FreqRange(0, 0, [])
_feedinfo = FRONTEND.FeedInfo('', '', _freqrange)
_sensorinfo = FRONTEND.SensorInfo('', '', '', _antennainfo, _feedinfo)
_rfcapabilities = FRONTEND.RFCapabilities(_freqrange, _freqrange)
_rfinfopkt = FRONTEND.RFInfoPkt('', 0.0, 0.0, 0.0, False, _sensorinfo,
[], _rfcapabilities, [])
rfinfo_port._set_rfinfo_pkt(_rfinfopkt)
# rfsource
self.assertEquals(len(rfsource_port._get_available_rf_inputs()), 0)
rfsource_port._set_available_rf_inputs([])
self.assertEquals(rfsource_port._get_current_rf_input().rf_flow_id, '')
rfsource_port._set_current_rf_input(_rfinfopkt)
