示例#1
0
 def testFalseControl(self):
     center_frequency = 110e6
     sample_rate = 2.5e6
     bandwidth = 2e6
     alloc = self._generateAlloc(cf=center_frequency,
                                 sr=sample_rate,
                                 bw=bandwidth)
     retval = self.comp.allocateCapacity(alloc)
     self.assertEquals(retval, True)
     _type = properties.props_to_dict(alloc)['FRONTEND::tuner_allocation'][
         'FRONTEND::tuner_allocation::tuner_type']
     _alloc_id = properties.props_to_dict(
         alloc)['FRONTEND::tuner_allocation'][
             'FRONTEND::tuner_allocation::allocation_id']
     listen_alloc = [
         frontend.createTunerGenericListenerAllocation(
             _type,
             allocation_id='foo',
             center_frequency=center_frequency,
             bandwidth=bandwidth,
             sample_rate=sample_rate,
             returnDict=False)
     ]
     retval = self.comp.allocateCapacity(listen_alloc)
     self.assertEquals(retval, True)
     self.comp.deallocateCapacity(listen_alloc)
     self.comp.deallocateCapacity(alloc)
    def test_MultipleUsesDevices(self):
        devices = dict((dev._get_label(), dev) for dev in self._devMgr._get_registeredDevices())

        appFact = self.createAppFact("Multiple")
        self._app = appFact.create(appFact._get_name(), [], [])

        # Check the usesdevice connections by inspecting the app's external
        # ports against the devices
        for connection in self._app.getPort("resource_out")._get_connections():
            deviceId = connection.port._get_identifier()
            if connection.connectionId == "connection1":
                self.assertTrue(deviceId, devices["SADUsesDevice_1"]._get_identifier())
            elif connection.connectionId == "connection2":
                self.assertTrue(deviceId, devices["BasicTestDevice1"]._get_identifier())

        # Try to create another instance of the application; there should only
        # be enough capacity to satisfy one of the usesdevices
        prop = CF.DataType("DCE:001fad60-b4b3-4ed2-94cb-40e1d956bf4f", any.to_any(None))
        pre_value = properties.props_to_dict(devices["BasicTestDevice1"].query([prop])[0].value._v)
        try:
            app2 = appFact.create(appFact._get_name(), [], [])
        except CF.ApplicationFactory.CreateApplicationError:
            # The first app instance should have exhausted the capacity on the
            # SADUsesDevice
            pass
        else:
            self.fail("Device should not have enough capacity to satisfy usesdevice")

        # Make sure that the successful usesdevice was deallocated
        post_value = properties.props_to_dict(devices["BasicTestDevice1"].query([prop])[0].value._v)
        self.assertEqual(pre_value["long_capacity"], post_value["long_capacity"])
        self.assertAlmostEqual(pre_value["float_capacity"], post_value["float_capacity"])
 def test_keyword_change(self):
     print "\n... Staring mid stream keyword change test"
     self._generate_config()
     self.comp_obj.configure(props_from_dict(self.config_dict))
     
     self._generate_keywords()
     self._send_data(last_pkt_eos=False)
     expected_data1 = self.expected_data
     
     time.sleep(1) # Allow SCAAudioTagger to process the already sent data before changing config parameters
     
     self.updated_config = copy.deepcopy(self.config_dict)
     self.updated_config["encoding"] = "PCM_SIGNED"
     self.updated_config["channels"] = 1
     self.comp_obj.configure(props_from_dict(self.updated_config))
     self._send_data(last_pkt_eos=True)
     expected_data2 = self.expected_data
     
     rx_data = self._get_received_data()
     rx_data1 = rx_data[:len(rx_data)/2]
     rx_data2 = rx_data[len(rx_data)/2:]
     print "Received SRI keywords: %s" % props_to_dict(rx_data1[-1].sri.keywords)
     print "Received SRI keywords: %s" % props_to_dict(rx_data2[-1].sri.keywords)
     self._validate_data(rx_data1, expected_data1, expected_frame_size=1, config_dict=self.config_dict)
     self._validate_data(rx_data2, expected_data2, expected_frame_size=1, config_dict=self.updated_config)
示例#4
0
 def _compareAllocation(self, lhs, rhs):
     self.assertEqual(lhs.allocationID, rhs.allocationID)
     self.assertEqual(lhs.requestingDomain, rhs.requestingDomain)
     lhsProps = properties.props_to_dict(lhs.allocationProperties)
     rhsProps = properties.props_to_dict(rhs.allocationProperties)
     self.assertEqual(lhsProps, rhsProps)
     self.assert_(lhs.allocatedDevice._is_equivalent(rhs.allocatedDevice))
     self.assert_(lhs.allocationDeviceManager._is_equivalent(rhs.allocationDeviceManager))
 def _compareAllocation(self, lhs, rhs):
     self.assertEqual(lhs.allocationID, rhs.allocationID)
     self.assertEqual(lhs.requestingDomain, rhs.requestingDomain)
     lhsProps = properties.props_to_dict(lhs.allocationProperties)
     rhsProps = properties.props_to_dict(rhs.allocationProperties)
     self.assertEqual(lhsProps, rhsProps)
     self.assert_(lhs.allocatedDevice._is_equivalent(rhs.allocatedDevice))
     self.assert_(lhs.allocationDeviceManager._is_equivalent(rhs.allocationDeviceManager))
示例#6
0
    def testKeywords(self):
        stream = self.port.createStream("test_keywords")
        self._writeSinglePacket(stream, 1)
        self.assertEqual(1, len(self.stub.H))

        # Set/get keywords
        stream.setKeyword('integer', 250)
        stream.setKeyword('string', "value")
        stream.setKeyword('double', 101.1e6)
        stream.setKeyword('boolean', False)
        self.assertEqual(250, stream.getKeyword('integer'))
        self.assertEqual('value', stream.getKeyword('string'))
        self.assertEqual(101.1e6, stream.getKeyword('double'))
        self.assertEqual(False, stream.getKeyword('boolean'))

        # Set with a specific type
        stream.setKeyword('float', -1.25, 'float')
        self.assertEqual(-1.25, stream.getKeyword('float'))
        any_value = stream.keywords[-1].value
        self.assertEqual(CORBA.TC_float, any_value.typecode())

        # Erase and check for presence of keywords
        stream.eraseKeyword('string')
        self.failUnless(stream.hasKeyword('integer'))
        self.failIf(stream.hasKeyword('string'))
        self.failUnless(stream.hasKeyword('double'))
        self.failUnless(stream.hasKeyword('boolean'))

        # Write a packet to trigger an SRI update
        self.assertEqual(1, len(self.stub.H))
        self._writeSinglePacket(stream, 1)
        self.assertEqual(2, len(self.stub.H))

        keywords = properties.props_to_dict(self.stub.H[-1].keywords)
        self.assertEqual(len(stream.keywords), len(keywords))
        for key, value in keywords.iteritems():
            self.assertEqual(stream.getKeyword(key), value)

        # Replace keywords with a new set
        stream.keywords = properties.props_from_dict({
            'COL_RF': 100.0e6,
            'CHAN_RF': 101.1e6
        })
        self.assertEqual(2, len(stream.keywords))
        self.assertEqual(100.0e6, stream.getKeyword('COL_RF'))
        self.assertEqual(101.1e6, stream.getKeyword('CHAN_RF'))

        # Trigger another SRI update
        self.assertEqual(2, len(self.stub.H))
        self._writeSinglePacket(stream, 1)
        self.assertEqual(3, len(self.stub.H))

        keywords = properties.props_to_dict(self.stub.H[-1].keywords)
        self.assertEqual(len(stream.keywords), len(keywords))
        for key, value in keywords.iteritems():
            self.assertEqual(stream.getKeyword(key), value)
def _compareAllocations(lhs, rhs):
    if lhs.allocationID != rhs.allocationID:
        return False
    lhsProps = properties.props_to_dict(lhs.allocationProperties)
    rhsProps = properties.props_to_dict(rhs.allocationProperties)
    if lhsProps != rhsProps:
        return False
    if not lhs.allocatedDevice._is_equivalent(rhs.allocatedDevice):
        return False
    if not lhs.allocationDeviceManager._is_equivalent(rhs.allocationDeviceManager):
        return False
    return True
示例#8
0
def compareAllocationStatus(lhs, rhs):
    if lhs.allocationID != rhs.allocationID:
        return False
    lhsProps = properties.props_to_dict(lhs.allocationProperties)
    rhsProps = properties.props_to_dict(rhs.allocationProperties)
    if lhsProps != rhsProps:
        return False
    if not lhs.allocatedDevice._is_equivalent(rhs.allocatedDevice):
        return False
    if not lhs.allocationDeviceManager._is_equivalent(
            rhs.allocationDeviceManager):
        return False
    return True
 def testTypoErrorAllocation(self):
     center_frequency = 110e6
     sample_rate = 2.5e6
     bandwidth = 2e6
     alloc = self._generateAlloc(cf=center_frequency,sr=sample_rate,bw=bandwidth)
     retval = self.comp.allocateCapacity(alloc)
     self.assertEquals(retval, True)
     _type = properties.props_to_dict(alloc)['FRONTEND::tuner_allocation']['FRONTEND::tuner_allocation::tuner_type']
     _alloc_id = properties.props_to_dict(alloc)['FRONTEND::tuner_allocation']['FRONTEND::tuner_allocation::allocation_id']
     listen_alloc = [frontend.createTunerListenerAllocation(_alloc_id, listener_allocation_id='foo',returnDict=False)]
     retval = self.comp.allocateCapacity(listen_alloc)
     self.assertEquals(retval, True)
     self.assertRaises(CF.Device.InvalidCapacity, self.comp.allocateCapacity, listen_alloc)
     self.comp.deallocateCapacity(listen_alloc)
     self.comp.deallocateCapacity(alloc)
    def eventReceived(self, data):
        dataEvent = any.from_any(data, keep_structs=True)
        if dataEvent.sourceId != self.sourceId:
            self.successfullPropChange = False
            return
        if len(dataEvent.properties) == 0:
            self.successfullPropChange = False
            return

        props = properties.props_to_dict(dataEvent.properties)
        if props.has_key('myprop'):
            self.received_myprop = True
            if self.successfullPropChange == None:
                self.successfullPropChange = True
        if props.has_key('anotherprop'):
            self.received_anotherprop = True
            if self.successfullPropChange == None:
                self.successfullPropChange = True
        if props.has_key('seqprop'):
            if props['seqprop'] == [1.0, 2.0, 3.0]:
                self.received_seqprop = True
                if self.successfullPropChange == None:
                    self.successfullPropChange = True
        if props.has_key('some_struct') and props['some_struct'] != None:
            if props['some_struct'] == {"some_number": 3.0, "some_string": "hello"}:
                self.received_some_struct = True
                if self.successfullPropChange == None:
                    self.successfullPropChange = True
        if props.has_key('structseq_prop'):
            if len(props['structseq_prop']) == 1:
                if props['structseq_prop'][0] == {"some_number": 7.0, "some_string": "second message"}:
                    self.received_structseq_prop = True
                    if self.successfullPropChange == None:
                        self.successfullPropChange = True
示例#11
0
    def testInValidRFInfoSR(self):
        """ Ask for a Allocation outside the range of the REceiver but should still work because the RFInfo packet tells the receiver a frequency down conversation has already occured"""

        #Create Allocation and Sink for Tuner 1
        sink = sb.DataSink()
        alloc = self._generateAlloc(cf=9050.1e6,
                                    sr=2.5e6,
                                    bw=0,
                                    rf_flow_id="testRFInfoPacket_FlowID")
        allocationID = properties.props_to_dict(
            alloc)['FRONTEND::tuner_allocation'][
                'FRONTEND::tuner_allocation::allocation_id']
        self.comp.connect(sink, connectionId=allocationID)
        sink.start()

        #Send an RF Info Packet
        rfInfo_port = self.comp.getPort("RFInfo_in")
        rf_info_pkt = self._generateRFInfoPkt(
            rf_freq=9000e6,
            rf_bw=100e6,
            if_freq=100e6,
            rf_flow_id="testRFInfoPacket_FlowID")
        rfInfo_port._set_rfinfo_pkt(rf_info_pkt)

        #Allocate a Tuner
        try:
            retval = self.comp.allocateCapacity(alloc)
        except Exception, e:
            self.assertFalse("Exception thrown on allocateCapactiy %s" %
                             str(e))
    def eventReceived(self, data):
        dataEvent = any.from_any(data, keep_structs=True)
        if dataEvent.sourceId != self.sourceId:
            self.successfullPropChange = False
            return
        if len(dataEvent.properties) == 0:
            self.successfullPropChange = False
            return

        props = properties.props_to_dict(dataEvent.properties)
        if props.has_key('myprop'):
            self.received_myprop = True
            if self.successfullPropChange == None:
                self.successfullPropChange = True
        if props.has_key('anotherprop'):
            self.received_anotherprop = True
            if self.successfullPropChange == None:
                self.successfullPropChange = True
        if props.has_key('seqprop'):
            if props['seqprop'] == [1.0, 2.0, 3.0]:
                self.received_seqprop = True
                if self.successfullPropChange == None:
                    self.successfullPropChange = True
        if props.has_key('some_struct') and props['some_struct'] != None:
            if props['some_struct'] == {"some_number": 3.0, "some_string": "hello"}:
                self.received_some_struct = True
                if self.successfullPropChange == None:
                    self.successfullPropChange = True
        if props.has_key('structseq_prop'):
            if len(props['structseq_prop']) == 1:
                if props['structseq_prop'][0] == {"some_number": 7.0, "some_string": "second message"}:
                    self.received_structseq_prop = True
                    if self.successfullPropChange == None:
                        self.successfullPropChange = True
示例#13
0
    def testInValidRFInfoPacket(self):

        #Create Allocation and Sink for Tuner 1
        sink = sb.DataSink()
        alloc = self._generateAlloc(cf=110e6,
                                    sr=2.5e6,
                                    bw=2e6,
                                    rf_flow_id="invalid_FlowID")
        allocationID = properties.props_to_dict(
            alloc)['FRONTEND::tuner_allocation'][
                'FRONTEND::tuner_allocation::allocation_id']
        self.comp.connect(sink, connectionId=allocationID)
        sink.start()

        #Send an RF Info Packet
        rfInfo_port = self.comp.getPort("RFInfo_in")
        rf_info_pkt = self._generateRFInfoPkt(
            rf_freq=100e6,
            rf_bw=100e6,
            if_freq=0,
            rf_flow_id="testRFInfoPacket_FlowID")
        rfInfo_port._set_rfinfo_pkt(rf_info_pkt)

        #Allocate a Tuner
        try:
            retval = self.comp.allocateCapacity(alloc)
        except Exception, e:
            self.assertFalse("Exception thrown on allocateCapactiy %s" %
                             str(e))
 def test_complex(self):
     print "\n... Staring complex data test"
     self._generate_config()
     self.comp_obj.configure(props_from_dict(self.config_dict))
     
     self._generate_keywords()
     self._send_data(complex=True)
     rx_data = self._get_received_data()
     print "Received SRI keywords: %s" % props_to_dict(rx_data[-1].sri.keywords)
     self._validate_data(rx_data, self.expected_data, expected_frame_size=2)
示例#15
0
 def testNoneImport(self):
     """Do a test with import configured to None rather than a sequence
     """
     print "\n... running testNoneImport"
     self.comp.configure(props_from_dict({'import': None}))
     props = props_to_dict(self.comp.query(props_from_dict({})))
     self.assertEqual(
         props['import'], [],
         '"import" property set to "%s" (instead of empty sequence) after configured with "None".'
         % props['import'])
示例#16
0
    def test_MultipleUsesDevices(self):
        devices = dict((dev._get_label(), dev)
                       for dev in self._devMgr._get_registeredDevices())

        appFact = self.createAppFact('Multiple')
        self._app = appFact.create(appFact._get_name(), [], [])

        # Check the usesdevice connections by inspecting the app's external
        # ports against the devices
        for connection in self._app.getPort('resource_out')._get_connections():
            deviceId = connection.port._get_identifier()
            if connection.connectionId == 'connection1':
                self.assertTrue(deviceId,
                                devices['SADUsesDevice_1']._get_identifier())
            elif connection.connectionId == 'connection2':
                self.assertTrue(deviceId,
                                devices['BasicTestDevice1']._get_identifier())

        # Try to create another instance of the application; there should only
        # be enough capacity to satisfy one of the usesdevices
        prop = CF.DataType('DCE:001fad60-b4b3-4ed2-94cb-40e1d956bf4f',
                           any.to_any(None))
        pre_value = properties.props_to_dict(devices['BasicTestDevice1'].query(
            [prop])[0].value._v)
        try:
            app2 = appFact.create(appFact._get_name(), [], [])
        except CF.ApplicationFactory.CreateApplicationError:
            # The first app instance should have exhausted the capacity on the
            # SADUsesDevice
            pass
        else:
            self.fail(
                'Device should not have enough capacity to satisfy usesdevice')

        # Make sure that the successful usesdevice was deallocated
        post_value = properties.props_to_dict(
            devices['BasicTestDevice1'].query([prop])[0].value._v)
        self.assertEqual(pre_value['long_capacity'],
                         post_value['long_capacity'])
        self.assertAlmostEqual(pre_value['float_capacity'],
                               post_value['float_capacity'])
        self.assertEqual(pre_value['struct_simple_seq'],
                         post_value['struct_simple_seq'])
示例#17
0
    def testRFInfoPkt(self):

        self.fei_dev, alloc_params = self.getAllocationContext(ALLOCATE_RCV)

        #create rf_info uses port and connect to MSDD
        out_rf_info_port=frontend.OutRFInfoPort("out_control")
        in_rf_info_port=self.fei_dev.getPort("RFInfo_in")
        out_rf_info_port.connectPort(in_rf_info_port,"test_rf_flow")

	bw=alloc_params['wbddc_bw']
	sr=alloc_params['wbddc_srate']
        # allocation params
        flow_id = "ca-710-flow-2"
        cf=100e6

        # send info pkto
        pkt=_generateRFInfoPkt(cf,bw,rf_flow_id=flow_id)
        out_rf_info_port._set_rfinfo_pkt(pkt)

        # check rf_flow_id was set
        n=len(self.fei_dev.frontend_tuner_status)
        expected=[flow_id]*n
        actual=[ x["FRONTEND::tuner_status::rf_flow_id"] for x in self.fei_dev.frontend_tuner_status ]
        self.assertEqual(expected,actual, "Mismatch of RF Flow Ids for tuners")

        # allocation for sample rate and rf_flow_id
        alloc1=frontend.createTunerAllocation(center_frequency=cf, sample_rate=sr, rf_flow_id=flow_id)
        ret=self.fei_dev.allocateCapacity( alloc1)
        alloc1_aid =  alloc1["FRONTEND::tuner_allocation"]["FRONTEND::tuner_allocation::allocation_id"]
        self.assertEqual(True,ret, "Allocation failed using rf_flow_id")
        self.alloc1=alloc1

        alloc2_aid = alloc1_aid
        if alloc_params['nbddc_srate'] is not None :
                # allocation for center freq and rf_flow_id
                alloc2=frontend.createTunerAllocation(center_frequency=cf,  rf_flow_id=flow_id)
                ret=self.fei_dev.allocateCapacity( alloc2)
                alloc2_aid =  alloc2["FRONTEND::tuner_allocation"]["FRONTEND::tuner_allocation::allocation_id"]
                self.assertEqual(True,ret, "Allocation failed using rf_flow_id again ")
                self.alloc2=alloc2

        # valid rf_flow_id was probagated downstream
        sink=sb.StreamSink()
        sdds_in=sb.launch('rh.SourceSDDS',  properties={'interface':INTERFACE})
        sb.start()
        self.fei_dev.connect(sdds_in, connectionId=alloc2_aid, usesPortName='dataSDDS_out')
        sdds_in.connect(sink, usesPortName="dataShortOut")

        kws=None
        try:
            sink_data=sink.read()
            kws=properties.props_to_dict(sink_data.sri.keywords)
        except:
            pass
        self.assertEqual( kws["FRONTEND::RF_FLOW_ID"] , flow_id, "Missing RF_FLOW_ID from keyword list")
示例#18
0
 def _messageReceived(self, message):
     payload = message.value(CF._tc_Properties)
     if not payload:
         return
     for dt in payload:
         if dt.id == 'state_change':
             value = properties.props_to_dict(dt.value.value(CF._tc_Properties))
             identifier = value['state_change::identifier']
             if value['state_change::event'] == 'start':
                 self._started.put(identifier)
             elif value['state_change::event'] == 'stop':
                 self._stopped.put(identifier)
示例#19
0
    def testReportedBandwidth(self):
        self.comp.start()

        alloc = self._generateAlloc(cf=110e6, sr=24.576e6, bw=20e6)
        allocationID = properties.props_to_dict(
            alloc)['FRONTEND::tuner_allocation'][
                'FRONTEND::tuner_allocation::allocation_id']

        try:
            retval = self.comp.allocateCapacity(alloc)
        except Exception, e:
            print str(e)
            self.fail("Exception thrown on allocateCapactiy %s" % str(e))
    def test_same_stream_snaps(self):
        print "\n... Staring multiple snapshots from one stream test"
        config_dict = self._generate_config()
        data_filename = config_dict['filename']

        if os.path.exists(data_filename):
            os.system("rm %s" % (data_filename+"*"))
            while os.path.exists(data_filename):
                time.sleep(self.t_delta)
                
        self._generate_keywords()
        self.comp.configure(props_from_dict(config_dict))
        
        data_filename = config_dict['filename']
        base_filename = data_filename
        
        count = 0
        expected_data = []
        results = []
        for i in xrange(6):
            # Disable file writing, this should cause the current file to be written out
            # and a new file to be created the next time write in enabled
            enabled_write = not ((i+1) % 2 == 0)

            
            self.comp.configure(props_from_dict({"write": enabled_write}))
            while props_to_dict(self.comp.query([]))['write']!=enabled_write:
                time.sleep(self.t_delta)
            
            first_pkt_time = None
            for j in xrange(3):
                self._send_data(last_pkt_eos=False) # send data but don't send eos (not stopping streaming just yet)
                first_pkt_time = first_pkt_time or self.first_pkt_time
                last_pkt_time = self.last_pkt_time
                if enabled_write:
                    expected_data.extend(self.expected_data)
                    self._sleepTillDone(data_filename, expected_data=expected_data)
                else:
                    time.sleep(self.t_data_wait)   
            
            if not enabled_write:
                # File should have been closed at the start of this pass
                sri_filename = data_filename + ".sri"
                self._validate_data(data_filename, expected_data, config_dict["endian"])
                self._validate_metadata(sri_filename, self.t_delta, self.stream_id1, self.keywords_dict, first_pkt_time, last_pkt_time)
                # reset for the next file
                expected_data = []
                count += 1
                data_filename = base_filename + ".%d" % count
示例#21
0
    def testReportedBandwidth(self):
        self.comp.start()

        self.fei_dev, alloc_params = self.getAllocationContext(ALLOCATE_RCV)

        alloc = self._generateAlloc(cf=110e6,
                                    sr=alloc_params['wbddc_srate'],
                                    bw=alloc_params['wbddc_bw'])
        allocationID = properties.props_to_dict(alloc)['FRONTEND::tuner_allocation']['FRONTEND::tuner_allocation::allocation_id']

        try:
            retval = self.fei_dev.allocateCapacity(alloc)
        except Exception, e:
            print str(e)
            self.fail("Exception thrown on allocateCapactiy %s" % str(e))
示例#22
0
    def propertyChange(self, _propChEv):
        if type(self._changeCallbacks) != dict:
            print 'Invalid change callbacks (must be dictionary with property id as a key and a callback function as a value). Printing received event', _propChEv

        _tmp_props = _propChEv.properties
        _triggers = {}

        for _prop_key in self._changeCallbacks:
            for _prop_idx in range(len(_tmp_props)):
                if _tmp_props[_prop_idx].id == _prop_key:
                    if not _triggers.has_key(self._changeCallbacks[_prop_key]):
                        _triggers[self._changeCallbacks[_prop_key]] = {}
                    _triggers[self._changeCallbacks[_prop_key]].update(
                        properties.prop_to_dict(_tmp_props[_prop_idx]))
                    _tmp_props.pop(_prop_idx)
                    break

        if len(_triggers) != 0:
            for _trigger in _triggers:
                _trigger(_propChEv.evt_id, _propChEv.reg_id,
                         _propChEv.resource_id, _triggers[_trigger],
                         _propChEv.timestamp)

        if len(_tmp_props) != 0:
            if self._defaultCallback:
                self._defaultCallback(_propChEv.evt_id, _propChEv.reg_id,
                                      _propChEv.resource_id,
                                      properties.props_to_dict(_tmp_props),
                                      _propChEv.timestamp)
                return
            print 'Property Change Event:'
            print ' event id:', _propChEv.evt_id
            print ' registration id:', _propChEv.reg_id
            print ' resource id:', _propChEv.resource_id
            print ' properties:', properties.props_to_dict(_tmp_props)
            print ' timestamp:', _propChEv.timestamp
示例#23
0
 def _query(self, props=[], printResults=False):
     results = self.query(props)
     # If querying all properties, display all property names and values
     propDict = _properties.props_to_dict(results)
     maxNameLen = 0
     if printResults:
         if results != [] and len(props) == 0: 
             for prop in propDict.items():
                 if len(prop[0]) > maxNameLen:
                     maxNameLen = len(prop[0])
             print "_query():"
             print "Property Name" + " "*(maxNameLen-len("Property Name")) + "\tProperty Value"
             print "-------------" + " "*(maxNameLen-len("Property Name")) + "\t--------------"
             for prop in propDict.items():
                 print str(prop[0]) + " "*(maxNameLen-len(str(prop[0]))) + "\t    " + str(prop[1])
     return propDict
 def _validate_data(self, received_data, expected_data, expected_frame_size=1, config_dict=None):
     config_dict = config_dict or self.config_dict
     exp_index = 0
     for rx_pkt in received_data:
         for d in rx_pkt.data:
             self.assertEqual(d, expected_data[exp_index])
             exp_index += 1
         
         # Verify keywords
         rx_keywords = props_to_dict(rx_pkt.sri.keywords)
         # Added audio keywords
         self.assertEqual(rx_keywords["AUDIO_ENCODING"], config_dict["encoding"])
         self.assertEqual(rx_keywords["AUDIO_CHANNELS"], config_dict["channels"])
         self.assertEqual(rx_keywords["AUDIO_FRAME_SIZE"], expected_frame_size) # 1 - scalar, 2 - complex
         self.assertEqual(rx_keywords["AUDIO_FRAME_RATE"], 1./self.t_delta)
         
         for k, v in self.keywords_dict.items():
             self.assertEqual(rx_keywords[k], v)
示例#25
0
 def get_available_hardware(self):
     '''
         Returns a list of the available RTL devices
         >> x.get_vailable_rtl()
          [ {
             'index': 0,
             'name': 'ezcap USB 2.0 DVB-T/DAB/FM dongle',
             'product': 'RTL2838UHIDIR',
             'serial': '000000000',
             'vendor': 'Realtek'
            } ]
     '''
     def fixd(d):
         return dict([(k.split('::')[-1], v) for k, v in d.items()])
 
     self.device.configure(props_from_dict(dict(update_available_devices=True)))
     q = props_to_dict(self.device.query(props_from_dict(dict(available_devices=None))))
     return [ fixd(d) for d in q['available_devices']]
    def testDoubleTunerAllocation(self):
        
        #self.comp.start()
        
        #Create Allocation and Sink for Tuner 1
        sink = sb.StreamSink()
        alloc = self._generateAlloc(cf=110e6,sr=2.5e6,bw=2e6)
        allocationID = properties.props_to_dict(alloc)['FRONTEND::tuner_allocation']['FRONTEND::tuner_allocation::allocation_id']
        self.comp.connect(sink,connectionId=allocationID)
        sink.start()


        
        #Allocate a Tuner
        try:
            retval = self.comp.allocateCapacity(alloc)
        except Exception, e:
            self.assertFalse("Exception thrown on allocateCapactiy %s" % str(e))
示例#27
0
 def testSingleTunerAllocation(self):
     
     #self.comp.start()
     
     sink = sb.DataSink()
     
            
     alloc = self._generateAlloc(cf=110e6,sr=2.5e6,bw=2e6)
     allocationID = properties.props_to_dict(alloc)['FRONTEND::tuner_allocation']['FRONTEND::tuner_allocation::allocation_id']
     self.comp.connect(sink,connectionId=allocationID)
     sink.start()
     
     try:
         retval = self.comp.allocateCapacity(alloc)
     except Exception, e:
         print "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%"
         print "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%"
         print "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%"
         print str(e)
         self.assertFalse("Exception thrown on allocateCapactiy %s" % str(e))
示例#28
0
    def get_available_hardware(self):
        '''
            Returns a list of the available RTL devices
            >> x.get_vailable_rtl()
             [ {
                'index': 0,
                'name': 'ezcap USB 2.0 DVB-T/DAB/FM dongle',
                'product': 'RTL2838UHIDIR',
                'serial': '000000000',
                'vendor': 'Realtek'
               } ]
        '''
        def fixd(d):
            return dict([(k.split('::')[-1], v) for k, v in d.items()])

        self.device.configure(
            props_from_dict(dict(update_available_devices=True)))
        q = props_to_dict(
            self.device.query(props_from_dict(dict(available_devices=None))))
        return [fixd(d) for d in q['available_devices']]
示例#29
0
    def testSingleTunerAllocation(self):
        
        self.comp.start()

        self.fei_dev, alloc_params = self.getAllocationContext(ALLOCATE_RCV)
        
        sink = sb.DataSinkSDDS()
               
        alloc = self._generateAlloc(cf=110e6,sr=0,bw=0)
        allocationID = properties.props_to_dict(alloc)['FRONTEND::tuner_allocation']['FRONTEND::tuner_allocation::allocation_id']
        self.fei_dev.connect(sink,usesPortName = "dataSDDS_out",connectionId=allocationID)
        sink.start()
        
        try:
            retval = self.fei_dev.allocateCapacity(alloc)
        except Exception, e:
            print "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%"
            print "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%"
            print "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%"
            print str(e)
            self.assertFalse("Exception thrown on allocateCapactiy %s" % str(e))
示例#30
0
    def set_target_hardware(self, rtlx):
        '''
            Sets the target RTL to use.  To choose a target device
            use a dictionary with the criteria to select (from the available
            rtl devices). Returns the target that was just set.

            > x.set_target_rtl(dict(index=0))
            [ {
                'index': 0,
                'name': None,
                'product': None,
                'serial': None,
                'vendor': None,
              } ]
        '''
        # the device has a bug in that if it gets the same value, it won't trigger 
        # target device.  So set it to some weird number and than change it again
        self.device.configure(dict(target_device=dict(index=-2)))

        # FIXME: Validate rtlx has the right fields
        self.device.configure(dict(target_device=rtlx))
        return props_to_dict(self.device.query(props_from_dict(dict(target_device=None))))
示例#31
0
    def set_target_hardware(self, rtlx):
        '''
            Sets the target RTL to use.  To choose a target device
            use a dictionary with the criteria to select (from the available
            rtl devices). Returns the target that was just set.

            > x.set_target_rtl(dict(index=0))
            [ {
                'index': 0,
                'name': None,
                'product': None,
                'serial': None,
                'vendor': None,
              } ]
        '''
        # the device has a bug in that if it gets the same value, it won't trigger
        # target device.  So set it to some weird number and than change it again
        self.device.configure(dict(target_device=dict(index=-2)))

        # FIXME: Validate rtlx has the right fields
        self.device.configure(dict(target_device=rtlx))
        return props_to_dict(
            self.device.query(props_from_dict(dict(target_device=None))))
示例#32
0
   def testConfigureQuerySeqs(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)
       
       #######################################################################
       # Simulate regular component startup
       # Verify that initialize nor configure throw errors
       self.comp_obj.initialize()
       
       values = [1,2,3,4,5]
       phrases = ['one','two','three','four','five']
       phrase = 'testing'
       octetData = struct.pack('5b', *[x for x in values]) #octet data must be packed bytes
       flags = [True, False, True, False]
       
       values_r = copy.deepcopy(values)
       values_r.reverse()
       phrases_r = copy.deepcopy(phrases)
       phrases_r.reverse()
       phrase_r = ([x for x in phrase])
       phrase_r.reverse()
       flags_r = copy.deepcopy(flags)
       flags_r.reverse()
       
       numTestRuns = 10
       for x in range(numTestRuns):    
           stringset = ossie.cf.CF.DataType(id='stringSeq', value=any.to_any(phrases))
           stringset.value._t = tcInternal.typeCodeFromClassOrRepoId(CORBA.StringSeq)
           self.comp_obj.configure([stringset])
             
           boolset = ossie.cf.CF.DataType(id='boolSeq', value=any.to_any(flags))  
           boolset.value._t = tcInternal.typeCodeFromClassOrRepoId(CORBA.BooleanSeq)
           self.comp_obj.configure([boolset])
 
           ulongset = ossie.cf.CF.DataType(id='ulongSeq', value=any.to_any(values))
           ulongset.value._t = tcInternal.typeCodeFromClassOrRepoId(CORBA.ULongSeq)
           self.comp_obj.configure([ulongset])
           
           shortset = ossie.cf.CF.DataType(id='shortSeq', value=any.to_any(values))
           shortset.value._t = tcInternal.typeCodeFromClassOrRepoId(CORBA.ShortSeq)
           self.comp_obj.configure([shortset])
           
           floatset = ossie.cf.CF.DataType(id='floatSeq', value=any.to_any(values))
           floatset.value._t = tcInternal.typeCodeFromClassOrRepoId(CORBA.FloatSeq)
           self.comp_obj.configure([floatset])
           
           charset = ossie.cf.CF.DataType(id='charSeq', value=any.to_any(phrase))
           charset.value._t = tcInternal.typeCodeFromClassOrRepoId(CORBA.CharSeq)
           self.comp_obj.configure([charset])
           
           octetset = ossie.cf.CF.DataType(id='octetSeq', value=any.to_any(octetData))
           octetset.value._t = tcInternal.typeCodeFromClassOrRepoId(CORBA.OctetSeq)
           self.comp_obj.configure([octetset])
           
           ushortset = ossie.cf.CF.DataType(id='ushortSeq', value=any.to_any(values))
           ushortset.value._t = tcInternal.typeCodeFromClassOrRepoId(CORBA.UShortSeq)
           self.comp_obj.configure([ushortset])
           
           doubleset = ossie.cf.CF.DataType(id='doubleSeq', value=any.to_any(values))
           doubleset.value._t = tcInternal.typeCodeFromClassOrRepoId(CORBA.DoubleSeq)
           self.comp_obj.configure([doubleset])
           
           longset = ossie.cf.CF.DataType(id='longSeq', value=any.to_any(values))
           longset.value._t = tcInternal.typeCodeFromClassOrRepoId(CORBA.LongSeq)
           self.comp_obj.configure([longset])
           
           longlongset = ossie.cf.CF.DataType(id='longlongSeq', value=any.to_any(values))
           longlongset.value._t = tcInternal.typeCodeFromClassOrRepoId(PortTypes.LongLongSequence)
           self.comp_obj.configure([longlongset])
           
           ulonglongset = ossie.cf.CF.DataType(id='ulonglongSeq', value=any.to_any(values))
           ulonglongset.value._t = tcInternal.typeCodeFromClassOrRepoId(PortTypes.UlongLongSequence)
           self.comp_obj.configure([ulonglongset])
   
           simple_list = self.comp_obj.query([
                                      ossie.cf.CF.DataType(id=str('stringSeq'),value=any.to_any(None)),
                                      ossie.cf.CF.DataType(id=str('boolSeq'),value=any.to_any(None)),
                                      ossie.cf.CF.DataType(id=str('ulongSeq'),value=any.to_any(None)),
                                      ossie.cf.CF.DataType(id=str('shortSeq'),value=any.to_any(None)),
                                      ossie.cf.CF.DataType(id=str('floatSeq'),value=any.to_any(None)),
                                      ossie.cf.CF.DataType(id=str('charSeq'),value=any.to_any(None)),
                                      ossie.cf.CF.DataType(id=str('octetSeq'),value=any.to_any(None)),
                                      ossie.cf.CF.DataType(id=str('ushortSeq'),value=any.to_any(None)),
                                      ossie.cf.CF.DataType(id=str('doubleSeq'),value=any.to_any(None)),
                                      ossie.cf.CF.DataType(id=str('longSeq'),value=any.to_any(None)),
                                      ossie.cf.CF.DataType(id=str('longlongSeq'),value=any.to_any(None)),
                                      ossie.cf.CF.DataType(id=str('ulonglongSeq'),value=any.to_any(None))
                                           ])         
           
           simple_dict = properties.props_to_dict(simple_list)
           
           #the onconfigure for the stringSeq is supposed to reverse the order of the phrases
           self.assertEquals(simple_dict['stringSeq'], phrases_r, msg=str(simple_dict['stringSeq']) + ' != ' + str(phrases_r) + '  for stringSeq')
           simple_dict.pop('stringSeq')
           
           #the onconfigure for the boolSeq is supposed to reverse the order of the flags
           self.assertEquals(simple_dict['boolSeq'], flags_r, msg=str(simple_dict['boolSeq']) + ' != ' + str(flags_r) + '  for boolSeq')
           simple_dict.pop('boolSeq')
           
           #the onconfigure for the charSeq is supposed to reverse the order of the phrase
           self.assertEquals([x for x in simple_dict['charSeq']], phrase_r, msg=str(simple_dict['charSeq']) + ' != ' + str(phrase_r) + '  for charSeq')
           simple_dict.pop('charSeq')
          
           #the onconfigure for the octetSeq is supposed to reverse the order of the phrase
           self.assertEquals([x for x in struct.unpack('5b', simple_dict['octetSeq'])], values_r, 
                             msg=str(struct.unpack('5b', simple_dict['octetSeq'])) + ' != ' + str(values_r) + '  for octetSeq')
           simple_dict.pop('octetSeq')
           
           #the rest of the onconfigures are supposed to reverse the values in the list
           for x in simple_dict:
               self.assertEquals(simple_dict[x], values_r, msg=str(simple_dict[x]) + ' != ' + str(values_r) + '  for ' + x)
示例#33
0
    def testConfigureQuerySimples(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)
        
        #######################################################################
        # Simulate regular component startup
        # Verify that initialize nor configure throw errors
        self.comp_obj.initialize()
        
        numTestRuns = 10
        val = 15
        charval = 'a'
        chardata = struct.pack('1c', charval)

        flag = True
        for x in range(numTestRuns):
            phrase = 'blah' + str(val)
            flag = not flag
            
            self.comp_obj.configure([ossie.cf.CF.DataType(id='stringSimple', value=CORBA.Any(CORBA.TC_string, phrase))])
            # Need to reset boolSimple value so value will definitely change
            self.comp_obj.configure([ossie.cf.CF.DataType(id='boolSimple', value=any.to_any(None))])
            self.comp_obj.configure([ossie.cf.CF.DataType(id='boolSimple', value=CORBA.Any(CORBA.TC_boolean, flag))])
            self.comp_obj.configure([ossie.cf.CF.DataType(id='ulongSimple', value=CORBA.Any(CORBA.TC_ulong, val))])
            self.comp_obj.configure([ossie.cf.CF.DataType(id='shortSimple', value=CORBA.Any(CORBA.TC_short, val))])
            self.comp_obj.configure([ossie.cf.CF.DataType(id='floatSimple', value=CORBA.Any(CORBA.TC_float, val))])
            self.comp_obj.configure([ossie.cf.CF.DataType(id='octetSimple', value=CORBA.Any(CORBA.TC_octet, val))])
            self.comp_obj.configure([ossie.cf.CF.DataType(id='charSimple', value=CORBA.Any(CORBA.TC_char, chardata))])
            self.comp_obj.configure([ossie.cf.CF.DataType(id='ushortSimple', value=CORBA.Any(CORBA.TC_ushort, val))])
            self.comp_obj.configure([ossie.cf.CF.DataType(id='doubleSimple', value=CORBA.Any(CORBA.TC_double, val))])
            self.comp_obj.configure([ossie.cf.CF.DataType(id='longSimple', value=CORBA.Any(CORBA.TC_long, val))])
            self.comp_obj.configure([ossie.cf.CF.DataType(id='longlongSimple', value=CORBA.Any(CORBA.TC_longlong, val))])
            self.comp_obj.configure([ossie.cf.CF.DataType(id='ulonglongSimple', value=CORBA.Any(CORBA.TC_ulonglong, val))])
            
            simple_list = self.comp_obj.query([
                                       ossie.cf.CF.DataType(id=str('stringSimple'),value=any.to_any(None)),
                                       ossie.cf.CF.DataType(id=str('boolSimple'),value=any.to_any(None)),
                                       ossie.cf.CF.DataType(id=str('ulongSimple'),value=any.to_any(None)),
                                       ossie.cf.CF.DataType(id=str('shortSimple'),value=any.to_any(None)),
                                       ossie.cf.CF.DataType(id=str('floatSimple'),value=any.to_any(None)),
                                       ossie.cf.CF.DataType(id=str('octetSimple'),value=any.to_any(None)),
                                       ossie.cf.CF.DataType(id=str('charSimple'),value=any.to_any(None)),
                                       ossie.cf.CF.DataType(id=str('ushortSimple'),value=any.to_any(None)),
                                       ossie.cf.CF.DataType(id=str('doubleSimple'),value=any.to_any(None)),
                                       ossie.cf.CF.DataType(id=str('longSimple'),value=any.to_any(None)),
                                       ossie.cf.CF.DataType(id=str('longlongSimple'),value=any.to_any(None)),
                                       ossie.cf.CF.DataType(id=str('ulonglongSimple'),value=any.to_any(None))
                                               ])

            
            simple_dict = properties.props_to_dict(simple_list)

            #the onconfigure for the stringSimple is supposed to double the phrase
            self.assertEquals(simple_dict['stringSimple'], phrase*2, msg=str(simple_dict['stringSimple']) + ' != ' + str(phrase*2) + '  for stringSimple')
            simple_dict.pop('stringSimple')
            
            #the onconfigure for the boolSimple is supposed to flip the flag
            self.assertEquals(simple_dict['boolSimple'], not flag, msg=str(simple_dict['boolSimple']) + ' != ' + str(not flag) + '  for boolSimple')
            simple_dict.pop('boolSimple')
            self.comp_obj.configure([ossie.cf.CF.DataType(id='boolSimple', value=CORBA.Any(CORBA.TC_boolean, flag))])
            
            #the onconfigure for the charSimple is supposed raise the case
            self.assertEquals(simple_dict['charSimple'], charval.upper(), msg=str(simple_dict['charSimple']) + ' != ' + str(charval.upper()) + '  for charSimple')
            simple_dict.pop('charSimple')
            
            #the rest of the onconfigures are supposed to double the value
            for x in simple_dict:
                self.assertEquals(simple_dict[x], val*2, msg=str(simple_dict[x]) + ' != ' + str(val*2) + '  for ' + x)
            val = val+1
示例#34
0
    def testBlueShortPortSwapped(self):
        #######################################################################
        # Test Bluefile Swapped SHORT Functionality
        print "\n**TESTING BLUEFILE Swapped + SHORT PORT"

        #Define test files
        dataFileIn = './bluefile.in'
        dataFileInSwap = './bluefile.in.swap'

        #Create Test Data File if it doesn't exist
        if not os.path.isfile(dataFileIn):
            tmpSink = bluefile_helpers.BlueFileWriter(dataFileIn,
                                                      BULKIO__POA.dataShort)
            tmpSink.start()
            tmpSri = createSri('bluefileShortSwapped', 5000)
            #kwVal = 1234
            #kwSwap = swap([kwVal], 'long')[0]
            #tmpSri.keywords = props_from_dict({'TEST_KW':kwSwap})
            tmpSri.keywords = props_from_dict({'TEST_KW': 1234})
            tmpSink.pushSRI(tmpSri)
            tmpTs = createTs()
            #tmpSink.pushPacket(swap(range(1024),'short'), tmpTs, True, 'bluefileShortSwapped')
            tmpSink.pushPacket(range(1024), tmpTs, True,
                               'bluefileShortSwapped')

        #Read in Data from Test File, modify header, and rewrite
        hdr, d = bluefile.read(dataFileIn, dict)
        hdr['file_name'] = dataFileInSwap
        hdr['head_rep'] = 'IEEE'
        hdr['data_rep'] = 'IEEE'
        bluefile.write(dataFileInSwap, hdr, d)

        #Read in Data from Swapped Test File
        hdr, d = bluefile.read(dataFileInSwap, dict)
        data = list(d)
        keywords = hdr['ext_header']

        #Create Components and Connections
        comp = sb.launch('../FileReader.spd.xml')
        comp.source_uri = dataFileInSwap
        comp.file_format = 'BLUEFILE'

        sink = sb.DataSink()
        comp.connect(sink, usesPortName='dataShort_out')

        #Start Components & Push Data
        sb.start()
        comp.playback_state = 'PLAY'
        time.sleep(2)
        readData = sink.getData()
        readKeywords = props_to_dict(sink.sri().keywords)
        sb.stop()

        #Check that the input and output files are the same
        try:
            self.assertEqual(data, readData)
        except self.failureException as e:
            comp.releaseObject()
            sink.releaseObject()
            os.remove(dataFileIn)
            os.remove(dataFileInSwap)
            raise e

        #Check that the keywords are the same
        try:
            self.assertEqual(keywords, readKeywords)
        except self.failureException as e:
            comp.releaseObject()
            sink.releaseObject()
            os.remove(dataFileIn)
            os.remove(dataFileInSwap)
            raise e

        #Release the components and remove the generated files
        comp.releaseObject()
        sink.releaseObject()
        os.remove(dataFileIn)
        os.remove(dataFileInSwap)

        print "........ PASSED\n"
        return
示例#35
0
    def testRFFlowID(self):

        #create rf_info uses port and connect to MSDD
        out_rf_info_port = frontend.OutRFInfoPort("out_control")
        in_rf_info_port = self.comp.getPort("RFInfo_in")
        out_rf_info_port.connectPort(in_rf_info_port, "test_rf_flow")

        # get params for allocations
        bw = self.alloc_params['wbddc_bw']
        sr = self.alloc_params['wbddc_srate']

        # allocation params
        flow_id = "ca-710-flow"
        cf = 100e6

        # set rf flow id
        out_rf_info_port._set_rf_flow_id(flow_id)

        # check rf_flow_id was set
        n = len(self.comp.frontend_tuner_status)
        expected = [flow_id] * n
        actual = [
            x["FRONTEND::tuner_status::rf_flow_id"]
            for x in self.comp.frontend_tuner_status
        ]
        self.assertEqual(expected, actual,
                         "Mismatch of RF Flow Ids for tuners")

        # allocation for sample rate and rf_flow_id
        alloc1 = frontend.createTunerAllocation(center_frequency=cf,
                                                sample_rate=sr,
                                                rf_flow_id=flow_id)
        ret = self.comp.allocateCapacity(alloc1)
        alloc1_aid = alloc1["FRONTEND::tuner_allocation"][
            "FRONTEND::tuner_allocation::allocation_id"]
        self.assertEqual(True, ret, "Allocation failed using rf_flow_id")

        alloc2_aid = alloc1_aid
        if self.alloc_params['nbddc_srate'] is not None:
            # dual channel we need to provide specific rate so the correct DDC is selected that matches the same rf_flow_id
            if '2w' in self.msdd_id:
                # allocation for center freq and rf_flow_id
                alloc2 = frontend.createTunerAllocation(
                    center_frequency=cf,
                    sample_rate=self.alloc_params['nbddc_srate'],
                    sample_rate_tolerance=1.0,
                    rf_flow_id=flow_id)
            else:
                # allocation for center freq and rf_flow_id
                alloc2 = frontend.createTunerAllocation(center_frequency=cf,
                                                        rf_flow_id=flow_id)
            ret = self.comp.allocateCapacity(alloc2)
            alloc2_aid = alloc2["FRONTEND::tuner_allocation"][
                "FRONTEND::tuner_allocation::allocation_id"]
            self.assertEqual(True, ret,
                             "Allocation failed using rf_flow_id again ")

        # valid rf_flow_id was probagated downstream
        sink = sb.StreamSink()
        sdds_in = sb.launch(
            'rh.SourceSDDS',
            properties={
                'interface': INTERFACE,
                'advanced_optimizations': {
                    'advanced_optimizations::sdds_pkts_per_bulkio_push': 5
                },
                'attachment_override': {
                    'attachment_override:endianness': "1234"
                }
            })
        sb.start()
        self.comp.connect(sdds_in,
                          connectionId=alloc2_aid,
                          usesPortName='dataSDDS_out')
        sdds_in.connect(sink, usesPortName="dataShortOut")

        kws = None
        try:
            sink_data = sink.read()
            kws = properties.props_to_dict(sink_data.sri.keywords)
        except:
            pass
        self.assertEqual(kws["FRONTEND::RF_FLOW_ID"], flow_id,
                         "Missing RF_FLOW_ID from keyword list")
 def _runTests(self, props):
     props = properties.props_from_dict(dict((p, None) for p in props))
     result = self.comp.runTest(0, props)
     return properties.props_to_dict(result)
 def getFilterProps(self):
     """ get the filter properties from the component
     """
     props = self.comp.query([])
     d = props_to_dict(props)
     return d['filterProps']
 def getFilterProps(self):
     """ get the filter properties from the component
     """
     props = self.comp.query([])
     d = props_to_dict(props)
     return d['filterProps']
示例#39
0
    def testRFFlowID(self):

        #create rf_info uses port and connect to MSDD
        out_rf_info_port = frontend.OutRFInfoPort("out_control")
        in_rf_info_port = self.comp.getPort("RFInfo_in")
        out_rf_info_port.connectPort(in_rf_info_port, "test_rf_flow")

        # get params for allocations
        bw = float(self.comp.frontend_tuner_status[0]
                   ["FRONTEND::tuner_status::available_bandwidth"])
        sr = float(self.comp.frontend_tuner_status[0]
                   ["FRONTEND::tuner_status::available_sample_rate"])

        # allocation params
        flow_id = "ca-710-flow"
        cf = 100e6

        # set rf flow id
        out_rf_info_port._set_rf_flow_id(flow_id)

        # check rf_flow_id was set
        n = len(self.comp.frontend_tuner_status)
        expected = [flow_id] * n
        actual = [
            x["FRONTEND::tuner_status::rf_flow_id"]
            for x in self.comp.frontend_tuner_status
        ]
        self.assertEqual(expected, actual,
                         "Mismatch of RF Flow Ids for tuners")

        # allocation for sample rate and rf_flow_id
        alloc1 = frontend.createTunerAllocation(center_frequency=cf,
                                                sample_rate=sr,
                                                rf_flow_id=flow_id)
        ret = self.comp.allocateCapacity(alloc1)
        alloc1_aid = alloc1["FRONTEND::tuner_allocation"][
            "FRONTEND::tuner_allocation::allocation_id"]
        self.assertEqual(True, ret, "Allocation failed using rf_flow_id")

        # allocation for center freq and rf_flow_id
        alloc2 = frontend.createTunerAllocation(center_frequency=cf,
                                                rf_flow_id=flow_id)
        ret = self.comp.allocateCapacity(alloc2)
        alloc2_aid = alloc2["FRONTEND::tuner_allocation"][
            "FRONTEND::tuner_allocation::allocation_id"]
        self.assertEqual(True, ret,
                         "Allocation failed using rf_flow_id again ")

        # valid rf_flow_id was probagated downstream
        sink = sb.StreamSink()
        sdds_in = sb.launch('rh.SourceSDDS',
                            properties={'interface': INTERFACE})
        sb.start()
        self.comp.connect(sdds_in,
                          connectionId=alloc2_aid,
                          usesPortName='dataSDDS_out')
        sdds_in.connect(sink, usesPortName="dataShortOut")

        kws = None
        try:
            sink_data = sink.read()
            kws = properties.props_to_dict(sink_data.sri.keywords)
        except:
            pass
        self.assertEqual(kws["FRONTEND::RF_FLOW_ID"], flow_id,
                         "Missing RF_FLOW_ID from keyword list")
        except Exception, e:
            self.assertFalse("Exception thrown on allocateCapactiy %s" % str(e))
        if not retval:
            self.assertFalse("Allocation Failed")

        #Check Tuner 1 SRI, letting data and SRI flow for up to 1s
        data = sink.read(timeout=1)
        self.failIf(data is None)
        print "SRI 1 1st Time" , data.sri
        self.assertEqual(data.sri.streamID, allocationID, "SRI 1 Did not Match")
        self.assertAlmostEqual(data.sri.xdelta, 1.0/2.5e6,5)

        #Create Allocation and Sink for Tuner 2
        sink2 = sb.StreamSink()
        alloc2 = self._generateAlloc(cf=110e6,sr=5e6,bw=4e6)
        allocationID2 = properties.props_to_dict(alloc2)['FRONTEND::tuner_allocation']['FRONTEND::tuner_allocation::allocation_id']
        self.comp.connect(sink2,connectionId=allocationID2)
        sink2.start()

        #Allocate a Second Tuner
        try:
            retval = self.comp.allocateCapacity(alloc2)
        except Exception, e:
            print str(e)
            self.assertFalse("Exception thrown on allocateCapactiy on second Tuner %s" % str(e))
        if not retval:
            self.assertFalse("Allocation Failed on second Tuner")
        
        #Sleep and let data and SRI flow    
        time.sleep(1)