Package SimPy :: Module testSimPyRTOO

[hide private]
[frames] | no frames]

# Source Code for Module SimPy.testSimPyRTOO

       1  #!/usr / bin / env python
       2  from SimPy.SimulationRT  import *
       3  from SimPy.MonitorTest import *
       4  import unittest
       5  from random import random
       6  # $Revision: 439 $ $Date: 2010-04-02 05:49:13 +0200 (Fri, 02 Apr 2010) $
       7  """testSimPyRT.py
       8  SimPy version 2.1
       9  Unit tests for SimulationRT.
      10  Based on testSimpy.py to test full compatibility
      11  between Simulation and SimulationRT.
      12
      13
      14  #'$Revision: 439 $ $Date: 2010-04-02 05:49:13 +0200 (Fri, 02 Apr 2010) $ kgm'
      15
      16  """
      17  simulationRTVersion=version
      18  print "Under test: SimulationRT.py %s"%simulationRTVersion
      19  __version__ = '2.1 $Revision: 439 $ $Date: 2010-04-02 05:49:13 +0200 (Fri, 02 Apr 2010) $ '
      20  print 'testSimPyRTOO.py %s'%__version__
      21
      22  ## -------------------------------------------------------------
      23  ##                    TEST SIMULATIONRT
      24  ## -------------------------------------------------------------
      25 -class P(Process):
      26     """ P class for testing"""
      27 -   def __init__(self,name="",T = 0,sim=None):
      28          Process.__init__(self,name=name,sim=sim)
      29          self.name=name
      30          self.T = T
      31
      32 -   def execute(self):
      33          yield hold,self,self.T
      34
      35 -class PActions(Process):
      36     """ PActions class for testing"""
      37 -   def __init__(self,name="",T = 0,sim=None):
      38          Process.__init__(self,name=name,sim=sim)
      39          self.T = T
      40
      41 -   def ACTIONS(self):
      42          yield hold,self,self.T
      43
      44 -class ToStop(Process):
      45      """For testing stopSimulation
      46      """
      47 -    def run(self,stopTime):
      48          yield hold,self,now()+stopTime
      49          self.sim.stopSimulation()
      50          yield hold,self,10
      51
      52 -class ToCollect(Process):
      53      """For testing startCollection
      54      """
      55 -    def run(self,mon1,mon2,tal1,tal2):
      56          while True:
      57              yield hold,self,1
      58              mon1.observe(self.sim.now())
      59              mon2.observe(self.sim.now())
      60              tal1.observe(self.sim.now())
      61              tal2.observe(self.sim.now())
      62
      63 -class ForEvtTimes(Process):
      64      """For testing allEventTimes
      65      """
      66 -    def run(self):
      67          yield hold,self
      68
      69
      70 -class makeSimulationtestcase(unittest.TestCase):
      71     """ Tests of simulation
      72     """
      73 -   def testInit(self):
      74          """Test initialisation
      75          """
      76          s=SimulationRT()
      77          s.initialize()
      78          result=s.simulate(until=10)
      79          assert result=="SimPy: No activities scheduled",\
      80                 "There should have been no activities."
      81          assert(s.now()==0),"time not 0"
      82
      83 -   def testActivate(self):
      84          """Test activate()
      85          """
      86          s=SimulationRT()
      87          s.initialize()
      88          P1 = P(name="P1",T=100.0,sim=s)
      89          s.activate(P1,P1.execute(),0)
      90          s.simulate(until=5)
      91          assert(s.now()==5),"Simulate stopped at %s not %s"%(s.now(),5)
      92
      93 -   def testStart(self):
      94         """Test start method
      95         """
      96         s=SimulationRT()
      97         P1 = P(name="P1",T=100.0,sim=s)
      98         s.initialize()
      99         P1.start(P1.execute(),0)
     100         s.simulate(until=5)
     101         assert(s.now()==5),"Simulate stopped at %s not %s"%(s.now(),5)
     102
     103 -   def testStartActions(self):
     104        """Test start method with ACTIONS PEM
     105        """
     106        s=SimulationRT()
     107        P1 = PActions(name="P1",T=100.0,sim=s)
     108        s.initialize()
     109        P1.start()
     110        s.simulate(until=5)
     111        assert(s.now()==5),"Simulate stopped at %s not %s"%(s.now(),5)
     112
     113 -   def testYield(self):
     114          """Test yield hold and simulate(until)
     115          """
     116          s=SimulationRT()
     117          s.initialize()
     118          P1 = P(name="P1",T=10,sim=s)
     119          s.initialize()
     120          s.activate(P1,P1.execute(),0)
     121          s.simulate(until=5)
     122          assert(s.now()==5),"Simulate stopped at %s not %s"%(s.now(),5)
     123          ## should stop at 0 for next event is at 10s
     124          P2 = P(name="P2",T=10,sim=s)
     125          s.initialize()
     126          s.activate(P2,P2.execute(),0)
     127          s.simulate(until=20)
     128          assert(s.now()==10),"P1 hold to %s not %s"%(s.now(),10)
     129
     130     ## ------------------------------------------------------------------------
     131     ## Tests of simulation utility functions/methods
     132     ## ------------------------------------------------------------------------
     133
     134 -   def testStopSimulation(self):
     135          """Test stopSimulation function/method
     136          """
     137          timeToStop = 7
     138          s = SimulationRT()
     139          ts = ToStop(sim = s)
     140          s.activate(ts,ts.run(stopTime = timeToStop))
     141          s.simulate(until = 50)
     142          assert(s.now()==timeToStop),\
     143          "stopSimulation not working; now = %s instead of %s"%(now(),timeToStop)
     144
     145 -   def testStartCollection(self):
     146         """Test startCollection function/method
     147         """
     148         s = SimulationRT()
     149         tStart = 9
     150         mon1 = Monitor("mon1",sim = s)
     151         mon2 = Monitor("mon2",sim = s)
     152         tal1 = Tally("tal1",sim = s)
     153         tal2 = Tally("tal2",sim = s)
     154         s.startCollection(when = tStart,monitors=[mon1,mon2],tallies=[tal1,tal2])
     155         tc = ToCollect(sim = s)
     156         s.activate(tc,tc.run(mon1,mon2,tal1,tal2))
     157         s.simulate(until=50)
     158         assert(mon1[0]==mon2[0]==[tStart,tStart]),\
     159                "startCollection not working correctly for Monitors"
     160         assert(tal1.count()==tal2.count()==50-tStart+1),\
     161                "startCollection not working for Tally"
     162
     163 -   def testAllEventTimes(self):
     164         """Test allEventTimes function/method
     165         """
     166         s = SimulationRT()
     167         for i in range(3):
     168             f = ForEvtTimes(sim = s)
     169             s.activate(f,f.run(),at=i)
     170         assert(s.allEventTimes()==[0,1,2]),\
     171                "allEventTimes not working"
     172
     173
     174 -def makeSSuite():
     175      suite = unittest.TestSuite()
     176      testInit = makeSimulationtestcase("testInit")
     177      testActivate = makeSimulationtestcase("testActivate")
     178      testStart=makeSimulationtestcase("testStart")
     179      testStartActions=makeSimulationtestcase("testStartActions")
     180      testYield = makeSimulationtestcase("testYield")
     181      testStopSimulation = makeSimulationtestcase('testStopSimulation')
     182      testStartCollection = makeSimulationtestcase('testStartCollection')
     183      testAllEventTimes = makeSimulationtestcase('testAllEventTimes')
     184      suite.addTests([testInit, testActivate, testStart, testStartActions,
     185                      testYield,testStopSimulation,testStartCollection,
     186                      testAllEventTimes])
     187      return suite
     188
     189  ## -------------------------------------------------------------
     190  ##                    TEST RESOURCES
     191  ## -------------------------------------------------------------
     192
     193 -class Job(Process):
     194     """ Job class for testing"""
     195 -   def __init__(self,server=None,name="",sim=None):
     196          Process.__init__(self,name=name,sim=sim)
     197          self.R=server
     198
     199 -   def execute(self):
     200          yield request,self,self.R
     201
     202 -class makeResourcetestcase(unittest.TestCase):
     203     """ First simple tests of Resources
     204     """
     205 -   def testInit(self):
     206          """Test initialisation"""
     207          s=SimulationRT()
     208          s.initialize()
     209          R = Resource(sim=s)
     210          assert R.name == "a_resource", "Not null name"
     211          assert R.capacity == 1, "Not unit capacity"
     212          assert R.unitName =="units", "Not the correct unit name"
     213          R = Resource(name='',capacity=1,sim=s)
     214          assert R.name == "", "Not null name"
     215          assert R.capacity == 1, "Not unit capacity"
     216          assert R.unitName =="units", "Not the correct unit name"
     217          R = Resource(capacity=3,name="3-version",unitName="blobs",sim=s)
     218          assert R.name =="3-version" , "Wrong name, it is"+R.name
     219          assert R.capacity == 3, "Not capacity 3, it is "+`R.capacity`
     220          assert R.unitName =="blobs", "Not the correct unit name"
     221          ## next test 0 capacity is allowed
     222          R = Resource(capacity=0,name="0-version",sim=s)
     223          assert R.capacity ==0, "Not capacity 0, it is "+`R.capacity`
     224
     225 -   def testrequest(self):
     226          """Test request"""
     227
     228          ## now test requesting: ------------------------------------
     229          s=SimulationRT()
     230          s.initialize()
     231          R0 = Resource(name='',capacity=0,sim=s)
     232          assert R0.name == "", "Not null name"
     233          assert R0.capacity == 0, "Not capacity 0, it is "+`R0.capacity`
     234          R1 = Resource(capacity=0,name="3-version",unitName="blobs",sim=s)
     235          J= Job(name="job",server=R1,sim=s)
     236          s.activate(J,J.execute(), at=0.0) # this requests a unit of R1
     237          ## when simulation starts
     238          s.simulate(until=10.0)
     239          assert R1.n == 0 , "Should be 0, it is "+str(R1.n)
     240          lenW = len(R1.waitQ)
     241          assert lenW==1,"Should be 1, it is "+str(lenW)
     242          assert len(R1.activeQ)==0,"len activeQ Should be 0, it is "+\
     243          str(len(R1.activeQ))
     244
     245 -   def testrequest2(self):
     246          """Test request2 with capacity = 1"""
     247          ## now test requesting: ------------------------------------
     248          s=SimulationRT()
     249          s.initialize()
     250          R2 = Resource(capacity=1,name="3-version",unitName="blobs",sim=s)
     251          J2= Job(name="job",server=R2,sim=s)
     252          s.activate(J2,J2.execute(), at=0.0) # requests a unit of R2
     253          ## when simulation starts
     254          s.simulate(until = 10.0)
     255          assert R2.n == 0 , "Should be 0, it is "+str(R2.n)
     256          lenW = len(R2.waitQ)
     257          lenA = len(R2.activeQ)
     258          assert lenW==0,"lenW Should be 0, it is "+str(lenW)
     259          assert lenA==1,"lenA Should be 1, it is "+str(lenA)
     260
     261 -   def testrequest3(self):
     262          """Test request3 with capacity = 1 several requests"""
     263          ## now test requesting: ------------------------------------
     264          s=SimulationRT()
     265          s.initialize()
     266          R3 = Resource(capacity=1,name="3-version",unitName="blobs",sim=s)
     267          J2= Job(name="job",server=R3,sim=s)
     268          J3= Job(name="job",server=R3,sim=s)
     269          J4= Job(name="job",server=R3,sim=s)
     270          s.activate(J2,J2.execute(), at=0.0) # requests a unit of R3
     271          s.activate(J3,J3.execute(), at=0.0) # requests a unit of R3
     272          s.activate(J4,J4.execute(), at=0.0) # requests a unit of R3
     273          ## when simulation starts
     274          s.simulate(until = 10.0)
     275          assert R3.n == 0 , "Should be 0, it is "+str(R3.n)
     276          lenW = len(R3.waitQ)
     277          lenA = len(R3.activeQ)
     278          assert lenW==2,"lenW Should be 2, it is "+str(lenW)
     279          assert R3.waitQ==[J3,J4],"WaitQ wrong"+str(R3.waitQ)
     280          assert lenA==1,"lenA Should be 1, it is "+str(lenA)
     281          assert R3.activeQ==[J2],"activeQ wrong, it is %s"%str(R3.activeQ[0])
     282
     283 -   def testrequest4(self):
     284          """Test request4 with capacity = 2 several requests"""
     285          ## now test requesting: ------------------------------------
     286          s=SimulationRT()
     287          s.initialize()
     288          R3 = Resource(capacity=2,name="4-version",unitName="blobs",sim=s)
     289          J2= Job(name="job",server=R3,sim=s)
     290          J3= Job(name="job",server=R3,sim=s)
     291          J4= Job(name="job",server=R3,sim=s)
     292          s.activate(J2,J2.execute(), at=0.0) # requests a unit of R3
     293          s.activate(J3,J3.execute(), at=0.0) # requests a unit of R3
     294          s.activate(J4,J4.execute(), at=0.0) # requests a unit of R3
     295          ## when simulation starts
     296          s.simulate(until = 10.0)
     297          assert R3.n == 0 , "Should be 0, it is "+str(R3.n)
     298          lenW = len(R3.waitQ)
     299          lenA = len(R3.activeQ)
     300          assert lenW==1,"lenW Should be 1, it is "+str(lenW)
     301          assert R3.waitQ==[J4],"WaitQ wrong"+str(R3.waitQ)
     302          assert lenA==2,"lenA Should be 2, it is "+str(lenA)
     303          assert R3.activeQ==[J2,J3],"activeQ wrong, it is %s"%str(R3.activeQ[0])
     304  ##
     305  #------- Test Priority Queues
     306  ##
     307 -   def testrequestPriority(self):
     308          """Test PriorityQ, with no preemption, 0 capacity"""
     309          class Job(Process):
     310             """ Job class for testing"""
     311             def __init__(self,server=None,name="",sim=None):
     312                Process.__init__(self,name=name,sim=sim)
     313                self.R=server
     314
     315             def execute(self,priority):
     316                yield request,self,self.R,priority
     317
     318          s=SimulationRT()
     319          s.initialize()
     320          Rp = Resource(capacity=0,qType=PriorityQ,sim=s)
     321          J5 = Job(name="job 5",server=Rp,sim=s)
     322          J6 = Job(name="job 6",server=Rp,sim=s)
     323          J7 = Job(name="job 7",server=Rp,sim=s)
     324          s.activate(J5,J5.execute(priority=3))
     325          s.activate(J6,J6.execute(priority=0))
     326          s.activate(J7,J7.execute(priority=1))
     327          s.simulate(until=100)
     328          assert Rp.waitQ == [J5,J7,J6],"WaitQ wrong: %s"\
     329                                 %str([(x.name,x.priority[Rp]) for x in Rp.waitQ])
     330
     331          """Test PriorityQ mechanism"""
     332
     333          def sorted(q):
     334             if not q or len(q) == 1:
     335                sortok=1
     336                return sortok
     337             sortok = q[0] >= q[1] and sorted(q[2:])
     338             return sortok
     339
     340          s=SimulationRT()
     341          s.initialize()
     342          Rp=Resource(capacity=0,qType=PriorityQ,sim=s)
     343          for i in range(10):
     344             J=Job(name="job "+str(i),server=Rp,sim=s)
     345             s.activate(J,J.execute(priority=random()))
     346          s.simulate(until=1000)
     347          qp=[x._priority[Rp] for x in Rp.waitQ]
     348          assert sorted(qp),"waitQ not sorted by priority: %s"\
     349                             %str([(x.name,x._priority[Rp]) for x in Rp.waitQ])
     350
     351 -   def testrequestPriority1(self):
     352          """Test PriorityQ, with no preemption, capacity == 1"""
     353          class Job(Process):
     354             """ Job class for testing"""
     355             def __init__(self,server=None,name="",sim=None):
     356                Process.__init__(self,name=name,sim=sim)
     357                self.R=server
     358
     359             def execute(self,priority):
     360                yield request,self,self.R,priority
     361
     362          s=SimulationRT()
     363          s.initialize()
     364          Rp = Resource(capacity=1,qType=PriorityQ,sim=s)
     365          J5 = Job(name="job 5",server=Rp,sim=s)
     366          J6 = Job(name="job 6",server=Rp,sim=s)
     367          J7 = Job(name="job 7",server=Rp,sim=s)
     368          s.activate(J5,J5.execute(priority=2))
     369          s.activate(J6,J6.execute(priority=4))
     370          s.activate(J7,J7.execute(priority=3))
     371          s.simulate(until=100)
     372          assert Rp.waitQ == [J6,J7],"WaitQ wrong: %s"\
     373                                     %[(x.name,x._priority[Rp]) for x in Rp.waitQ]
     374
     375 -   def testrequestPriority2(self):
     376         """Test PriorityQ, with preemption, capacity == 1"""
     377         class nuJob(Process):
     378            def __init__(self,name="",sim=None):
     379               Process.__init__(self,name=name,sim=sim)
     380
     381            def execute(self,res,priority):
     382               self.preempt=len(res.activeQ) > 0\
     383                            and priority > res.activeQ[-1]._priority[res]
     384               t=self.sim.now()
     385               yield request,self,res,priority
     386               if self.preempt:
     387                  assert len(res.waitQ) == 1, \
     388                         "No preemption activeQ= %s"%res.activeQ[0].name
     389               yield hold,self,30
     390               t1=self.sim.now()
     391               if self.preempt:
     392                  assert t+30 == t1,\
     393                         "Wrong completion time for preemptor %s"%self.name
     394               else:
     395                  assert t+60 == t1,\
     396                          "Wrong completion time for preempted %s %s:"\
     397                          %(self.name,self.sim.now())
     398               yield release,self,res
     399
     400         s = SimulationRT()
     401         s.initialize()
     402         res=Resource(name="server",capacity=1,qType=PriorityQ,preemptable=1,
     403                      sim=s)
     404         n1=nuJob(name="nuJob 1",sim=s)
     405         n2=nuJob(name="nuJob 2",sim=s)
     406         s.activate(n1,n1.execute(res,priority=0))
     407         s.activate(n2,n2.execute(res,priority=1),at=15)
     408         s.simulate(until=100)
     409
     410 -   def testrequestPriority3(self):
     411         """Test preemption of preemptor"""
     412         class nuJob(Process):
     413            seqOut=[]
     414            def __init__(self,name="",sim=None):
     415               Process.__init__(self,name=name,sim=sim)
     416               self.serviceTime=30
     417
     418            def execute(self,res,priority):
     419               self.preempt=len(res.activeQ) > 0\
     420                            and priority > res.activeQ[-1]._priority[res]
     421               nrwaiting=len(res.waitQ)
     422               yield request,self,res,priority
     423               if self.preempt:
     424                  assert len(res.waitQ) == nrwaiting + 1,\
     425                         "No preemption activeQ= %s"%res.activeQ[0].name
     426               yield hold,self,self.serviceTime
     427               yield release,self,res
     428               nuJob.seqOut.append((self,self.sim.now()))
     429
     430         s=SimulationRT()
     431         s.initialize()
     432         res=Resource(name="server",capacity=1,qType=PriorityQ,preemptable=1,
     433                      sim=s)
     434         n1=nuJob(name="nuJob 1",sim=s)
     435         n2=nuJob(name="nuJob 2",sim=s)
     436         n3=nuJob(name="nuJob 3",sim=s)
     437         s.activate(n1,n1.execute(res,priority=-1))
     438         start2=10
     439         s.activate(n2,n2.execute(res,priority=0),at=start2)
     440         start3=20
     441         s.activate(n3,n3.execute(res,priority=1),at=start3)
     442         s.simulate(until=100)
     443         assert [x[1] for x in nuJob.seqOut]\
     444                 == [start3+n3.serviceTime,start2+2*n2.serviceTime,90],\
     445                "Wrong service sequence/times: %s"%[x[1] for x in nuJob.seqOut]
     446
     447 -   def testrequestNestedPreempt(self):
     448        """Test that a process can preempt another process holding multiple resources
     449        """
     450        class Requestor(Process):
     451            def run(self,res1,res2,res3,priority=1):
     452                yield request,self,res1,priority
     453                yield request,self,res2,priority
     454                yield request,self,res3,priority
     455                record.observe(t=s.now(),y=self.name)
     456                yield hold,self,100
     457                record.observe(t=s.now(),y=self.name)
     458                yield release,self,res3
     459                yield release,self,res2
     460                yield release,self,res1
     461
     462        s=SimulationRT()
     463        s.initialize()
     464        outer=Resource(name="outer",qType=PriorityQ,preemptable=True,sim=s)
     465        inner=Resource(name="inner",qType=PriorityQ,preemptable=True,sim=s)
     466        innermost=Resource(name="innermost",qType=PriorityQ,preemptable=True,
     467                           sim=s)
     468        record=Monitor(sim=s)
     469        r1=Requestor("r1",sim=s)
     470        s.activate(r1,r1.run(res1=outer,res2=inner,res3=innermost,priority=1))
     471        r2=Requestor("r2",sim=s)
     472        s.activate(r2,r2.run(res1=outer,res2=inner,res3=innermost,priority=10),
     473                   at=50)
     474        s.simulate(until=200)
     475        assert record==[[0,"r1"],[50,"r2"],[150,"r2"],[200,"r1"]],\
     476                "was %s; preempt did not work"%record
     477
     478 -   def testmonitored(self):
     479        """ test monitoring of number in the two queues, waitQ and activeQ
     480        """
     481        class Job(Process):
     482            def __init__(self,name="",sim=None):
     483               Process.__init__(self,name=name,sim=sim)
     484
     485            def execute(self,res):
     486               yield request,self,res
     487               yield hold,self,2
     488               yield release,self,res
     489
     490        s=SimulationRT()
     491        s.initialize()
     492        res=Resource(name="server",capacity=1,monitored=1,sim=s)
     493        n1=Job(name="Job 1",sim=s)
     494        n2=Job(name="Job 2",sim=s)
     495        n3=Job(name="Job 3",sim=s)
     496        s.activate(n1,n1.execute(res),at=2)
     497        s.activate(n2,n2.execute(res),at=2)
     498        s.activate(n3,n3.execute(res),at=2) # 3 arrive at 2
     499        s.simulate(until=100)
     500        assert res.waitMon == [[2, 1], [2, 2], [4, 1], [6, 0]],\
     501               'Wrong waitMon:%s'%res.waitMon
     502        assert res.actMon == [[2, 1], [4, 0], [4, 1], [6, 0], [6, 1], [8, 0]],\
     503                'Wrong actMon:%s'%res.actMon
     504        self.assertAlmostEqual( res.waitMon.timeAverage(t=s.now()), (0*2+2*2+1*2)/6.0,2,
     505               'Wrong waitMon.timeAverage:%s'%res.waitMon.timeAverage(t=s.now()))
     506
     507 -def makeRSuite():
     508      suite = unittest.TestSuite()
     509      testInit = makeResourcetestcase("testInit")
     510      testrequest = makeResourcetestcase("testrequest")
     511      testrequest2 = makeResourcetestcase("testrequest2")
     512      testrequest3 = makeResourcetestcase("testrequest3")
     513      testrequest4 = makeResourcetestcase("testrequest4")
     514      testrequestPriority = makeResourcetestcase("testrequestPriority")
     515      testrequestPriority1 = makeResourcetestcase("testrequestPriority1")
     516      testrequestPriority2 = makeResourcetestcase("testrequestPriority2")
     517      testrequestPriority3 = makeResourcetestcase("testrequestPriority3")
     518      testrequestNestedPreempt = makeResourcetestcase("testrequestNestedPreempt")
     519      testmonitored = makeResourcetestcase("testmonitored")
     520
     521      suite.addTests([testInit,testrequest,testrequest2,testrequest3,testrequest4,
     522                      testrequestPriority,testrequestPriority1,
     523                      testrequestPriority2,testrequestPriority3,
     524                      testrequestNestedPreempt,
     525                      testmonitored])
     526      return suite
     527
     528  ##=====================================================
     529  ##                   Test Interrupts
     530  ##=====================================================
     531
     532 -class Interruptor(Process):
     533 -   def __init__(self,sim=None):
     534        Process.__init__(self,sim=sim)
     535
     536 -   def breakin(self,waitbefore,howoften=1):
     537        for i in range(howoften):
     538           yield hold,self,waitbefore
     539           self.interrupt(victim)
     540
     541 -class Interrupted(Process):
     542 -   def __init__(self,sim=None):
     543        Process.__init__(self,sim=sim)
     544
     545 -   def myActivity(self,howlong,theEnd=200):
     546        global igothit
     547        igothit={}
     548        while self.sim.now()<=theEnd:
     549           yield hold,self,howlong
     550           if self.interrupted():
     551              byWhom=self.interruptCause
     552              igothit[self.sim.now()]=byWhom
     553           else:
     554              pass
     555
     556 -class makeInterrupttestcase(unittest.TestCase):
     557     """
     558     Tests interrupts as defined in SEP001v17
     559     """
     560 -   def testInterrupt1(self):
     561        """
     562        Test single interrupt during victim activity
     563        """
     564        global victim
     565        s=SimulationRT()
     566        s.initialize()
     567        breaker=Interruptor(sim=s)
     568        s.activate(breaker,breaker.breakin(10))
     569        victim=Interrupted(sim=s)
     570        s.activate(victim,victim.myActivity(100))
     571        s.simulate(until=200)
     572        assert igothit[10] == breaker, "Not interrupted at 10 by breaker"
     573        assert len(igothit) == 1 , "Interrupted more than once"
     574
     575  #      assert len(igothit) == 3 , "Interrupted wrong number of times"
     576
     577 -   def testInterrupt2(self):
     578        """
     579        Test multiple interrupts during victim activity
     580        """
     581        global victim
     582        s=SimulationRT()
     583        s.initialize()
     584        breaker=Interruptor(sim=s)
     585        s.activate(breaker,breaker.breakin(10,howoften=3))
     586        victim=Interrupted(sim=s)
     587        s.activate(victim,victim.myActivity(100))
     588        s.simulate(until=200)
     589        for i in (10,20,30):
     590           assert igothit[i] == breaker, "Not interrupted at %s by breaker" %i
     591        assert len(igothit) == 3 , "Interrupted wrong number of times"
     592
     593 -   def testInterrupt3(self):
     594        """
     595        Test interrupts after victim activity
     596        """
     597        global victim
     598        s=SimulationRT()
     599        s.initialize()
     600        breaker=Interruptor(sim=s)
     601        s.activate(breaker,breaker.breakin(50,howoften=5))
     602        victim=Interrupted(sim=s)
     603        s.activate(victim,victim.myActivity(10,theEnd=10))
     604        s.simulate(until=200)
     605        assert len(igothit) == 0 , "There has been an interrupt after victim lifetime"
     606
     607 -   def testInterrupt4(self):
     608        """
     609        Test multiple interrupts by multiple processes during victim activity
     610        """
     611        global victim
     612        s=SimulationRT()
     613        s.initialize()
     614        breaker1=Interruptor(sim=s)
     615        s.activate(breaker1,breaker1.breakin(15,howoften=3))
     616        breaker2=Interruptor(sim=s)
     617        s.activate(breaker2,breaker2.breakin(20,howoften=3))
     618        victim=Interrupted(sim=s)
     619        s.activate(victim,victim.myActivity(100))
     620        s.simulate(until=200)
     621        for i in (15,30,45):
     622           assert igothit[i] == breaker1, "Not interrupted at %s by breaker1" %i
     623        for i in (20,40,60):
     624           assert igothit[i] == breaker2, "Not interrupted at %s by breaker2" %i
     625        assert len(igothit) == 6 , "Interrupted wrong number of times"
     626
     627 -   def testInterrupt5(self):
     628        """
     629        Test reset of 'interrupted' state.
     630        """
     631        global victim
     632        s=SimulationRT()
     633        s.initialize()
     634        breaker=Interruptor(sim=s)
     635        victim=Interrupted(sim=s)
     636
     637        def newProcess(self):
     638           while True:
     639              assert not self.interrupted(),"Incorrectly interrupted"
     640              yield hold,self,100
     641              if self.interrupted():
     642                 self.interruptReset()
     643                 assert not self.interrupted(),"Incorrectly interrupted"
     644
     645        victim.newProcess=newProcess
     646        s.activate(victim,newProcess(victim))
     647        s.activate(breaker,breaker.breakin(10,howoften=3))
     648        s.simulate(until=1000)
     649
     650 -def makeISuite():
     651     suite=unittest.TestSuite()
     652     testInterrupt1=makeInterrupttestcase("testInterrupt1")
     653     testInterrupt2=makeInterrupttestcase("testInterrupt2")
     654     testInterrupt3=makeInterrupttestcase("testInterrupt3")
     655     testInterrupt4=makeInterrupttestcase("testInterrupt4")
     656     testInterrupt5=makeInterrupttestcase("testInterrupt5")
     657     suite.addTests([testInterrupt1,testInterrupt2,testInterrupt3,
     658                     testInterrupt4,testInterrupt5])
     659     return suite
     660
     661  ## -------------------------------------------------------------
     662  ##                    TEST PROCESS STATES
     663  ## -------------------------------------------------------------
     664
     665 -class PS1(Process):
     666 -   def __init__(self,sim=None):
     667        Process.__init__(self,sim=sim)
     668
     669 -   def life1(self):
     670        yield hold,self,10
     671
     672 -   def life2(self):
     673        yield hold,self,10
     674        yield passivate,self
     675        yield hold,self,10
     676
     677 -class Observer1(Process):
     678 -   def __init__(self,sim=None):
     679        Process.__init__(self,sim=sim)
     680
     681 -   def look1(self,p):
     682        assert p.active(),"p not active"
     683        assert not p.passive(), "p passive"
     684        assert not p.terminated(),"p terminated"
     685        assert not p.interrupted(),"p interrupted"
     686        yield hold,self,11
     687        assert not p.active(),"p active"
     688        assert not p.passive(),"p passive"
     689        assert p.terminated(),"p not terminated"
     690        assert not p.interrupted(),"p interrupted"
     691
     692 -   def look2(self,p):
     693        assert not p.active(),"p active"
     694        assert p.passive(),"p not passive"
     695        assert not p.terminated(),"p not terminated"
     696        assert not p.interrupted(),"p interrupted"
     697        self.sim.activate(p,p.life1())
     698        yield hold,self,11
     699        assert not p.active(),"p active"
     700        assert not p.passive(),"p not passive"
     701        assert p.terminated(),"p not terminated"
     702        assert not p.interrupted(),"p interrupted"
     703
     704 -   def look3(self,p):
     705        assert not p.active(),"p active"
     706        assert p.passive(),"p not passive"
     707        assert not p.terminated(),"p not terminated"
     708        assert not p.interrupted(),"p interrupted"
     709        self.sim.activate(p,p.life2())
     710        yield hold,self,11
     711        assert not p.active(),"p active"
     712        assert p.passive(),"p not passive"
     713        assert not p.terminated(),"p terminated"
     714        assert not p.interrupted(),"p interrupted"
     715
     716 -   def look4(self,p):
     717        yield hold,self,5
     718        assert p.active(),"p not active"
     719        assert not p.passive(),"p passive"
     720        assert not p.terminated(),"p terminated"
     721        assert not p.interrupted(),"p interrupted"
     722        self.cancel(p)
     723        assert not p.active(),"p active"
     724        assert p.passive(),"p not passive"
     725        assert not p.terminated(),"p terminated"
     726        assert not p.interrupted(),"p interrupted"
     727        self.sim.reactivate(p)
     728        assert p.active(),"p not active"
     729        assert not p.passive(),"p passive"
     730        assert not p.terminated(),"p terminated"
     731        assert not p.interrupted(),"p interrupted"
     732        yield hold,self
     733        assert not p.active(),"p active"
     734        assert not p.passive(),"p passive"
     735        assert p.terminated(),"p terminated"
     736        assert not p.interrupted(),"p interrupted"
     737
     738 -   def look5(self,p):
     739        yield hold,self,11
     740        assert not p.active(),"p active"
     741        assert p.passive(),"p not passive"
     742        assert not p.terminated(),"p terminated"
     743        assert not p.interrupted(),"p interrupted"
     744        self.cancel(p)
     745        assert not p.active(),"p active"
     746        assert p.passive(),"p not passive"
     747        assert not p.terminated(),"p terminated"
     748        assert not p.interrupted(),"p interrupted"
     749
     750 -class PS2(Process):
     751 -   def __init__(self,sim=None):
     752        Process.__init__(self,sim=sim)
     753
     754 -   def life1(self,res):
     755        yield hold,self,1
     756        yield request,self,res
     757        yield hold,self,5
     758        yield request,self,res
     759
     760 -   def life2(self,res):
     761        yield request,self,res
     762        assert self.interrupted(),"p not interrupted"
     763        assert self.queuing(res)
     764        self.interruptReset()
     765        assert not self.interrupted(), "p interrupted"
     766        assert self.queuing(res)
     767
     768 -class Observer2(Process):
     769 -   def __init__(self,sim=None):
     770        Process.__init__(self,sim=sim)
     771
     772 -   def look1(self,p1,p2,res):
     773        assert p1.active(), "p1 not active"
     774        assert not p1.queuing(res), "p1 queuing"
     775        assert p2.active(), "p2 not active"
     776        assert not p2.queuing(res), "p2 queuing"
     777        yield hold,self,2
     778        assert p1.active(), "p1 not active"
     779        assert not p1.queuing(res), "p1 queuing"
     780        assert p2.passive(), "p2 active"
     781        assert p2.queuing(res), "p2 not queuing"
     782
     783 -   def look2(self,p,res):
     784        yield request,self,res
     785        yield hold,self,5
     786        assert p.passive(),"p not passive"
     787        assert p.queuing(res),"p not queuing for resource"
     788        assert not p.interrupted(), "p interrupted"
     789        self.interrupt(p)
     790        yield hold,self
     791
     792 -class makePStatetestcase(unittest.TestCase):
     793     """
     794     Tests states and state transitions as defined in SEP003
     795     """
     796
     797 -   def testState1(self):
     798        """
     799        Tests state transitions by hold
     800        """
     801        ## active => hold => terminated
     802        s=SimulationRT()
     803        s.initialize()
     804        p=PS1(sim=s)
     805        s.activate(p,p.life1())
     806        ob=Observer1(sim=s)
     807        s.activate(ob,ob.look1(p),prior=True)
     808        s.simulate(until=12)
     809
     810 -   def testState2(self):
     811        """
     812        Tests state transitions by activate and passivate
     813        """
     814        ## passive => activate => hold => terminated
     815        s=SimulationRT()
     816        s.initialize()
     817        p=PS1(sim=s)
     818        ob1=Observer1(sim=s)
     819        s.activate(ob1,ob1.look2(p))
     820        s.simulate(until=12)
     821        ## passive => activate => hold => active => passivate => passive
     822        s=SimulationRT()
     823        s.initialize()
     824        p1=PS1(sim=s)
     825        ob2=Observer1(sim=s)
     826        s.activate(ob2,ob2.look3(p1),prior=True)
     827        s.simulate(until=12)
     828
     829 -   def testState3(self):
     830        """
     831        Tests state transitions by cancel()
     832        """
     833        ## active => cancel => passive => reactivate => active => terminated
     834        s=SimulationRT()
     835        s.initialize()
     836        p2=PS1(sim=s)
     837        s.activate(p2,p2.life1())
     838        ob3=Observer1(sim=s)
     839        s.activate(ob3,ob3.look4(p2))
     840        s.simulate(until=12)
     841
     842        ## passive => cancel => passive
     843        s=SimulationRT()
     844        s.initialize()
     845        p3=PS1(sim=s)
     846        s.activate(p3,p3.life2())
     847        ob4=Observer1(sim=s)
     848        s.activate(ob4,ob4.look5(p3))
     849        s.simulate(until=12)
     850
     851 -   def testState4(self):
     852        """
     853        Test request/release state transitions
     854        """
     855        ## not queuing,active => request => queuing,passive => release => not queuing,active
     856        s=SimulationRT()
     857        s.initialize()
     858        res=Resource(capacity=1,sim=s)
     859        pq1=PS2(sim=s)
     860        s.activate(pq1,pq1.life1(res))
     861        pq2=PS2(sim=s)
     862        s.activate(pq2,pq2.life1(res))
     863        obq1=Observer2(sim=s)
     864        s.activate(obq1,obq1.look1(pq1,pq2,res))
     865        s.simulate(until=12)
     866
     867        ## queuing,passive => interrupt =>  queuing, interrupted => interruptRest => queuing, not interrupted
     868        s=SimulationRT()
     869        s.initialize()
     870        res=Resource(capacity=1,sim=s)
     871        pq3=PS2(sim=s)
     872        s.activate(pq3,pq3.life2(res))
     873        obq2=Observer2(sim=s)
     874        s.activate(obq2,obq2.look2(pq3,res),prior=True)
     875        s.simulate(until=12)
     876
     877 -def makePSuite():
     878     suite=unittest.TestSuite()
     879     testState1=makePStatetestcase("testState1")
     880     testState2=makePStatetestcase("testState2")
     881     testState3=makePStatetestcase("testState3")
     882     testState4=makePStatetestcase("testState4")
     883
     884     suite.addTests([testState1,testState2,testState3,testState4])
     885     return suite
     886
     887  ## -------------------------------------------------------------
     888  ##                    TEST Events/Signals
     889  ## -------------------------------------------------------------
     890
     891 -class SignalProcess(Process):
     892 -   def __init__(self,**var):
     893         Process.__init__(self,**var)
     894 -   def makeSignal(self,ev1,ev2):
     895        yield hold,self,1
     896        ev1.signal("from SignalProcess")
     897        while ev2.queues:
     898           nq0=len(ev2.queues)
     899           ev2.signal("from SignalProcess")
     900           assert len(ev2.queues)==(nq0-1),"wrong number of processes dequeued"
     901
     902 -class WaitProcess(Process):
     903 -   def __init__(self,**var):
     904         Process.__init__(self,**var)
     905 -   def waitForSig(self,ev1):
     906        yield waitevent,self,ev1
     907        assert ev1.waits==[],"not all processes waiting for event out of waiting list"
     908        assert ev1 in self.eventsFired,"did not record firing event"
     909
     910 -class QueueProcess(Process):
     911 -   def __init__(self,**var):
     912         Process.__init__(self,**var)
     913 -   def queueForSig(self,ev2):
     914        yield queueevent,self,ev2
     915        assert ev2 in self.eventsFired,"did not record firing event"
     916
     917 -class SignalProcessOR(Process):
     918 -   def makeSignal(self,ev1,ev2):
     919        yield hold,self,1
     920        ev1.signal("from SignalProcess")
     921        yield hold,self,3
     922        assert len(ev2.queues)==QueueProcessOR.nrProcesses,"wrong number of processes queuing for event ev2"
     923        while ev2.queues:
     924           nq0=len(ev2.queues)
     925           ev2.signal("from SignalProcess")
     926           assert len(ev2.queues)==(nq0-1),"wrong number of processes dequeued"
     927        assert not ev2.queues,"not all processes queuing for ev2 dequeued"
     928
     929 -class WaitProcessOR(Process):
     930 -   def __init__(self,**var):
     931         Process.__init__(self,**var)
     932 -   def waitForSig(self,evset):
     933        yield waitevent,self,evset
     934        for e in evset:
     935           assert e.waits==[],"process not out of waiting list for all events in OR"
     936
     937 -class WaitProcessOR1(Process):
     938 -    def __init__(self,**var):
     939         Process.__init__(self,**var)
     940 -    def signalandwait(self):
     941        e1=SimEvent(sim=self.sim)
     942        e1.signal()
     943        e2=SimEvent(sim=self.sim)
     944        e2.signal()
     945        yield waitevent,self,[e1,e2]
     946        assert self.eventsFired==[e1,e2],"eventsFired does not report all events"
     947
     948
     949 -class QueueProcessOR(Process):
     950      nrProcesses=0
     951 -    def __init__(self,sim=None):
     952          Process.__init__(self,sim=sim)
     953          QueueProcessOR.nrProcesses+=1
     954 -    def queueForSig(self,evset):
     955        yield queueevent,self,evset
     956        occurred=False
     957        for e in evset:
     958            occurred=occurred or (e in self.eventsFired)
     959        assert occurred,"queuing process activated by wrong event(s)"
     960
     961 -class QueueProcessOR1(Process):
     962 -    def __init__(self,**var):
     963         Process.__init__(self,**var)
     964 -    def signalandqueue(self):
     965          e1=SimEvent(sim=self.sim)
     966          e1.signal()
     967          e2=SimEvent(sim=self.sim)
     968          e2.signal()
     969          yield queueevent,self,[e1,e2]
     970          assert self.eventsFired==[e1,e2],\
     971                  "(queueevent) eventsFired does not report all fired events"
     972
     973 -class makeEtestcase(unittest.TestCase):
     974     """
     975     Test SimEvent/signal as introduced with SimPy 1.5
     976     """
     977
     978 -   def testSimEvents1(self):
     979        """
     980        Tests basic signal semantics
     981        """
     982        s=SimulationRT()
     983        s.initialize()
     984        e=SimEvent(sim=s)
     985        e.signal("param")
     986        assert e.occurred,"signal does not set 'occurred' to True"
     987        assert e.signalparam=="param","signal parameter wrong"
     988        e.signal()
     989        assert e.signalparam is None,"signal with no parameter did not overwrite signalparam"
     990        e.signal()
     991        assert e.occurred,"multiple calls to signal do not set 'occurred'"
     992
     993 -   def testSimEvents2(self):
     994        """
     995        Tests basic waiting and queuing semantics
     996        """
     997        s=SimulationRT()
     998        s.initialize()
     999        ev1=SimEvent("ev1",sim=s)
    1000        ev2=SimEvent("ev2",sim=s)
    1001        w1=WaitProcess(sim=s)
    1002        s.activate(w1,w1.waitForSig(ev1))
    1003        w2=WaitProcess(sim=s)
    1004        s.activate(w2,w2.waitForSig(ev1))
    1005        for i in range(3):
    1006           q=QueueProcess(sim=s)
    1007           s.activate(q,q.queueForSig(ev2))
    1008        s.simulate(until=2)
    1009
    1010 -   def testSimEvents3(self):
    1011        """
    1012        Tests waiting, queuing for at least one event out of a list/tuple.
    1013        """
    1014        si=SimulationRT()
    1015        si.initialize()
    1016        e1=SimEvent("e1",sim=si)
    1017        e2=SimEvent("e2",sim=si)
    1018        e3=SimEvent("e3",sim=si)
    1019        s=SignalProcessOR(sim=si)
    1020        si.activate(s,s.makeSignal(e1,e3))
    1021        w=WaitProcessOR(sim=si)
    1022        si.activate(w,w.waitForSig([e1,e2]))
    1023        for i in range(5):
    1024           q=QueueProcessOR(sim=si)
    1025           si.activate(q,q.queueForSig([e2,e3]))
    1026        si.simulate(until=10)
    1027
    1028 -   def testSimEvents4(self):
    1029        """Tests that eventsFired reports all events which fired
    1030        """
    1031        s=SimulationRT()
    1032        s.initialize()
    1033        w=WaitProcessOR1(sim=s)
    1034        s.activate(w,w.signalandwait())
    1035        s.simulate(until=5)
    1036
    1037 -   def testSimEvents5(self):
    1038        """Tests that eventsFired reports all events which fired
    1039        """
    1040        s=SimulationRT()
    1041        s.initialize()
    1042        w=QueueProcessOR1(sim=s)
    1043        s.activate(w,w.signalandqueue())
    1044        s.simulate(until=5)
    1045
    1046 -def makeESuite():
    1047     suite=unittest.TestSuite()
    1048     testSimEvents1=makeEtestcase("testSimEvents1")
    1049     testSimEvents2=makeEtestcase("testSimEvents2")
    1050     testSimEvents3=makeEtestcase("testSimEvents3")
    1051     testSimEvents4=makeEtestcase("testSimEvents4")
    1052     testSimEvents5=makeEtestcase("testSimEvents5")
    1053     suite.addTests([testSimEvents1,testSimEvents2,testSimEvents3,
    1054                     testSimEvents4,testSimEvents5])
    1055     return suite
    1056
    1057  ## -------------------------------------------------------------
    1058  ##                    TEST waituntil
    1059  ## -------------------------------------------------------------
    1060
    1061 -class Signaller(Process):
    1062 -    def __init__(self,sim=None):
    1063          Process.__init__(self,sim=sim)
    1064 -    def makeconditions(self,waiter):
    1065          global a,b,c
    1066          a=True
    1067          yield hold,self,1
    1068          b=True
    1069          yield hold,self,1
    1070          c=True
    1071          yield hold,self,1
    1072          assert waiter.terminated(),"waituntil did not fire"
    1073
    1074 -class Waiter(Process):
    1075 -    def __init__(self,sim=None):
    1076          Process.__init__(self,sim=sim)
    1077 -    def waitforit(self):
    1078          def waitcond():
    1079              return a and b and c
    1080          yield waituntil,self,waitcond
    1081
    1082 -class makeWtestcase(unittest.TestCase):
    1083     """
    1084     Test waituntil as introduced with SimPy 1.5
    1085     """
    1086
    1087 -   def testwaituntil1(self):
    1088         global a,b,c
    1089         a=b=c=False
    1090         si=SimulationRT()
    1091         si.initialize()
    1092         w=Waiter(sim=si)
    1093         si.activate(w,w.waitforit())
    1094         s=Signaller(sim=si)
    1095         si.activate(s,s.makeconditions(w))
    1096         si.simulate(until=5)
    1097
    1098 -def makeWSuite():
    1099     suite=unittest.TestSuite()
    1100     testwaituntil1=makeWtestcase("testwaituntil1")
    1101     suite.addTests([testwaituntil1])
    1102     return suite
    1103
    1104  ## -------------------------------------------------------------
    1105  ##                    TEST COMPOUND "YIELD REQUEST" COMMANDS
    1106  ## -------------------------------------------------------------
    1107
    1108  ## -------------------------------------------------------------
    1109  ##             TEST "yield (request,self,res),(hold,self,delay)"
    1110  ##                   == timeout renege
    1111  ##             for both unmonitored and monitored resources
    1112  ## -------------------------------------------------------------
    1113
    1114 -class JobTO(Process):
    1115     """ Job class for testing timeout reneging
    1116     """
    1117 -   def __init__(self,server=None,name="",sim=None):
    1118          Process.__init__(self,name=name,sim=sim)
    1119          self.res=server
    1120          self.gotResource=None
    1121
    1122 -   def execute(self,timeout,usetime):
    1123          yield (request,self,self.res),(hold,self,timeout)
    1124          if self.acquired(self.res):
    1125              self.gotResource=True
    1126              yield hold,self,usetime
    1127              yield release,self,self.res
    1128          else:
    1129              self.gotResource=False
    1130
    1131 -class JobTO_P(Process):
    1132     """ Job class for testing timeout reneging with priorities
    1133     """
    1134 -   def __init__(self,server=None,name="",sim=None):
    1135          Process.__init__(self,name=name,sim=sim)
    1136          self.res=server
    1137          self.gotResource=None
    1138
    1139 -   def execute(self,timeout,usetime,priority):
    1140          yield (request,self,self.res,priority),(hold,self,timeout)
    1141          if self.acquired(self.res):
    1142              self.gotResource=True
    1143              yield hold,self,usetime
    1144              yield release,self,self.res
    1145          else:
    1146              self.gotResource=False
    1147
    1148 -class makeTimeoutTestcase(unittest.TestCase):
    1149      """ Tests of "yield (request,self,res),(hold,self,delay)"
    1150          timeout reneging command
    1151      """
    1152 -    def testNoTimeout(self):
    1153          """Test that resource gets acquired without timeout
    1154          """
    1155
    1156          s=SimulationRT()
    1157          s.initialize()
    1158          res=Resource(name="Server",capacity=1,sim=s)
    1159          usetime=5
    1160          timeout=1000000
    1161          j1=JobTO(server=res,name="Job_1",sim=s)
    1162          s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
    1163          j2=JobTO(server=res,name="Job_2",sim=s)
    1164          s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
    1165          s.simulate(until=2*usetime)
    1166          assert s.now()==2*usetime,"time not ==2*usetime"
    1167          assert j1.gotResource and j2.gotResource,\
    1168              "at least one job failed to get resource"
    1169          assert not (res.waitQ or res.activeQ),\
    1170              "job waiting or using resource"
    1171
    1172 -    def testNoTimeoutM(self):
    1173          """Test that resource gets acquired without timeout.
    1174             Resource monitored.
    1175          """
    1176
    1177          s=SimulationRT()
    1178          s.initialize()
    1179          res=Resource(name="Server",capacity=1,monitored=True,sim=s)
    1180          usetime=5
    1181          timeout=1000000
    1182          j1=JobTO(server=res,name="Job_1",sim=s)
    1183          s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
    1184          j2=JobTO(server=res,name="Job_2",sim=s)
    1185          s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
    1186          s.simulate(until=2*usetime)
    1187          assert s.now()==2*usetime,"time not ==2*usetime"
    1188          assert j1.gotResource and j2.gotResource,\
    1189              "at least one job failed to get resource"
    1190          assert not (res.waitQ or res.activeQ),\
    1191              "job waiting or using resource"
    1192          assert res.waitMon==[[0,1],[usetime,0]],"res.waitMon wrong: %s"%res.waitMon
    1193
    1194 -    def testTimeout1(self):
    1195          """Test that timeout occurs when resource busy
    1196          """
    1197
    1198          s=SimulationRT()
    1199          s.initialize()
    1200          res=Resource(name="Server",capacity=1,sim=s)
    1201          usetime=5
    1202          timeout=3
    1203          j1=JobTO(server=res,name="Job_1",sim=s)
    1204          s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
    1205          j2=JobTO(server=res,name="Job_2",sim=s)
    1206          s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
    1207          s.simulate(until=2*usetime)
    1208          assert(s.now()==usetime),"time not ==usetime"
    1209          assert(j1.gotResource),"Job_1 did not get resource"
    1210          assert(not j2.gotResource),"Job_2 did not renege"
    1211          assert not (res.waitQ or res.activeQ),\
    1212              "job waiting or using resource"
    1213
    1214 -    def testTimeout1M(self):
    1215          """Test that timeout occurs when resource busy.
    1216             Resource monitored.
    1217          """
    1218          s=SimulationRT()
    1219          s.initialize()
    1220          res=Resource(name="Server",capacity=1,monitored=True,sim=s)
    1221          usetime=5
    1222          timeout=3
    1223          j1=JobTO(server=res,name="Job_1",sim=s)
    1224          s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
    1225          j2=JobTO(server=res,name="Job_2",sim=s)
    1226          s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
    1227          s.simulate(until=2*usetime)
    1228          assert(s.now()==usetime),"time not == usetime"
    1229          assert(j1.gotResource),"Job_1 did not get resource"
    1230          assert(not j2.gotResource),"Job_2 did not renege"
    1231          assert not (res.waitQ or res.activeQ),\
    1232              "job waiting or using resource"
    1233          assert res.waitMon==[[0,1],[timeout,0]],"res.waitMon wrong: %s"%res.waitMon
    1234
    1235 -    def testTimeout_MP(self):
    1236          """Test that timeout occurs when resource busy.
    1237             Resource monitored. Requests with priority and preemption.
    1238          """
    1239          s=SimulationRT()
    1240          s.initialize()
    1241          res=Resource(name="Server",capacity=1,monitored=True,
    1242                       qType=PriorityQ,preemptable=True,sim=s)
    1243          usetime=5
    1244          timeout=3
    1245          j1=JobTO_P(server=res,name="Job_1",sim=s)
    1246          s.activate(j1,j1.execute(timeout=timeout,usetime=usetime,priority=1))
    1247          j2=JobTO_P(server=res,name="Job_2",sim=s)
    1248          j2_arrival=1
    1249          s.activate(j2,j2.execute(timeout=timeout,usetime=usetime,priority=5),
    1250                     at=j2_arrival)
    1251          j3=JobTO_P(server=res,name="Job_2",sim=s)
    1252          j3_arrival=2
    1253          s.activate(j3,j3.execute(timeout=timeout,usetime=usetime,priority=10),
    1254                     at=j3_arrival)
    1255          s.simulate(until=3*usetime)
    1256          assert(s.now()== 3*usetime),"time not == 2* usetime, but %s"%now()
    1257          assert(j1.gotResource),"Job_1 did not get resource"
    1258          assert(j2.gotResource),"Job_2 did renege"
    1259          assert(j2.gotResource),"Job_3 did renege"
    1260          assert not (res.waitQ or res.activeQ),\
    1261              "job waiting or using resource"
    1262          assert res.waitMon==[[j2_arrival,1],[j3_arrival,2],[usetime+j3_arrival,1],[usetime+j2_arrival+usetime,0]],\
    1263               "res.waitMon wrong: %s"%res.waitMon
    1264
    1265 -    def testTimeout2(self):
    1266          """Test that timeout occurs when resource has no capacity free
    1267          """
    1268
    1269          s=SimulationRT()
    1270          s.initialize()
    1271          res=Resource(name="Server",capacity=0,sim=s)
    1272          usetime=5
    1273          timeout=3
    1274          j1=JobTO(server=res,name="Job_1",sim=s)
    1275          s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
    1276          j2=JobTO(server=res,name="Job_2",sim=s)
    1277          s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
    1278          s.simulate(until=2*usetime)
    1279          assert s.now()==timeout,"time %s not == timeout"%s.now()
    1280          assert not j1.gotResource,"Job_1 got resource"
    1281          assert not j2.gotResource,"Job_2 got resource"
    1282          assert not (res.waitQ or res.activeQ),\
    1283                 "job waiting or using resource"
    1284
    1285 -    def testTimeout2M(self):
    1286          """Test that timeout occurs when resource has no capacity free.
    1287             Resource monitored.
    1288          """
    1289
    1290          s=SimulationRT()
    1291          s.initialize()
    1292          res=Resource(name="Server",capacity=0,monitored=True,sim=s)
    1293          usetime=5
    1294          timeout=3
    1295          j1=JobTO(server=res,name="Job_1",sim=s)
    1296          s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
    1297          j2=JobTO(server=res,name="Job_2",sim=s)
    1298          s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
    1299          s.simulate(until=2*usetime)
    1300          assert s.now()==timeout,"time %s not == timeout"%s.now()
    1301          assert not j1.gotResource,"Job_1 got resource"
    1302          assert not j2.gotResource,"Job_2 got resource"
    1303          assert not (res.waitQ or res.activeQ),\
    1304              "job waiting or using resource"
    1305          assert res.waitMon==[[0,1],[0,2],[timeout,1],[timeout,0]],\
    1306              "res.waitMon is wrong: %s"%res.waitMon
    1307
    1308 -def makeTOSuite():
    1309      suite = unittest.TestSuite()
    1310      testNoTimeout = makeTimeoutTestcase("testNoTimeout")
    1311      testNoTimeoutM = makeTimeoutTestcase("testNoTimeoutM")
    1312      testTimeout1=makeTimeoutTestcase("testTimeout1")
    1313      testTimeout1M=makeTimeoutTestcase("testTimeout1M")
    1314      testTimeout_MP=makeTimeoutTestcase("testTimeout_MP")
    1315      testTimeout2=makeTimeoutTestcase("testTimeout2")
    1316      testTimeout2M=makeTimeoutTestcase("testTimeout2M")
    1317      suite.addTests([testNoTimeout,testNoTimeoutM,testTimeout1,
    1318                      testTimeout1M,testTimeout_MP,testTimeout2,
    1319                      testTimeout2M])
    1320      return suite
    1321
    1322  ## ------------------------------------------------------------------
    1323  ##             TEST "yield (request,self,res),(waitevent,self,event)"
    1324  ##                   == event renege
    1325  ##             for both unmonitored and monitored resources
    1326  ## ------------------------------------------------------------------
    1327
    1328
    1329 -class JobEvt(Process):
    1330     """ Job class for testing event reneging
    1331     """
    1332 -   def __init__(self,server=None,name="",sim=None):
    1333          Process.__init__(self,name=name,sim=sim)
    1334          self.res=server
    1335          self.gotResource=None
    1336
    1337 -   def execute(self,event,usetime):
    1338          yield (request,self,self.res),(waitevent,self,event)
    1339          if self.acquired(self.res):
    1340              self.gotResource=True
    1341              yield hold,self,usetime
    1342              yield release,self,self.res
    1343          else:
    1344              self.gotResource=False
    1345
    1346 -class JobEvtMulti(Process):
    1347     """ Job class for testing event reneging with multi-event lists
    1348     """
    1349 -   def __init__(self,server=None,name="",sim=None):
    1350          Process.__init__(self,name=name,sim=sim)
    1351          self.res=server
    1352          self.gotResource=None
    1353
    1354 -   def execute(self,eventlist,usetime):
    1355          yield (request,self,self.res),(waitevent,self,eventlist)
    1356          if self.acquired(self.res):
    1357              self.gotResource=True
    1358              yield hold,self,usetime
    1359              yield release,self,self.res
    1360          else:
    1361              self.gotResource=False
    1362
    1363 -class FireEvent(Process):
    1364      """Fires reneging event
    1365      """
    1366 -    def __init__(self,name="",sim=None):
    1367          Process.__init__(self,name=name,sim=sim)
    1368 -    def fire(self,fireDelay,event):
    1369          yield hold,self,fireDelay
    1370          event.signal()
    1371
    1372 -class makeEventRenegeTestcase(unittest.TestCase):
    1373      """Tests of "yield (request,self,res),(waiteevent,self,event)"
    1374         event reneging command
    1375      """
    1376 -    def testNoEvent(self):
    1377          """Test that processes acquire resource normally if no event fires
    1378          """
    1379          s=SimulationRT()
    1380          s.initialize()
    1381          event=SimEvent("Renege_trigger",sim=s) #never gets fired
    1382          res=Resource(name="Server",capacity=1,sim=s)
    1383          usetime=5
    1384          j1=JobEvt(server=res,name="Job_1",sim=s)
    1385          s.activate(j1,j1.execute(event=event,usetime=usetime))
    1386          j2=JobEvt(server=res,name="Job_2",sim=s)
    1387          s.activate(j2,j2.execute(event=event,usetime=usetime))
    1388          s.simulate(until=2*usetime)
    1389          # Both jobs should get server (in sequence)
    1390          assert s.now()==2*usetime,"time not ==2*usetime"
    1391          assert j1.gotResource and j2.gotResource,\
    1392              "at least one job failed to get resource"
    1393          assert not (res.waitQ or res.activeQ),\
    1394              "job waiting or using resource"
    1395
    1396 -    def testNoEventM(self):
    1397          """Test that processes acquire resource normally if no event fires.
    1398             Resource monitored.
    1399          """
    1400          s=SimulationRT()
    1401          s.initialize()
    1402          res=Resource(name="Server",capacity=1,monitored=True,sim=s)
    1403          event=SimEvent("Renege_trigger",sim=s) #never gets fired
    1404          usetime=5
    1405          j1=JobEvt(server=res,name="Job_1",sim=s)
    1406          s.activate(j1,j1.execute(event=event,usetime=usetime))
    1407          j2=JobEvt(server=res,name="Job_2",sim=s)
    1408          s.activate(j2,j2.execute(event=event,usetime=usetime))
    1409          s.simulate(until=2*usetime)
    1410          # Both jobs should get server (in sequence)
    1411          assert s.now()==2*usetime,"time not ==2*usetime"
    1412          assert j1.gotResource and j2.gotResource,\
    1413              "at least one job failed to get resource"
    1414          assert not (res.waitQ or res.activeQ),\
    1415              "job waiting or using resource"
    1416          assert res.waitMon==[[0,1],[usetime,0]],"res.waitMoni is wrong: %s"%res.waitMon
    1417
    1418 -    def testWaitEvent1(self):
    1419          """Test that signalled event leads to renege when resource busy
    1420          """
    1421
    1422          s=SimulationRT()
    1423          s.initialize()
    1424          res=Resource(name="Server",capacity=1,sim=s)
    1425          event=SimEvent("Renege_trigger",sim=s)
    1426          usetime=5
    1427          eventtime=1
    1428          j1=JobEvt(server=res,name="Job_1",sim=s)
    1429          s.activate(j1,j1.execute(event=event,usetime=usetime))
    1430          j2=JobEvt(server=res,name="Job_2",sim=s)
    1431          s.activate(j2,j2.execute(event=event,usetime=usetime))
    1432          f=FireEvent(name="FireEvent",sim=s)
    1433          s.activate(f,f.fire(fireDelay=eventtime,event=event))
    1434          s.simulate(until=2*usetime)
    1435          # Job_1 should get server, Job_2 renege
    1436          assert(s.now()==usetime),"time not ==usetime"
    1437          assert(j1.gotResource),"Job_1 did not get resource"
    1438          assert(not j2.gotResource),"Job_2 did not renege"
    1439          assert not (res.waitQ or res.activeQ),\
    1440              "job waiting or using resource"
    1441
    1442 -    def testWaitEvent1M(self):
    1443          """Test that signalled event leads to renege when resource busy.
    1444             Resource monitored.
    1445          """
    1446
    1447          s=SimulationRT()
    1448          s.initialize()
    1449          res=Resource(name="Server",capacity=1,monitored=True,sim=s)
    1450          event=SimEvent("Renege_trigger",sim=s)
    1451          usetime=5
    1452          eventtime=1
    1453          j1=JobEvt(server=res,name="Job_1",sim=s)
    1454          s.activate(j1,j1.execute(event=event,usetime=usetime))
    1455          j2=JobEvt(server=res,name="Job_2",sim=s)
    1456          s.activate(j2,j2.execute(event=event,usetime=usetime))
    1457          f=FireEvent(name="FireEvent",sim=s)
    1458          s.activate(f,f.fire(fireDelay=eventtime,event=event))
    1459          s.simulate(until=2*usetime)
    1460          # Job_1 should get server, Job_2 renege
    1461          assert(s.now()==usetime),"time not == usetime"
    1462          assert(j1.gotResource),"Job_1 did not get resource"
    1463          assert(not j2.gotResource),"Job_2 did not renege"
    1464          assert not (res.waitQ or res.activeQ),\
    1465              "job waiting or using resource"
    1466          assert res.waitMon==[[0,1],[eventtime,0]],"res.waitMon is wrong: %s"%res.waitMon
    1467
    1468 -    def testWaitEvent2(self):
    1469          """Test that renege-triggering event can be one of an event list
    1470          """
    1471
    1472          s=SimulationRT()
    1473          s.initialize()
    1474          res=Resource(name="Server",capacity=1,sim=s)
    1475          event1=SimEvent("Renege_trigger_1",sim=s)
    1476          event2=SimEvent("Renege_trigger_2",sim=s)
    1477          usetime=5
    1478          eventtime=1 #for both events
    1479          j1=JobEvtMulti(server=res,name="Job_1",sim=s)
    1480          s.activate(j1,j1.execute(eventlist=[event1,event2],usetime=usetime))
    1481          j2=JobEvtMulti(server=res,name="Job_2",sim=s)
    1482          s.activate(j2,j2.execute(eventlist=[event1,event2],usetime=usetime))
    1483          f1=FireEvent(name="FireEvent_1",sim=s)
    1484          s.activate(f1,f1.fire(fireDelay=eventtime,event=event1))
    1485          f2=FireEvent(name="FireEvent_2",sim=s)
    1486          s.activate(f2,f2.fire(fireDelay=eventtime,event=event2))
    1487          s.simulate(until=2*usetime)
    1488          # Job_1 should get server, Job_2 should renege
    1489          assert(s.now()==usetime),"time not ==usetime"
    1490          assert(j1.gotResource),"Job_1 did not get resource"
    1491          assert(not j2.gotResource),"Job_2 did not renege"
    1492          assert not (res.waitQ or res.activeQ),\
    1493              "job waiting or using resource"
    1494
    1495 -    def testWaitEvent2M(self):
    1496          """Test that renege-triggering event can be one of an event list.
    1497             Resource monitored.
    1498          """
    1499
    1500          s=SimulationRT()
    1501          s.initialize()
    1502          res=Resource(name="Server",capacity=1,monitored=True,sim=s)
    1503          event1=SimEvent("Renege_trigger_1",sim=s)
    1504          event2=SimEvent("Renege_trigger_2",sim=s)
    1505          usetime=5
    1506          eventtime=1 #for both events
    1507          j1=JobEvtMulti(server=res,name="Job_1",sim=s)
    1508          s.activate(j1,j1.execute(eventlist=[event1,event2],usetime=usetime))
    1509          j2=JobEvtMulti(server=res,name="Job_2",sim=s)
    1510          s.activate(j2,j2.execute(eventlist=[event1,event2],usetime=usetime))
    1511          f1=FireEvent(name="FireEvent_1",sim=s)
    1512          s.activate(f1,f1.fire(fireDelay=eventtime,event=event1))
    1513          f2=FireEvent(name="FireEvent_2",sim=s)
    1514          s.activate(f2,f2.fire(fireDelay=eventtime,event=event2))
    1515          s.simulate(until=2*usetime)
    1516          # Job_1 should get server, Job_2 should renege
    1517          assert(s.now()==usetime),"time not ==usetime"
    1518          assert(j1.gotResource),"Job_1 did not get resource"
    1519          assert(not j2.gotResource),"Job_2 did not renege"
    1520          assert not (res.waitQ or res.activeQ),\
    1521              "job waiting or using resource"
    1522          assert res.waitMon==[[0,1],[eventtime,0]],"res.waitMon is wrong: %s"%res.waitMon
    1523
    1524 -def makeEvtRenegeSuite():
    1525      suite = unittest.TestSuite()
    1526      testNoEvent = makeEventRenegeTestcase("testNoEvent")
    1527      testNoEventM = makeEventRenegeTestcase("testNoEventM")
    1528      testWaitEvent1=makeEventRenegeTestcase("testWaitEvent1")
    1529      testWaitEvent1M=makeEventRenegeTestcase("testWaitEvent1M")
    1530      testWaitEvent2=makeEventRenegeTestcase("testWaitEvent2")
    1531      testWaitEvent2M=makeEventRenegeTestcase("testWaitEvent2M")
    1532
    1533      suite.addTests([testNoEvent,testNoEventM,testWaitEvent1,
    1534                      testWaitEvent1M,testWaitEvent2,testWaitEvent2M])
    1535      return suite
    1536
    1537  ## ------------------------------------------------------------------
    1538  ##             TEST "yield get,self,level,whatToGet" and
    1539  ##                  "yield put,self,level,whatToPut,priority"
    1540  ##             for Level instances
    1541  ## ------------------------------------------------------------------
    1542 -class Producer(Process):
    1543      produced=0
    1544 -    def __init__(self,name="",sim=None):
    1545          Process.__init__(self,name=name,sim=sim)
    1546 -    def produce(self,buffer):
    1547          for i in range(4):
    1548              Producer.produced+=1
    1549              yield put,self,buffer
    1550              yield hold,self,1
    1551 -    def producePriority(self,buffer,priority):
    1552          """PriorityQ for Producers"""
    1553          Producer.produced+=4
    1554          yield put,self,buffer,4,priority
    1555          yield hold,self,1
    1556          self.done=self.sim.now()
    1557          doneList.append(self.name)
    1558 -    def produce1(self,buffer):
    1559          for i in range(4):
    1560              yield put,self,buffer,4
    1561              yield hold,self,1
    1562 -class Consumer(Process):
    1563      consumed=0
    1564 -    def __init__(self,name="",sim=None):
    1565          Process.__init__(self,name=name,sim=sim)
    1566 -    def consume(self,buffer):
    1567          """FIFO"""
    1568          yield get,self,buffer
    1569          Consumer.consumed+=1
    1570          assert self.got==1,"wrong self.got: %s"%self.got
    1571          yield get,self,buffer,3
    1572          Consumer.consumed+=3
    1573          assert self.got==3,"wrong self.got: %s"%self.got
    1574
    1575 -    def consume1(self,buffer):
    1576          """producer PriorityQ, consumer FIFO"""
    1577          while True:
    1578              yield get,self,buffer,2
    1579              yield hold,self,1
    1580 -    def consumePriority(self,buffer,priority):
    1581          """PriorityQ for Consumers"""
    1582          yield get,self,buffer,4,priority
    1583          doneList.append(self.name)
    1584
    1585  ### Begin classes for testConPrinciple (Level) ###
    1586 -class  ProducerPrincL(Process):
    1587 -    def __init__(self,sim=None):
    1588          Process.__init__(self,sim=sim)
    1589 -    def produce(self,buffer,productionTime):
    1590          while True:
    1591              assert not(buffer.amount>0 and len(buffer.getQ)>0),\
    1592                  "Consumer(s) waiting while buffer not empty"
    1593              yield hold,self,productionTime
    1594              yield put,self,buffer,1
    1595
    1596 -class ConsumerPrincL(Process):
    1597 -    def __init__(self,sim=None):
    1598          Process.__init__(self,sim=sim)
    1599 -    def consume(self,buffer,consumptionTime):
    1600          while True:
    1601              assert not(buffer.amount==0 and len(buffer.putQ)>0),\
    1602                  "Producer(s) waiting while buffer empty"
    1603              yield get,self,buffer,1
    1604              yield hold,self,consumptionTime
    1605
    1606  ### End classes for testConPrinciple (Level) ###
    1607
    1608 -class makeLevelTestcase(unittest.TestCase):
    1609 -    def testStatic(self):
    1610          """Tests initialization of Level instances
    1611          """
    1612          s=SimulationRT()
    1613          s.initialize()
    1614          a=Level(sim=s)
    1615          assert a.capacity==sys.maxint,"wrong capacity:%s"%a
    1616          assert a.amount==0,"wrong buffer content: %s"%a
    1617          assert a.name=="a_level","wrong name: %s"%a
    1618          assert not a.monitored,"should not be monitored: %s"%a
    1619          assert a.putQMon is None,"should not have putQMon: %s"%a
    1620          assert a.getQMon is None,"should not have getQMon: %s"%a
    1621          assert a.bufferMon is None,"should not have bufferMon: %s"%a
    1622          assert a.putQType.__name__=="FIFO" and a.getQType.__name__=="FIFO",\
    1623                 "putQType and getQType should be FIFO: %s"%a
    1624
    1625          b=Level(name="b",initialBuffered=10.0,monitored=True,capacity=12,
    1626                      putQType=PriorityQ,sim=s)
    1627          a=Level(sim=s)
    1628          assert b.capacity==12,"wrong capacity:%s"%b
    1629          assert b.amount==10,"wrong buffer content: %s"%b
    1630          assert b.name=="b","wrong name: %s"%b
    1631          assert b.monitored,"should be monitored: %s"%b
    1632          assert not (b.putQMon is None),"should have putQMon: %s"%b
    1633          assert not (b.getQMon is None),"should have getQMon: %s"%b
    1634          assert not (b.bufferMon is None),"should have bufferMon: %s"%b
    1635          assert b.putQType.__name__=="PriorityQ",\
    1636                 "putQType should be PriorityQ: %s"%b
    1637          assert b.getQType.__name__=="FIFO",\
    1638                  "getQType should be PriorityQ: %s"%b
    1639
    1640 -    def testConProdPrinciple(self):
    1641          """Level: tests basic Producer/Consumer principles:
    1642          -   Consumers must not be waiting while Level buffer value > 0,
    1643          -   Producers must not be waiting while Level buffer value == 0
    1644          """
    1645          s=SimulationRT()
    1646          s.initialize()
    1647          bufferSize=1
    1648          productionTime=1
    1649          consumptionTime=5
    1650          endtime=50
    1651          buffer=Level(capacity=bufferSize,sim=s)
    1652          consumer=ConsumerPrincL(sim=s)
    1653          s.activate(consumer,consumer.consume(buffer,consumptionTime))
    1654          producer=ProducerPrincL(sim=s)
    1655          s.activate(producer,producer.produce(buffer,productionTime))
    1656          s.simulate(until=endtime)
    1657
    1658 -    def testConProd1(self):
    1659          """Level: tests put/get in 1 Producer/ 1 Consumer scenario"""
    1660          s=SimulationRT()
    1661          s.initialize()
    1662          buffer=Level(initialBuffered=0,sim=s)
    1663          p=Producer(sim=s)
    1664          s.activate(p,p.produce(buffer))
    1665          c=Consumer(sim=s)
    1666          s.activate(c,c.consume(buffer))
    1667          s.simulate(until=100)
    1668          assert Producer.produced-Consumer.consumed==buffer.amount,\
    1669              "items produced/consumed/buffered do not tally: %s %s %s"\
    1670                  %(Producer.produced,Consumer.consumed,buffer.amount)
    1671
    1672 -    def testConProdM(self):
    1673          """Level: tests put/get in multiple Producer/Consumer scenario"""
    1674          s=SimulationRT()
    1675          s.initialize()
    1676          buffer=Level(initialBuffered=0,sim=s)
    1677          Producer.produced=0
    1678          Consumer.consumed=0
    1679          for i in range(2):
    1680              c=Consumer(sim=s)
    1681              s.activate(c,c.consume(buffer))
    1682          for i in range(3):
    1683              p=Producer(sim=s)
    1684              s.activate(p,p.produce(buffer))
    1685          s.simulate(until=10)
    1686          assert Producer.produced-Consumer.consumed==buffer.amount,\
    1687              "items produced/consumed/buffered do not tally: %s %s %s"\
    1688                  %(Producer.produced,Consumer.consumed,buffer.amount)
    1689
    1690 -    def testConProdPriorM(self):
    1691          """Level: tests put/get in multiple Producer/Consumer scenario,
    1692          with Producers having different priorities.
    1693          How: Producers forced to queue; all after first should be done in
    1694          priority order
    1695          """
    1696          global doneList
    1697          doneList=[]
    1698          s=SimulationRT()
    1699          s.initialize()
    1700          buffer=Level(capacity=7,putQType=PriorityQ,monitored=True,sim=s)
    1701          for i in range(4):
    1702              p=Producer(str(i), sim=s)
    1703              pPriority=i
    1704              s.activate(p,p.producePriority(buffer=buffer,priority=pPriority))
    1705          c=Consumer(sim=s)
    1706          s.activate(c,c.consume1(buffer=buffer))
    1707          s.simulate(until=100)
    1708          assert doneList==["0","3","2","1"],"puts were not done in priority order: %s"\
    1709                                      %doneList
    1710
    1711 -    def testConPriorProdM(self):
    1712          """Level: tests put/get in multiple Producer/Consumer scenario, with
    1713          Consumers having different priorities.
    1714          How: Consumers forced to queue; all after first should be done in
    1715          priority order
    1716          """
    1717          global doneList
    1718          doneList=[]
    1719          s=SimulationRT()
    1720          s.initialize()
    1721          buffer=Level(capacity=7,getQType=PriorityQ,monitored=True,sim=s)
    1722          for i in range(4):
    1723              c=Consumer(str(i), sim=s)
    1724              cPriority=i
    1725              s.activate(c,c.consumePriority(buffer=buffer,priority=cPriority))
    1726          p=Producer(sim=s)
    1727          s.activate(p,p.produce1(buffer=buffer))
    1728          s.simulate(until=100)
    1729          assert doneList==["3","2","1","0"],"gets were not done in priority order: %s"\
    1730                            %doneList
    1731
    1732 -def makeLevelSuite():
    1733      suite = unittest.TestSuite()
    1734      testStatic = makeLevelTestcase("testStatic")
    1735      testConProdPrinciple=makeLevelTestcase("testConProdPrinciple")
    1736      testConProd1=makeLevelTestcase("testConProd1")
    1737      testConProdM=makeLevelTestcase("testConProdM")
    1738      testConProdPriorM=makeLevelTestcase("testConProdPriorM")
    1739      testConPriorProdM=makeLevelTestcase("testConPriorProdM")
    1740      suite.addTests([testStatic,testConProdPrinciple,testConProd1,
    1741                      testConProdM,testConProdPriorM,testConPriorProdM])
    1742      return suite
    1743
    1744  ## ------------------------------------------------------------------
    1745  ##             TEST "yield get,self,store,whatToGet" and
    1746  ##                  "yield put,self,store,whatToPut"
    1747  ##             for Store instances
    1748  ## ------------------------------------------------------------------
    1749
    1750 -class ProducerWidget(Process):
    1751      produced=0
    1752 -    def __init__(self,name="",sim=None):
    1753          Process.__init__(self,name=name,sim=sim)
    1754 -    def produce(self,buffer):
    1755          for i in range(4):
    1756              ProducerWidget.produced+=1
    1757              yield put,self,buffer,[Widget(weight=5)]
    1758              yield hold,self,1
    1759 -    def producePriority(self,buffer,priority):
    1760          """PriorityQ for Producers"""
    1761          ProducerWidget.produced+=4
    1762          toStore=[Widget(weight=5)]*4
    1763          yield put,self,buffer,toStore,priority
    1764          yield hold,self,1
    1765          self.done=self.sim.now()
    1766          doneList.append(self.name)
    1767 -    def produce1(self,buffer):
    1768          for i in range(4):
    1769              yield put,self,buffer,[Widget(weight=5)]*4
    1770              yield hold,self,1
    1771 -    def produceUnordered(self,buffer):
    1772          produced=[Widget(weight=i) for i in [9,1,8,2,7,3,6,4,5]]
    1773          yield put,self,buffer,produced
    1774
    1775 -class ConsumerWidget(Process):
    1776      consumed=0
    1777 -    def __init__(self,name="",sim=None):
    1778          Process.__init__(self,name=name,sim=sim)
    1779 -    def consume(self,buffer):
    1780          """FIFO"""
    1781          yield get,self,buffer
    1782          ConsumerWidget.consumed+=1
    1783          assert len(self.got)==1,"wrong self.got: %s"%self.got
    1784          yield get,self,buffer,3
    1785          ConsumerWidget.consumed+=3
    1786          assert len(self.got)==3,"wrong self.got: %s"%self.got
    1787
    1788 -    def consume1(self,buffer):
    1789          """producer PriorityQ, consumer FIFO"""
    1790          while True:
    1791              yield get,self,buffer,2
    1792              yield hold,self,1
    1793
    1794 -    def consumePriority(self,buffer,priority):
    1795          """PriorityQ for Consumers"""
    1796          yield get,self,buffer,4,priority
    1797          doneList.append(self.name)
    1798
    1799 -    def consumeSorted(self,buffer,gotten):
    1800          yield get,self,buffer
    1801          gotten.append(self.got[0].weight)
    1802
    1803 -class Widget:
    1804 -    def __init__(self,weight):
    1805          self.weight=weight
    1806
    1807 -def mySortFunc(self,par):
    1808      """Sorts Widget instances by weight attribute."""
    1809      tmplist=[(x.weight,x) for x in par]
    1810      tmplist.sort()
    1811      return [x for (key,x) in tmplist]
    1812
    1813  ### Begin classes for testConPrinciple (Store) ###
    1814 -class  ProducerPrincS(Process):
    1815 -    def __init__(self,sim=None):
    1816          Process.__init__(self,sim=sim)
    1817 -    def produce(self,buffer,productionTime):
    1818          while True:
    1819              assert not(buffer.nrBuffered>0 and len(buffer.getQ)>0),\
    1820                  "Consumer(s) waiting while buffer not empty"
    1821              yield hold,self,productionTime
    1822              product=WidgetPrinc()
    1823              yield put,self,buffer,[product]
    1824
    1825 -class ConsumerPrincS(Process):
    1826 -    def __init__(self,sim=None):
    1827          Process.__init__(self,sim=sim)
    1828 -    def consume(self,buffer,consumptionTime):
    1829          while True:
    1830              assert not(buffer.nrBuffered==0 and buffer.putQ),\
    1831                  "Producer(s) waiting while buffer empty"
    1832              yield get,self,buffer,1
    1833              yield hold,self,consumptionTime
    1834
    1835 -class WidgetPrinc:
    1836      pass
    1837
    1838 -class FilterConsumer(Process):
    1839      """Used in testBufferFilter"""
    1840 -    def __init__(self,sim=None):
    1841          Process.__init__(self,sim=sim)
    1842 -    class Widget:
    1843 -        def __init__(self,weighs):
    1844              self.weight=weighs
    1845
    1846 -    def getItems(self,store,a,b):
    1847          """get all items with weight between a and b"""
    1848          def between_a_and_b(buf):
    1849              res=[]
    1850              for item in buf:
    1851                  if a<item.weight<b:
    1852                      res.append(item)
    1853
    1854          all=store.buffered
    1855          yield get,self,store,between_a_and_b
    1856          "All retrieved items weight in range?"
    1857          for it in self.got:
    1858              assert a<it.weight<b,"weight %s not in range %s..%s"\
    1859                                   %(it.weight,a,b)
    1860          "Any item fitting filter pred left in buffer?"
    1861          for it in store.buffer:
    1862              assert not (a<it.weight<b),\
    1863                  "item left in buffer which fits filter (%s<%s<%s)"\
    1864                  %(a,it.weight,b)
    1865          "All items either in store.buffer of self.got?"
    1866          for it in all:
    1867              assert (it in self.buffer) or (it in self.got),\
    1868                     "item w. weight %s neither in store nor in got"%it.weight
    1869
    1870  ### End classes for testConPrinciple (Store) ###
    1871
    1872 -class makeStoreTestcase(unittest.TestCase):
    1873 -    def testStatic(self):
    1874          """Store: tests initialization of Store instances
    1875          """
    1876          s=SimulationRT()
    1877          s.initialize()
    1878          a=Store(sim=s)
    1879          assert a.capacity==sys.maxint,"wrong capacity:%s"%a
    1880          assert a.nrBuffered==0,"wrong buffer content: %s"%a
    1881          assert a.name=="a_store","wrong name: %s"%a
    1882          assert not a.monitored,"should not be monitored: %s"%a
    1883          assert a.putQMon is None,"should not have putQMon: %s"%a
    1884          assert a.getQMon is None,"should not have getQMon: %s"%a
    1885          assert a.bufferMon is None,"should not have bufferMon: %s"%a
    1886          assert a.putQType.__name__=="FIFO" and a.getQType.__name__=="FIFO",\
    1887                 "putQType and getQType should be FIFO: %s"%a
    1888
    1889          stored=[Widget(weight=5)]*10
    1890          b=Store(name="b",initialBuffered=stored,monitored=True,capacity=12,
    1891                      putQType=PriorityQ,sim=s)
    1892          assert b.capacity==12,"wrong capacity:%s"%b
    1893          assert b.nrBuffered==10,"wrong buffer content: %s"%b
    1894          assert b.name=="b","wrong name: %s"%b
    1895          assert b.monitored,"should be monitored: %s"%b
    1896          assert not (b.putQMon is None),"should have putQMon: %s"%b
    1897          assert not (b.getQMon is None),"should have getQMon: %s"%b
    1898          assert not (b.bufferMon is None),"should have bufferMon: %s"%b
    1899          assert b.putQType.__name__=="PriorityQ",\
    1900                 "putQType should be PriorityQ: %s"%b
    1901          assert b.getQType.__name__=="FIFO",\
    1902                  "getQType should be PriorityQ: %s"%b
    1903
    1904 -    def testConProdPrinciple(self):
    1905          """Store: tests basic Producer/Consumer principles:
    1906          -   Consumers must not be waiting while items in Store buffer,
    1907          -   Producers must not be waiting while space available in Store buffer
    1908          """
    1909          bufferSize=1
    1910          productionTime=1
    1911          consumptionTime=5
    1912          endtime=50
    1913          s=SimulationRT()
    1914          s.initialize()
    1915          buffer=Store(capacity=bufferSize,sim=s)
    1916          consumer=ConsumerPrincS(sim=s)
    1917          s.activate(consumer,consumer.consume(buffer,consumptionTime))
    1918          producer=ProducerPrincS(sim=s)
    1919          s.activate(producer,producer.produce(buffer,productionTime))
    1920          s.simulate(until=endtime)
    1921
    1922 -    def testConProd1(self):
    1923          """Store: tests put/get in 1 Producer/ 1 Consumer scenario"""
    1924          s=SimulationRT()
    1925          s.initialize()
    1926          buffer=Store(initialBuffered=[],sim=s)
    1927          p=ProducerWidget(sim=s)
    1928          s.activate(p,p.produce(buffer))
    1929          c=ConsumerWidget(sim=s)
    1930          s.activate(c,c.consume(buffer))
    1931          s.simulate(until=100)
    1932          assert \
    1933             ProducerWidget.produced-ConsumerWidget.consumed==buffer.nrBuffered,\
    1934             "items produced/consumed/buffered do not tally: %s %s %s"\
    1935             %(ProducerWidget.produced,ConsumerWidget.consumed,buffer.nrBuffered)
    1936
    1937 -    def testConProdM(self):
    1938          """Store: tests put/get in multiple Producer/Consumer scenario"""
    1939          s=SimulationRT()
    1940          s.initialize()
    1941          buffer=Store(initialBuffered=[],sim=s)
    1942          ProducerWidget.produced=0
    1943          ConsumerWidget.consumed=0
    1944          for i in range(2):
    1945              c=ConsumerWidget(sim=s)
    1946              s.activate(c,c.consume(buffer))
    1947          for i in range(3):
    1948              p=ProducerWidget(sim=s)
    1949              s.activate(p,p.produce(buffer))
    1950          s.simulate(until=10)
    1951          assert ProducerWidget.produced-ConsumerWidget.consumed==buffer.nrBuffered,\
    1952              "items produced/consumed/buffered do not tally: %s %s %s"\
    1953              %(ProducerWidget.produced,ConsumerWidget.consumed,buffer.nrBuffered)
    1954
    1955 -    def testConProdPriorM(self):
    1956          """Store: Tests put/get in multiple Producer/Consumer scenario,
    1957          with Producers having different priorities.
    1958          How; Producers forced to queue; all after first should be done in
    1959          priority order
    1960          """
    1961          global doneList
    1962          doneList=[]
    1963          s=SimulationRT()
    1964          s.initialize()
    1965          buffer=Store(capacity=7,putQType=PriorityQ,monitored=True,sim=s)
    1966          for i in range(4):
    1967              p=ProducerWidget(name=str(i), sim=s)
    1968              pPriority=i
    1969              s.activate(p,p.producePriority(buffer=buffer,priority=pPriority))
    1970          c=ConsumerWidget(sim=s)
    1971          s.activate(c,c.consume1(buffer=buffer))
    1972          s.simulate(until=100)
    1973          assert doneList==["0","3","2","1"],"puts were not done in priority order: %s"\
    1974                                      %doneList
    1975
    1976 -    def testConPriorProdM(self):
    1977          """Tests put/get in multiple Producer/Consumer scenario, with
    1978          Consumers having different priorities.
    1979          How; Consumers forced to queue; all after first should be done in
    1980          priority order
    1981          """
    1982          global doneList
    1983          doneList=[]
    1984          s=SimulationRT()
    1985          s.initialize()
    1986          buffer=Store(capacity=7,getQType=PriorityQ,monitored=True,sim=s)
    1987          for i in range(4):
    1988              c=ConsumerWidget(name=str(i),sim=s)
    1989              cPriority=i
    1990              s.activate(c,c.consumePriority(buffer=buffer,priority=cPriority))
    1991          p=ProducerWidget(sim=s)
    1992          s.activate(p,p.produce1(buffer=buffer))
    1993          s.simulate(until=100)
    1994          assert doneList==["3","2","1","0"],\
    1995                "gets were not done in priority order: %s"%doneList
    1996
    1997 -    def testBufferSort(self):
    1998          """Tests the optional sorting of theBuffer by applying a user-defined
    1999          sort function."""
    2000          s=SimulationRT()
    2001          s.initialize()
    2002          gotten=[]
    2003          sortedStore=Store(sim=s)
    2004          sortedStore.addSort(mySortFunc)
    2005          p=ProducerWidget(sim=s)
    2006          s.activate(p,p.produceUnordered(sortedStore))
    2007          for i in range(9):
    2008              c=ConsumerWidget(sim=s)
    2009              s.activate(c,c.consumeSorted(buffer=sortedStore,gotten=gotten),at=1)
    2010          s.simulate(until=10)
    2011          assert gotten==[1,2,3,4,5,6,7,8,9],"sort wrong: %s"%gotten
    2012
    2013 -    def testBufferFilter(self):
    2014          """Tests get from a Store with a filter function
    2015          """
    2016          s=SimulationRT()
    2017          s.initialize()
    2018          ItClass=FilterConsumer.Widget
    2019          all=[ItClass(1),ItClass(4),ItClass(6),ItClass(12)]
    2020          st=Store(initialBuffered = all, sim = s)
    2021          fc=FilterConsumer(sim = s)
    2022          minw=2;maxw=10
    2023          s.activate(fc,fc.getItems(store=st,a=minw,b=maxw))
    2024          s.simulate(until=1)
    2025
    2026 -def makeStoreSuite():
    2027      suite = unittest.TestSuite()
    2028      testStatic = makeStoreTestcase("testStatic")
    2029      testConProdPrinciple=makeStoreTestcase("testConProdPrinciple")
    2030      testConProd1=makeStoreTestcase("testConProd1")
    2031      testConProdM=makeStoreTestcase("testConProdM")
    2032      testConProdPriorM=makeStoreTestcase("testConProdPriorM")
    2033      testConPriorProdM=makeStoreTestcase("testConPriorProdM")
    2034      testBufferSort=makeStoreTestcase("testBufferSort")
    2035      testBufferFilter=makeStoreTestcase("testBufferFilter")
    2036      suite.addTests([testStatic,testConProdPrinciple,testConProd1,
    2037                      testConProdM,testConProdPriorM,testConPriorProdM,
    2038                      testBufferSort,testBufferFilter])
    2039      return suite
    2040
    2041  ## ------------------------------------------------------------------
    2042  ##
    2043  ##  Store: Tests for compound get/put
    2044  ##
    2045  ## ------------------------------------------------------------------
    2046 -class TBT(Process):
    2047      """Store: For testBasicTime"""
    2048 -    def __init__(self,sim=None):
    2049          Process.__init__(self,sim=sim)
    2050 -    def tbt(self,store):
    2051          yield get,self,store,1
    2052          assert self.got,"Did not get Item"
    2053          yield (get,self,store,1),(hold,self,5)
    2054          if self.acquired(store):
    2055              assert len(self.got)==1,"did not get 1 Item"
    2056          else:
    2057              assert not self.got and self.sim.now()==5 and not store.getQ,\
    2058                     "time renege not working"
    2059
    2060 -class TBE(Process):
    2061      """Store: For testBasicEvent"""
    2062 -    def __init__(self,name="",sim=None):
    2063          Process.__init__(self,sim=sim)
    2064 -    def tbe(self,store,trigger):
    2065          yield get,self,store,1
    2066          assert self.got,"Did not get Item"
    2067          yield (get,self,store,1),(waitevent,self,trigger)
    2068          if self.acquired(store):
    2069              assert False, "should have reneged"
    2070          else:
    2071              assert self.eventsFired[0]==trigger and self.sim.now()==5 \
    2072                  and not store.getQ,"event renege not working"
    2073
    2074 -class TBEtrigger(Process):
    2075      """Store: For testBasicEvent"""
    2076 -    def __init__(self,sim=None):
    2077          Process.__init__(self,sim=sim)
    2078 -    def fire(self,trigger):
    2079          yield hold,self,5
    2080          trigger.signal()
    2081
    2082
    2083 -class TBTput(Process):
    2084      """Store: for testBasicTimePut"""
    2085 -    def __init__(self,sim=None):
    2086          Process.__init__(self,sim=sim)
    2087 -    def tbt(self,store):
    2088          class Item:pass
    2089          yield (put,self,store,[Item()]),(hold,self,4)
    2090          if self.stored(store):
    2091              assert store.nrBuffered==1 and not store.putQ,\
    2092                     "put did not execute"
    2093          else:
    2094              assert False,"should not have reneged"
    2095          yield (put,self,store,[Item()]),(hold,self,5)
    2096          if self.stored(store):
    2097              assert False,"should have reneged"
    2098          else:
    2099              assert store.nrBuffered==1 and not store.putQ,\
    2100                     "renege not working correctly"
    2101
    2102 -class TBEput(Process):
    2103      """Store: for testBasicEventPut"""
    2104 -    def __init__(self,sim=None):
    2105          Process.__init__(self,sim=sim)
    2106 -    def tbe(self,store,trigger):
    2107          class Item:pass
    2108          yield (put,self,store,[Item()]),(waitevent,self,trigger)
    2109          if self.stored(store):
    2110              assert store.nrBuffered==1 and not store.putQ,\
    2111                     "put did not execute"
    2112          else:
    2113              assert False,"should have not have reneged"
    2114          yield (put,self,store,[Item()]),(waitevent,self,trigger)
    2115          if self.stored(store):
    2116              assert False,"should have reneged"
    2117          else:
    2118              assert self.sim.now()==5 and self.eventsFired[0]==trigger\
    2119                     and not store.putQ,"renege not working correctly"
    2120
    2121 -class TBEtriggerPut(Process):
    2122      """Store: For testBasicEventPut"""
    2123 -    def __init__(self,sim=None):
    2124          Process.__init__(self,sim=sim)
    2125 -    def fire(self,trigger):
    2126          yield hold,self,5
    2127          trigger.signal()
    2128
    2129 -class makeStoreCompTestcase(unittest.TestCase):
    2130      """Store: Testcase for compound get statements"""
    2131      ## ------------------------------------------------------------------
    2132      ##             TEST "yield (get,self,store),(hold,self,time)"
    2133      ##                   == timeout renege
    2134      ##             for both unmonitored and monitored Stores
    2135      ## ------------------------------------------------------------------
    2136
    2137 -    def testBasicTime(self):
    2138          """Store (unmonitored):
    2139          test 'yield (get,self,store),(hold,self,timeout)"""
    2140          s=SimulationRT()
    2141          s.initialize()
    2142          class Item:pass
    2143          st=Store(initialBuffered=[Item()],sim=s)
    2144          t=TBT(sim=s)
    2145          s.activate(t,t.tbt(store=st))
    2146          s.simulate(until=10)
    2147
    2148      ## ------------------------------------------------------------------
    2149      ##             TEST "yield (put,self,store),(hold,self,time)"
    2150      ##                   == timeout renege
    2151      ##             for both unmonitored and monitored Stores
    2152      ## ------------------------------------------------------------------
    2153 -    def testBasicTimePut(self):
    2154          """Store (unmonitored):
    2155          test 'yield (put,self,store),(hold,self,time)"""
    2156          s=SimulationRT()
    2157          s.initialize()
    2158          st=Store(capacity=1,sim=s)
    2159          t=TBTput(sim=s)
    2160          s.activate(t,t.tbt(store=st))
    2161          s.simulate(until=10)
    2162
    2163 -    def testBasicTimePutM(self):
    2164          """Store (monitored):
    2165          test monitors with 'yield (put,self,store),(hold,self,time)"""
    2166          s=SimulationRT()
    2167          s.initialize()
    2168          st=Store(capacity=1,monitored=True,sim=s)
    2169          t=TBTput(sim=s)
    2170          s.activate(t,t.tbt(store=st))
    2171          s.simulate(until=10)
    2172          #First put succeeds, second attempt reneges at t=5?
    2173          assert st.putQMon==[[0,0],[0,1],[5,0]],"putQMon wrong: %s"\
    2174                                                 %st.putQMon
    2175          #First Item goes into buffer at t=0, second not (renege)?
    2176          assert st.bufferMon==[[0,0],[0,1]],"bufferMon wrong: %s"%st.bufferMon
    2177
    2178      ## ------------------------------------------------------------------
    2179      ##             TEST "yield (get,self,store),(waitevent,self,event)"
    2180      ##                   == event renege
    2181      ##             for both unmonitored and monitored Stores
    2182      ## ------------------------------------------------------------------
    2183 -    def testBasicEvent(self):
    2184          """Store (unmonitored):
    2185          test 'yield (get,self,store),(waitevent,self,event)"""
    2186          si=SimulationRT()
    2187          si.initialize()
    2188          class Item:pass
    2189          st=Store(initialBuffered=[Item()],sim=si)
    2190          trig=SimEvent(sim=si)
    2191          t=TBE(sim=si)
    2192          si.activate(t,t.tbe(store=st,trigger=trig))
    2193          tr=TBEtrigger(sim=si)
    2194          si.activate(tr,tr.fire(trigger=trig))
    2195          si.simulate(until=10)
    2196
    2197      ## ------------------------------------------------------------------
    2198      ##             TEST "yield (put,self,store),(waitevent,self,event)"
    2199      ##                   == event renege
    2200      ##             for both unmonitored and monitored Stores
    2201      ## ------------------------------------------------------------------
    2202 -    def testBasicEventPut(self):
    2203          """Store (unmonitored):
    2204          test 'yield (put,self,store),(waitevent,self,event)"""
    2205          si=SimulationRT()
    2206          si.initialize()
    2207          s=SimEvent(sim=si)
    2208          store=Store(capacity=1,sim=si)
    2209          t=TBEtriggerPut(sim=si)
    2210          si.activate(t,t.fire(trigger=s))
    2211          tb=TBEput(sim=si)
    2212          si.activate(tb,tb.tbe(store=store,trigger=s))
    2213          si.simulate(until=10)
    2214
    2215 -    def testBasicEventPutM(self):
    2216          """Store (monitored):
    2217          test monitors with 'yield (put,self,store),(waitevent,self,event)"""
    2218          si=SimulationRT()
    2219          si.initialize()
    2220          s=SimEvent(sim=si)
    2221          st=Store(capacity=1,monitored=True,sim=si)
    2222          t=TBEtriggerPut(sim=si)
    2223          si.activate(t,t.fire(trigger=s))
    2224          tb=TBEput(sim=si)
    2225          si.activate(tb,tb.tbe(store=st,trigger=s))
    2226          si.simulate(until=10)
    2227          #First put succeeds, second attempt reneges at t=5?
    2228          assert st.putQMon==[[0,0],[0,1],[5,0]],"putQMon wrong: %s"\
    2229                                                 %st.putQMon
    2230          #First Item goes into buffer at t=0, second not (renege)?
    2231          assert st.bufferMon==[[0,0],[0,1]],"bufferMon wrong: %s"%st.bufferMon
    2232
    2233 -def makeStoreCompSuite():
    2234      suite = unittest.TestSuite()
    2235      ## Unmonitored Stores
    2236      testBasicTime  = makeStoreCompTestcase("testBasicTime")
    2237      testBasicEvent = makeStoreCompTestcase("testBasicEvent")
    2238      testBasicTimePut  = makeStoreCompTestcase("testBasicTimePut")
    2239      testBasicEventPut = makeStoreCompTestcase("testBasicEventPut")
    2240  ##    ## Monitored Stores
    2241      testBasicTimePutM = makeStoreCompTestcase("testBasicTimePutM")
    2242      testBasicEventPutM = makeStoreCompTestcase("testBasicEventPutM")
    2243
    2244      suite.addTests([testBasicTime,testBasicTimePut,testBasicTimePutM,
    2245                      testBasicEvent,testBasicEventPut,testBasicEventPutM
    2246                     ])
    2247      return suite
    2248
    2249  ## ------------------------------------------------------------------
    2250  ##
    2251  ##  Level: Tests for compound get
    2252  ##
    2253  ## ------------------------------------------------------------------
    2254 -class TBTLev(Process):
    2255      """Level: For testBasicTime"""
    2256 -    def __init__(self,**par):
    2257          Process.__init__(self,**par)
    2258 -    def tbt(self,level):
    2259          yield get,self,level,1
    2260          assert self.got,"did not get 1 unit"
    2261          yield (get,self,level,1),(hold,self,5)
    2262          if self.acquired(level):
    2263              assert self.got==1,"did not get 1 unit"
    2264          else:
    2265              assert not self.got and self.sim.now()==5,\
    2266                     "time renege not working"
    2267
    2268 -class TBELev(Process):
    2269      """Level: For testBasicEvent"""
    2270 -    def __init__(self,**par):
    2271          Process.__init__(self,**par)
    2272 -    def tbe(self,level,trigger):
    2273          yield get,self,level,1
    2274          assert self.got,"did not get 1 unit"
    2275          yield (get,self,level,1),(waitevent,self,trigger)
    2276          if self.acquired(level):
    2277              assert self.got==1,"did not get 1 Item"
    2278          else:
    2279              assert self.sim.now()==5.5 and self.eventsFired[0]==trigger,\
    2280                     "event renege not working"
    2281
    2282 -class TBEtriggerLev(Process):
    2283      """Level: For testBasicEvent"""
    2284 -    def __init__(self,**par):
    2285          Process.__init__(self,**par)
    2286 -    def fire(self,trigger):
    2287          yield hold,self,5.5
    2288          trigger.signal()
    2289
    2290 -class TBTLevPut(Process):
    2291      """Level: For testBasicTimePut"""
    2292 -    def __init__(self,**par):
    2293          Process.__init__(self,**par)
    2294 -    def tbt(self,level):
    2295          yield put,self,level,1
    2296          assert level.amount,"did not put 1 unit"
    2297          yield (put,self,level,1),(hold,self,5)
    2298          if self.stored(level):
    2299              assert False,"should have reneged"
    2300          else:
    2301              assert level.amount==1 and self.sim.now()==5,\
    2302                     "time renege not working"
    2303
    2304 -class TBELevPut(Process):
    2305      """Level: For testBasicEventPut and testBasicEventPutM"""
    2306 -    def __init__(self,**par):
    2307          Process.__init__(self,**par)
    2308 -    def tbe(self,level,trigger):
    2309          yield (put,self,level,1),(waitevent,self,trigger)
    2310          if self.stored(level):
    2311              assert level.amount==1,"did not put 1 unit"
    2312          else:
    2313              assert False,"should not have reneged"
    2314          yield (put,self,level,1),(waitevent,self,trigger)
    2315          if self.stored(level):
    2316              assert False, "should have reneged"
    2317          else:
    2318              assert self.sim.now()==5.5 and self.eventsFired[0]==trigger ,\
    2319                     "renege not working"
    2320
    2321 -class TBEtriggerLevPut(Process):
    2322      """Level: For testBasicEventPut"""
    2323 -    def __init__(self,**par):
    2324          Process.__init__(self,**par)
    2325 -    def fire(self,trigger):
    2326          yield hold,self,5.5
    2327          trigger.signal()
    2328
    2329 -class makeLevelCompTestcase(unittest.TestCase):
    2330      """Level: Testcase for compound get and put statements"""
    2331      ## ------------------------------------------------------------------
    2332      ##             TEST "yield (get,self,level),(hold,self,time)"
    2333      ##                   == timeout renege
    2334      ##             for both unmonitored and monitored Levels
    2335      ## ------------------------------------------------------------------
    2336
    2337 -    def testBasicTime(self):
    2338          """Level (unmonitored):
    2339              test 'yield (get,self,level),(hold,self,timeout)
    2340          """
    2341          s=SimulationRT()
    2342          s.initialize()
    2343          l=Level(initialBuffered=1,sim=s)
    2344          t=TBTLev(sim=s)
    2345          s.activate(t,t.tbt(level=l))
    2346          s.simulate(until=10)
    2347
    2348      ## ------------------------------------------------------------------
    2349      ##             TEST "yield (put,self,store),(hold,self,time)"
    2350      ##                   == timeout renege
    2351      ##             for both unmonitored and monitored Stores
    2352      ## ------------------------------------------------------------------
    2353 -    def testBasicTimePut(self):
    2354          """Level (unmonitored):
    2355          test 'yield (put,self,level),(hold,self,timeout)"""
    2356          s=SimulationRT()
    2357          s.initialize()
    2358          l=Level(capacity=1,sim=s)
    2359          t=TBTLevPut(sim=s)
    2360          s.activate(t,t.tbt(level=l))
    2361          s.simulate(until=10)
    2362
    2363      ## ------------------------------------------------------------------
    2364      ##             TEST "yield (get,self,store),(waitevent,self,event)"
    2365      ##                   == event renege
    2366      ##             for both unmonitored and monitored Levels
    2367      ## ------------------------------------------------------------------
    2368 -    def testBasicEvent(self):
    2369          """Level (unmonitored):
    2370          test 'yield (get,self,level),(waitevent,self,event)"""
    2371          s=SimulationRT()
    2372          s.initialize()
    2373          l=Level(initialBuffered=1,sim=s)
    2374          trig=SimEvent(sim=s)
    2375          t=TBELev(sim=s)
    2376          s.activate(t,t.tbe(level=l,trigger=trig))
    2377          tr=TBEtriggerLev(sim=s)
    2378          s.activate(tr,tr.fire(trigger=trig))
    2379          s.simulate(until=10)
    2380
    2381 -    def testBasicEventM(self):
    2382          """Level (monitored):
    2383          test monitors with 'yield (get,self,level),(waitevent,self,event)"""
    2384          s=SimulationRT()
    2385          s.initialize()
    2386          l=Level(initialBuffered=1,monitored=True,sim=s)
    2387          trig=SimEvent(sim=s)
    2388          t=TBELev(sim=s)
    2389          s.activate(t,t.tbe(level=l,trigger=trig))
    2390          tr=TBEtriggerLev(sim=s)
    2391          s.activate(tr,tr.fire(trigger=trig))
    2392          s.simulate(until=10)
    2393          #First get (t=0) succeeded and second timed out at t=5.5?
    2394          assert l.getQMon==[[0,0],[0,1],[5.5,0]],"getQMon not working: %s"\
    2395                                                 %l.getQMon
    2396          #Level amount incr. then decr. by 1 (t=0), 2nd get reneged at t=5.5?
    2397          assert l.bufferMon==[[0,1],[0,0]],\
    2398                 "bufferMon not working: %s"%l.bufferMon
    2399
    2400      ## ------------------------------------------------------------------
    2401      ##             TEST "yield (put,self,store),(waitevent,self,event)"
    2402      ##                   == event renege
    2403      ##             for both unmonitored and monitored Levels
    2404      ## ------------------------------------------------------------------
    2405 -    def testBasicEventPut(self):
    2406          """Level (unmonitored):
    2407          test 'yield (put,self,level),(waitevent,self,event)"""
    2408          s=SimulationRT()
    2409          s.initialize()
    2410          l=Level(capacity=1,sim=s)
    2411          trig=SimEvent(sim=s)
    2412          t=TBELevPut(sim=s)
    2413          s.activate(t,t.tbe(level=l,trigger=trig))
    2414          tr=TBEtriggerLevPut(sim=s)
    2415          s.activate(tr,tr.fire(trigger=trig))
    2416          s.simulate(until=10)
    2417
    2418 -    def testBasicEventPutM(self):
    2419          """Level (monitored):
    2420          test monitors with 'yield (put,self,level),(waitevent,self,event)"""
    2421          s=SimulationRT()
    2422          s.initialize()
    2423          l=Level(capacity=1,monitored=True,sim=s)
    2424          trig=SimEvent(sim=s)
    2425          t=TBELevPut(sim=s)
    2426          s.activate(t,t.tbe(level=l,trigger=trig))
    2427          tr=TBEtriggerLevPut(sim=s)
    2428          s.activate(tr,tr.fire(trigger=trig))
    2429          s.simulate(until=10)
    2430          "First put succeeds, second reneges at t=5.5?"
    2431          assert l.putQMon==[[0,0],[0,1],[5.5,0]],"putQMon wrong: %s"\
    2432                                                  %l.putQMon
    2433          "1 unit added at t=0, renege at t=5 before 2nd unit added?"
    2434          assert l.bufferMon==[[0,0],[0,1]],"bufferMon wrong: %s"%l.bufferMon
    2435
    2436 -def makeLevelCompSuite():
    2437      suite = unittest.TestSuite()
    2438      ## Unmonitored Levels
    2439      testBasicTime  = makeLevelCompTestcase("testBasicTime")
    2440      testBasicEvent = makeLevelCompTestcase("testBasicEvent")
    2441      testBasicTimePut = makeLevelCompTestcase("testBasicTimePut")
    2442      testBasicEventPut = makeLevelCompTestcase("testBasicEventPut")
    2443  ##    ## Monitored Levels
    2444      testBasicEventM = makeLevelCompTestcase("testBasicEventM")
    2445      testBasicEventPutM = makeLevelCompTestcase("testBasicEventPutM")
    2446
    2447      suite.addTests([testBasicTime,testBasicEvent,testBasicTimePut,
    2448                      testBasicEventM,testBasicEventPut,testBasicEventPutM])
    2449      return suite
    2450
    2451  if __name__ == '__main__':
    2452      alltests = unittest.TestSuite((
    2453                                     makeSSuite(),
    2454                                     makeRSuite(),
    2455                                     makeISuite(),
    2456                                     makePSuite(),
    2457                                     makeESuite(),
    2458                                     makeWSuite(),
    2459                                     makeTOSuite(),
    2460                                     makeEvtRenegeSuite(),
    2461                                     makeLevelSuite(),
    2462                                     makeStoreSuite(),
    2463                                     makeStoreCompSuite(),
    2464                                     makeLevelCompSuite(),
    2465                                     makeMSuite()
    2466                                    ))
    2467
    2468      runner = unittest.TextTestRunner()
    2469      runner.run(alltests)
    2470  ##
    2471