Exemplo n.º 1
0
 def test_update_acs_client(self):
     other_client = PySimpleClient()
     other_client.getLogger().setLevel(logging.CRITICAL)
     self._front_end.update_acs_client(other_client)
     self.assertTrue(self._front_end.is_acs_client_ok)
     self._front_end.start_recording()
     yet_other_client = PySimpleClient()
     yet_other_client.getLogger().setLevel(logging.CRITICAL)
     self._front_end.update_acs_client(yet_other_client)
     self._front_end.stop_recording()
class prsComponentCppImplTestPy(unittest.TestCase):

	################################################
	# lifecycle
	################################################
	
	def setUp(self):
		self.simpleClient = PySimpleClient()
		self.componentName = "testInstanceprsComponentCppImpl"
		self.simpleClient.getLogger().logInfo("pyUnitTestprsComponentCppImpl.prsComponentCppImplTestPy.setUp()...")
        self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
        self.component = self.simpleClient.getComponent(self.componentName)
	#__pPp__	    	           
	
	def tearDown(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestprsComponentCppImpl.prsComponentCppImplTestPy.tearDown()...")
		self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
		self.simpleClient.releaseComponent(self.componentName)
		self.simpleClient.disconnect()
	#__pPp__       
        
	################################################
	# test methods
	################################################
	
	def testPark(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestprsComponentCppImpl.prsComponentCppImplTestPy.testPark()...")
		response = None
		response = self.component.Park()
		# no return is expected, response should be None
		assert response is None
class MasterComponentImplTestPy(unittest.TestCase):

	################################################
	# lifecycle
	################################################
	
	def setUp(self):
		self.simpleClient = PySimpleClient()
		self.componentName = "testInstanceMasterComponentImpl"
		self.simpleClient.getLogger().logInfo("pyUnitTestMasterComponentImpl.MasterComponentImplTestPy.setUp()...")
        self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
        self.component = self.simpleClient.getComponent(self.componentName)
	#__pPp__	    	           
	
	def tearDown(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestMasterComponentImpl.MasterComponentImplTestPy.tearDown()...")
		self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
		self.simpleClient.releaseComponent(self.componentName)
		self.simpleClient.disconnect()
	#__pPp__       
        
	################################################
	# test methods
	################################################
	
	def testDoTransition(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestMasterComponentImpl.MasterComponentImplTestPy.testDoTransition()...")
		response = None
		event = SubsystemStateEvent()
		response = self.component.doTransition(event)
		# no return is expected, response should be None
		assert response is None
Exemplo n.º 4
0
class DCSImplTestPy(unittest.TestCase):

	################################################
	# lifecycle
	################################################
	
	def setUp(self):
		self.simpleClient = PySimpleClient()
		self.componentName = "testInstanceDCSImpl"
		self.simpleClient.getLogger().logInfo("pyUnitTestDCSImpl.DCSImplTestPy.setUp()...")
        self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
        self.component = self.simpleClient.getComponent(self.componentName)
	#__pPp__	    	           
	
	def tearDown(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestDCSImpl.DCSImplTestPy.tearDown()...")
		self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
		self.simpleClient.releaseComponent(self.componentName)
		self.simpleClient.disconnect()
	#__pPp__       
        
	################################################
	# test methods
	################################################
	
	def testSendCommand(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestDCSImpl.DCSImplTestPy.testSendCommand()...")
		response = None
		commandName = 'emptyString'
		parameterList = 'emptyString'
		cb = CBstring()
		desc = CBDescIn()
		response = self.component.sendCommand(commandName, parameterList, cb, desc)
		# a return is expected, response should be not None
		assert response is not None
class StopWatchLightImplTestPy(unittest.TestCase):

	################################################
	# lifecycle
	################################################
	
	def setUp(self):
		self.simpleClient = PySimpleClient()
		self.componentName = "testInstanceStopWatchLightImpl"
		self.simpleClient.getLogger().logInfo("pyUnitTestStopWatchLightImpl.StopWatchLightImplTestPy.setUp()...")
        self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
        self.component = self.simpleClient.getComponent(self.componentName)
	#__pPp__	    	           
	
	def tearDown(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestStopWatchLightImpl.StopWatchLightImplTestPy.tearDown()...")
		self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
		self.simpleClient.releaseComponent(self.componentName)
		self.simpleClient.disconnect()
	#__pPp__       
        
	################################################
	# test methods
	################################################
	
	def testGetDisplay(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestStopWatchLightImpl.StopWatchLightImplTestPy.testGetDisplay()...")
		response = None
		response = self.component.getDisplay()
		# a return is expected, response should be not None
		assert response is not None
Exemplo n.º 6
0
class MoreComponentUtilTest(unittest.TestCase):
    """
    Test the integration of the component utilities
    """
    def setUp(self):
        self._my_acs_client = PySimpleClient()
        logger = self._my_acs_client.getLogger()
        logger.setLevel(logging.WARNING)

    def tearDown(self):
        self._my_acs_client.disconnect()

    def test_is_characteristic_component(self):
        my_component = self._my_acs_client.getComponent(
            "TEST_PROPERTIES_COMPONENT", True)
        self.assertTrue(
            component_util.is_characteristic_component(my_component))
        # Now check a component that is not characteristic
        my_component2 = self._my_acs_client.getComponent("TIMER1", True)
        self.assertFalse(
            component_util.is_characteristic_component(my_component2))

    def test_is_python_char_component(self):
        my_component = self._my_acs_client.getComponent(
            "TEST_PROPERTIES_PYTHON", True)
        self.assertTrue(component_util.is_python_char_component(my_component))
        # Now check a component that is not characteristic

        my_component2 = self._my_acs_client.getComponent("TIMER1", True)

        self.assertRaises(AttributeError,
                          component_util.is_python_char_component,
                          my_component2)

        my_component3 = self._my_acs_client.getComponent(
            "TEST_PROPERTIES_COMPONENT", True)

        self.assertFalse(
            component_util.is_python_char_component(my_component3))

    def test_is_a_property_recorder_component(self):
        my_component = self._my_acs_client.getComponent(
            "propertyRecorder1", True)
        self.assertTrue(
            component_util.is_a_property_recorder_component(my_component))
        # Now check a component that is not characteristic
        my_component2 = self._my_acs_client.getComponent("TIMER1", True)
        self.assertFalse(
            component_util.is_a_property_recorder_component(my_component2))

    def test_is_component_state_ok(self):
        my_component = self._my_acs_client.getComponent(
            "TEST_PROPERTIES_COMPONENT", True)
        self.assertTrue(component_util.is_component_state_ok(my_component))
class BasicAntennaJavaImplTestPy(unittest.TestCase):

	################################################
	# lifecycle
	################################################
	
	def setUp(self):
		self.simpleClient = PySimpleClient()
		self.componentName = "testInstanceBasicAntennaJavaImpl"
		self.simpleClient.getLogger().logInfo("pyUnitTestBasicAntennaJavaImpl.BasicAntennaJavaImplTestPy.setUp()...")
        self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
        self.component = self.simpleClient.getComponent(self.componentName)
	#__pPp__	    	           
	
	def tearDown(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestBasicAntennaJavaImpl.BasicAntennaJavaImplTestPy.tearDown()...")
		self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
		self.simpleClient.releaseComponent(self.componentName)
		self.simpleClient.disconnect()
	#__pPp__       
        
	################################################
	# test methods
	################################################
	
	def testSetAntennaPosition(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestBasicAntennaJavaImpl.BasicAntennaJavaImplTestPy.testSetAntennaPosition()...")
		response = None
		pos = position()
		response = self.component.setAntennaPosition(pos)
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testGetAntennaPosition(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestBasicAntennaJavaImpl.BasicAntennaJavaImplTestPy.testGetAntennaPosition()...")
		response = None
		response = self.component.getAntennaPosition()
		# a return is expected, response should be not None
		assert response is not None
class EventSubscriberImplTestPy(unittest.TestCase):

	################################################
	# lifecycle
	################################################
	
	def setUp(self):
		self.simpleClient = PySimpleClient()
		self.componentName = "testInstanceEventSubscriberImpl"
		self.simpleClient.getLogger().logInfo("pyUnitTestEventSubscriberImpl.EventSubscriberImplTestPy.setUp()...")
        self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
        self.component = self.simpleClient.getComponent(self.componentName)
	#__pPp__	    	           
	
	def tearDown(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestEventSubscriberImpl.EventSubscriberImplTestPy.tearDown()...")
		self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
		self.simpleClient.releaseComponent(self.componentName)
		self.simpleClient.disconnect()
Exemplo n.º 9
0
LINKS
- <a href="../../idl/html/interfaceHelloWorld_1_1HelloWorld.html">HelloWorld IDL Documentation</a>
'''

# Import command-line arguments
from sys import argv

# Import the SimpleClient class
from Acspy.Clients.SimpleClient import PySimpleClient

# Make an instance of the PySimpleClient
simpleClient = PySimpleClient()

# Obtain a reference to a dynamic component using the ContainerServices
# getComponent method.
hwRef = simpleClient.getDynamicComponent(
    None, "IDL:alma/acsexmplHelloWorld/HelloWorld:1.0",
    "acsexmplHelloWorldImpl", str(argv[1]))

if hwRef != None:
    simpleClient.getLogger().logInfo("Retrieved valid reference from manager.")
    #Do something useful with the reference.
    hwRef.displayMessage()
    simpleClient.getLogger().logInfo(
        "Method of dynamic component successfully invoked. Have a nice day!")
else:
    simpleClient.getLogger().logAlert("Bad reference retrieved from manager")

simpleClient.disconnect()
print "The end __oOo__"
Exemplo n.º 10
0
        count = count + 1
        LOGGER.logInfo('The temperature difference is ' + str(someParam.absoluteDiff))
        
    return
#------------------------------------------------------------------------------
if __name__ == "__main__":
    
    print 'Making sure there is a fridge available...'
    
    #Start publishing events through a C++ Supplier
    simpleClient = PySimpleClient()
    aFridge = simpleClient.getComponent("FRIDGE1")
    aFridge.on()

    #Create a FridgeConsumer
    simpleClient.getLogger().logInfo('Creating FridgeConsumer')
    g = Consumer(FRIDGE.CHANNELNAME_FRIDGE)

    #Subscribe to temperatureDataBlockEvent events and register this handler to process
    #those events
    g.addSubscription(FRIDGE.temperatureDataBlockEvent, fridgeDataHandler)

    #Let the Notification Service know we are ready to start processing events.
    g.consumerReady()

    #After five events have been received, disconnect from the channel
    simpleClient.getLogger().logInfo("Waiting for events . . .")
    while(count<5):
        sleep(1)

    simpleClient.getLogger().logInfo("Events all done . . . exiting")
Exemplo n.º 11
0
class LegoImplTestPy(unittest.TestCase):

	################################################
	# lifecycle
	################################################
	
	def setUp(self):
		self.simpleClient = PySimpleClient()
		self.componentName = "testInstanceLegoImpl"
		self.simpleClient.getLogger().logInfo("pyUnitTestLegoImpl.LegoImplTestPy.setUp()...")
        self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
        self.component = self.simpleClient.getComponent(self.componentName)
	#__pPp__	    	           
	
	def tearDown(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestLegoImpl.LegoImplTestPy.tearDown()...")
		self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
		self.simpleClient.releaseComponent(self.componentName)
		self.simpleClient.disconnect()
	#__pPp__       
        
	################################################
	# test methods
	################################################
	
	def testObserve(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestLegoImpl.LegoImplTestPy.testObserve()...")
		response = None
		coordinates = Position()
		exposureTime = 0
		response = self.component.observe(coordinates, exposureTime)
		# a return is expected, response should be not None
		assert response is not None
	#__pPp__
			    
	def testMoveTo(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestLegoImpl.LegoImplTestPy.testMoveTo()...")
		response = None
		coordinates = Position()
		response = self.component.moveTo(coordinates)
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testGetCurrentPosition(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestLegoImpl.LegoImplTestPy.testGetCurrentPosition()...")
		response = None
		response = self.component.getCurrentPosition()
		# a return is expected, response should be not None
		assert response is not None
Exemplo n.º 12
0
class NexstarImplTestPy(unittest.TestCase):

	################################################
	# lifecycle
	################################################
	
	def setUp(self):
		self.simpleClient = PySimpleClient()
		self.componentName = "testInstanceNexstarImpl"
		self.simpleClient.getLogger().logInfo("pyUnitTestNexstarImpl.NexstarImplTestPy.setUp()...")
        self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
        self.component = self.simpleClient.getComponent(self.componentName)
	#__pPp__	    	           
	
	def tearDown(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestNexstarImpl.NexstarImplTestPy.tearDown()...")
		self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
		self.simpleClient.releaseComponent(self.componentName)
		self.simpleClient.disconnect()
	#__pPp__       
        
	################################################
	# test methods
	################################################
	
	def testImage(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestNexstarImpl.NexstarImplTestPy.testImage()...")
		response = None
		exposure = double()
		response = self.component.image(exposure)
		# a return is expected, response should be not None
		assert response is not None
	#__pPp__
			    
	def testLock(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestNexstarImpl.NexstarImplTestPy.testLock()...")
		response = None
		response = self.component.lock()
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testUnlock(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestNexstarImpl.NexstarImplTestPy.testUnlock()...")
		response = None
		response = self.component.unlock()
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testOn(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestNexstarImpl.NexstarImplTestPy.testOn()...")
		response = None
		response = self.component.on()
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testOff(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestNexstarImpl.NexstarImplTestPy.testOff()...")
		response = None
		response = self.component.off()
		# no return is expected, response should be None
		assert response is None
Exemplo n.º 13
0
class DatabaseImplTestPy(unittest.TestCase):

	################################################
	# lifecycle
	################################################
	
	def setUp(self):
		self.simpleClient = PySimpleClient()
		self.componentName = "testInstanceDatabaseImpl"
		self.simpleClient.getLogger().logInfo("pyUnitTestDatabaseImpl.DatabaseImplTestPy.setUp()...")
        self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
        self.component = self.simpleClient.getComponent(self.componentName)
	#__pPp__	    	           
	
	def tearDown(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestDatabaseImpl.DatabaseImplTestPy.tearDown()...")
		self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
		self.simpleClient.releaseComponent(self.componentName)
		self.simpleClient.disconnect()
	#__pPp__       
        
	################################################
	# test methods
	################################################
	
	def testStoreProposal(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestDatabaseImpl.DatabaseImplTestPy.testStoreProposal()...")
		response = None
		targets = Target()
		response = self.component.storeProposal(targets)
		# a return is expected, response should be not None
		assert response is not None
	#__pPp__
			    
	def testRemoveProposal(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestDatabaseImpl.DatabaseImplTestPy.testRemoveProposal()...")
		response = None
		pid = 0
		response = self.component.removeProposal(pid)
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testGetProposals(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestDatabaseImpl.DatabaseImplTestPy.testGetProposals()...")
		response = None
		response = self.component.getProposals()
		# a return is expected, response should be not None
		assert response is not None
	#__pPp__
			    
	def testGetProposalStatus(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestDatabaseImpl.DatabaseImplTestPy.testGetProposalStatus()...")
		response = None
		pid = 0
		response = self.component.getProposalStatus(pid)
		# a return is expected, response should be not None
		assert response is not None
	#__pPp__
			    
	def testStoreImage(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestDatabaseImpl.DatabaseImplTestPy.testStoreImage()...")
		response = None
		pid = 0
		image = ImageType()
		response = self.component.storeImage(pid, image)
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testClean(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestDatabaseImpl.DatabaseImplTestPy.testClean()...")
		response = None
		response = self.component.clean()
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testSetProposalStatus(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestDatabaseImpl.DatabaseImplTestPy.testSetProposalStatus()...")
		response = None
		pid = 0
		status = 0
		response = self.component.setProposalStatus(pid, status)
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testGetProposalObservations(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestDatabaseImpl.DatabaseImplTestPy.testGetProposalObservations()...")
		response = None
		pid = 0
		response = self.component.getProposalObservations(pid)
		# a return is expected, response should be not None
		assert response is not None
Exemplo n.º 14
0
class SCJavaImpTestPy(unittest.TestCase):

	################################################
	# lifecycle
	################################################
	
	def setUp(self):
		self.simpleClient = PySimpleClient()
		self.componentName = "testInstanceSCJavaImp"
		self.simpleClient.getLogger().logInfo("pyUnitTestSCJavaImp.SCJavaImpTestPy.setUp()...")
        self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
        self.component = self.simpleClient.getComponent(self.componentName)
	#__pPp__	    	           
	
	def tearDown(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestSCJavaImp.SCJavaImpTestPy.tearDown()...")
		self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
		self.simpleClient.releaseComponent(self.componentName)
		self.simpleClient.disconnect()
	#__pPp__       
        
	################################################
	# test methods
	################################################
	
	def testReset(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestSCJavaImp.SCJavaImpTestPy.testReset()...")
		response = None
		response = self.component.reset()
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testStatus(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestSCJavaImp.SCJavaImpTestPy.testStatus()...")
		response = None
		response = self.component.status()
		# a return is expected, response should be not None
		assert response is not None
	#__pPp__
			    
	def testGetPosition(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestSCJavaImp.SCJavaImpTestPy.testGetPosition()...")
		response = None
		response = self.component.getPosition()
		# a return is expected, response should be not None
		assert response is not None
	#__pPp__
			    
	def testSensorType(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestSCJavaImp.SCJavaImpTestPy.testSensorType()...")
		response = None
		response = self.component.sensorType()
		# a return is expected, response should be not None
		assert response is not None
Exemplo n.º 15
0
class InstrumentImplTestPy(unittest.TestCase):

	################################################
	# lifecycle
	################################################
	
	def setUp(self):
		self.simpleClient = PySimpleClient()
		self.componentName = "testInstanceInstrumentImpl"
		self.simpleClient.getLogger().logInfo("pyUnitTestInstrumentImpl.InstrumentImplTestPy.setUp()...")
        self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
        self.component = self.simpleClient.getComponent(self.componentName)
	#__pPp__	    	           
	
	def tearDown(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestInstrumentImpl.InstrumentImplTestPy.tearDown()...")
		self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
		self.simpleClient.releaseComponent(self.componentName)
		self.simpleClient.disconnect()
	#__pPp__       
        
	################################################
	# test methods
	################################################
	
	def testTakeImage(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestInstrumentImpl.InstrumentImplTestPy.testTakeImage()...")
		response = None
		exposureTime = 0
		response = self.component.takeImage(exposureTime)
		# a return is expected, response should be not None
		assert response is not None
	#__pPp__
			    
	def testCameraOn(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestInstrumentImpl.InstrumentImplTestPy.testCameraOn()...")
		response = None
		response = self.component.cameraOn()
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testCameraOff(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestInstrumentImpl.InstrumentImplTestPy.testCameraOff()...")
		response = None
		response = self.component.cameraOff()
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testSetRGB(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestInstrumentImpl.InstrumentImplTestPy.testSetRGB()...")
		response = None
		rgbConfig = RGB()
		response = self.component.setRGB(rgbConfig)
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testSetPixelBias(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestInstrumentImpl.InstrumentImplTestPy.testSetPixelBias()...")
		response = None
		bias = 0
		response = self.component.setPixelBias(bias)
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testSetResetLevel(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestInstrumentImpl.InstrumentImplTestPy.testSetResetLevel()...")
		response = None
		resetLevel = 0
		response = self.component.setResetLevel(resetLevel)
		# no return is expected, response should be None
		assert response is None
Exemplo n.º 16
0
    #------------------------------------------------------------------------------
    def negotiate (self, time_to_transmit, desc):
        '''
        For simplicitys sake, we always return true.  If you want more detailed,
        information on this method, please see the BACI specs.
        Parameters: See the BACI specs.
        '''
        return TRUE
#------------------------------------------------------------------------------


# Make an instance of the PySimpleClient
simpleClient = PySimpleClient()

# Do something on a device.
simpleClient.getLogger().logInfo("We can directly manipulate a device once we get it, which is easy!!")

# Get the standard MOUNT1 Mount device
mount = simpleClient.getComponent("MOUNT1")
# Get the actAz property
actAzProperty = mount._get_actAz()

# Create a callback monitor for the actAz Property
cbMon = MyMonitor("actAz")
# Activate the callback monitor
cbMonServant = simpleClient.activateOffShoot(cbMon)
# Create the real monitor registered with MOUNT1
desc = ACS.CBDescIn(0L, 0L, 0L)
actMon = actAzProperty.create_monitor(cbMonServant, desc)

# Tell MOUNT1 that the monitor's working method should be invoked 1 once second
Exemplo n.º 17
0
class ConsoleImplTestPy(unittest.TestCase):

	################################################
	# lifecycle
	################################################
	
	def setUp(self):
		self.simpleClient = PySimpleClient()
		self.componentName = "testInstanceConsoleImpl"
		self.simpleClient.getLogger().logInfo("pyUnitTestConsoleImpl.ConsoleImplTestPy.setUp()...")
        self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
        self.component = self.simpleClient.getComponent(self.componentName)
	#__pPp__	    	           
	
	def tearDown(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestConsoleImpl.ConsoleImplTestPy.tearDown()...")
		self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
		self.simpleClient.releaseComponent(self.componentName)
		self.simpleClient.disconnect()
	#__pPp__       
        
	################################################
	# test methods
	################################################
	
	def testSetMode(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestConsoleImpl.ConsoleImplTestPy.testSetMode()...")
		response = None
		mode = False
		response = self.component.setMode(mode)
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testGetMode(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestConsoleImpl.ConsoleImplTestPy.testGetMode()...")
		response = None
		response = self.component.getMode()
		# a return is expected, response should be not None
		assert response is not None
	#__pPp__
			    
	def testMoveTelescope(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestConsoleImpl.ConsoleImplTestPy.testMoveTelescope()...")
		response = None
		coordinates = Position()
		response = self.component.moveTelescope(coordinates)
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testGetTelescopePosition(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestConsoleImpl.ConsoleImplTestPy.testGetTelescopePosition()...")
		response = None
		response = self.component.getTelescopePosition()
		# a return is expected, response should be not None
		assert response is not None
	#__pPp__
			    
	def testGetCameraImage(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestConsoleImpl.ConsoleImplTestPy.testGetCameraImage()...")
		response = None
		response = self.component.getCameraImage()
		# a return is expected, response should be not None
		assert response is not None
	#__pPp__
			    
	def testCameraOn(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestConsoleImpl.ConsoleImplTestPy.testCameraOn()...")
		response = None
		response = self.component.cameraOn()
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testCameraOff(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestConsoleImpl.ConsoleImplTestPy.testCameraOff()...")
		response = None
		response = self.component.cameraOff()
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testSetRGB(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestConsoleImpl.ConsoleImplTestPy.testSetRGB()...")
		response = None
		rgbConfig = RGB()
		response = self.component.setRGB(rgbConfig)
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testSetPixelBias(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestConsoleImpl.ConsoleImplTestPy.testSetPixelBias()...")
		response = None
		bias = 0
		response = self.component.setPixelBias(bias)
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testSetResetLevel(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestConsoleImpl.ConsoleImplTestPy.testSetResetLevel()...")
		response = None
		resetLevel = 0
		response = self.component.setResetLevel(resetLevel)
		# no return is expected, response should be None
		assert response is None
        if self.activate:
            self.map.aboutToActivate(self.compName)
        else:
            self.map.aboutToDeactivate(self.compName)
        assert(self.map.isProcessing(self.compName))
        self.logger.logInfo(self.name+" processing "+self.compName)
        if self.activate:
            self.map.activated(self.compName)
        else:
            self.map.deactivated(self.compName)
        self.logger.logInfo(self.name+" processed "+self.compName)
    
            
simpleClient = PySimpleClient("acspyTestContainerActivationMap")

map = ContainerActivationMap(simpleClient.getLogger())

# Simulate the starting of the activation of multiple components
simpleClient.getLogger().logInfo("Testing activation of components from the main thread...")
for i in range(1000):
    name="TestComponent_"+str(i)
    map.aboutToActivate(name)
    if not map.isProcessing(name):
        simpleClient.getLogger().logError("The map does not contain "+name)
        assert(map.numOfProcessingItems()==i+1)
# And then their termination of their activation
for i in range(1000):
    name="TestComponent_"+str(i)
    map.activated(name)
    if map.isProcessing(name):
        simpleClient.getLogger().logError("The map should NOT contain "+name)
Exemplo n.º 19
0
class TSJavaImpTestPy(unittest.TestCase):

	################################################
	# lifecycle
	################################################
	
	def setUp(self):
		self.simpleClient = PySimpleClient()
		self.componentName = "testInstanceTSJavaImp"
		self.simpleClient.getLogger().logInfo("pyUnitTestTSJavaImp.TSJavaImpTestPy.setUp()...")
        self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
        self.component = self.simpleClient.getComponent(self.componentName)
	#__pPp__	    	           
	
	def tearDown(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestTSJavaImp.TSJavaImpTestPy.tearDown()...")
		self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
		self.simpleClient.releaseComponent(self.componentName)
		self.simpleClient.disconnect()
	#__pPp__       
        
	################################################
	# test methods
	################################################
	
	def testRunManualRAB(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestTSJavaImp.TSJavaImpTestPy.testRunManualRAB()...")
		response = None
		type = 0
		pos = position()
		response = self.component.runManualRAB(type, pos)
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testRunAutoRAB(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestTSJavaImp.TSJavaImpTestPy.testRunAutoRAB()...")
		response = None
		type = 0
		pos = position()
		response = self.component.runAutoRAB(type, pos)
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testGetRobotsList(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestTSJavaImp.TSJavaImpTestPy.testGetRobotsList()...")
		response = None
		response = self.component.getRobotsList()
		# a return is expected, response should be not None
		assert response is not None
	#__pPp__
			    
	def testGetRobotStatus(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestTSJavaImp.TSJavaImpTestPy.testGetRobotStatus()...")
		response = None
		id = 0
		response = self.component.getRobotStatus(id)
		# a return is expected, response should be not None
		assert response is not None
Exemplo n.º 20
0
class PingerImplTestPy(unittest.TestCase):

	################################################
	# lifecycle
	################################################
	
	def setUp(self):
		self.simpleClient = PySimpleClient()
		self.componentName = "testInstancePingerImpl"
		self.simpleClient.getLogger().logInfo("pyUnitTestPingerImpl.PingerImplTestPy.setUp()...")
        self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
        self.component = self.simpleClient.getComponent(self.componentName)
	#__pPp__	    	           
	
	def tearDown(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestPingerImpl.PingerImplTestPy.tearDown()...")
		self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
		self.simpleClient.releaseComponent(self.componentName)
		self.simpleClient.disconnect()
	#__pPp__       
        
	################################################
	# test methods
	################################################
	
	def testSpawnChildren(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestPingerImpl.PingerImplTestPy.testSpawnChildren()...")
		response = None
		howMany = 0
		container = 'emptyString'
		baseName = 'emptyString'
		response = self.component.spawnChildren(howMany, container, baseName)
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testLogInfo(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestPingerImpl.PingerImplTestPy.testLogInfo()...")
		response = None
		response = self.component.logInfo()
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testPing(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestPingerImpl.PingerImplTestPy.testPing()...")
		response = None
		fast = False
		recursive = False
		id = 0
		response = self.component.ping(fast, recursive, id)
		# a return is expected, response should be not None
		assert response is not None
Exemplo n.º 21
0
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston,
# MA 02111-1307  USA
#
#------------------------------------------------------------------------------

#from loggingts.ACSLogTypeExample import SimpleLog,ComplexLog
from ACSLogTypeExampleLTS import SimpleLog, ComplexLog

# Import the acspy.PySimpleClient class
from Acspy.Clients.SimpleClient import PySimpleClient

# Make an instance of the PySimpleClient
simpleClient = PySimpleClient()

simpleClient.getLogger().logInfo("Starting test client.")

SimpleLog().log()

SimpleLog("Array01", "Antenna01").log()

a = ComplexLog()
a.setsomeDoubleMember(3.14159)
a.setsomeStringMember("test string")
a.setsomeLongMember(42)
a.setsomeBooleanMember(True)
a.log()

b = ComplexLog()
b.setArray("Array01")
b.setAntenna("Antenna01")
Exemplo n.º 22
0
class MotorImplTestPy(unittest.TestCase):

	################################################
	# lifecycle
	################################################
	
	def setUp(self):
		self.simpleClient = PySimpleClient()
		self.componentName = "testInstanceMotorImpl"
		self.simpleClient.getLogger().logInfo("pyUnitTestMotorImpl.MotorImplTestPy.setUp()...")
        self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
        self.component = self.simpleClient.getComponent(self.componentName)
	#__pPp__	    	           
	
	def tearDown(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestMotorImpl.MotorImplTestPy.tearDown()...")
		self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
		self.simpleClient.releaseComponent(self.componentName)
		self.simpleClient.disconnect()
	#__pPp__       
        
	################################################
	# test methods
	################################################
	
	def testMove(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestMotorImpl.MotorImplTestPy.testMove()...")
		response = None
		response = self.component.move()
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testStandby(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestMotorImpl.MotorImplTestPy.testStandby()...")
		response = None
		response = self.component.standby()
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testOnline(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestMotorImpl.MotorImplTestPy.testOnline()...")
		response = None
		response = self.component.online()
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testOff(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestMotorImpl.MotorImplTestPy.testOff()...")
		response = None
		response = self.component.off()
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testSetup(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestMotorImpl.MotorImplTestPy.testSetup()...")
		response = None
		val = 'emptyString'
		timeout = 0
		response = self.component.setup(val, timeout)
		# no return is expected, response should be None
		assert response is None
Exemplo n.º 23
0
class FrontEndTest(unittest.TestCase):
    """
    This test requires ACS running with the testacsproperties CDB and
    the myC cpp container up
    """
    def setUp(self):
        self._my_acs_client = PySimpleClient()
        self._my_acs_client.getLogger().setLevel(logging.CRITICAL)
        self._front_end = FrontEnd(RecorderConfig(), self._my_acs_client)
        self.__my_component_id = "TEST_PROPERTIES_COMPONENT"

    def test_is_acs_client_ok(self):
        self.assertTrue(self._front_end.is_acs_client_ok)

    def test_update_acs_client(self):
        other_client = PySimpleClient()
        other_client.getLogger().setLevel(logging.CRITICAL)
        self._front_end.update_acs_client(other_client)
        self.assertTrue(self._front_end.is_acs_client_ok)
        self._front_end.start_recording()
        yet_other_client = PySimpleClient()
        yet_other_client.getLogger().setLevel(logging.CRITICAL)
        self._front_end.update_acs_client(yet_other_client)
        self._front_end.stop_recording()

    def test_start_recording(self):
        self._front_end.start_recording()
        self.assertTrue(self._front_end.is_recording)
        self._front_end.stop_recording()

        self._my_acs_client.getComponent(self.__my_component_id, True)
        self._front_end.start_recording()
        self.assertTrue(self._front_end.is_recording)
        self._front_end.stop_recording()
        self._my_acs_client.releaseComponent(self.__my_component_id)

    def test_process_component(self):
        self._my_acs_client.getComponent(self.__my_component_id, True)

        self._front_end.process_component(self.__my_component_id)

        self._my_acs_client.releaseComponent(self.__my_component_id)

        self.assertRaises(CannotAddComponentException,
                          self._front_end.process_component, "I_DO_NOT_EXIST")

    def test_remove_wrong_components(self):
        self._my_acs_client.getComponent(self.__my_component_id, True)
        self._front_end.start_recording()

        time.sleep(3)

        self._my_acs_client.releaseComponent(self.__my_component_id)

        time.sleep(10)

        self._front_end.stop_recording()

    def tearDown(self):
        self._front_end.cancel()
        self._front_end = None
Exemplo n.º 24
0
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, 
# MA 02111-1307  USA
#
#------------------------------------------------------------------------------

#from loggingts.ACSLogTypeExample import simpleLog,complexLog
from ACSLogTypeExampleLTS  import simpleLog,complexLog

# Import the acspy.PySimpleClient class
from Acspy.Clients.SimpleClient import PySimpleClient

# Make an instance of the PySimpleClient
simpleClient = PySimpleClient()


simpleClient.getLogger().logInfo("Starting test client.")

simpleLog().log()

simpleLog("Array01","Antenna01").log()

a=complexLog()
a.setsomeDoubleMember(3.14159)
a.setsomeStringMember("test string")
a.setsomeLongMember(42)
a.setsomeBooleanMember(True)
a.log()

b=complexLog()
b.setArray("Array01")
b.setAntenna("Antenna01")
Exemplo n.º 25
0
    def negotiate(self, time_to_transmit, desc):
        '''
        For simplicitys sake, we always return true.  If you want more detailed,
        information on this method, please see the BACI specs.
        Parameters: See the BACI specs.
        '''
        return TRUE


#------------------------------------------------------------------------------

# Make an instance of the PySimpleClient
simpleClient = PySimpleClient()

# Do something on a device.
simpleClient.getLogger().logInfo(
    "We can directly manipulate a device once we get it, which is easy!!")

# Get the standard MOUNT1 Mount device
mount = simpleClient.getComponent("MOUNT1")
# Get the actAz property
actAzProperty = mount._get_actAz()

# Create a callback monitor for the actAz Property
cbMon = MyMonitor("actAz")
# Activate the callback monitor
cbMonServant = simpleClient.activateOffShoot(cbMon)
# Create the real monitor registered with MOUNT1
desc = ACS.CBDescIn(0L, 0L, 0L)
actMon = actAzProperty.create_monitor(cbMonServant, desc)

# Tell MOUNT1 that the monitor's working method should be invoked 1 once second
Exemplo n.º 26
0
LINKS
- <li><a href="../../idl/html/interfaceMOUNT_ACS_1_1Mount.html">Mount IDL Documentation</a>
'''

# Import the acspy.PySimpleClient class
from Acspy.Clients.SimpleClient import PySimpleClient


# Make an instance of the PySimpleClient
simpleClient = PySimpleClient()

# Print information about the available COBs
components = simpleClient.availableComponents()

simpleClient.getLogger().logInfo("COBs available are: ")
for cob in components:
    simpleClient.getLogger().logInfo(cob.name + " of type " + cob.type)

# Do something on a device.
simpleClient.getLogger().logInfo("We can directly manipulate a device once we get it, which is easy.")
try:
    # Get the standard MOUNT1 Mount device
    mount = simpleClient.getComponent("MOUNT1")

    # Get the actAz property
    actAzProperty = mount._get_actAz()

    # Ask the current value of the property
    (azm, compl) = actAzProperty.get_sync()
    simpleClient.getLogger().logInfo("MOUNT1 actual azimuth: " + str(azm))
Exemplo n.º 27
0
class StandaloneRecorder(object):
    """
    A property recorder that works as an stand-alone application

    """
    def __init__(self, recorder_config, verbosity):
        '''
        Ctor

        @param recorder_config: the configuration of the recorder
        @type recorder_config: RecorderConfig
        @param verbosity: the verbosity level
        (logging.WARNING, logging.DEBUG, etc) of the logger
        @type verbosity: int
        '''
        self._verbosity = verbosity
        self._recorder_config = recorder_config

        self._setup_acs_client()
        self._setup_front_end()
        self.__canceled = False

        self._logger.info('Property recorder up')

    def _setup_acs_client(self):
        self._my_acs_client = PySimpleClient()
        self._logger = self._my_acs_client.getLogger()
        self._logger.setLevel(self._verbosity)

    def _setup_front_end(self):
        self._front_end = FrontEnd(self._recorder_config, self._my_acs_client)

    def make_new_acs_client(self):
        '''
        Will make a new ACS client and replace the existing one

        To be used to recover from ACS restarts.
        @raise CORBAProblemExImpl: if the client cannot be created.
        '''
        self._setup_acs_client()
        self._front_end.update_acs_client(self._my_acs_client)

    def start(self):
        '''
        The property recorded will start to record properties

        @raises RuntimeError: if the recorder is cancelled
        '''
        if self.__canceled:
            raise RuntimeError("The recorded is cancelled")

        self._front_end.start_recording()
        self._logger.info('Recording start')

    def stop(self):
        '''
        The property recorded will stop to record properties

        All the monitors are stopped, the components are unregistered
        @raises RuntimeError: if the recorder is cancelled
        '''
        if self.__canceled:
            raise RuntimeError("The recorded is cancelled")
        self._front_end.stop_recording()
        self._logger.info('Recording stop')

    def close(self):
        '''
        Closes the property recorder, ready to be destroyed

        All the resources will be freed and the connection with
        ACS closed. The recorder will be cancelled from now on,
        Meaning that the recorder is not anymore usable and
        is ready to be destroyed
        '''
        if not self.__canceled:
            self._logger.info('Switching off property recorder')
            self.stop()
            self._front_end.cancel()
            self._front_end = None
            self._recorder_config = None
            self._my_acs_client.disconnect()
            self._my_acs_client = None
            self.__canceled = True

    def is_acs_client_ok(self):
        '''
        Checks if the ACS client is OK or not.

        When not OK, this typically means that ACS is
        down. This lets the client know when a new client should be created
        @return: if the client is OK or not
        @rtype: bool
        '''
        return self._front_end.is_acs_client_ok

    def print_config(self):
        '''
        Prints into the logger the existing configuration
        '''
        self._logger.debug('Property Recorder Configuration'
                           '\n--------------------------------------\n' +
                           pprint.pformat(vars(self._recorder_config)) +
                           '\n--------------------------------------')
Exemplo n.º 28
0
class ComponentUtilTest(unittest.TestCase):
    """
    This test requires ACS running with the testacsproperties CDB and
    the myC cpp container up
    """
    def setUp(self):
        self._my_acs_client = PySimpleClient()
        logger = self._my_acs_client.getLogger()
        logger.setLevel(logging.WARNING)
        # disable annoying output from the tests

    def tearDown(self):
        self._my_acs_client.disconnect()

    def test_get_enum_prop_dict(self):

        my_component = self._my_acs_client.getComponent(
            "TEST_PROPERTIES_COMPONENT", True)

        enum_prop = my_component._get_EnumTestROProp()

        decoded = component_util.get_enum_prop_dict(enum_prop)
        expected_value = {'0': 'STATE1', '1': 'STATE2', '2': 'STATE3'}
        self.assertEqual(expected_value, decoded)

        enum_prop = my_component._get_EnumTestRWProp()

        decoded = component_util.get_enum_prop_dict(enum_prop)
        expected_value = {'0': 'STATE1', '1': 'STATE2', '2': 'STATE3'}
        self.assertEqual(expected_value, decoded)

        self._my_acs_client.releaseComponent("TEST_PROPERTIES_COMPONENT")

    def test_get_property_type(self):
        my_component = self._my_acs_client.getComponent(
            "TEST_PROPERTIES_COMPONENT", True)

        self.assertEqual(
            component_util.get_property_type(
                my_component._get_EnumTestROProp()._NP_RepositoryId),
            PropertyType.OBJECT)

        self.assertEqual(
            component_util.get_property_type(
                my_component._get_EnumTestRWProp()._NP_RepositoryId),
            PropertyType.OBJECT)

        PropertyType.OBJECT

        self.assertEqual(
            component_util.get_property_type(
                my_component._get_doubleROProp()._NP_RepositoryId),
            PropertyType.DOUBLE)

        self.assertEqual(
            component_util.get_property_type(
                my_component._get_floatSeqRWProp()._NP_RepositoryId),
            PropertyType.FLOAT_SEQ)

        self.assertEqual(
            component_util.get_property_type(
                my_component._get_longSeqRWProp()._NP_RepositoryId),
            PropertyType.LONG_SEQ)

        self.assertEqual(
            component_util.get_property_type(
                my_component._get_uLongLongRWProp()._NP_RepositoryId),
            PropertyType.LONG_LONG)

        self.assertEqual(
            component_util.get_property_type(
                my_component._get_uLongLongRWProp()._NP_RepositoryId),
            PropertyType.LONG_LONG)
        self.assertEqual(
            component_util.get_property_type(
                my_component._get_doubleRWProp()._NP_RepositoryId),
            PropertyType.DOUBLE)

        self.assertEqual(
            component_util.get_property_type(
                my_component._get_uLongROProp()._NP_RepositoryId),
            PropertyType.LONG)

        self.assertEqual(
            component_util.get_property_type(
                my_component._get_booleanROProp()._NP_RepositoryId),
            PropertyType.BOOL)

        self.assertEqual(
            component_util.get_property_type(
                my_component._get_doubleSeqROProp()._NP_RepositoryId),
            PropertyType.DOUBLE_SEQ)

        self.assertEqual(
            component_util.get_property_type(
                my_component._get_longLongROProp()._NP_RepositoryId),
            PropertyType.LONG_LONG)

        self.assertEqual(
            component_util.get_property_type(
                my_component._get_patternROProp()._NP_RepositoryId),
            PropertyType.BIT_FIELD)

        self.assertEqual(
            component_util.get_property_type(
                my_component._get_uLongRWProp()._NP_RepositoryId),
            PropertyType.LONG)

        self.assertEqual(
            component_util.get_property_type(
                my_component._get_booleanRWProp()._NP_RepositoryId),
            PropertyType.BOOL)

        self.assertEqual(
            component_util.get_property_type(
                my_component._get_doubleSeqRWProp()._NP_RepositoryId),
            PropertyType.DOUBLE_SEQ)

        self.assertEqual(
            component_util.get_property_type(
                my_component._get_longLongRWProp()._NP_RepositoryId),
            PropertyType.LONG_LONG)

        self.assertEqual(
            component_util.get_property_type(
                my_component._get_patternRWProp()._NP_RepositoryId),
            PropertyType.BIT_FIELD)

        self.assertEqual(
            component_util.get_property_type(
                my_component._get_uLongSeqROProp()._NP_RepositoryId),
            PropertyType.LONG_SEQ)

        self.assertRaises(
            UnsupporterPropertyTypeError, component_util.get_property_type,
            my_component._get_booleanSeqROProp()._NP_RepositoryId)

        self.assertEqual(
            component_util.get_property_type(
                my_component._get_floatROProp()._NP_RepositoryId),
            PropertyType.FLOAT)

        self.assertEqual(
            component_util.get_property_type(
                my_component._get_longROProp()._NP_RepositoryId),
            PropertyType.LONG)

        self.assertEqual(
            component_util.get_property_type(
                my_component._get_stringROProp()._NP_RepositoryId),
            PropertyType.STRING)

        self.assertEqual(
            component_util.get_property_type(
                my_component._get_uLongSeqRWProp()._NP_RepositoryId),
            PropertyType.LONG_SEQ)

        self.assertRaises(
            UnsupporterPropertyTypeError, component_util.get_property_type,
            my_component._get_booleanSeqRWProp()._NP_RepositoryId)

        self.assertEqual(
            component_util.get_property_type(
                my_component._get_floatRWProp()._NP_RepositoryId),
            PropertyType.FLOAT)

        self.assertEqual(
            component_util.get_property_type(
                my_component._get_longRWProp()._NP_RepositoryId),
            PropertyType.LONG)

        self.assertEqual(
            component_util.get_property_type(
                my_component._get_stringRWProp()._NP_RepositoryId),
            PropertyType.STRING)

        self.assertEqual(
            component_util.get_property_type(
                my_component._get_floatSeqROProp()._NP_RepositoryId),
            PropertyType.FLOAT_SEQ)

        self.assertEqual(
            component_util.get_property_type(
                my_component._get_longSeqROProp()._NP_RepositoryId),
            PropertyType.LONG_SEQ)

        self.assertEqual(
            component_util.get_property_type(
                my_component._get_uLongLongROProp()._NP_RepositoryId),
            PropertyType.LONG_LONG)

    def test_is_archive_delta_enabled(self):

        # First test the cases when it should be false
        self.assertFalse(component_util.is_archive_delta_enabled(None))
        self.assertFalse(component_util.is_archive_delta_enabled(False))
        self.assertFalse(component_util.is_archive_delta_enabled("0"))
        self.assertFalse(component_util.is_archive_delta_enabled("0.0"))
        self.assertFalse(component_util.is_archive_delta_enabled(0))
        self.assertFalse(component_util.is_archive_delta_enabled(0.0))
Exemplo n.º 29
0
class SchedulerImplTestPy(unittest.TestCase):

	################################################
	# lifecycle
	################################################
	
	def setUp(self):
		self.simpleClient = PySimpleClient()
		self.componentName = "testInstanceSchedulerImpl"
		self.simpleClient.getLogger().logInfo("pyUnitTestSchedulerImpl.SchedulerImplTestPy.setUp()...")
        self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
        self.component = self.simpleClient.getComponent(self.componentName)
	#__pPp__	    	           
	
	def tearDown(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestSchedulerImpl.SchedulerImplTestPy.tearDown()...")
		self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
		self.simpleClient.releaseComponent(self.componentName)
		self.simpleClient.disconnect()
	#__pPp__       
        
	################################################
	# test methods
	################################################
	
	def testStart(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestSchedulerImpl.SchedulerImplTestPy.testStart()...")
		response = None
		response = self.component.start()
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testStop(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestSchedulerImpl.SchedulerImplTestPy.testStop()...")
		response = None
		response = self.component.stop()
		# no return is expected, response should be None
		assert response is None
	#__pPp__
			    
	def testProposalUnderExecution(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestSchedulerImpl.SchedulerImplTestPy.testProposalUnderExecution()...")
		response = None
		response = self.component.proposalUnderExecution()
		# a return is expected, response should be not None
		assert response is not None
Exemplo n.º 30
0
from subprocess import *
import ACSErrTypeCommon
import ACSErrTypeCommonImpl
import sys
import time

# Import the acspy.PySimpleClient class
from Acspy.Clients.SimpleClient import PySimpleClient
from Acspy.Nc.Consumer import Consumer
from Control import CHANNELNAME_CONTROLSYSTEM
from Control import ExecBlockStartedEvent
from Control import ExecBlockEndedEvent

# Make an instance of the PySimpleClient
simpleClient = PySimpleClient()
simpleClient.getLogger().logInfo("Simple client instantiated.")

global started
global ended

def handlerStarted(event):
    global started
    started += 1
    print event.execId
    print event.sbId
    print event.sessionId
    print event.arrayName
    print event.startTime
    return

def handlerEnded(event):
Exemplo n.º 31
0
- <a href="../../idl/html/interfaceHelloWorld_1_1HelloWorld.html">HelloWorld IDL Documentation</a>
'''

import ACSErrTypeCommon
import ACSErrTypeCommonImpl

# Import the acspy.PySimpleClient class
from Acspy.Clients.SimpleClient import PySimpleClient

# Make an instance of the PySimpleClient
simpleClient = PySimpleClient()

try:
    # Get the standard HelloWorld device
    hw = simpleClient.getComponent("HELLOWORLD1")
    simpleClient.getLogger().logInfo("Trying to invoke bad method")
    hw.badMethod()
    
except ACSErrTypeCommon.UnknownEx, e:
    simpleClient.getLogger().logCritical("Caught an ACSException...don't worry because this SHOULD happen.")
    helperException = ACSErrTypeCommonImpl.UnknownExImpl(exception=e)
    helperException.Print()
    helperException.log(simpleClient.getLogger())
    # Release it
    simpleClient.releaseComponent("HELLOWORLD1")

except Exception, e:
    simpleClient.getLogger().logAlert("Caught the wrong type of exception!!!")
    simpleClient.getLogger().logDebug("The exception was:" + str(e))

simpleClient.disconnect()
Exemplo n.º 32
0
- <a href="../../idl/html/interfaceHelloWorld_1_1HelloWorld.html">HelloWorld IDL Documentation</a>
'''

import ACSErrTypeCommon
import ACSErrTypeCommonImpl

# Import the acspy.PySimpleClient class
from Acspy.Clients.SimpleClient import PySimpleClient

# Make an instance of the PySimpleClient
simpleClient = PySimpleClient()

try:
    # Get the standard HelloWorld device
    hw = simpleClient.getComponent("HELLOWORLD1")
    simpleClient.getLogger().logInfo("Trying to invoke bad method")
    hw.badMethod()

except ACSErrTypeCommon.UnknownEx, e:
    simpleClient.getLogger().logCritical(
        "Caught an ACSException...don't worry because this SHOULD happen.")
    helperException = ACSErrTypeCommonImpl.UnknownExImpl(exception=e)
    helperException.Print()
    helperException.log(simpleClient.getLogger())
    # Release it
    simpleClient.releaseComponent("HELLOWORLD1")

except Exception, e:
    simpleClient.getLogger().logAlert("Caught the wrong type of exception!!!")
    simpleClient.getLogger().logDebug("The exception was:" + str(e))
Exemplo n.º 33
0
- Manipulating BACI properties

LINKS
- <li><a href="../../idl/html/interfaceMOUNT_ACS_1_1Mount.html">Mount IDL Documentation</a>
'''

# Import the acspy.PySimpleClient class
from Acspy.Clients.SimpleClient import PySimpleClient

# Make an instance of the PySimpleClient
simpleClient = PySimpleClient()

# Print information about the available COBs
components = simpleClient.availableComponents()

simpleClient.getLogger().logInfo("COBs available are: ")
for cob in components:
    simpleClient.getLogger().logInfo(cob.name + " of type " + cob.type)

# Do something on a device.
simpleClient.getLogger().logInfo(
    "We can directly manipulate a device once we get it, which is easy.")
try:
    # Get the standard MOUNT1 Mount device
    mount = simpleClient.getComponent("MOUNT1")

    # Get the actAz property
    actAzProperty = mount._get_actAz()

    # Ask the current value of the property
    (azm, compl) = actAzProperty.get_sync()
        if self.activate:
            self.map.aboutToActivate(self.compName)
        else:
            self.map.aboutToDeactivate(self.compName)
        assert (self.map.isProcessing(self.compName))
        self.logger.logInfo(self.name + " processing " + self.compName)
        if self.activate:
            self.map.activated(self.compName)
        else:
            self.map.deactivated(self.compName)
        self.logger.logInfo(self.name + " processed " + self.compName)


simpleClient = PySimpleClient("acspyTestContainerActivationMap")

map = ContainerActivationMap(simpleClient.getLogger())

# Simulate the starting of the activation of multiple components
simpleClient.getLogger().logInfo(
    "Testing activation of components from the main thread...")
for i in range(1000):
    name = "TestComponent_" + str(i)
    map.aboutToActivate(name)
    if not map.isProcessing(name):
        simpleClient.getLogger().logError("The map does not contain " + name)
        assert (map.numOfProcessingItems() == i + 1)
# And then their termination of their activation
for i in range(1000):
    name = "TestComponent_" + str(i)
    map.activated(name)
    if map.isProcessing(name):
Exemplo n.º 35
0
#   BUGS
#
#------------------------------------------------------------------------
#

# Import the acspy.PySimpleClient class
import time
from Acspy.Clients.SimpleClient import PySimpleClient

# Make an instance of the PySimpleClient
simpleClient = PySimpleClient()

# Print information about the available COBs

# Do something on a device.
simpleClient.getLogger().logInfo(
    "We can directly manipulate a device once we get it, which is easy.")
try:
    # Get the standard MOUNT1 Mount device
    ws = simpleClient.getComponent("MONITOR_COLLECTOR")

    # Get the humidity
    ws.registerMonitoredDevice("SensorTag", "1")
    # Print value
    ws.startMonitoring("SensorTag")
    raw_input("##################Press enter to quit#########################")
    # Release it
    simpleClient.releaseComponent("MONITOR_COLLECTOR")

except Exception, e:
    simpleClient.getLogger().logCritical(
        "Sorry, I expected there to be a Mount in the system and there isn't.")
Exemplo n.º 36
0
class TRDJavaImpTestPy(unittest.TestCase):

	################################################
	# lifecycle
	################################################
	
	def setUp(self):
		self.simpleClient = PySimpleClient()
		self.componentName = "testInstanceTRDJavaImp"
		self.simpleClient.getLogger().logInfo("pyUnitTestTRDJavaImp.TRDJavaImpTestPy.setUp()...")
        self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
        self.component = self.simpleClient.getComponent(self.componentName)
	#__pPp__	    	           
	
	def tearDown(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestTRDJavaImp.TRDJavaImpTestPy.tearDown()...")
		self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
		self.simpleClient.releaseComponent(self.componentName)
		self.simpleClient.disconnect()
	#__pPp__       
        
	################################################
	# test methods
	################################################
	
	def testGetRAB(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestTRDJavaImp.TRDJavaImpTestPy.testGetRAB()...")
		response = None
		type = 0
		response = self.component.getRAB(type)
		# a return is expected, response should be not None
		assert response is not None
	#__pPp__
			    
	def testCreateReport(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestTRDJavaImp.TRDJavaImpTestPy.testCreateReport()...")
		response = None
		rep = report()
		response = self.component.createReport(rep)
		# a return is expected, response should be not None
		assert response is not None
	#__pPp__
			    
	def testGetReportsList(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestTRDJavaImp.TRDJavaImpTestPy.testGetReportsList()...")
		response = None
		response = self.component.getReportsList()
		# a return is expected, response should be not None
		assert response is not None
	#__pPp__
			    
	def testGetReport(self):
		self.simpleClient.getLogger().logInfo("pyUnitTestTRDJavaImp.TRDJavaImpTestPy.testGetReport()...")
		response = None
		id = 0
		response = self.component.getReport(id)
		# a return is expected, response should be not None
		assert response is not None
- <a href="../../idl/html/interfaceHelloWorld_1_1HelloWorld.html">HelloWorld IDL Documentation</a>
'''

# Import command-line arguments
from sys import argv

# Import the SimpleClient class
from Acspy.Clients.SimpleClient import PySimpleClient

# Make an instance of the PySimpleClient
simpleClient = PySimpleClient()

# Obtain a reference to a dynamic component using the ContainerServices
# getComponent method.
hwRef = simpleClient.getDynamicComponent(None,
                                         "IDL:alma/acsexmplHelloWorld/HelloWorld:1.0",
                                         "acsexmplHelloWorldImpl",
                                         str(argv[1]))

if hwRef != None:
    simpleClient.getLogger().logInfo("Retrieved valid reference from manager.")
    #Do something useful with the reference.
    hwRef.displayMessage()
    simpleClient.getLogger().logInfo("Method of dynamic component successfully invoked. Have a nice day!")
else:
    simpleClient.getLogger().logAlert("Bad reference retrieved from manager")

simpleClient.disconnect()
print "The end __oOo__"