Package SimPy :: Module testSimPyOO

[hide private]
[frames] | no frames]

# Source Code for Module SimPy.testSimPyOO

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