class TestDynamicNodesModel(unittest.TestCase):
    
    def setUp(self):
        self.simulation = Simulation()
        self.simulation.initialize()
        
        self.nodes = []
        for _ in range(10):
            self.nodes.append( FakeNode( sim=self.simulation ) )
        
        self.random = Mock()
        self.random.normalvariate.side_effect = lambda *args: args[0] - args[1]/2 # just to check how to configure different returns

    def get_nodes(self):
        return self.nodes
    
    @patch.object(NodeManager, 'getNodes')
    def test_configure(self, mock_method):
        mock_method.side_effect = self.get_nodes
        
        simulateUntil = 2000
        
        model = DynamicNodesModel(simulateUntil, 500, 200)
        model._random = self.random
                
        model.configure() # test method
        self.simulation.simulate(until=simulateUntil)
        
        for node in self.get_nodes():
            self.assertItemsEqual( ( (400, "down"),
                                     (800, "up"),
                                     (1200, "down"),
                                     (1600, "up") ), node.trace )
예제 #2
0
    def __init__(self, configuration, callback=None):
        """
        Args:
            - `callback`: A callback can be specified. This function will be \
                called to report the advance of the simulation (useful for a \
                progression bar).
            - `configuration`: The :class:`configuration \
                <simso.configuration.Configuration>` of the simulation.

        Methods:
        """
        Simulation.__init__(self)
        self._logger = Logger(self)
        self._measurements = []
        task_info_list = configuration.task_info_list
        proc_info_list = configuration.proc_info_list
        self._cycles_per_ms = configuration.cycles_per_ms
        self.scheduler = configuration.scheduler_info.instantiate(self)

        try:
            self._etm = execution_time_models[configuration.etm](
                self, len(proc_info_list))
        except KeyError:
            print("Unknowned Execution Time Model.", configuration.etm)

        self._task_list = []
        for task_info in task_info_list:
            self._task_list.append(Task(self, task_info))

        # Init the processor class. This will in particular reinit the
        # identifiers to 0.
        Processor.init()

        # Initialization of the caches
        for cache in configuration.caches_list:
            cache.init()

        self._processors = []
        for proc_info in proc_info_list:
            proc = Processor(self, proc_info)
            proc.caches = proc_info.caches
            self._processors.append(proc)

        # XXX: too specific.
        self.penalty_preemption = configuration.penalty_preemption
        self.penalty_migration = configuration.penalty_migration

        self._etm.init()

        self._duration = configuration.duration
        self.progress = Timer(self,
                              Model._on_tick, (self, ),
                              self.duration // 20 + 1,
                              one_shot=False,
                              in_ms=False)
        self._callback = callback
        self.scheduler.task_list = self._task_list
        self.scheduler.processors = self._processors
        self.results = None
예제 #3
0
    def __init__(self, configuration, callback=None):
        """
        Args:
            - `callback`: A callback can be specified. This function will be \
                called to report the advance of the simulation (useful for a \
                progression bar).
            - `configuration`: The :class:`configuration \
                <simso.configuration.Configuration>` of the simulation.

        Methods:
        """
        Simulation.__init__(self)
        self._logger = Logger(self)
        task_info_list = configuration.task_info_list
        proc_info_list = configuration.proc_info_list
        self._cycles_per_ms = configuration.cycles_per_ms
        self.scheduler = configuration.scheduler_info.instantiate(self)

        try:
            self._etm = execution_time_models[configuration.etm](
                self, len(proc_info_list)
            )
        except KeyError:
            print("Unknowned Execution Time Model.", configuration.etm)

        self._task_list = []
        for task_info in task_info_list:
            self._task_list.append(Task(self, task_info))

        # Init the processor class. This will in particular reinit the
        # identifiers to 0.
        Processor.init()

        # Initialization of the caches
        for cache in configuration.caches_list:
            cache.init()

        self._processors = []
        for proc_info in proc_info_list:
            proc = Processor(self, proc_info)
            proc.caches = proc_info.caches
            self._processors.append(proc)

        # XXX: too specific.
        self.penalty_preemption = configuration.penalty_preemption
        self.penalty_migration = configuration.penalty_migration

        self._etm.init()

        self._duration = configuration.duration
        self.progress = Timer(self, Model._on_tick, (self,),
                              self.duration // 20 + 1, one_shot=False,
                              in_ms=False)
        self._callback = callback
        self.scheduler.task_list = self._task_list
        self.scheduler.processors = self._processors
        self.results = None
 def setUp(self):
     self.simulation = Simulation()
     self.cache = Cache(self.simulation)
     
     for i in range(5):
         at = i * 10
         
         record = PTRRecord("_http._tcp.local", "name%d._http._tcp.local"%i, )
         self.cache.records.append(record)
         self.cache.pending_events.append((at, Cache.EVENT_KNOWN_ANSWER, record))
         
         record = SVRRecord("name%d._http._tcp.local"%i, None, None)
         self.cache.records.append(record)
         self.cache.pending_events.append((at, Cache.EVENT_KNOWN_ANSWER, record))
         
         record = TXTRecord("name%d._http._tcp.local"%i, {})
         self.cache.records.append(record)
         self.cache.pending_events.append((at, Cache.EVENT_RENEW, record))
     
     self.assertEquals(15, len(self.cache.records))
     self.assertEquals(15, len(self.cache.pending_events))
     
     self.sample_txt = TXTRecord("name0._http._tcp.local", {})
     self.sample_svr = SVRRecord("name2._http._tcp.local", None, None)
     self.sample_ptr = PTRRecord("_http._tcp.local", "name4._http._tcp.local")
class TestOneNodeDownModel(unittest.TestCase):
    
    def setUp(self):
        self.simulation = Simulation()
        self.simulation.initialize()
        
        self.nodes = []
        for _ in range(10):
            self.nodes.append( FakeNode( sim=self.simulation ) )
        
        self.random = Mock()
        self.random.normalvariate.side_effect = lambda *args: args[0] - args[1]/2 # just to check how to configure different returns
        import random
        self.random.choice.side_effect = random.choice # otherwise choice method will be mocked!

    def get_nodes(self):
        return self.nodes
    
    @patch.object(NodeManager, 'getNodes')
    def test_configure(self, mock_method):
        mock_method.side_effect = self.get_nodes
        
        simulateUntil = 2000
        
        model = OneNodeDownModel(simulateUntil, 500, 200)
        model._random = self.random
        
        model.configure() # test method
        self.simulation.simulate(until=simulateUntil)
        
        total_activity = [ (400, "down"), (800, "up"),
                           (800, "down"), (1200, "up"),
                           (1200, "down"), (1600, "up"),
                           (1600, "down"), ]
        
        for node in self.get_nodes():
            for trace in node.trace:
                self.assertTrue( trace in total_activity )
                if trace[1] is "down" and trace[0]<1600:
                    # if the node goes down, in 400 ms should go up again
                    self.assertTrue( (trace[0]+400, "up") in node.trace )
                
                total_activity.remove(trace)
        
        # all the traces should have been conveniently removed in the previous for
        self.assertEquals(0, len(total_activity))
class ActivatableTestCase(unittest.TestCase): # wrapper under test: activatable

    def setUp(self):
        self.simulation = Simulation()
        self.simulation.initialize()
        
        self.proc1 = SimpleProcess(sim=self.simulation)
        self.proc2 = SimpleProcess(sim=self.simulation)
        
    def test_exception_not_generator(self):
        self.proc1 = SimpleProcess(sim=self.simulation)
        try:
            self.proc1.not_generator(at=300)
            self.fail()
        except Exception, e:
            #print e
            pass
 def setUp(self):
     self.simulation = Simulation()
     self.simulation.initialize()
     
     self.nodes = []
     for _ in range(10):
         self.nodes.append( FakeNode( sim=self.simulation ) )
     
     self.random = Mock()
     self.random.normalvariate.side_effect = lambda *args: args[0] - args[1]/2 # just to check how to configure different returns
 def test_wait(self):        
     s = Simulation()
     s.initialize()
     
     obj = ObjectWhichUsesTimer(timeToWait=10, sim=s)
     s.activate(obj, obj.do_whatever_you_do_in_simulation())
     
     s.simulate(until=300)
     self.assertEquals(10, obj.time_after_waiting)
 def setUp(self):
     self.simulation = Simulation()
     
     self.mdns_instance = Mock()
     self.mdns_instance.get_whitepage_record.return_value = None
     self.mdns_instance.notify_whitepage_changed.side_effect = self._log_event
     
     self.detector = NewWPDetector(self.mdns_instance, self.simulation)
     
     self.log = []
     
     self.simulation.initialize()
 def setUp(self):
     self.simulation = Simulation()
     
     self.browsing_subquery = SubQuery( name = "_services._dns-sd._udp.local",
                                        record_type = "PTR" )
     self.sender = FakeSender(self.simulation) # used for the asserts
     self.querier = ContinuousQuerier(self.browsing_subquery, self.simulation, self.sender)
     
     self.querier._random = Mock()
     self.querier._random.random.side_effect = lambda *args: 0.5
     
     self.simulation.initialize()
     self.simulation.activate(self.querier, self.querier.query_continuously())
class TestChaoticModel(unittest.TestCase):
    
    def setUp(self):
        self.simulation = Simulation()
        self.simulation.initialize()
        
        self.nodes = []
        for _ in range(10):
            self.nodes.append( FakeNode( sim=self.simulation ) )
        
        self.random = Mock()
        self.random.normalvariate.side_effect = lambda *args: args[0] - args[1]/2 # just to check how to configure different returns
    
    def _get_node_for_record(self, record):
        print record
    
    def patch_find_whitepage(self, model):
        model.find_whitepage = Mock()
        model.find_whitepage.return_value = self.nodes[0] # select the first as WP
    
    def test_run(self):
        model = ChaoticModel(self.simulation, 500, 200)
        model._random = self.random
        self.patch_find_whitepage(model)
        
        model.run(at=0) # test method
        self.simulation.simulate(until=2000)
        
        # WP from the previous loop goes up, current WP goes down
        # In this case the WP is always the same
        self.assertItemsEqual( ( (400, "down"),
                                 (800, "up"), (800, "down"),
                                 (1200, "up"), (1200, "down"),
                                 (1600, "up"), (1600, "down"),
                                 (2000, "up"), (2000, "down") ), self.nodes[0].trace )
        
        for n in range( 1, len(self.nodes) ):
            self.assertEquals( 0, len(self.nodes[n].trace) )
class RequestInstanceTestCase(unittest.TestCase):

    def setUp(self):
        self.s = Simulation()
        self.s.initialize()
    
    def get_me(self):
        me = Mock()
        me.name = "origin"
        return me
    
    def get_unavailable_node(self, name):
        node = Mock()
        node.queueRequest.return_value = None
        node.name = name
        return node
    
    def get_available_node(self, name):
        n = FakeAvailableNode(name, self.s)
        n.processRequests(at=0)
        return n
    
    @patch('netuse.results.G._tracer', Mock()) # new global unrandomized variable 
    def test_get_unanswered_nodes(self):
        nodes = []
        nodes.append( self.get_available_node("aval1") )
        nodes.append( self.get_unavailable_node("unaval") )
        nodes.append( self.get_available_node("aval2") )
        me = self.get_me() # otherwise weakref of RequestInstance will delete it
        
        ri = RequestInstance(me, nodes, "/fakeurl", sim=self.s)
        RequestManager.launchNormalRequest(ri)
        self.s.simulate(100000)
        
        unanswered = ri.get_unanswered_nodes()
        self.assertTrue( nodes[1].name in unanswered )
        self.assertFalse( nodes[0].name in unanswered )
        self.assertFalse( nodes[2].name in unanswered )
예제 #13
0
    def initialize(self):
        """
        Initializes the object.
        @rtype: NoneType
        """
        self.__simInstance = Simulation() 
        self.__simInstance.initialize()

        
        self.__simulationTime = 0
        self.__currentSimulationTime = 0
        self.__network = None
        self.__simulationProcessFactory = []
        self.__resourcePeer = 0
        self.__transactionNumber = 0
        self.__transactionDateTimeStart = ""
        self.__transactionDateTimeStop = ""
        #self.__logger = SimulationLogger() 
        #self.__logger.resgiterLoggingInfo("Create Simulation ")
        SimulationLogger().resgiterLoggingInfo("Create Simulation ")
 def setUp(self):
     self.simulation = Simulation()
     self.simulation.initialize()
     
     self.obj1 = FakeClass(self.simulation)
     self.obj2 = FakeClass(self.simulation)
예제 #15
0
class AbstractSimulation(ISimulation):
    """
    Defines the interface of simulation objects.
    @author: Luiz Gustavo
    @organization: Federal University of Rio de Janeiro
   
    """
     
    def __init__(self):
        raise NotImplementedError()

    
    def initialize(self):
        """
        Initializes the object.
        @rtype: NoneType
        """
        self.__simInstance = Simulation() 
        self.__simInstance.initialize()

        
        self.__simulationTime = 0
        self.__currentSimulationTime = 0
        self.__network = None
        self.__simulationProcessFactory = []
        self.__resourcePeer = 0
        self.__transactionNumber = 0
        self.__transactionDateTimeStart = ""
        self.__transactionDateTimeStop = ""
        #self.__logger = SimulationLogger() 
        #self.__logger.resgiterLoggingInfo("Create Simulation ")
        SimulationLogger().resgiterLoggingInfo("Create Simulation ")
    
   
    def initializeNetwork(self, peers ,newPeerTime ,neighbors):
        raise NotImplementedError() 

    
    def addSimulationProcessFactory(self, simulationProcessFactory):
       
        if simulationProcessFactory in self.__simulationProcessFactory:
            return None
        simulationProcessFactory.setSimulation(self)
        simulationProcessFactory.initializeProcess()
        self.__simulationProcessFactory.append(simulationProcessFactory)
       
        
        return self.__simulationProcessFactory[self.__simulationProcessFactory.index(simulationProcessFactory)]

    
    def removeSimulationProcessFactory(self, simulationProcessFactory):
       
        if not simulationProcessFactory in self.__simulationProcessFactory:
            return None
        self.__simulationProcessFactory.remove(simulationProcessFactory)
        return simulationProcessFactory

    
    def getSimulationProcessFactorys(self):
        return self.__simulationProcessFactory

    
    def countSimulationProcessFactorys(self):
        return len(self.__simulationProcessFactory)
    
       
    def configure(self):
        raise NotImplementedError()
    
        
    def getNetwork(self):
        return self.__network
    
    
    def setNetwork(self, network):
        
        self.__network = network
        self.__network.setSimulation(self)
        return self.__network
    
       
    def getSimulationTime(self):
        return self.__simulationTime

    
    def setSimulationTime(self, simulationTime):
        
        self.__simulationTime = simulationTime
        return self.__simulationTime
    
        
    def getResourcePeer(self):
        return self.__resourcePeer

    
    def setResourcePeer(self, resourcePeer):
        
        self.__resourcePeer = resourcePeer
        return self.__resourcePeer
    
    def getTransactionNumber(self):
        return self.__transactionNumber
    
    def setTransactionNumber(self, number):
        
        self.__transactionNumber = number
        return self.__transactionNumber
    
    def getTransactionDateTimeStart(self):
        return self.__transactionDateTimeStart
    
    def setTransactionDateTimeStart(self, date):
        
        self.__transactionDateTimeStart = date
        return self.__transactionDateTimeStart
    
    
    def getTransactionDateTimeStop(self):
        return self.__transactionDateTimeStop
    
    def setTransactionDateTimeStop(self, date):
        
        self.__transactionDateTimeStop = date
        return self.__transactionDateTimeStop
    
    def getCurrentSimulationTime(self):
        semaphore = Semaphore()
        semaphore.acquire()
        time = self.__currentSimulationTime
        semaphore.release()
        return time
    
    
    def setCurrentSimulationTime(self, currentSimulationTime):
       
        semaphore = Semaphore()
        semaphore.acquire()
        self.__currentSimulationTime = currentSimulationTime
        semaphore.release()
        return self.__currentSimulationTime
    
    
    def getSimInstance(self):
        return self.__simInstance
    
        
    
    def start(self):
        
        mySim = self.getSimInstance()
        
        SimulationLogger().resgiterLoggingInfo("Start Simulation ")
        #Logger().resgiterLoggingInfo("Start Simulation ")
        factoryProcess = 0
        for factory in self.__simulationProcessFactory:
            print factory.getName()
            mySim.activate( factory, factory.factorySimulationProcess(),at=factory.getActive()) 
            
            factoryProcess +=1
            
            
        mySim.simulate( until = self.getSimulationTime() )    
        return factoryProcess
       
    
    
    def stop(self):
        raise NotImplementedError()
       
    
    
    simInstance = property(getSimInstance, None, None, None)
   
    simulationTime = property(getSimulationTime, setSimulationTime, None, None)
    
    currentSimulationTime = property(getCurrentSimulationTime, setCurrentSimulationTime, None, None)
   
    network = property(getNetwork, setNetwork, None, None)
    
    
예제 #16
0
 def __init__(self, resource, name="Experiment"):
     Simulation.__init__(self)
     self.name = name
     self.resource = resource
     self.scheduler = None
class RequestManagerTestCase(unittest.TestCase): # classes under test: DelayedRequest, ScheduledRequest

    def setUp(self):
        self.simulation = Simulation()
        self.simulation.initialize()
        
        self.obj1 = FakeClass(self.simulation)
        self.obj2 = FakeClass(self.simulation)
        
    def test_get_result_method1(self):
        r = self.obj1.method1(at=100, simulation=self.simulation) # or directly: r = self.fc.method1(100)        
        self.simulation.simulate(1000)
        self.assertEquals(100, r.get_result())
        
    def test_get_result_method2(self):
        r = self.obj1.method2(at=200, simulation=self.simulation, str_param="helloworld")
        self.simulation.simulate(1000)
        self.assertEquals((200, "helloworld"), r.get_result())
        
    def test_scheduled_method1(self):
        self.obj1.method1(at=100)
        self.obj1.method1(at=300)
        self.obj2.method1(at=500)
        
        self.simulation.simulate(1000)
        
        self.assertItemsEqual( ( ("method1", 100), ("method1", 300) ), self.obj1.traces)
        self.assertItemsEqual( ( ("method1", 500),  ), self.obj2.traces)
        
    def test_scheduled_method1(self):
        self.obj1.method1(at=100)
        self.obj1.method1(at=300)
        self.obj2.method1(at=500)
        
        self.simulation.simulate(1000)
        
        self.assertItemsEqual( ( ("method1", 100), ("method1", 300) ), self.obj1.traces)
        self.assertItemsEqual( ( ("method1", 500),  ), self.obj2.traces)
    
    def test_scheduled_method2(self):
        self.obj1.method2(at=500, str_param="gato")
        self.obj1.method2(at=300, str_param="perro")
        self.obj2.method2(at=100, str_param="iguana")
        
        self.simulation.simulate(1000)
        
        self.assertItemsEqual( ( ("method2", 300, "perro"), ("method2", 500, "gato") ), self.obj1.traces)
        self.assertItemsEqual( ( ("method2", 100, "iguana"),  ), self.obj2.traces)
    
    def test_scheduled_methods_all(self):
        self.obj1.method2(at=600, str_param="lagartija")
        self.obj1.method1(at=400)
        self.obj1.method2(at=500, str_param="gato")
        
        self.obj2.method1(at=300)
        self.obj2.method2(at=100, str_param="iguana")
        self.obj2.method2(at=200, str_param="salamandra")
        
        self.simulation.simulate(1000)
        
        self.assertItemsEqual( ( ("method1", 400), ("method2", 500, "gato"), ("method2", 600, "lagartija") ), self.obj1.traces)
        self.assertItemsEqual( ( ("method1", 300), ("method2", 100, "iguana"), ("method2", 200, "salamandra")  ), self.obj2.traces)
        
    def test_normal_call(self):
        self.obj1.method2(str_param="before")
        self.simulation.simulate(1000)
        self.obj1.method2(str_param="after") 
        
        # independent of simulation because no "simulation", "at" and "delay" are specified in both calls
        self.assertItemsEqual( ( ("method2", 0, "before"), ("method2", 0, "after") ), self.obj1.traces)
예제 #18
0
    def __init__(self, configuration, callback=None):
        """
        Args:
            - `callback`: A callback can be specified. This function will be \
                called to report the advance of the simulation (useful for a \
                progression bar).
            - `configuration`: The :class:`configuration \
                <simso.configuration.Configuration>` of the simulation.

        Methods:
        """
        Simulation.__init__(self)
        self._logger = Logger(self)
        task_info_list = configuration.task_info_list
        part_info_list = configuration.part_info_list
        proc_info_list = configuration.proc_info_list
        self._cycles_per_ms = configuration.cycles_per_ms
        self._time_partitioning = False
        self._donation_policy = configuration.donation_policy
        self._task_list = []

        self._aborted_jobs = []
        self._aborted_insts = []
        self._aborted_jobs_times = {}
        self._aborted_insts_times = {}
        self._released_opt_jobs = 0
        self._completed_opt_jobs = 0
        self._released_opt_by_part = {}
        self._completed_opt_by_part = {}

        if(configuration.part_scheduler_info):
            self._time_partitioning = True
            self.part_scheduler = configuration.part_scheduler_info.instantiate(self)
            self.scheduler = None
        else:
            self.scheduler = configuration.scheduler_info.instantiate(self)
            self.scheduler.task_list = self._task_list

        try:
            self._etm = execution_time_models[configuration.etm](
                self, len(proc_info_list)
            )
        except KeyError:
            print("Unknowned Execution Time Model.", configuration.etm)

        for task_info in task_info_list:
            self._task_list.append(Task(self, task_info))

        self._part_list = []
        for part_info in part_info_list:
            self._part_list.append(TimePartition(self, part_info))
            self._released_opt_by_part[part_info] = 0
            self._completed_opt_by_part[part_info] = 0

        # Init the processor class. This will in particular reinit the
        # identifiers to 0.
        Processor.init()

        # Initialization of the caches
        for cache in configuration.caches_list:
            cache.init()

        self._processors = []
        for proc_info in proc_info_list:
            proc = Processor(self, proc_info)
            if(self._time_partitioning):
                proc.activate_time_partitioning(self.part_scheduler)
                for i in range(len(self._part_list)):
                    if proc_info in part_info_list[i].cpus:
                        self._part_list[i].cpus.append(proc)
                        
            proc.caches = proc_info.caches
            self._processors.append(proc)

        # Now that processors have been added, init list of
        # interrupted jobs per partition
        for part in self._part_list:
            part.init_part()

        # XXX: too specific.
        self.penalty_preemption = configuration.penalty_preemption
        self.penalty_migration = configuration.penalty_migration

        self._etm.init()

        self._duration = configuration.duration
        self.progress = Timer(self, Model._on_tick, (self,),
                              self.duration // 20 + 1, one_shot=False,
                              in_ms=False)
        self._callback = callback

        
        # Add processors to either task scheduler or partition
        # scheduler
        if(self._time_partitioning):
            self.part_scheduler.processors = self._processors
        else:
            self.scheduler.processors = self._processors

        self.results = None
class TestCache(unittest.TestCase):
    
    def setUp(self):
        self.simulation = Simulation()
        
        self.browsing_subquery = SubQuery( name = "_services._dns-sd._udp.local",
                                           record_type = "PTR" )
        self.sender = FakeSender(self.simulation) # used for the asserts
        self.querier = ContinuousQuerier(self.browsing_subquery, self.simulation, self.sender)
        
        self.querier._random = Mock()
        self.querier._random.random.side_effect = lambda *args: 0.5
        
        self.simulation.initialize()
        self.simulation.activate(self.querier, self.querier.query_continuously())
    
    def assert_contains_log(self, at, query_type="QM"):
        asserted = False
        for log_line in self.sender.log:
            if log_line[FakeSender.WHEN_FIELD] == at:
                self.assertEquals(query_type, log_line[FakeSender.QUERY_TYPE_FIELD])
                self.assertEquals(self.browsing_subquery, log_line[FakeSender.SUBQUERY_FIELD])
                asserted = True
        self.assertTrue(asserted)
    
    def test_query_continuously_one_query(self):
        self.simulation.simulate( until=20 + 100*0.5 + 1 )
        self.assertEquals(1, len(self.sender.log))
        self.assert_contains_log(20 + 100*0.5, "QU")
    
    def test_query_continuously_two_queries(self):
        self.simulation.simulate( until=20 + 100*0.5 + 1000 + 1 )
        self.assertEquals(2, len(self.sender.log))
        self.assert_contains_log(20 + 100*0.5, "QU")
        self.assert_contains_log(20 + 100*0.5 + 1000, "QM")
    
    def test_query_continuously_three_queries(self):
        self.simulation.simulate( until=20 + 100*0.5 + 1000 + 2000 + 1 )
        self.assertEquals(3, len(self.sender.log))
        self.assert_contains_log(20 + 100*0.5, "QU")
        self.assert_contains_log(20 + 100*0.5 + 1000, "QM")
        self.assert_contains_log(20 + 100*0.5 + 3000, "QM")
    
    def get_time_for_iteration_waiting_1hour(self):
        n = 1 # loops needed to reach to 60mins interval
        interval = 1000
        acum_time = interval
        while interval<3600000:
            interval = interval * 2
            if interval > 3600000: interval = 3600000
            n += 1
            acum_time += interval 
        return acum_time, n
    
    def test_query_continuously_n_queries(self):
        t, n = self.get_time_for_iteration_waiting_1hour()
        self.simulation.simulate( until=20 + 100*0.5 + t + 1 )
        self.assertEquals(n+1, len(self.sender.log)) # +1 for the 1st query!
        self.assert_contains_log(20 + 100*0.5 + t, "QM")
        self.assert_contains_log(20 + 100*0.5 + t - 3600000, "QM")
class RequestManagerTestCase(unittest.TestCase): # classes under test: DelayedRequest, ScheduledRequest

    def setUp(self):
        self.s = Simulation()
        self.s.initialize()
        self.request = FakeRequestInstance(sim=self.s)
    
    def test_NormalRequest(self):
        RequestManager.launchNormalRequest(self.request)
        self.s.simulate(100000)
        self.assertEquals(0, self.request.when)
    
    def test_DelayedRequest(self):
        RequestManager.launchDelayedRequest(self.request, 100)
        self.s.simulate(100000)
        self.assertEquals(100, self.request.when) # after 100 starting in 0
    
    def test_cancel_DelayedRequest(self):
        RequestManager.launchDelayedRequest(self.request, 100)
        RequestManager.cancelRequest(self.request)
        self.s.simulate(100000)
        self.assertEquals(None, self.request.when)
        
    def test_ScheduledRequest(self):
        RequestManager.launchScheduledRequest(self.request, at=1000)
        self.s.simulate(100000)
        self.assertEquals(1000, self.request.when) # at 1000
    
    def test_cancel_ScheduledRequest(self):
        RequestManager.launchScheduledRequest(self.request, 1000)
        RequestManager.cancelRequest(self.request)
        self.s.simulate(100000)
        self.assertEquals(None, self.request.when)
예제 #21
0
파일: fsm.py 프로젝트: reidlindsay/wins
def _fixreactivate(self, *args, **kwargs):
    """Fix to make all reactivate() calls prior by default."""
    if (len(args)<4) and ('prior' not in kwargs):
        # prior is not defined -> set to True
        kwargs['prior'] = True
    return Simulation.reactivate(self, *args, **kwargs)
 def setUp(self):
     self.s = Simulation()
     self.s.initialize()
     self.request = FakeRequestInstance(sim=self.s)
 def setUp(self):
     self.s = Simulation()
     self.s.initialize()
예제 #24
0
파일: bank04_OO.py 프로젝트: yeungsl/simpy
 def __init__(self, seed):
     Simulation.__init__(self)
     self.rv = Random(seed)
class NewWPDetectorTestCase(unittest.TestCase):
    
    def setUp(self):
        self.simulation = Simulation()
        
        self.mdns_instance = Mock()
        self.mdns_instance.get_whitepage_record.return_value = None
        self.mdns_instance.notify_whitepage_changed.side_effect = self._log_event
        
        self.detector = NewWPDetector(self.mdns_instance, self.simulation)
        
        self.log = []
        
        self.simulation.initialize()
    
    def _log_event(self):
        self.log.append(self.simulation.now()) # notification at
    
    def test_check_new_wps(self):
        self.simulation.activate(self.detector, self.detector.check_new_wps(), at = 0)
        
        s = WhitepageSetter(self.mdns_instance, "node0", self.simulation)
        self.simulation.activate(s, s.set_wp(), at = 1500)
        
        s = WhitepageSetter(self.mdns_instance, "node1", self.simulation)
        self.simulation.activate(s, s.set_wp(), at = 2500)
        
        self.simulation.simulate(until = 10000)
        
        self.assertEquals(2, len(self.log))
        self.assertEquals(2000, self.log[0]) # when it does not discover a WP, it waits 1 secs
        self.assertEquals(7000, self.log[1]) # after discovering a it waits 5 secs
예제 #26
0
from SimPy.Simulation import (Simulation, Process, Resource, request, hold,
                              release)
"""Object Oriented SimPy API"""

# Model components -------------------------------


class Car(Process):
    def run(self, res):
        yield request, self, res
        yield hold, self, 10
        yield release, self, res
        print("Time: %s" % self.sim.now())


# Model and Experiment ---------------------------

s = Simulation()
s.initialize()
r = Resource(capacity=5, sim=s)
auto = Car(sim=s)
s.activate(auto, auto.run(res=r))
s.simulate(until=100)
 def setUp(self):
     self.simulation = Simulation()
     self.simulation.initialize()
     
     self.proc1 = SimpleProcess(sim=self.simulation)
     self.proc2 = SimpleProcess(sim=self.simulation)
class TestCache(unittest.TestCase):
    
    def setUp(self):
        self.simulation = Simulation()
        self.cache = Cache(self.simulation)
        
        for i in range(5):
            at = i * 10
            
            record = PTRRecord("_http._tcp.local", "name%d._http._tcp.local"%i, )
            self.cache.records.append(record)
            self.cache.pending_events.append((at, Cache.EVENT_KNOWN_ANSWER, record))
            
            record = SVRRecord("name%d._http._tcp.local"%i, None, None)
            self.cache.records.append(record)
            self.cache.pending_events.append((at, Cache.EVENT_KNOWN_ANSWER, record))
            
            record = TXTRecord("name%d._http._tcp.local"%i, {})
            self.cache.records.append(record)
            self.cache.pending_events.append((at, Cache.EVENT_RENEW, record))
        
        self.assertEquals(15, len(self.cache.records))
        self.assertEquals(15, len(self.cache.pending_events))
        
        self.sample_txt = TXTRecord("name0._http._tcp.local", {})
        self.sample_svr = SVRRecord("name2._http._tcp.local", None, None)
        self.sample_ptr = PTRRecord("_http._tcp.local", "name4._http._tcp.local")
    
    def does_contain_event(self, ttype, name, when=None, action=None):
        for event in self.cache.pending_events:
            cond = event is None or event[Cache.WHEN_FIELD]==when
            cond = cond and ( event is None or event[Cache.ACTION_FIELD]==action )
            cond = cond and event[Cache.RECORD_FIELD].name == name
            cond = cond and event[Cache.RECORD_FIELD].type == ttype
            if cond:
                return True
        return False
    
    def test_get_known_answers(self):
        ka = self.cache.get_known_answers()
        
        # only records with action Cache.EVENT_KNOWN_ANSWER associated in pending_events
        self.assertEquals(10, len(ka))
        self.assertFalse( self.sample_txt in ka )
        self.assertTrue( self.sample_svr in ka )
        self.assertTrue( self.sample_ptr in ka )
    
    def test_delete_events_for_record(self):
        self.cache._delete_events_for_record(self.sample_txt)
        self.assertEquals(14, len(self.cache.pending_events))
        self.assertFalse( self.does_contain_event(self.sample_txt.type, self.sample_txt.name) )
        
        self.cache._delete_events_for_record(self.sample_svr)
        self.assertEquals(13, len(self.cache.pending_events))
        self.assertFalse( self.does_contain_event(self.sample_svr.type, self.sample_svr.name) )
        
        self.cache._delete_events_for_record(self.sample_ptr)
        self.assertEquals(12, len(self.cache.pending_events))
        self.assertFalse( self.does_contain_event(self.sample_ptr.type, self.sample_ptr.name) )

    def test_create_new_events(self):
        self.cache._random = Mock()
        self.cache._random.random.side_effect = lambda *args: 0.5 # 0.5 * 2% == 1% of variation
        self.cache.sim = Mock()
        self.cache.sim.now.side_effect = lambda: 0
        
        self.sample_txt.ttl = 1 # to ease calculations
        self.cache._create_new_events(self.sample_txt)
        self.assertEquals(15+5, len(self.cache.pending_events))
        
        self.assertTrue( self.does_contain_event(self.sample_txt.type, self.sample_txt.name, when=500, action=Cache.EVENT_KNOWN_ANSWER) )
        self.assertTrue( self.does_contain_event(self.sample_txt.type, self.sample_txt.name, when=810, action=Cache.EVENT_RENEW) )
        self.assertTrue( self.does_contain_event(self.sample_txt.type, self.sample_txt.name, when=860, action=Cache.EVENT_RENEW) )
        self.assertTrue( self.does_contain_event(self.sample_txt.type, self.sample_txt.name, when=910, action=Cache.EVENT_RENEW) )
        self.assertTrue( self.does_contain_event(self.sample_txt.type, self.sample_txt.name, when=960, action=Cache.EVENT_RENEW) )
        
    def test_cache_record(self):
        new_record = copy.deepcopy(self.sample_txt)
        new_record.ttl = 1234
        self.cache.cache_record(new_record) # substitutes 1 record, removes 1 event, adds 6
        
        # already tested in test_delete_events_for_record and test_create_new_events
        self.assertEquals(15-1+5, len(self.cache.pending_events))
        
        self.assertEquals(15, len(self.cache.records))
        
        found = False
        for record in self.cache.records:
            if record.name == new_record.name and record.type == new_record.type:
                self.assertEquals( 1234, record.ttl ) # the cache contains the new version of the TXT record
                found = True
                break
        self.assertTrue(found)
        
    def test_wait_for_next_event(self):        
        self.simulation.initialize()
        self.simulation.activate(self.cache, self.cache.wait_for_next_event())
        
        self.simulation.simulate( until=90*60*1000 ) # simulate 90 mins
        
        self.assertEquals(0, len(self.cache.pending_events))
        self.assertEquals(15, len(self.cache.records))