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

Source Code for Module SimPy.testSimPyStepOO

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