1
2 from SimPy.SimulationRT import *
3 from SimPy.MonitorTest import *
4 import unittest
5 from random import random
6
7 """testSimPyRT.py
8 SimPy version 2.0
9 Unit tests for SimulationRT.
10 Based on testSimpy.py to test full compatibility
11 between Simulation and SimulationRT.
12
13 **Change history**:
14 # 2002 11 15 Added tests for priority queues and preemption
15 # 2002 11 22 testing problem in accum
16 # 2003 03 30 added tests for SEP001v17 interrupts
17 # 2003 04 05 added test for interruptReset
18 # 2003 04 08 added tests for process state transitions
19 # 2003 04 10 changed to 'self.cancel(victim)' syntax
20 # 2003 04 13 removed dummy init assertions
21 # 2004 02 28 added test for monitored queues (gav)
22 # 2004 05 03 corrected test for monitored queues (gav)
23 # 2004 05 15 first version of SimulationRT; just tests
24 # compatibility with Simulation.py
25 # 2004 09 17 added tests for waitevent, queueevent, waituntil (new in 1.5)
26 # 2005 05 19 added tests for compound yield statements (reneging)
27 # 2006 01 15 added tests for Store and Level and the get / put yield statements
28 # 2006 02 02 removed histogram plotting suite
29 # 2006 05 10 changed test testStatic for Level to test that float type
30 supported for initialBuffered
31 # 2006 05 16 added tests for Store and Level to test basic Producer / Consumer
32 principles
33 # 2006 10 16 added tests for compound get statement (Unmonitored Store / Level)
34 # 2006 10 17 added tests for compound put statement (Unmonitored Store / Level)
35 # 2007 01 08 added tests for monitoring of Store / Level with compound get / put
36 # 2007 01 08 added test for Store with filter function
37 # 2007 12 05 added tests for start method (Process)
38 # 2008 03 03 added test for nested preempts
39
40 #'$Revision: 163 $ $Date: 2008-12-15 12:47:44 +0100 (Mo, 15 Dez 2008) $ kgm'
41
42 """
43
44 simulationVersion=version
45 print "Under test: SimulationRT.py %s"%simulationVersion
46 __version__ = '2.0 $Revision: 163 $ $Date: 2008-12-15 12:47:44 +0100 (Mo, 15 Dez 2008) $ '
47 print 'testSimPyRT.py %s'%__version__
48
49
50
51
53 """ P class for testing"""
58
60 yield hold, self, self.T
61
63 """ PActions class for testing"""
68
70 yield hold, self, self.T
71
73 """ Tests of simulation
74 """
76 """Test initialisation
77 """
78 initialize()
79 simulate(until = 10)
80 assert(now() == 0),'time not 0'
81
90
92 """Test start method
93 """
94 P1 = P(name = 'P1', T = 100.0)
95 initialize()
96 P1.start(P1.execute(),0)
97 simulate(until = 5)
98 assert(now() == 5),'Simulate stopped at %s not %s' % (now(),5)
99
101 """Test start method with ACTIONS PEM
102 """
103 P1 = PActions(name = 'P1', T = 100.0)
104 initialize()
105 P1.start()
106 simulate(until = 5)
107 assert(now() == 5),'Simulate stopped at %s not %s' % (now(),5)
108
110 """Test yield hold and simulate(until)
111 """
112 P1 = P(name = 'P1', T = 10)
113 initialize()
114 activate(P1, P1.execute(),0)
115 simulate(until = 5)
116 assert(now() == 5),'Simulate stopped at %s not %s' % (now(),5)
117
118 P2 = P(name = 'P2', T = 10)
119 initialize()
120 activate(P2, P2.execute(),0)
121 simulate(until = 20)
122 assert(now() == 10),'P1 hold to %s not %s' % (now(),10)
123
124
136
137
138
139
140
142 """ Job class for testing"""
143 - def __init__(self, server = None, name = ''):
147
149 yield request, self, self.R
150
151
153 """ First simple tests of Resources
154 """
156 """Test initialisation"""
157 R = Resource()
158 assert R.name == 'a_resource', 'Not null name'
159 assert R.capacity == 1, 'Not unit capacity'
160 assert R.unitName == 'units', 'Not the correct unit name'
161 R = Resource(name = '', capacity = 1)
162 assert R.name == '', 'Not null name'
163 assert R.capacity == 1, 'Not unit capacity'
164 assert R.unitName == 'units', 'Not the correct unit name'
165 R = Resource(capacity = 3, name = '3 - version', unitName = 'blobs')
166 assert R.name == '3 - version', 'Wrong name, it is' + R.name
167 assert R.capacity == 3, 'Not capacity 3, it is '+`R.capacity`
168 assert R.unitName == 'blobs', 'Not the correct unit name'
169
170 R = Resource(capacity = 0, name = '0 - version')
171 assert R.capacity == 0, 'Not capacity 0, it is '+`R.capacity`
172
174 """Test request"""
175
176
177 R0 = Resource(name = '', capacity = 0)
178 assert R0.name == '', 'Not null name'
179 assert R0.capacity == 0, 'Not capacity 0, it is '+`R0.capacity`
180
181 initialize()
182 R1 = Resource(capacity = 0, name = '3 - version', unitName = 'blobs')
183 J = Job(name = 'job', server = R1)
184 activate(J, J.execute(), at = 0.0)
185
186 simulate(until = 10.0)
187 assert R1.n == 0, 'Should be 0, it is ' + str(R1.n)
188 lenW = len(R1.waitQ)
189 assert lenW == 1, 'Should be 1, it is ' + str(lenW)
190 assert len(R1.activeQ) == 0, 'len activeQ Should be 0, it is '+\
191 str(len(R1.activeQ))
192
194 """Test request2 with capacity = 1"""
195
196 initialize()
197 R2 = Resource(capacity = 1, name = '3 - version', unitName = 'blobs')
198 J2 = Job(name = 'job', server = R2)
199 activate(J2, J2.execute(), at = 0.0)
200
201 simulate(until = 10.0)
202 assert R2.n == 0, 'Should be 0, it is ' + str(R2.n)
203 lenW = len(R2.waitQ)
204 lenA = len(R2.activeQ)
205 assert lenW == 0, 'lenW Should be 0, it is ' + str(lenW)
206 assert lenA == 1, 'lenA Should be 1, it is ' + str(lenA)
207
209 """Test request3 with capacity = 1 several requests"""
210
211 initialize()
212 R3 = Resource(capacity = 1, name = '3 - version', unitName = 'blobs')
213 J2 = Job(name = 'job', server = R3)
214 J3 = Job(name = 'job', server = R3)
215 J4 = Job(name = 'job', server = R3)
216 activate(J2, J2.execute(), at = 0.0)
217 activate(J3, J3.execute(), at = 0.0)
218 activate(J4, J4.execute(), at = 0.0)
219
220 simulate(until = 10.0)
221 assert R3.n == 0, 'Should be 0, it is ' + str(R3.n)
222 lenW = len(R3.waitQ)
223 lenA = len(R3.activeQ)
224 assert lenW == 2, 'lenW Should be 2, it is ' + str(lenW)
225 assert R3.waitQ == [J3, J4],'WaitQ wrong' + str(R3.waitQ)
226 assert lenA == 1, 'lenA Should be 1, it is ' + str(lenA)
227 assert R3.activeQ == [J2],'activeQ wrong, it is ' + str(R3.activeQ[0])
228
230 """Test request4 with capacity = 2 several requests"""
231
232 initialize()
233 R3 = Resource(capacity = 2, name = '4 - version', unitName = 'blobs')
234 J2 = Job(name = 'job', server = R3)
235 J3 = Job(name = 'job', server = R3)
236 J4 = Job(name = 'job', server = R3)
237 activate(J2, J2.execute(), at = 0.0)
238 activate(J3, J3.execute(), at = 0.0)
239 activate(J4, J4.execute(), at = 0.0)
240
241 simulate(until = 10.0)
242 assert R3.n == 0, 'Should be 0, it is ' + str(R3.n)
243 lenW = len(R3.waitQ)
244 lenA = len(R3.activeQ)
245 assert lenW == 1, 'lenW Should be 1, it is ' + str(lenW)
246 assert R3.waitQ == [J4],'WaitQ wrong' + str(R3.waitQ)
247 assert lenA == 2, 'lenA Should be 2, it is ' + str(lenA)
248 assert R3.activeQ == [J2, J3],'activeQ wrong, it is ' + str(R3.activeQ[0])
249
250
251
253 """Test PriorityQ, with no preemption, 0 capacity"""
254 class Job(Process):
255 """ Job class for testing"""
256 def __init__(self, server = None, name = ''):
257 Process.__init__(self)
258 self.name = name
259 self.R = server
260
261 def execute(self, priority):
262 yield request, self, self.R, priority
263
264 initialize()
265 Rp = Resource(capacity = 0, qType = PriorityQ)
266 J5 = Job(name = 'job 5', server = Rp)
267 J6 = Job(name = 'job 6', server = Rp)
268 J7 = Job(name = 'job 7', server = Rp)
269 activate(J5, J5.execute(priority = 3))
270 activate(J6, J6.execute(priority = 0))
271 activate(J7, J7.execute(priority = 1))
272 simulate(until = 100)
273 assert Rp.waitQ == [J5, J7, J6],'WaitQ wrong' + str([(x.name, x.priority[Rp]) for x in Rp.waitQ])
274
275 """Test PriorityQ mechanism"""
276
277 def sorted(q):
278 if not q or len(q) == 1:
279 sortok = 1
280 return sortok
281 sortok = q[0] >= q[1] and sorted(q[2:])
282 return sortok
283
284 initialize()
285 Rp = Resource(capacity = 0, qType = PriorityQ)
286 for i in range(10):
287 J = Job(name = 'job ' + str(i),server = Rp)
288 activate(J, J.execute(priority = random()))
289 simulate(until = 1000)
290 qp = [x._priority[Rp] for x in Rp.waitQ]
291 assert sorted(qp),'waitQ not sorted by priority: ' + str([(x.name, x._priority[Rp]) for x in Rp.waitQ])
292
293
295 """Test PriorityQ, with no preemption, capacity == 1"""
296 class Job(Process):
297 """ Job class for testing"""
298 def __init__(self, server = None, name = ''):
299 Process.__init__(self)
300 self.name = name
301 self.R = server
302
303 def execute(self, priority):
304 yield request, self, self.R, priority
305
306 initialize()
307 Rp = Resource(capacity = 1, qType = PriorityQ)
308 J5 = Job(name = 'job 5', server = Rp)
309 J6 = Job(name = 'job 6', server = Rp)
310 J7 = Job(name = 'job 7', server = Rp)
311 activate(J5, J5.execute(priority = 2))
312 activate(J6, J6.execute(priority = 4))
313 activate(J7, J7.execute(priority = 3))
314 simulate(until = 100)
315 assert Rp.waitQ == [J6, J7],'WaitQ wrong ' + str([(x.name, x._priority[Rp]) for x in Rp.waitQ])
316
318 """Test PriorityQ, with preemption, capacity == 1"""
319 class nuJob(Process):
320 def __init__(self, name):
321 Process.__init__(self, name)
322
323 def execute(self, res, priority):
324 self.preempt = len(res.activeQ) > 0 and priority > res.activeQ[-1]._priority[res]
325 t = now()
326 yield request, self, res, priority
327 if self.preempt:
328 assert len(res.waitQ) == 1, 'No preemption ' + 'activeQ = ' + str(res.activeQ[0].name)
329 yield hold, self, 30
330 t1 = now()
331 if self.preempt:
332 assert t + 30 == t1, 'Wrong completion time for preemptor ' + self.name
333 else:
334 assert t + 60 == t1, 'Wrong completion time for preempted ' + self.name + ' ' + str(now())
335 yield release, self, res
336
337 initialize()
338 res = Resource(name = 'server', capacity = 1, qType = PriorityQ, preemptable = 1)
339 n1 = nuJob(name = 'nuJob 1')
340 n2 = nuJob(name = 'nuJob 2')
341 activate(n1, n1.execute(res, priority = 0))
342 activate(n2, n2.execute(res, priority = 1),at = 15)
343 simulate(until = 100)
344
346 """Test preemption of preemptor"""
347 class nuJob(Process):
348 seqOut = []
349 def __init__(self, name):
350 Process.__init__(self, name)
351 self.serviceTime = 30
352
353 def execute(self, res, priority):
354 self.preempt = len(res.activeQ) > 0 and priority > res.activeQ[-1]._priority[res]
355 nrwaiting = len(res.waitQ)
356 yield request, self, res, priority
357 if self.preempt:
358 assert len(res.waitQ) == nrwaiting + 1, 'No preemption ' + 'activeQ = ' + str(res.activeQ[0].name)
359 yield hold, self, self.serviceTime
360 yield release, self, res
361 nuJob.seqOut.append((self, now()))
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
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
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)
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
430 assert res.waitMon.timeAverage() == (0 * 2 + 2 * 2 + 1 * 2) / 8.0, 'Wrong waitMon.timeAverage:%s'%res.waitMon.timeAverage()
431
432
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
454
455
456
460
461 - def breakin(self, waitbefore, howoften = 1):
462 for i in range(howoften):
463 yield hold, self, waitbefore
464 self.interrupt(victim)
465
469
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
482 """
483 Tests interrupts as defined in SEP001v17
484 """
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
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
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
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
562
563 victim.newProcess = newProcess
564 activate(victim, newProcess(victim))
565 activate(breaker, breaker.breakin(10, howoften = 3))
566 simulate(until = 1000)
567
577
578
579
580
581
593
597
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
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
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
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
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
684
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
708
710 """
711 Tests states and state transitions as defined in SEP003
712 """
713
725
742
762
786
787
788
797
798
799
800
801
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
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
819 yield queueevent, self, ev2
820 assert ev2 in self.eventsFired, 'did not record firing event'
821
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
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
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
851 nrProcesses = 0
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
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
873 """
874 Test SimEvent / signal as introduced with SimPy 1.5
875 """
876
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
905
922
930
938
948
949
950
951
952
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
966 def waitcond():
967 return a and b and c
968 yield waituntil, self, waitcond
969
971 """
972 Test waituntil as introduced with SimPy 1.5
973 """
974
984
990
991
992
993
994
995
996
997
998
999
1000
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
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
1036 """ Tests of 'yield (request, self, res),(hold, self, delay)'
1037 timeout reneging command
1038 """
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
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
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
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
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
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
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
1193
1194
1195
1196
1197
1198
1199
1200
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
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
1236 """Fires reneging event
1237 """
1238 - def fire(self, fireDelay, event):
1239 yield hold, self, fireDelay
1240 event.signal()
1241
1243 """Tests of 'yield (request, self, res),(waiteevent, self, event)'
1244 event reneging command
1245 """
1247 """Test that processes acquire resource normally if no event fires
1248 """
1249 res = Resource(name = 'Server', capacity = 1)
1250 event = SimEvent('Renege_trigger')
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
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
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')
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
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
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
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
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
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
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
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
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
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
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
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
1396
1397
1398
1399
1400
1401
1402
1404 produced = 0
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)
1418 for i in range(4):
1419 yield put, self, buffer, 4
1420 yield hold, self, 1
1422 consumed = 0
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
1433 """producer PriorityQ, consumer FIFO"""
1434 while True:
1435 yield get, self, buffer, 2
1436 yield hold, self, 1
1438 """PriorityQ for Consumers"""
1439 yield get, self, buffer, 4,priority
1440 doneList.append(self.name)
1441
1442
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
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
1460
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
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
1521
1538
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
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
1591
1592
1593
1594
1595
1596
1597
1620
1646
1650
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
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
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
1677
1679 """Used in testBufferFilter"""
1683
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
1709
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
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
1771
1788
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
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
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
1855
1871
1872
1873
1874
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
1902 """Store: For testBasicEvent"""
1903 - def fire(self, trigger):
1906
1908 """Store: Testcase for compound get statements"""
1909
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
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
1945 """Store: For testBasicEventPut"""
1946 - def fire(self, trigger):
1949
1951 """Store: Testcase for compound get statements"""
1952
1953
1954
1955
1956
1957
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
1971
1972
1973
1982
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
1992 assert st.putQMon == [[0, 0],[0, 1],[5, 0]],'putQMon wrong: %s'\
1993 %st.putQMon
1994
1995 assert st.bufferMon == [[0, 0],[0, 1]],'bufferMon wrong: %s'%st.bufferMon
1996
1997
1998
1999
2000
2001
2002
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
2019
2020
2021
2033
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
2046 assert st.putQMon == [[0, 0],[0, 1],[5, 0]],'putQMon wrong: %s'\
2047 %st.putQMon
2048
2049 assert st.bufferMon == [[0, 0],[0, 1]],'bufferMon wrong: %s'%st.bufferMon
2050
2069
2070
2071
2072
2073
2074
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
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
2099 """Level: For testBasicEvent"""
2100 - def fire(self, trigger):
2103
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
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
2131 """Level: For testBasicEventPut"""
2132 - def fire(self, trigger):
2135
2137 """Level: Testcase for compound get and put statements"""
2138
2139
2140
2141
2142
2143
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
2154
2155
2156
2165
2166
2167
2168
2169
2170
2171
2183
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
2196 assert l.getQMon == [[0, 0],[0, 1],[5.5, 0]],'getQMon not working: %s'\
2197 %l.getQMon
2198
2199 assert l.bufferMon == [[0, 1],[0, 0]],\
2200 'bufferMon not working: %s'%l.bufferMon
2201
2202
2203
2204
2205
2206
2218
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
2254
2255 if __name__ == '__main__':
2256 alltests = unittest.TestSuite((makeSSuite(),makeRSuite(),
2257 makeMSuite(),
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