Package SimPy :: Module testSimPyRTOO
[hide private]
[frames] | no frames]

Source Code for Module SimPy.testSimPyRTOO

   1  #!/usr / bin / env python 
   2  from SimPy.SimulationRT  import * 
   3  from SimPy.MonitorTest import * 
   4  import unittest 
   5  from random import random 
   6  # $Revision: 265 $ $Date: 2009-03-22 22:13:56 +0100 (So, 22 Mrz 2009) $ 
   7  """testSimPyRT.py 
   8  SimPy version 2.0 
   9  Unit tests for SimulationRT. 
  10  Based on testSimpy.py to test full compatibility 
  11  between Simulation and SimulationRT. 
  12               
  13  **Change history**:        
  14  # 2002 11 15 Added tests for priority queues and preemption 
  15  # 2002 11 22 testing problem in accum 
  16  # 2003 03 30 added tests for SEP001v17 interrupts 
  17  # 2003 04 05 added test for interruptReset 
  18  # 2003 04 08 added tests for process state transitions 
  19  # 2003 04 10 changed to 'self.cancel(victim)' syntax 
  20  # 2003 04 13 removed dummy init assertions 
  21  # 2004 02 28 added test for monitored queues (gav) 
  22  # 2004 05 03 corrected test for monitored queues (gav) 
  23  # 2004 05 15 first version of SimulationRT; just tests 
  24  #                 compatibility with Simulation.py 
  25  # 2004 09 17 added tests for waitevent, queueevent, waituntil (new in 1.5) 
  26  # 2005 05 19 added tests for compound yield statements (reneging) 
  27  # 2006 01 15 added tests for Store and Level and the get / put yield statements 
  28  # 2006 02 02 removed histogram plotting suite 
  29  # 2006 05 10 changed test testStatic for Level to test that float type  
  30               supported for initialBuffered 
  31  # 2006 05 16 added tests for Store and Level to test basic Producer / Consumer  
  32               principles 
  33  # 2006 10 16 added tests for compound get statement (Unmonitored Store / Level) 
  34  # 2006 10 17 added tests for compound put statement (Unmonitored Store / Level) 
  35  # 2007 01 08 added tests for monitoring of Store / Level with compound get / put 
  36  # 2007 01 08 added test for Store with filter function 
  37  # 2007 12 05 added tests for start method (Process) 
  38  # 2008 03 03 added test for nested preempts 
  39  # 2009 03 19 added SimulationRT OO API testing 
  40   
  41  #'$Revision: 265 $ $Date: 2009-03-22 22:13:56 +0100 (So, 22 Mrz 2009) $ kgm' 
  42   
  43  """ 
  44  simulationRTVersion=version 
  45  print "Under test: SimulationRT.py %s"%simulationRTVersion 
  46  __version__ = '2.0 $Revision: 265 $ $Date: 2009-03-22 22:13:56 +0100 (So, 22 Mrz 2009) $ ' 
  47  print 'testSimPyRTOO.py %s'%__version__ 
  48   
  49  ## ------------------------------------------------------------- 
  50  ##                    TEST SIMULATIONRT 
  51  ## ------------------------------------------------------------- 
52 -class P(Process):
53 """ P class for testing"""
54 - def __init__(self,name="",T = 0,sim=None):
55 Process.__init__(self,name=name,sim=sim) 56 self.name=name 57 self.T = T
58
59 - def execute(self):
60 yield hold,self,self.T
61
62 -class PActions(Process):
63 """ PActions class for testing"""
64 - def __init__(self,name="",T = 0,sim=None):
65 Process.__init__(self,name=name,sim=sim) 66 self.T = T
67
68 - def ACTIONS(self):
69 yield hold,self,self.T
70
71 -class makeSimulationtestcase(unittest.TestCase):
72 """ Tests of simulation 73 """
74 - def testInit(self):
75 """Test initialisation 76 """ 77 s=SimulationRT() 78 s.initialize() 79 result=s.simulate(until=10) 80 assert result=="SimPy: No activities scheduled",\ 81 "There should have been no activities." 82 assert(s.now()==0),"time not 0"
83
84 - def testActivate(self):
85 """Test activate() 86 """ 87 s=SimulationRT() 88 s.initialize() 89 P1 = P(name="P1",T=100.0,sim=s) 90 s.activate(P1,P1.execute(),0) 91 s.simulate(until=5) 92 assert(s.now()==5),"Simulate stopped at %s not %s"%(s.now(),5)
93
94 - def testStart(self):
95 """Test start method 96 """ 97 s=SimulationRT() 98 P1 = P(name="P1",T=100.0,sim=s) 99 s.initialize() 100 P1.start(P1.execute(),0) 101 s.simulate(until=5) 102 assert(s.now()==5),"Simulate stopped at %s not %s"%(s.now(),5)
103
104 - def testStartActions(self):
105 """Test start method with ACTIONS PEM 106 """ 107 s=SimulationRT() 108 P1 = PActions(name="P1",T=100.0,sim=s) 109 s.initialize() 110 P1.start() 111 s.simulate(until=5) 112 assert(s.now()==5),"Simulate stopped at %s not %s"%(s.now(),5)
113
114 - def testYield(self):
115 """Test yield hold and simulate(until) 116 """ 117 s=SimulationRT() 118 s.initialize() 119 P1 = P(name="P1",T=10,sim=s) 120 s.initialize() 121 s.activate(P1,P1.execute(),0) 122 s.simulate(until=5) 123 assert(s.now()==5),"Simulate stopped at %s not %s"%(s.now(),5) 124 ## should stop at 0 for next event is at 10s 125 P2 = P(name="P2",T=10,sim=s) 126 s.initialize() 127 s.activate(P2,P2.execute(),0) 128 s.simulate(until=20) 129 assert(s.now()==10),"P1 hold to %s not %s"%(s.now(),10)
130
131 -def makeSSuite():
132 suite = unittest.TestSuite() 133 testInit = makeSimulationtestcase("testInit") 134 testActivate = makeSimulationtestcase("testActivate") 135 testStart=makeSimulationtestcase("testStart") 136 testStartActions=makeSimulationtestcase("testStartActions") 137 testYield = makeSimulationtestcase("testYield") 138 suite.addTests([testInit,testActivate,testStart,testStartActions, 139 testYield]) 140 return suite
141 142 ## ------------------------------------------------------------- 143 ## TEST RESOURCES 144 ## ------------------------------------------------------------- 145
146 -class Job(Process):
147 """ Job class for testing"""
148 - def __init__(self,server=None,name="",sim=None):
149 Process.__init__(self,name=name,sim=sim) 150 self.R=server
151
152 - def execute(self):
153 yield request,self,self.R
154
155 -class makeResourcetestcase(unittest.TestCase):
156 """ First simple tests of Resources 157 """
158 - def testInit(self):
159 """Test initialisation""" 160 s=SimulationRT() 161 s.initialize() 162 R = Resource(sim=s) 163 assert R.name == "a_resource", "Not null name" 164 assert R.capacity == 1, "Not unit capacity" 165 assert R.unitName =="units", "Not the correct unit name" 166 R = Resource(name='',capacity=1,sim=s) 167 assert R.name == "", "Not null name" 168 assert R.capacity == 1, "Not unit capacity" 169 assert R.unitName =="units", "Not the correct unit name" 170 R = Resource(capacity=3,name="3-version",unitName="blobs",sim=s) 171 assert R.name =="3-version" , "Wrong name, it is"+R.name 172 assert R.capacity == 3, "Not capacity 3, it is "+`R.capacity` 173 assert R.unitName =="blobs", "Not the correct unit name" 174 ## next test 0 capacity is allowed 175 R = Resource(capacity=0,name="0-version",sim=s) 176 assert R.capacity ==0, "Not capacity 0, it is "+`R.capacity`
177
178 - def testrequest(self):
179 """Test request""" 180 181 ## now test requesting: ------------------------------------ 182 s=SimulationRT() 183 s.initialize() 184 R0 = Resource(name='',capacity=0,sim=s) 185 assert R0.name == "", "Not null name" 186 assert R0.capacity == 0, "Not capacity 0, it is "+`R0.capacity` 187 R1 = Resource(capacity=0,name="3-version",unitName="blobs",sim=s) 188 J= Job(name="job",server=R1,sim=s) 189 s.activate(J,J.execute(), at=0.0) # this requests a unit of R1 190 ## when simulation starts 191 s.simulate(until=10.0) 192 assert R1.n == 0 , "Should be 0, it is "+str(R1.n) 193 lenW = len(R1.waitQ) 194 assert lenW==1,"Should be 1, it is "+str(lenW) 195 assert len(R1.activeQ)==0,"len activeQ Should be 0, it is "+\ 196 str(len(R1.activeQ))
197
198 - def testrequest2(self):
199 """Test request2 with capacity = 1""" 200 ## now test requesting: ------------------------------------ 201 s=SimulationRT() 202 s.initialize() 203 R2 = Resource(capacity=1,name="3-version",unitName="blobs",sim=s) 204 J2= Job(name="job",server=R2,sim=s) 205 s.activate(J2,J2.execute(), at=0.0) # requests a unit of R2 206 ## when simulation starts 207 s.simulate(until = 10.0) 208 assert R2.n == 0 , "Should be 0, it is "+str(R2.n) 209 lenW = len(R2.waitQ) 210 lenA = len(R2.activeQ) 211 assert lenW==0,"lenW Should be 0, it is "+str(lenW) 212 assert lenA==1,"lenA Should be 1, it is "+str(lenA)
213
214 - def testrequest3(self):
215 """Test request3 with capacity = 1 several requests""" 216 ## now test requesting: ------------------------------------ 217 s=SimulationRT() 218 s.initialize() 219 R3 = Resource(capacity=1,name="3-version",unitName="blobs",sim=s) 220 J2= Job(name="job",server=R3,sim=s) 221 J3= Job(name="job",server=R3,sim=s) 222 J4= Job(name="job",server=R3,sim=s) 223 s.activate(J2,J2.execute(), at=0.0) # requests a unit of R3 224 s.activate(J3,J3.execute(), at=0.0) # requests a unit of R3 225 s.activate(J4,J4.execute(), at=0.0) # requests a unit of R3 226 ## when simulation starts 227 s.simulate(until = 10.0) 228 assert R3.n == 0 , "Should be 0, it is "+str(R3.n) 229 lenW = len(R3.waitQ) 230 lenA = len(R3.activeQ) 231 assert lenW==2,"lenW Should be 2, it is "+str(lenW) 232 assert R3.waitQ==[J3,J4],"WaitQ wrong"+str(R3.waitQ) 233 assert lenA==1,"lenA Should be 1, it is "+str(lenA) 234 assert R3.activeQ==[J2],"activeQ wrong, it is %s"%str(R3.activeQ[0])
235
236 - def testrequest4(self):
237 """Test request4 with capacity = 2 several requests""" 238 ## now test requesting: ------------------------------------ 239 s=SimulationRT() 240 s.initialize() 241 R3 = Resource(capacity=2,name="4-version",unitName="blobs",sim=s) 242 J2= Job(name="job",server=R3,sim=s) 243 J3= Job(name="job",server=R3,sim=s) 244 J4= Job(name="job",server=R3,sim=s) 245 s.activate(J2,J2.execute(), at=0.0) # requests a unit of R3 246 s.activate(J3,J3.execute(), at=0.0) # requests a unit of R3 247 s.activate(J4,J4.execute(), at=0.0) # requests a unit of R3 248 ## when simulation starts 249 s.simulate(until = 10.0) 250 assert R3.n == 0 , "Should be 0, it is "+str(R3.n) 251 lenW = len(R3.waitQ) 252 lenA = len(R3.activeQ) 253 assert lenW==1,"lenW Should be 1, it is "+str(lenW) 254 assert R3.waitQ==[J4],"WaitQ wrong"+str(R3.waitQ) 255 assert lenA==2,"lenA Should be 2, it is "+str(lenA) 256 assert R3.activeQ==[J2,J3],"activeQ wrong, it is %s"%str(R3.activeQ[0])
257 ## 258 #------- Test Priority Queues 259 ##
260 - def testrequestPriority(self):
261 """Test PriorityQ, with no preemption, 0 capacity""" 262 class Job(Process): 263 """ Job class for testing""" 264 def __init__(self,server=None,name="",sim=None): 265 Process.__init__(self,name=name,sim=sim) 266 self.R=server
267 268 def execute(self,priority): 269 yield request,self,self.R,priority
270 271 s=SimulationRT() 272 s.initialize() 273 Rp = Resource(capacity=0,qType=PriorityQ,sim=s) 274 J5 = Job(name="job 5",server=Rp,sim=s) 275 J6 = Job(name="job 6",server=Rp,sim=s) 276 J7 = Job(name="job 7",server=Rp,sim=s) 277 s.activate(J5,J5.execute(priority=3)) 278 s.activate(J6,J6.execute(priority=0)) 279 s.activate(J7,J7.execute(priority=1)) 280 s.simulate(until=100) 281 assert Rp.waitQ == [J5,J7,J6],"WaitQ wrong: %s"\ 282 %str([(x.name,x.priority[Rp]) for x in Rp.waitQ]) 283 284 """Test PriorityQ mechanism""" 285 286 def sorted(q): 287 if not q or len(q) == 1: 288 sortok=1 289 return sortok 290 sortok = q[0] >= q[1] and sorted(q[2:]) 291 return sortok 292 293 s=SimulationRT() 294 s.initialize() 295 Rp=Resource(capacity=0,qType=PriorityQ,sim=s) 296 for i in range(10): 297 J=Job(name="job "+str(i),server=Rp,sim=s) 298 s.activate(J,J.execute(priority=random())) 299 s.simulate(until=1000) 300 qp=[x._priority[Rp] for x in Rp.waitQ] 301 assert sorted(qp),"waitQ not sorted by priority: %s"\ 302 %str([(x.name,x._priority[Rp]) for x in Rp.waitQ]) 303
304 - def testrequestPriority1(self):
305 """Test PriorityQ, with no preemption, capacity == 1""" 306 class Job(Process): 307 """ Job class for testing""" 308 def __init__(self,server=None,name="",sim=None): 309 Process.__init__(self,name=name,sim=sim) 310 self.R=server
311 312 def execute(self,priority): 313 yield request,self,self.R,priority 314 315 s=SimulationRT() 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=name,sim=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.name,self.sim.now()) 351 yield release,self,res 352 353 s = SimulationRT() 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=name,sim=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=SimulationRT() 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=SimulationRT() 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=name,sim=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=SimulationRT() 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=SimulationRT() 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=SimulationRT() 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=SimulationRT() 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=SimulationRT() 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=SimulationRT() 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 not 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=SimulationRT() 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=SimulationRT() 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=SimulationRT() 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=SimulationRT() 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=SimulationRT() 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=SimulationRT() 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=SimulationRT() 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(sim=self.sim) 895 e1.signal() 896 e2=SimEvent(sim=self.sim) 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):
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(sim=self.sim) 919 e1.signal() 920 e2=SimEvent(sim=self.sim) 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=SimulationRT() 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=SimulationRT() 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 si=SimulationRT() 968 si.initialize() 969 e1=SimEvent("e1",sim=si) 970 e2=SimEvent("e2",sim=si) 971 e3=SimEvent("e3",sim=si) 972 s=SignalProcessOR(sim=si) 973 si.activate(s,s.makeSignal(e1,e3)) 974 w=WaitProcessOR(sim=si) 975 si.activate(w,w.waitForSig([e1,e2])) 976 for i in range(5): 977 q=QueueProcessOR(sim=si) 978 si.activate(q,q.queueForSig([e2,e3])) 979 si.simulate(until=10)
980
981 - def testSimEvents4(self):
982 """Tests that eventsFired reports all events which fired 983 """ 984 s=SimulationRT() 985 s.initialize() 986 w=WaitProcessOR1(sim=s) 987 s.activate(w,w.signalandwait()) 988 s.simulate(until=5)
989
990 - def testSimEvents5(self):
991 """Tests that eventsFired reports all events which fired 992 """ 993 s=SimulationRT() 994 s.initialize() 995 w=QueueProcessOR1(sim=s) 996 s.activate(w,w.signalandqueue()) 997 s.simulate(until=5)
998
999 -def makeESuite():
1000 suite=unittest.TestSuite() 1001 testSimEvents1=makeEtestcase("testSimEvents1") 1002 testSimEvents2=makeEtestcase("testSimEvents2") 1003 testSimEvents3=makeEtestcase("testSimEvents3") 1004 testSimEvents4=makeEtestcase("testSimEvents4") 1005 testSimEvents5=makeEtestcase("testSimEvents5") 1006 suite.addTests([testSimEvents1,testSimEvents2,testSimEvents3, 1007 testSimEvents4,testSimEvents5]) 1008 return suite
1009 1010 ## ------------------------------------------------------------- 1011 ## TEST waituntil 1012 ## ------------------------------------------------------------- 1013
1014 -class Signaller(Process):
1015 - def __init__(self,sim=None):
1016 Process.__init__(self,sim=sim)
1017 - def makeconditions(self,waiter):
1018 global a,b,c 1019 a=True 1020 yield hold,self,1 1021 b=True 1022 yield hold,self,1 1023 c=True 1024 yield hold,self,1 1025 assert waiter.terminated(),"waituntil did not fire"
1026
1027 -class Waiter(Process):
1028 - def __init__(self,sim=None):
1029 Process.__init__(self,sim=sim)
1030 - def waitforit(self):
1031 def waitcond(): 1032 return a and b and c
1033 yield waituntil,self,waitcond
1034
1035 -class makeWtestcase(unittest.TestCase):
1036 """ 1037 Test waituntil as introduced with SimPy 1.5 1038 """ 1039
1040 - def testwaituntil1(self):
1041 global a,b,c 1042 a=b=c=False 1043 si=SimulationRT() 1044 si.initialize() 1045 w=Waiter(sim=si) 1046 si.activate(w,w.waitforit()) 1047 s=Signaller(sim=si) 1048 si.activate(s,s.makeconditions(w)) 1049 si.simulate(until=5)
1050
1051 -def makeWSuite():
1052 suite=unittest.TestSuite() 1053 testwaituntil1=makeWtestcase("testwaituntil1") 1054 suite.addTests([testwaituntil1]) 1055 return suite
1056 1057 ## ------------------------------------------------------------- 1058 ## TEST COMPOUND "YIELD REQUEST" COMMANDS 1059 ## ------------------------------------------------------------- 1060 1061 ## ------------------------------------------------------------- 1062 ## TEST "yield (request,self,res),(hold,self,delay)" 1063 ## == timeout renege 1064 ## for both unmonitored and monitored resources 1065 ## ------------------------------------------------------------- 1066
1067 -class JobTO(Process):
1068 """ Job class for testing timeout reneging 1069 """
1070 - def __init__(self,server=None,name="",sim=None):
1071 Process.__init__(self,name=name,sim=sim) 1072 self.res=server 1073 self.gotResource=None
1074
1075 - def execute(self,timeout,usetime):
1076 yield (request,self,self.res),(hold,self,timeout) 1077 if self.acquired(self.res): 1078 self.gotResource=True 1079 yield hold,self,usetime 1080 yield release,self,self.res 1081 else: 1082 self.gotResource=False
1083
1084 -class JobTO_P(Process):
1085 """ Job class for testing timeout reneging with priorities 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,priority):
1093 yield (request,self,self.res,priority),(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 makeTimeoutTestcase(unittest.TestCase):
1102 """ Tests of "yield (request,self,res),(hold,self,delay)" 1103 timeout reneging command 1104 """
1105 - def testNoTimeout(self):
1106 """Test that resource gets acquired without timeout 1107 """ 1108 1109 s=SimulationRT() 1110 s.initialize() 1111 res=Resource(name="Server",capacity=1,sim=s) 1112 usetime=5 1113 timeout=1000000 1114 j1=JobTO(server=res,name="Job_1",sim=s) 1115 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime)) 1116 j2=JobTO(server=res,name="Job_2",sim=s) 1117 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime)) 1118 s.simulate(until=2*usetime) 1119 assert s.now()==2*usetime,"time not ==2*usetime" 1120 assert j1.gotResource and j2.gotResource,\ 1121 "at least one job failed to get resource" 1122 assert not (res.waitQ or res.activeQ),\ 1123 "job waiting or using resource"
1124
1125 - def testNoTimeoutM(self):
1126 """Test that resource gets acquired without timeout. 1127 Resource monitored. 1128 """ 1129 1130 s=SimulationRT() 1131 s.initialize() 1132 res=Resource(name="Server",capacity=1,monitored=True,sim=s) 1133 usetime=5 1134 timeout=1000000 1135 j1=JobTO(server=res,name="Job_1",sim=s) 1136 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime)) 1137 j2=JobTO(server=res,name="Job_2",sim=s) 1138 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime)) 1139 s.simulate(until=2*usetime) 1140 assert s.now()==2*usetime,"time not ==2*usetime" 1141 assert j1.gotResource and j2.gotResource,\ 1142 "at least one job failed to get resource" 1143 assert not (res.waitQ or res.activeQ),\ 1144 "job waiting or using resource" 1145 assert res.waitMon==[[0,1],[usetime,0]],"res.waitMon wrong: %s"%res.waitMon
1146
1147 - def testTimeout1(self):
1148 """Test that timeout occurs when resource busy 1149 """ 1150 1151 s=SimulationRT() 1152 s.initialize() 1153 res=Resource(name="Server",capacity=1,sim=s) 1154 usetime=5 1155 timeout=3 1156 j1=JobTO(server=res,name="Job_1",sim=s) 1157 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime)) 1158 j2=JobTO(server=res,name="Job_2",sim=s) 1159 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime)) 1160 s.simulate(until=2*usetime) 1161 assert(s.now()==usetime),"time not ==usetime" 1162 assert(j1.gotResource),"Job_1 did not get resource" 1163 assert(not j2.gotResource),"Job_2 did not renege" 1164 assert not (res.waitQ or res.activeQ),\ 1165 "job waiting or using resource"
1166
1167 - def testTimeout1M(self):
1168 """Test that timeout occurs when resource busy. 1169 Resource monitored. 1170 """ 1171 s=SimulationRT() 1172 s.initialize() 1173 res=Resource(name="Server",capacity=1,monitored=True,sim=s) 1174 usetime=5 1175 timeout=3 1176 j1=JobTO(server=res,name="Job_1",sim=s) 1177 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime)) 1178 j2=JobTO(server=res,name="Job_2",sim=s) 1179 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime)) 1180 s.simulate(until=2*usetime) 1181 assert(s.now()==usetime),"time not == usetime" 1182 assert(j1.gotResource),"Job_1 did not get resource" 1183 assert(not j2.gotResource),"Job_2 did not renege" 1184 assert not (res.waitQ or res.activeQ),\ 1185 "job waiting or using resource" 1186 assert res.waitMon==[[0,1],[timeout,0]],"res.waitMon wrong: %s"%res.waitMon
1187
1188 - def testTimeout_MP(self):
1189 """Test that timeout occurs when resource busy. 1190 Resource monitored. Requests with priority and preemption. 1191 """ 1192 s=SimulationRT() 1193 s.initialize() 1194 res=Resource(name="Server",capacity=1,monitored=True, 1195 qType=PriorityQ,preemptable=True,sim=s) 1196 usetime=5 1197 timeout=3 1198 j1=JobTO_P(server=res,name="Job_1",sim=s) 1199 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime,priority=1)) 1200 j2=JobTO_P(server=res,name="Job_2",sim=s) 1201 j2_arrival=1 1202 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime,priority=5), 1203 at=j2_arrival) 1204 j3=JobTO_P(server=res,name="Job_2",sim=s) 1205 j3_arrival=2 1206 s.activate(j3,j3.execute(timeout=timeout,usetime=usetime,priority=10), 1207 at=j3_arrival) 1208 s.simulate(until=3*usetime) 1209 assert(s.now()== 3*usetime),"time not == 2* usetime, but %s"%now() 1210 assert(j1.gotResource),"Job_1 did not get resource" 1211 assert(j2.gotResource),"Job_2 did renege" 1212 assert(j2.gotResource),"Job_3 did renege" 1213 assert not (res.waitQ or res.activeQ),\ 1214 "job waiting or using resource" 1215 assert res.waitMon==[[j2_arrival,1],[j3_arrival,2],[usetime+j3_arrival,1],[usetime+j2_arrival+usetime,0]],\ 1216 "res.waitMon wrong: %s"%res.waitMon
1217
1218 - def testTimeout2(self):
1219 """Test that timeout occurs when resource has no capacity free 1220 """ 1221 1222 s=SimulationRT() 1223 s.initialize() 1224 res=Resource(name="Server",capacity=0,sim=s) 1225 usetime=5 1226 timeout=3 1227 j1=JobTO(server=res,name="Job_1",sim=s) 1228 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime)) 1229 j2=JobTO(server=res,name="Job_2",sim=s) 1230 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime)) 1231 s.simulate(until=2*usetime) 1232 assert s.now()==timeout,"time %s not == timeout"%s.now() 1233 assert not j1.gotResource,"Job_1 got resource" 1234 assert not j2.gotResource,"Job_2 got resource" 1235 assert not (res.waitQ or res.activeQ),\ 1236 "job waiting or using resource"
1237
1238 - def testTimeout2M(self):
1239 """Test that timeout occurs when resource has no capacity free. 1240 Resource monitored. 1241 """ 1242 1243 s=SimulationRT() 1244 s.initialize() 1245 res=Resource(name="Server",capacity=0,monitored=True,sim=s) 1246 usetime=5 1247 timeout=3 1248 j1=JobTO(server=res,name="Job_1",sim=s) 1249 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime)) 1250 j2=JobTO(server=res,name="Job_2",sim=s) 1251 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime)) 1252 s.simulate(until=2*usetime) 1253 assert s.now()==timeout,"time %s not == timeout"%s.now() 1254 assert not j1.gotResource,"Job_1 got resource" 1255 assert not j2.gotResource,"Job_2 got resource" 1256 assert not (res.waitQ or res.activeQ),\ 1257 "job waiting or using resource" 1258 assert res.waitMon==[[0,1],[0,2],[timeout,1],[timeout,0]],\ 1259 "res.waitMon is wrong: %s"%res.waitMon
1260
1261 -def makeTOSuite():
1262 suite = unittest.TestSuite() 1263 testNoTimeout = makeTimeoutTestcase("testNoTimeout") 1264 testNoTimeoutM = makeTimeoutTestcase("testNoTimeoutM") 1265 testTimeout1=makeTimeoutTestcase("testTimeout1") 1266 testTimeout1M=makeTimeoutTestcase("testTimeout1M") 1267 testTimeout_MP=makeTimeoutTestcase("testTimeout_MP") 1268 testTimeout2=makeTimeoutTestcase("testTimeout2") 1269 testTimeout2M=makeTimeoutTestcase("testTimeout2M") 1270 suite.addTests([testNoTimeout,testNoTimeoutM,testTimeout1, 1271 testTimeout1M,testTimeout_MP,testTimeout2, 1272 testTimeout2M]) 1273 return suite
1274 1275 ## ------------------------------------------------------------------ 1276 ## TEST "yield (request,self,res),(waitevent,self,event)" 1277 ## == event renege 1278 ## for both unmonitored and monitored resources 1279 ## ------------------------------------------------------------------ 1280 1281
1282 -class JobEvt(Process):
1283 """ Job class for testing event reneging 1284 """
1285 - def __init__(self,server=None,name="",sim=None):
1286 Process.__init__(self,name=name,sim=sim) 1287 self.res=server 1288 self.gotResource=None
1289
1290 - def execute(self,event,usetime):
1291 yield (request,self,self.res),(waitevent,self,event) 1292 if self.acquired(self.res): 1293 self.gotResource=True 1294 yield hold,self,usetime 1295 yield release,self,self.res 1296 else: 1297 self.gotResource=False
1298
1299 -class JobEvtMulti(Process):
1300 """ Job class for testing event reneging with multi-event lists 1301 """
1302 - def __init__(self,server=None,name="",sim=None):
1303 Process.__init__(self,name=name,sim=sim) 1304 self.res=server 1305 self.gotResource=None
1306
1307 - def execute(self,eventlist,usetime):
1308 yield (request,self,self.res),(waitevent,self,eventlist) 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 FireEvent(Process):
1317 """Fires reneging event 1318 """
1319 - def __init__(self,name="",sim=None):
1320 Process.__init__(self,name=name,sim=sim)
1321 - def fire(self,fireDelay,event):
1322 yield hold,self,fireDelay 1323 event.signal()
1324
1325 -class makeEventRenegeTestcase(unittest.TestCase):
1326 """Tests of "yield (request,self,res),(waiteevent,self,event)" 1327 event reneging command 1328 """
1329 - def testNoEvent(self):
1330 """Test that processes acquire resource normally if no event fires 1331 """ 1332 s=SimulationRT() 1333 s.initialize() 1334 event=SimEvent("Renege_trigger",sim=s) #never gets fired 1335 res=Resource(name="Server",capacity=1,sim=s) 1336 usetime=5 1337 j1=JobEvt(server=res,name="Job_1",sim=s) 1338 s.activate(j1,j1.execute(event=event,usetime=usetime)) 1339 j2=JobEvt(server=res,name="Job_2",sim=s) 1340 s.activate(j2,j2.execute(event=event,usetime=usetime)) 1341 s.simulate(until=2*usetime) 1342 # Both jobs should get server (in sequence) 1343 assert s.now()==2*usetime,"time not ==2*usetime" 1344 assert j1.gotResource and j2.gotResource,\ 1345 "at least one job failed to get resource" 1346 assert not (res.waitQ or res.activeQ),\ 1347 "job waiting or using resource"
1348
1349 - def testNoEventM(self):
1350 """Test that processes acquire resource normally if no event fires. 1351 Resource monitored. 1352 """ 1353 s=SimulationRT() 1354 s.initialize() 1355 res=Resource(name="Server",capacity=1,monitored=True,sim=s) 1356 event=SimEvent("Renege_trigger",sim=s) #never gets fired 1357 usetime=5 1358 j1=JobEvt(server=res,name="Job_1",sim=s) 1359 s.activate(j1,j1.execute(event=event,usetime=usetime)) 1360 j2=JobEvt(server=res,name="Job_2",sim=s) 1361 s.activate(j2,j2.execute(event=event,usetime=usetime)) 1362 s.simulate(until=2*usetime) 1363 # Both jobs should get server (in sequence) 1364 assert s.now()==2*usetime,"time not ==2*usetime" 1365 assert j1.gotResource and j2.gotResource,\ 1366 "at least one job failed to get resource" 1367 assert not (res.waitQ or res.activeQ),\ 1368 "job waiting or using resource" 1369 assert res.waitMon==[[0,1],[usetime,0]],"res.waitMoni is wrong: %s"%res.waitMon
1370
1371 - def testWaitEvent1(self):
1372 """Test that signalled event leads to renege when resource busy 1373 """ 1374 1375 s=SimulationRT() 1376 s.initialize() 1377 res=Resource(name="Server",capacity=1,sim=s) 1378 event=SimEvent("Renege_trigger",sim=s) 1379 usetime=5 1380 eventtime=1 1381 j1=JobEvt(server=res,name="Job_1",sim=s) 1382 s.activate(j1,j1.execute(event=event,usetime=usetime)) 1383 j2=JobEvt(server=res,name="Job_2",sim=s) 1384 s.activate(j2,j2.execute(event=event,usetime=usetime)) 1385 f=FireEvent(name="FireEvent",sim=s) 1386 s.activate(f,f.fire(fireDelay=eventtime,event=event)) 1387 s.simulate(until=2*usetime) 1388 # Job_1 should get server, Job_2 renege 1389 assert(s.now()==usetime),"time not ==usetime" 1390 assert(j1.gotResource),"Job_1 did not get resource" 1391 assert(not j2.gotResource),"Job_2 did not renege" 1392 assert not (res.waitQ or res.activeQ),\ 1393 "job waiting or using resource"
1394
1395 - def testWaitEvent1M(self):
1396 """Test that signalled event leads to renege when resource busy. 1397 Resource monitored. 1398 """ 1399 1400 s=SimulationRT() 1401 s.initialize() 1402 res=Resource(name="Server",capacity=1,monitored=True,sim=s) 1403 event=SimEvent("Renege_trigger",sim=s) 1404 usetime=5 1405 eventtime=1 1406 j1=JobEvt(server=res,name="Job_1",sim=s) 1407 s.activate(j1,j1.execute(event=event,usetime=usetime)) 1408 j2=JobEvt(server=res,name="Job_2",sim=s) 1409 s.activate(j2,j2.execute(event=event,usetime=usetime)) 1410 f=FireEvent(name="FireEvent",sim=s) 1411 s.activate(f,f.fire(fireDelay=eventtime,event=event)) 1412 s.simulate(until=2*usetime) 1413 # Job_1 should get server, Job_2 renege 1414 assert(s.now()==usetime),"time not == usetime" 1415 assert(j1.gotResource),"Job_1 did not get resource" 1416 assert(not j2.gotResource),"Job_2 did not renege" 1417 assert not (res.waitQ or res.activeQ),\ 1418 "job waiting or using resource" 1419 assert res.waitMon==[[0,1],[eventtime,0]],"res.waitMon is wrong: %s"%res.waitMon
1420
1421 - def testWaitEvent2(self):
1422 """Test that renege-triggering event can be one of an event list 1423 """ 1424 1425 s=SimulationRT() 1426 s.initialize() 1427 res=Resource(name="Server",capacity=1,sim=s) 1428 event1=SimEvent("Renege_trigger_1",sim=s) 1429 event2=SimEvent("Renege_trigger_2",sim=s) 1430 usetime=5 1431 eventtime=1 #for both events 1432 j1=JobEvtMulti(server=res,name="Job_1",sim=s) 1433 s.activate(j1,j1.execute(eventlist=[event1,event2],usetime=usetime)) 1434 j2=JobEvtMulti(server=res,name="Job_2",sim=s) 1435 s.activate(j2,j2.execute(eventlist=[event1,event2],usetime=usetime)) 1436 f1=FireEvent(name="FireEvent_1",sim=s) 1437 s.activate(f1,f1.fire(fireDelay=eventtime,event=event1)) 1438 f2=FireEvent(name="FireEvent_2",sim=s) 1439 s.activate(f2,f2.fire(fireDelay=eventtime,event=event2)) 1440 s.simulate(until=2*usetime) 1441 # Job_1 should get server, Job_2 should renege 1442 assert(s.now()==usetime),"time not ==usetime" 1443 assert(j1.gotResource),"Job_1 did not get resource" 1444 assert(not j2.gotResource),"Job_2 did not renege" 1445 assert not (res.waitQ or res.activeQ),\ 1446 "job waiting or using resource"
1447
1448 - def testWaitEvent2M(self):
1449 """Test that renege-triggering event can be one of an event list. 1450 Resource monitored. 1451 """ 1452 1453 s=SimulationRT() 1454 s.initialize() 1455 res=Resource(name="Server",capacity=1,monitored=True,sim=s) 1456 event1=SimEvent("Renege_trigger_1",sim=s) 1457 event2=SimEvent("Renege_trigger_2",sim=s) 1458 usetime=5 1459 eventtime=1 #for both events 1460 j1=JobEvtMulti(server=res,name="Job_1",sim=s) 1461 s.activate(j1,j1.execute(eventlist=[event1,event2],usetime=usetime)) 1462 j2=JobEvtMulti(server=res,name="Job_2",sim=s) 1463 s.activate(j2,j2.execute(eventlist=[event1,event2],usetime=usetime)) 1464 f1=FireEvent(name="FireEvent_1",sim=s) 1465 s.activate(f1,f1.fire(fireDelay=eventtime,event=event1)) 1466 f2=FireEvent(name="FireEvent_2",sim=s) 1467 s.activate(f2,f2.fire(fireDelay=eventtime,event=event2)) 1468 s.simulate(until=2*usetime) 1469 # Job_1 should get server, Job_2 should renege 1470 assert(s.now()==usetime),"time not ==usetime" 1471 assert(j1.gotResource),"Job_1 did not get resource" 1472 assert(not j2.gotResource),"Job_2 did not renege" 1473 assert not (res.waitQ or res.activeQ),\ 1474 "job waiting or using resource" 1475 assert res.waitMon==[[0,1],[eventtime,0]],"res.waitMon is wrong: %s"%res.waitMon
1476
1477 -def makeEvtRenegeSuite():
1478 suite = unittest.TestSuite() 1479 testNoEvent = makeEventRenegeTestcase("testNoEvent") 1480 testNoEventM = makeEventRenegeTestcase("testNoEventM") 1481 testWaitEvent1=makeEventRenegeTestcase("testWaitEvent1") 1482 testWaitEvent1M=makeEventRenegeTestcase("testWaitEvent1M") 1483 testWaitEvent2=makeEventRenegeTestcase("testWaitEvent2") 1484 testWaitEvent2M=makeEventRenegeTestcase("testWaitEvent2M") 1485 1486 suite.addTests([testNoEvent,testNoEventM,testWaitEvent1, 1487 testWaitEvent1M,testWaitEvent2,testWaitEvent2M]) 1488 return suite
1489 1490 ## ------------------------------------------------------------------ 1491 ## TEST "yield get,self,level,whatToGet" and 1492 ## "yield put,self,level,whatToPut,priority" 1493 ## for Level instances 1494 ## ------------------------------------------------------------------
1495 -class Producer(Process):
1496 produced=0
1497 - def __init__(self,name="",sim=None):
1498 Process.__init__(self,name=name,sim=sim)
1499 - def produce(self,buffer):
1500 for i in range(4): 1501 Producer.produced+=1 1502 yield put,self,buffer 1503 yield hold,self,1
1504 - def producePriority(self,buffer,priority):
1505 """PriorityQ for Producers""" 1506 Producer.produced+=4 1507 yield put,self,buffer,4,priority 1508 yield hold,self,1 1509 self.done=self.sim.now() 1510 doneList.append(self.name)
1511 - def produce1(self,buffer):
1512 for i in range(4): 1513 yield put,self,buffer,4 1514 yield hold,self,1
1515 -class Consumer(Process):
1516 consumed=0
1517 - def __init__(self,name="",sim=None):
1518 Process.__init__(self,name=name,sim=sim)
1519 - def consume(self,buffer):
1520 """FIFO""" 1521 yield get,self,buffer 1522 Consumer.consumed+=1 1523 assert self.got==1,"wrong self.got: %s"%self.got 1524 yield get,self,buffer,3 1525 Consumer.consumed+=3 1526 assert self.got==3,"wrong self.got: %s"%self.got
1527
1528 - def consume1(self,buffer):
1529 """producer PriorityQ, consumer FIFO""" 1530 while True: 1531 yield get,self,buffer,2 1532 yield hold,self,1
1533 - def consumePriority(self,buffer,priority):
1534 """PriorityQ for Consumers""" 1535 yield get,self,buffer,4,priority 1536 doneList.append(self.name)
1537 1538 ### Begin classes for testConPrinciple (Level) ###
1539 -class ProducerPrincL(Process):
1540 - def __init__(self,sim=None):
1541 Process.__init__(self,sim=sim)
1542 - def produce(self,buffer,productionTime):
1543 while True: 1544 assert not(buffer.amount>0 and len(buffer.getQ)>0),\ 1545 "Consumer(s) waiting while buffer not empty" 1546 yield hold,self,productionTime 1547 yield put,self,buffer,1
1548
1549 -class ConsumerPrincL(Process):
1550 - def __init__(self,sim=None):
1551 Process.__init__(self,sim=sim)
1552 - def consume(self,buffer,consumptionTime):
1553 while True: 1554 assert not(buffer.amount==0 and len(buffer.putQ)>0),\ 1555 "Producer(s) waiting while buffer empty" 1556 yield get,self,buffer,1 1557 yield hold,self,consumptionTime
1558 1559 ### End classes for testConPrinciple (Level) ### 1560
1561 -class makeLevelTestcase(unittest.TestCase):
1562 - def testStatic(self):
1563 """Tests initialization of Level instances 1564 """ 1565 s=SimulationRT() 1566 s.initialize() 1567 a=Level(sim=s) 1568 assert a.capacity==sys.maxint,"wrong capacity:%s"%a 1569 assert a.amount==0,"wrong buffer content: %s"%a 1570 assert a.name=="a_level","wrong name: %s"%a 1571 assert not a.monitored,"should not be monitored: %s"%a 1572 assert a.putQMon is None,"should not have putQMon: %s"%a 1573 assert a.getQMon is None,"should not have getQMon: %s"%a 1574 assert a.bufferMon is None,"should not have bufferMon: %s"%a 1575 assert a.putQType.__name__=="FIFO" and a.getQType.__name__=="FIFO",\ 1576 "putQType and getQType should be FIFO: %s"%a 1577 1578 b=Level(name="b",initialBuffered=10.0,monitored=True,capacity=12, 1579 putQType=PriorityQ,sim=s) 1580 a=Level(sim=s) 1581 assert b.capacity==12,"wrong capacity:%s"%b 1582 assert b.amount==10,"wrong buffer content: %s"%b 1583 assert b.name=="b","wrong name: %s"%b 1584 assert b.monitored,"should be monitored: %s"%b 1585 assert not (b.putQMon is None),"should have putQMon: %s"%b 1586 assert not (b.getQMon is None),"should have getQMon: %s"%b 1587 assert not (b.bufferMon is None),"should have bufferMon: %s"%b 1588 assert b.putQType.__name__=="PriorityQ",\ 1589 "putQType should be PriorityQ: %s"%b 1590 assert b.getQType.__name__=="FIFO",\ 1591 "getQType should be PriorityQ: %s"%b
1592
1593 - def testConProdPrinciple(self):
1594 """Level: tests basic Producer/Consumer principles: 1595 - Consumers must not be waiting while Level buffer value > 0, 1596 - Producers must not be waiting while Level buffer value == 0 1597 """ 1598 s=SimulationRT() 1599 s.initialize() 1600 bufferSize=1 1601 productionTime=1 1602 consumptionTime=5 1603 endtime=50 1604 buffer=Level(capacity=bufferSize,sim=s) 1605 consumer=ConsumerPrincL(sim=s) 1606 s.activate(consumer,consumer.consume(buffer,consumptionTime)) 1607 producer=ProducerPrincL(sim=s) 1608 s.activate(producer,producer.produce(buffer,productionTime)) 1609 s.simulate(until=endtime)
1610
1611 - def testConProd1(self):
1612 """Level: tests put/get in 1 Producer/ 1 Consumer scenario""" 1613 s=SimulationRT() 1614 s.initialize() 1615 buffer=Level(initialBuffered=0,sim=s) 1616 p=Producer(sim=s) 1617 s.activate(p,p.produce(buffer)) 1618 c=Consumer(sim=s) 1619 s.activate(c,c.consume(buffer)) 1620 s.simulate(until=100) 1621 assert Producer.produced-Consumer.consumed==buffer.amount,\ 1622 "items produced/consumed/buffered do not tally: %s %s %s"\ 1623 %(Producer.produced,Consumer.consumed,buffer.amount)
1624
1625 - def testConProdM(self):
1626 """Level: tests put/get in multiple Producer/Consumer scenario""" 1627 s=SimulationRT() 1628 s.initialize() 1629 buffer=Level(initialBuffered=0,sim=s) 1630 Producer.produced=0 1631 Consumer.consumed=0 1632 for i in range(2): 1633 c=Consumer(sim=s) 1634 s.activate(c,c.consume(buffer)) 1635 for i in range(3): 1636 p=Producer(sim=s) 1637 s.activate(p,p.produce(buffer)) 1638 s.simulate(until=10) 1639 assert Producer.produced-Consumer.consumed==buffer.amount,\ 1640 "items produced/consumed/buffered do not tally: %s %s %s"\ 1641 %(Producer.produced,Consumer.consumed,buffer.amount)
1642
1643 - def testConProdPriorM(self):
1644 """Level: tests put/get in multiple Producer/Consumer scenario, 1645 with Producers having different priorities. 1646 How: Producers forced to queue; all after first should be done in 1647 priority order 1648 """ 1649 global doneList 1650 doneList=[] 1651 s=SimulationRT() 1652 s.initialize() 1653 buffer=Level(capacity=7,putQType=PriorityQ,monitored=True,sim=s) 1654 for i in range(4): 1655 p=Producer(i,sim=s) 1656 pPriority=i 1657 s.activate(p,p.producePriority(buffer=buffer,priority=pPriority)) 1658 c=Consumer(sim=s) 1659 s.activate(c,c.consume1(buffer=buffer)) 1660 s.simulate(until=100) 1661 assert doneList==[0,3,2,1],"puts were not done in priority order: %s"\ 1662 %doneList
1663
1664 - def testConPriorProdM(self):
1665 """Level: tests put/get in multiple Producer/Consumer scenario, with 1666 Consumers having different priorities. 1667 How: Consumers forced to queue; all after first should be done in 1668 priority order 1669 """ 1670 global doneList 1671 doneList=[] 1672 s=SimulationRT() 1673 s.initialize() 1674 buffer=Level(capacity=7,getQType=PriorityQ,monitored=True,sim=s) 1675 for i in range(4): 1676 c=Consumer(i,sim=s) 1677 cPriority=i 1678 s.activate(c,c.consumePriority(buffer=buffer,priority=cPriority)) 1679 p=Producer(sim=s) 1680 s.activate(p,p.produce1(buffer=buffer)) 1681 s.simulate(until=100) 1682 assert doneList==[3,2,1,0],"gets were not done in priority order: %s"\ 1683 %doneList
1684
1685 -def makeLevelSuite():
1686 suite = unittest.TestSuite() 1687 testStatic = makeLevelTestcase("testStatic") 1688 testConProdPrinciple=makeLevelTestcase("testConProdPrinciple") 1689 testConProd1=makeLevelTestcase("testConProd1") 1690 testConProdM=makeLevelTestcase("testConProdM") 1691 testConProdPriorM=makeLevelTestcase("testConProdPriorM") 1692 testConPriorProdM=makeLevelTestcase("testConPriorProdM") 1693 suite.addTests([testStatic,testConProdPrinciple,testConProd1, 1694 testConProdM,testConProdPriorM,testConPriorProdM]) 1695 return suite
1696 1697 ## ------------------------------------------------------------------ 1698 ## TEST "yield get,self,store,whatToGet" and 1699 ## "yield put,self,store,whatToPut" 1700 ## for Store instances 1701 ## ------------------------------------------------------------------ 1702
1703 -class ProducerWidget(Process):
1704 produced=0
1705 - def __init__(self,name="",sim=None):
1706 Process.__init__(self,name=name,sim=sim)
1707 - def produce(self,buffer):
1708 for i in range(4): 1709 ProducerWidget.produced+=1 1710 yield put,self,buffer,[Widget(weight=5)] 1711 yield hold,self,1
1712 - def producePriority(self,buffer,priority):
1713 """PriorityQ for Producers""" 1714 ProducerWidget.produced+=4 1715 toStore=[Widget(weight=5)]*4 1716 yield put,self,buffer,toStore,priority 1717 yield hold,self,1 1718 self.done=self.sim.now() 1719 doneList.append(self.name)
1720 - def produce1(self,buffer):
1721 for i in range(4): 1722 yield put,self,buffer,[Widget(weight=5)]*4 1723 yield hold,self,1
1724 - def produceUnordered(self,buffer):
1725 produced=[Widget(weight=i) for i in [9,1,8,2,7,3,6,4,5]] 1726 yield put,self,buffer,produced
1727
1728 -class ConsumerWidget(Process):
1729 consumed=0
1730 - def __init__(self,name="",sim=None):
1731 Process.__init__(self,name=name,sim=sim)
1732 - def consume(self,buffer):
1733 """FIFO""" 1734 yield get,self,buffer 1735 ConsumerWidget.consumed+=1 1736 assert len(self.got)==1,"wrong self.got: %s"%self.got 1737 yield get,self,buffer,3 1738 ConsumerWidget.consumed+=3 1739 assert len(self.got)==3,"wrong self.got: %s"%self.got
1740
1741 - def consume1(self,buffer):
1742 """producer PriorityQ, consumer FIFO""" 1743 while True: 1744 yield get,self,buffer,2 1745 yield hold,self,1
1746
1747 - def consumePriority(self,buffer,priority):
1748 """PriorityQ for Consumers""" 1749 yield get,self,buffer,4,priority 1750 doneList.append(self.name)
1751
1752 - def consumeSorted(self,buffer,gotten):
1753 yield get,self,buffer 1754 gotten.append(self.got[0].weight)
1755
1756 -class Widget:
1757 - def __init__(self,weight):
1758 self.weight=weight
1759
1760 -def mySortFunc(self,par):
1761 """Sorts Widget instances by weight attribute.""" 1762 tmplist=[(x.weight,x) for x in par] 1763 tmplist.sort() 1764 return [x for (key,x) in tmplist]
1765 1766 ### Begin classes for testConPrinciple (Store) ###
1767 -class ProducerPrincS(Process):
1768 - def __init__(self,sim=None):
1769 Process.__init__(self,sim=sim)
1770 - def produce(self,buffer,productionTime):
1771 while True: 1772 assert not(buffer.nrBuffered>0 and len(buffer.getQ)>0),\ 1773 "Consumer(s) waiting while buffer not empty" 1774 yield hold,self,productionTime 1775 product=WidgetPrinc() 1776 yield put,self,buffer,[product]
1777
1778 -class ConsumerPrincS(Process):
1779 - def __init__(self,sim=None):
1780 Process.__init__(self,sim=sim)
1781 - def consume(self,buffer,consumptionTime):
1782 while True: 1783 assert not(buffer.nrBuffered==0 and buffer.putQ),\ 1784 "Producer(s) waiting while buffer empty" 1785 yield get,self,buffer,1 1786 yield hold,self,consumptionTime
1787
1788 -class WidgetPrinc:
1789 pass
1790
1791 -class FilterConsumer(Process):
1792 """Used in testBufferFilter"""
1793 - def __init__(self,sim=None):
1794 Process.__init__(self,sim=sim)
1795 - class Widget:
1796 - def __init__(self,weighs):
1797 self.weight=weighs
1798
1799 - def getItems(self,store,a,b):
1800 """get all items with weight between a and b""" 1801 def between_a_and_b(buf): 1802 res=[] 1803 for item in buf: 1804 if a<item.weight<b: 1805 res.append(item)
1806 1807 all=store.buffered 1808 yield get,self,store,between_a_and_b 1809 "All retrieved items weight in range?" 1810 for it in self.got: 1811 assert a<it.weight<b,"weight %s not in range %s..%s"\ 1812 %(it.weight,a,b) 1813 "Any item fitting filter pred left in buffer?" 1814 for it in store.buffer: 1815 assert not (a<it.weight<b),\ 1816 "item left in buffer which fits filter (%s<%s<%s)"\ 1817 %(a,it.weight,b) 1818 "All items either in store.buffer of self.got?" 1819 for it in all: 1820 assert (it in self.buffer) or (it in self.got),\ 1821 "item w. weight %s neither in store nor in got"%it.weight
1822 1823 ### End classes for testConPrinciple (Store) ### 1824
1825 -class makeStoreTestcase(unittest.TestCase):
1826 - def testStatic(self):
1827 """Store: tests initialization of Store instances 1828 """ 1829 s=SimulationRT() 1830 s.initialize() 1831 a=Store(sim=s) 1832 assert a.capacity==sys.maxint,"wrong capacity:%s"%a 1833 assert a.nrBuffered==0,"wrong buffer content: %s"%a 1834 assert a.name=="a_store","wrong name: %s"%a 1835 assert not a.monitored,"should not be monitored: %s"%a 1836 assert a.putQMon is None,"should not have putQMon: %s"%a 1837 assert a.getQMon is None,"should not have getQMon: %s"%a 1838 assert a.bufferMon is None,"should not have bufferMon: %s"%a 1839 assert a.putQType.__name__=="FIFO" and a.getQType.__name__=="FIFO",\ 1840 "putQType and getQType should be FIFO: %s"%a 1841 1842 stored=[Widget(weight=5)]*10 1843 b=Store(name="b",initialBuffered=stored,monitored=True,capacity=12, 1844 putQType=PriorityQ,sim=s) 1845 assert b.capacity==12,"wrong capacity:%s"%b 1846 assert b.nrBuffered==10,"wrong buffer content: %s"%b 1847 assert b.name=="b","wrong name: %s"%b 1848 assert b.monitored,"should be monitored: %s"%b 1849 assert not (b.putQMon is None),"should have putQMon: %s"%b 1850 assert not (b.getQMon is None),"should have getQMon: %s"%b 1851 assert not (b.bufferMon is None),"should have bufferMon: %s"%b 1852 assert b.putQType.__name__=="PriorityQ",\ 1853 "putQType should be PriorityQ: %s"%b 1854 assert b.getQType.__name__=="FIFO",\ 1855 "getQType should be PriorityQ: %s"%b
1856
1857 - def testConProdPrinciple(self):
1858 """Store: tests basic Producer/Consumer principles: 1859 - Consumers must not be waiting while items in Store buffer, 1860 - Producers must not be waiting while space available in Store buffer 1861 """ 1862 bufferSize=1 1863 productionTime=1 1864 consumptionTime=5 1865 endtime=50 1866 s=SimulationRT() 1867 s.initialize() 1868 buffer=Store(capacity=bufferSize,sim=s) 1869 consumer=ConsumerPrincS(sim=s) 1870 s.activate(consumer,consumer.consume(buffer,consumptionTime)) 1871 producer=ProducerPrincS(sim=s) 1872 s.activate(producer,producer.produce(buffer,productionTime)) 1873 s.simulate(until=endtime)
1874
1875 - def testConProd1(self):
1876 """Store: tests put/get in 1 Producer/ 1 Consumer scenario""" 1877 s=SimulationRT() 1878 s.initialize() 1879 buffer=Store(initialBuffered=[],sim=s) 1880 p=ProducerWidget(sim=s) 1881 s.activate(p,p.produce(buffer)) 1882 c=ConsumerWidget(sim=s) 1883 s.activate(c,c.consume(buffer)) 1884 s.simulate(until=100) 1885 assert \ 1886 ProducerWidget.produced-ConsumerWidget.consumed==buffer.nrBuffered,\ 1887 "items produced/consumed/buffered do not tally: %s %s %s"\ 1888 %(ProducerWidget.produced,ConsumerWidget.consumed,buffer.nrBuffered)
1889
1890 - def testConProdM(self):
1891 """Store: tests put/get in multiple Producer/Consumer scenario""" 1892 s=SimulationRT() 1893 s.initialize() 1894 buffer=Store(initialBuffered=[],sim=s) 1895 ProducerWidget.produced=0 1896 ConsumerWidget.consumed=0 1897 for i in range(2): 1898 c=ConsumerWidget(sim=s) 1899 s.activate(c,c.consume(buffer)) 1900 for i in range(3): 1901 p=ProducerWidget(sim=s) 1902 s.activate(p,p.produce(buffer)) 1903 s.simulate(until=10) 1904 assert ProducerWidget.produced-ConsumerWidget.consumed==buffer.nrBuffered,\ 1905 "items produced/consumed/buffered do not tally: %s %s %s"\ 1906 %(ProducerWidget.produced,ConsumerWidget.consumed,buffer.nrBuffered)
1907
1908 - def testConProdPriorM(self):
1909 """Store: Tests put/get in multiple Producer/Consumer scenario, 1910 with Producers having different priorities. 1911 How; Producers forced to queue; all after first should be done in 1912 priority order 1913 """ 1914 global doneList 1915 doneList=[] 1916 s=SimulationRT() 1917 s.initialize() 1918 buffer=Store(capacity=7,putQType=PriorityQ,monitored=True,sim=s) 1919 for i in range(4): 1920 p=ProducerWidget(name=i,sim=s) 1921 pPriority=i 1922 s.activate(p,p.producePriority(buffer=buffer,priority=pPriority)) 1923 c=ConsumerWidget(sim=s) 1924 s.activate(c,c.consume1(buffer=buffer)) 1925 s.simulate(until=100) 1926 assert doneList==[0,3,2,1],"puts were not done in priority order: %s"\ 1927 %doneList
1928
1929 - def testConPriorProdM(self):
1930 """Tests put/get in multiple Producer/Consumer scenario, with 1931 Consumers having different priorities. 1932 How; Consumers forced to queue; all after first should be done in 1933 priority order 1934 """ 1935 global doneList 1936 doneList=[] 1937 s=SimulationRT() 1938 s.initialize() 1939 buffer=Store(capacity=7,getQType=PriorityQ,monitored=True,sim=s) 1940 for i in range(4): 1941 c=ConsumerWidget(name=str(i),sim=s) 1942 cPriority=i 1943 s.activate(c,c.consumePriority(buffer=buffer,priority=cPriority)) 1944 p=ProducerWidget(sim=s) 1945 s.activate(p,p.produce1(buffer=buffer)) 1946 s.simulate(until=100) 1947 assert doneList==["3","2","1","0"],\ 1948 "gets were not done in priority order: %s"%doneList
1949
1950 - def testBufferSort(self):
1951 """Tests the optional sorting of theBuffer by applying a user-defined 1952 sort function.""" 1953 s=SimulationRT() 1954 s.initialize() 1955 gotten=[] 1956 sortedStore=Store(sim=s) 1957 sortedStore.addSort(mySortFunc) 1958 p=ProducerWidget(sim=s) 1959 s.activate(p,p.produceUnordered(sortedStore)) 1960 for i in range(9): 1961 c=ConsumerWidget(sim=s) 1962 s.activate(c,c.consumeSorted(buffer=sortedStore,gotten=gotten),at=1) 1963 s.simulate(until=10) 1964 assert gotten==[1,2,3,4,5,6,7,8,9],"sort wrong: %s"%gotten
1965
1966 - def testBufferFilter(self):
1967 """Tests get from a Store with a filter function 1968 """ 1969 s=SimulationRT() 1970 s.initialize() 1971 ItClass=FilterConsumer.Widget 1972 all=[ItClass(1),ItClass(4),ItClass(6),ItClass(12)] 1973 st=Store(initialBuffered=all) 1974 fc=FilterConsumer() 1975 minw=2;maxw=10 1976 s.activate(fc,fc.getItems(store=st,a=minw,b=maxw)) 1977 s.simulate(until=1)
1978
1979 -def makeStoreSuite():
1980 suite = unittest.TestSuite() 1981 testStatic = makeStoreTestcase("testStatic") 1982 testConProdPrinciple=makeStoreTestcase("testConProdPrinciple") 1983 testConProd1=makeStoreTestcase("testConProd1") 1984 testConProdM=makeStoreTestcase("testConProdM") 1985 testConProdPriorM=makeStoreTestcase("testConProdPriorM") 1986 testConPriorProdM=makeStoreTestcase("testConPriorProdM") 1987 testBufferSort=makeStoreTestcase("testBufferSort") 1988 testBufferFilter=makeStoreTestcase("testBufferFilter") 1989 suite.addTests([testStatic,testConProdPrinciple,testConProd1, 1990 testConProdM,testConProdPriorM,testConPriorProdM, 1991 testBufferSort,testBufferFilter]) 1992 return suite
1993 1994 ## ------------------------------------------------------------------ 1995 ## 1996 ## Store: Tests for compound get/put 1997 ## 1998 ## ------------------------------------------------------------------
1999 -class TBT(Process):
2000 """Store: For testBasicTime"""
2001 - def __init__(self,sim=None):
2002 Process.__init__(self,sim=sim)
2003 - def tbt(self,store):
2004 yield get,self,store,1 2005 assert self.got,"Did not get Item" 2006 yield (get,self,store,1),(hold,self,5) 2007 if self.acquired(store): 2008 assert len(self.got)==1,"did not get 1 Item" 2009 else: 2010 assert not self.got and self.sim.now()==5 and not store.getQ,\ 2011 "time renege not working"
2012
2013 -class TBE(Process):
2014 """Store: For testBasicEvent"""
2015 - def __init__(self,name="",sim=None):
2016 Process.__init__(self,sim=sim)
2017 - def tbe(self,store,trigger):
2018 yield get,self,store,1 2019 assert self.got,"Did not get Item" 2020 yield (get,self,store,1),(waitevent,self,trigger) 2021 if self.acquired(store): 2022 assert False, "should have reneged" 2023 else: 2024 assert self.eventsFired[0]==trigger and self.sim.now()==5 \ 2025 and not store.getQ,"event renege not working"
2026
2027 -class TBEtrigger(Process):
2028 """Store: For testBasicEvent"""
2029 - def __init__(self,sim=None):
2030 Process.__init__(self,sim=sim)
2031 - def fire(self,trigger):
2032 yield hold,self,5 2033 trigger.signal()
2034 2035
2036 -class TBTput(Process):
2037 """Store: for testBasicTimePut"""
2038 - def __init__(self,sim=None):
2039 Process.__init__(self,sim=sim)
2040 - def tbt(self,store):
2041 class Item:pass 2042 yield (put,self,store,[Item()]),(hold,self,4) 2043 if self.stored(store): 2044 assert store.nrBuffered==1 and not store.putQ,\ 2045 "put did not execute" 2046 else: 2047 assert False,"should not have reneged" 2048 yield (put,self,store,[Item()]),(hold,self,5) 2049 if self.stored(store): 2050 assert False,"should have reneged" 2051 else: 2052 assert store.nrBuffered==1 and not store.putQ,\ 2053 "renege not working correctly"
2054
2055 -class TBEput(Process):
2056 """Store: for testBasicEventPut"""
2057 - def __init__(self,sim=None):
2058 Process.__init__(self,sim=sim)
2059 - def tbe(self,store,trigger):
2060 class Item:pass 2061 yield (put,self,store,[Item()]),(waitevent,self,trigger) 2062 if self.stored(store): 2063 assert store.nrBuffered==1 and not store.putQ,\ 2064 "put did not execute" 2065 else: 2066 assert False,"should have not have reneged" 2067 yield (put,self,store,[Item()]),(waitevent,self,trigger) 2068 if self.stored(store): 2069 assert False,"should have reneged" 2070 else: 2071 assert self.sim.now()==5 and self.eventsFired[0]==trigger\ 2072 and not store.putQ,"renege not working correctly"
2073
2074 -class TBEtriggerPut(Process):
2075 """Store: For testBasicEventPut"""
2076 - def __init__(self,sim=None):
2077 Process.__init__(self,sim=sim)
2078 - def fire(self,trigger):
2079 yield hold,self,5 2080 trigger.signal()
2081
2082 -class makeStoreCompTestcase(unittest.TestCase):
2083 """Store: Testcase for compound get statements""" 2084 ## ------------------------------------------------------------------ 2085 ## TEST "yield (get,self,store),(hold,self,time)" 2086 ## == timeout renege 2087 ## for both unmonitored and monitored Stores 2088 ## ------------------------------------------------------------------ 2089
2090 - def testBasicTime(self):
2091 """Store (unmonitored): 2092 test 'yield (get,self,store),(hold,self,timeout)""" 2093 s=SimulationRT() 2094 s.initialize() 2095 class Item:pass 2096 st=Store(initialBuffered=[Item()],sim=s) 2097 t=TBT(sim=s) 2098 s.activate(t,t.tbt(store=st)) 2099 s.simulate(until=10)
2100 2101 ## ------------------------------------------------------------------ 2102 ## TEST "yield (put,self,store),(hold,self,time)" 2103 ## == timeout renege 2104 ## for both unmonitored and monitored Stores 2105 ## ------------------------------------------------------------------
2106 - def testBasicTimePut(self):
2107 """Store (unmonitored): 2108 test 'yield (put,self,store),(hold,self,time)""" 2109 s=SimulationRT() 2110 s.initialize() 2111 st=Store(capacity=1,sim=s) 2112 t=TBTput(sim=s) 2113 s.activate(t,t.tbt(store=st)) 2114 s.simulate(until=10)
2115
2116 - def testBasicTimePutM(self):
2117 """Store (monitored): 2118 test monitors with 'yield (put,self,store),(hold,self,time)""" 2119 s=SimulationRT() 2120 s.initialize() 2121 st=Store(capacity=1,monitored=True,sim=s) 2122 t=TBTput(sim=s) 2123 s.activate(t,t.tbt(store=st)) 2124 s.simulate(until=10) 2125 #First put succeeds, second attempt reneges at t=5? 2126 assert st.putQMon==[[0,0],[0,1],[5,0]],"putQMon wrong: %s"\ 2127 %st.putQMon 2128 #First Item goes into buffer at t=0, second not (renege)? 2129 assert st.bufferMon==[[0,0],[0,1]],"bufferMon wrong: %s"%st.bufferMon
2130 2131 ## ------------------------------------------------------------------ 2132 ## TEST "yield (get,self,store),(waitevent,self,event)" 2133 ## == event renege 2134 ## for both unmonitored and monitored Stores 2135 ## ------------------------------------------------------------------
2136 - def testBasicEvent(self):
2137 """Store (unmonitored): 2138 test 'yield (get,self,store),(waitevent,self,event)""" 2139 si=SimulationRT() 2140 si.initialize() 2141 class Item:pass 2142 st=Store(initialBuffered=[Item()],sim=si) 2143 trig=SimEvent(sim=si) 2144 t=TBE(sim=si) 2145 si.activate(t,t.tbe(store=st,trigger=trig)) 2146 tr=TBEtrigger(sim=si) 2147 si.activate(tr,tr.fire(trigger=trig)) 2148 si.simulate(until=10)
2149 2150 ## ------------------------------------------------------------------ 2151 ## TEST "yield (put,self,store),(waitevent,self,event)" 2152 ## == event renege 2153 ## for both unmonitored and monitored Stores 2154 ## ------------------------------------------------------------------
2155 - def testBasicEventPut(self):
2156 """Store (unmonitored): 2157 test 'yield (put,self,store),(waitevent,self,event)""" 2158 si=SimulationRT() 2159 si.initialize() 2160 s=SimEvent(sim=si) 2161 store=Store(capacity=1,sim=si) 2162 t=TBEtriggerPut(sim=si) 2163 si.activate(t,t.fire(trigger=s)) 2164 tb=TBEput(sim=si) 2165 si.activate(tb,tb.tbe(store=store,trigger=s)) 2166 si.simulate(until=10)
2167
2168 - def testBasicEventPutM(self):
2169 """Store (monitored): 2170 test monitors with 'yield (put,self,store),(waitevent,self,event)""" 2171 si=SimulationRT() 2172 si.initialize() 2173 s=SimEvent(sim=si) 2174 st=Store(capacity=1,monitored=True,sim=si) 2175 t=TBEtriggerPut(sim=si) 2176 si.activate(t,t.fire(trigger=s)) 2177 tb=TBEput(sim=si) 2178 si.activate(tb,tb.tbe(store=st,trigger=s)) 2179 si.simulate(until=10) 2180 #First put succeeds, second attempt reneges at t=5? 2181 assert st.putQMon==[[0,0],[0,1],[5,0]],"putQMon wrong: %s"\ 2182 %st.putQMon 2183 #First Item goes into buffer at t=0, second not (renege)? 2184 assert st.bufferMon==[[0,0],[0,1]],"bufferMon wrong: %s"%st.bufferMon
2185
2186 -def makeStoreCompSuite():
2187 suite = unittest.TestSuite() 2188 ## Unmonitored Stores 2189 testBasicTime = makeStoreCompTestcase("testBasicTime") 2190 testBasicEvent = makeStoreCompTestcase("testBasicEvent") 2191 testBasicTimePut = makeStoreCompTestcase("testBasicTimePut") 2192 testBasicEventPut = makeStoreCompTestcase("testBasicEventPut") 2193 ## ## Monitored Stores 2194 testBasicTimePutM = makeStoreCompTestcase("testBasicTimePutM") 2195 testBasicEventPutM = makeStoreCompTestcase("testBasicEventPutM") 2196 2197 suite.addTests([testBasicTime,testBasicTimePut,testBasicTimePutM, 2198 testBasicEvent,testBasicEventPut,testBasicEventPutM 2199 ]) 2200 return suite
2201 2202 ## ------------------------------------------------------------------ 2203 ## 2204 ## Level: Tests for compound get 2205 ## 2206 ## ------------------------------------------------------------------
2207 -class TBTLev(Process):
2208 """Level: For testBasicTime"""
2209 - def __init__(self,**par):
2210 Process.__init__(self,**par)
2211 - def tbt(self,level):
2212 yield get,self,level,1 2213 assert self.got,"did not get 1 unit" 2214 yield (get,self,level,1),(hold,self,5) 2215 if self.acquired(level): 2216 assert self.got==1,"did not get 1 unit" 2217 else: 2218 assert not self.got and self.sim.now()==5,\ 2219 "time renege not working"
2220
2221 -class TBELev(Process):
2222 """Level: For testBasicEvent"""
2223 - def __init__(self,**par):
2224 Process.__init__(self,**par)
2225 - def tbe(self,level,trigger):
2226 yield get,self,level,1 2227 assert self.got,"did not get 1 unit" 2228 yield (get,self,level,1),(waitevent,self,trigger) 2229 if self.acquired(level): 2230 assert self.got==1,"did not get 1 Item" 2231 else: 2232 assert self.sim.now()==5.5 and self.eventsFired[0]==trigger,\ 2233 "event renege not working"
2234
2235 -class TBEtriggerLev(Process):
2236 """Level: For testBasicEvent"""
2237 - def __init__(self,**par):
2238 Process.__init__(self,**par)
2239 - def fire(self,trigger):
2240 yield hold,self,5.5 2241 trigger.signal()
2242
2243 -class TBTLevPut(Process):
2244 """Level: For testBasicTimePut"""
2245 - def __init__(self,**par):
2246 Process.__init__(self,**par)
2247 - def tbt(self,level):
2248 yield put,self,level,1 2249 assert level.amount,"did not put 1 unit" 2250 yield (put,self,level,1),(hold,self,5) 2251 if self.stored(level): 2252 assert False,"should have reneged" 2253 else: 2254 assert level.amount==1 and self.sim.now()==5,\ 2255 "time renege not working"
2256
2257 -class TBELevPut(Process):
2258 """Level: For testBasicEventPut and testBasicEventPutM"""
2259 - def __init__(self,**par):
2260 Process.__init__(self,**par)
2261 - def tbe(self,level,trigger):
2262 yield (put,self,level,1),(waitevent,self,trigger) 2263 if self.stored(level): 2264 assert level.amount==1,"did not put 1 unit" 2265 else: 2266 assert False,"should not have reneged" 2267 yield (put,self,level,1),(waitevent,self,trigger) 2268 if self.stored(level): 2269 assert False, "should have reneged" 2270 else: 2271 assert self.sim.now()==5.5 and self.eventsFired[0]==trigger ,\ 2272 "renege not working"
2273
2274 -class TBEtriggerLevPut(Process):
2275 """Level: For testBasicEventPut"""
2276 - def __init__(self,**par):
2277 Process.__init__(self,**par)
2278 - def fire(self,trigger):
2279 yield hold,self,5.5 2280 trigger.signal()
2281
2282 -class makeLevelCompTestcase(unittest.TestCase):
2283 """Level: Testcase for compound get and put statements""" 2284 ## ------------------------------------------------------------------ 2285 ## TEST "yield (get,self,level),(hold,self,time)" 2286 ## == timeout renege 2287 ## for both unmonitored and monitored Levels 2288 ## ------------------------------------------------------------------ 2289
2290 - def testBasicTime(self):
2291 """Level (unmonitored): 2292 test 'yield (get,self,level),(hold,self,timeout) 2293 """ 2294 s=SimulationRT() 2295 s.initialize() 2296 l=Level(initialBuffered=1,sim=s) 2297 t=TBTLev(sim=s) 2298 s.activate(t,t.tbt(level=l)) 2299 s.simulate(until=10)
2300 2301 ## ------------------------------------------------------------------ 2302 ## TEST "yield (put,self,store),(hold,self,time)" 2303 ## == timeout renege 2304 ## for both unmonitored and monitored Stores 2305 ## ------------------------------------------------------------------
2306 - def testBasicTimePut(self):
2307 """Level (unmonitored): 2308 test 'yield (put,self,level),(hold,self,timeout)""" 2309 s=SimulationRT() 2310 s.initialize() 2311 l=Level(capacity=1,sim=s) 2312 t=TBTLevPut(sim=s) 2313 s.activate(t,t.tbt(level=l)) 2314 s.simulate(until=10)
2315 2316 ## ------------------------------------------------------------------ 2317 ## TEST "yield (get,self,store),(waitevent,self,event)" 2318 ## == event renege 2319 ## for both unmonitored and monitored Levels 2320 ## ------------------------------------------------------------------
2321 - def testBasicEvent(self):
2322 """Level (unmonitored): 2323 test 'yield (get,self,level),(waitevent,self,event)""" 2324 s=SimulationRT() 2325 s.initialize() 2326 l=Level(initialBuffered=1,sim=s) 2327 trig=SimEvent(sim=s) 2328 t=TBELev(sim=s) 2329 s.activate(t,t.tbe(level=l,trigger=trig)) 2330 tr=TBEtriggerLev(sim=s) 2331 s.activate(tr,tr.fire(trigger=trig)) 2332 s.simulate(until=10)
2333
2334 - def testBasicEventM(self):
2335 """Level (monitored): 2336 test monitors with 'yield (get,self,level),(waitevent,self,event)""" 2337 s=SimulationRT() 2338 s.initialize() 2339 l=Level(initialBuffered=1,monitored=True,sim=s) 2340 trig=SimEvent(sim=s) 2341 t=TBELev(sim=s) 2342 s.activate(t,t.tbe(level=l,trigger=trig)) 2343 tr=TBEtriggerLev(sim=s) 2344 s.activate(tr,tr.fire(trigger=trig)) 2345 s.simulate(until=10) 2346 #First get (t=0) succeeded and second timed out at t=5.5? 2347 assert l.getQMon==[[0,0],[0,1],[5.5,0]],"getQMon not working: %s"\ 2348 %l.getQMon 2349 #Level amount incr. then decr. by 1 (t=0), 2nd get reneged at t=5.5? 2350 assert l.bufferMon==[[0,1],[0,0]],\ 2351 "bufferMon not working: %s"%l.bufferMon
2352 2353 ## ------------------------------------------------------------------ 2354 ## TEST "yield (put,self,store),(waitevent,self,event)" 2355 ## == event renege 2356 ## for both unmonitored and monitored Levels 2357 ## ------------------------------------------------------------------
2358 - def testBasicEventPut(self):
2359 """Level (unmonitored): 2360 test 'yield (put,self,level),(waitevent,self,event)""" 2361 s=SimulationRT() 2362 s.initialize() 2363 l=Level(capacity=1,sim=s) 2364 trig=SimEvent(sim=s) 2365 t=TBELevPut(sim=s) 2366 s.activate(t,t.tbe(level=l,trigger=trig)) 2367 tr=TBEtriggerLevPut(sim=s) 2368 s.activate(tr,tr.fire(trigger=trig)) 2369 s.simulate(until=10)
2370
2371 - def testBasicEventPutM(self):
2372 """Level (monitored): 2373 test monitors with 'yield (put,self,level),(waitevent,self,event)""" 2374 s=SimulationRT() 2375 s.initialize() 2376 l=Level(capacity=1,monitored=True,sim=s) 2377 trig=SimEvent(sim=s) 2378 t=TBELevPut(sim=s) 2379 s.activate(t,t.tbe(level=l,trigger=trig)) 2380 tr=TBEtriggerLevPut(sim=s) 2381 s.activate(tr,tr.fire(trigger=trig)) 2382 s.simulate(until=10) 2383 "First put succeeds, second reneges at t=5.5?" 2384 assert l.putQMon==[[0,0],[0,1],[5.5,0]],"putQMon wrong: %s"\ 2385 %l.putQMon 2386 "1 unit added at t=0, renege at t=5 before 2nd unit added?" 2387 assert l.bufferMon==[[0,0],[0,1]],"bufferMon wrong: %s"%l.bufferMon
2388
2389 -def makeLevelCompSuite():
2390 suite = unittest.TestSuite() 2391 ## Unmonitored Levels 2392 testBasicTime = makeLevelCompTestcase("testBasicTime") 2393 testBasicEvent = makeLevelCompTestcase("testBasicEvent") 2394 testBasicTimePut = makeLevelCompTestcase("testBasicTimePut") 2395 testBasicEventPut = makeLevelCompTestcase("testBasicEventPut") 2396 ## ## Monitored Levels 2397 testBasicEventM = makeLevelCompTestcase("testBasicEventM") 2398 testBasicEventPutM = makeLevelCompTestcase("testBasicEventPutM") 2399 2400 suite.addTests([testBasicTime,testBasicEvent,testBasicTimePut, 2401 testBasicEventM,testBasicEventPut,testBasicEventPutM]) 2402 return suite
2403 2404 if __name__ == '__main__': 2405 alltests = unittest.TestSuite(( 2406 makeSSuite(), 2407 makeRSuite(), 2408 makeISuite(), 2409 makePSuite(), 2410 makeESuite(), 2411 makeWSuite(), 2412 makeTOSuite(), 2413 makeEvtRenegeSuite(), 2414 makeLevelSuite(), 2415 makeStoreSuite(), 2416 makeStoreCompSuite(), 2417 makeLevelCompSuite(), 2418 makeMSuite() 2419 )) 2420 2421 runner = unittest.TextTestRunner() 2422 runner.run(alltests) 2423 ## 2424