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