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

Source Code for Module SimPy.testSimPyTraceOO

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