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

Source Code for Module SimPy.testSimPyStep

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