Package SimPy :: Module testSimPyStepOO

[hide private]
[frames] | no frames]

# Source Code for Module SimPy.testSimPyStepOO

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