1
2 from SimPy.Simulation import *
3 from SimPy.MonitorTest import *
4 import unittest
5 from random import random
6
7 """testSimPy.py
8 SimPy version 2.0
9 Unit tests for Simulation.py.
10
11 **Change history**:
12 # 2002 11 15 Added tests for priority queues and preemption
13 # 2002 11 22 testing problem in accum
14 # 2003 03 30 added tests for SEP001v17 interrupts
15 # 2003 04 05 added test for interruptReset
16 # 2003 04 08 added tests for process state transitions
17 # 2003 04 10 changed to 'self.cancel(victim)' syntax
18 # 2003 04 13 removed dummy init assertions
19 # 2004 02 28 added test for monitored queues (gav)
20 # 2004 05 03 corrected test for monitored queues (gav)
21 # 2004 09 17 added tests for waitevent, queueevent, waituntil (new in 1.5)
22 # 2005 05 19 added tests for compound yield statements (reneging)
23 # 2006 01 15 added tests for Store and Level and the get / put yield statements
24 # 2006 02 02 removed histogram plotting suite
25 # 2006 05 10 changed test testStatic for Level to test that float type
26 supported for initialBuffered
27 # 2006 05 16 added tests for Store and Level to test basic Producer / Consumer
28 principles
29 # 2006 10 16 added tests for compound get statement (Unmonitored Store / Level)
30 # 2006 10 17 added tests for compound put statement (Unmonitored Store / Level)
31 # 2007 01 08 added tests for monitoring of Store / Level with compound get / put
32 # 2007 01 08 added test for Store with filter function
33 # 2007 12 05 added tests for start method (Process)
34 # 2008 03 03 added test for nested preempts
35
36 #'$Revision: 163 $ $Date: 2008-12-15 12:47:44 +0100 (Mo, 15 Dez 2008) $ kgm'
37
38 """
39
40
41 simulationVersion=version
42 print "Under test: Simulation.py %s"%simulationVersion
43 __version__ = '2.0 $Revision: 163 $ $Date: 2008-12-15 12:47:44 +0100 (Mo, 15 Dez 2008) $ '
44 print 'testSimpy.py %s'%__version__
45
46
47
49 """ P class for testing"""
54
56 yield hold, self, self.T
57
59 """ PActions class for testing"""
64
66 yield hold, self, self.T
67
69 """ Tests of simulation
70 """
72 """Test initialisation
73 """
74 initialize()
75 simulate(until = 10)
76 assert(now() == 0),'time not 0'
77
86
88 """Test start method
89 """
90 P1 = P(name = 'P1', T = 100.0)
91 initialize()
92 P1.start(P1.execute(),0)
93 simulate(until = 5)
94 assert(now() == 5),'Simulate stopped at %s not %s' % (now(),5)
95
97 """Test start method with ACTIONS PEM
98 """
99 P1 = PActions(name = 'P1', T = 100.0)
100 initialize()
101 P1.start()
102 simulate(until = 5)
103 assert(now() == 5),'Simulate stopped at %s not %s' % (now(),5)
104
106 """Test yield hold and simulate(until)
107 """
108 P1 = P(name = 'P1', T = 10)
109 initialize()
110 activate(P1, P1.execute(),0)
111 simulate(until = 5)
112 assert(now() == 5),'Simulate stopped at %s not %s' % (now(),5)
113
114 P2 = P(name = 'P2', T = 10)
115 initialize()
116 activate(P2, P2.execute(),0)
117 simulate(until = 20)
118 assert(now() == 10),'P1 hold to %s not %s' % (now(),10)
119
120
132
133
134
135
136
138 """ Job class for testing"""
139 - def __init__(self, server = None, name = ''):
143
145 yield request, self, self.R
146
147
149 """ First simple tests of Resources
150 """
152 """Test initialisation"""
153 R = Resource()
154 assert R.name == 'a_resource', 'Not null name'
155 assert R.capacity == 1, 'Not unit capacity'
156 assert R.unitName == 'units', 'Not the correct unit name'
157 R = Resource(name = '', capacity = 1)
158 assert R.name == '', 'Not null name'
159 assert R.capacity == 1, 'Not unit capacity'
160 assert R.unitName == 'units', 'Not the correct unit name'
161 R = Resource(capacity = 3, name = '3 - version', unitName = 'blobs')
162 assert R.name == '3 - version', 'Wrong name, it is' + R.name
163 assert R.capacity == 3, 'Not capacity 3, it is '+`R.capacity`
164 assert R.unitName == 'blobs', 'Not the correct unit name'
165
166 R = Resource(capacity = 0, name = '0 - version')
167 assert R.capacity == 0, 'Not capacity 0, it is '+`R.capacity`
168
170 """Test request"""
171
172
173 R0 = Resource(name = '', capacity = 0)
174 assert R0.name == '', 'Not null name'
175 assert R0.capacity == 0, 'Not capacity 0, it is '+`R0.capacity`
176
177 initialize()
178 R1 = Resource(capacity = 0, name = '3 - version', unitName = 'blobs')
179 J = Job(name = 'job', server = R1)
180 activate(J, J.execute(), at = 0.0)
181
182 simulate(until = 10.0)
183 assert R1.n == 0, 'Should be 0, it is ' + str(R1.n)
184 lenW = len(R1.waitQ)
185 assert lenW == 1, 'Should be 1, it is ' + str(lenW)
186 assert len(R1.activeQ) == 0, 'len activeQ Should be 0, it is '+\
187 str(len(R1.activeQ))
188
190 """Test request2 with capacity = 1"""
191
192 initialize()
193 R2 = Resource(capacity = 1, name = '3 - version', unitName = 'blobs')
194 J2 = Job(name = 'job', server = R2)
195 activate(J2, J2.execute(), at = 0.0)
196
197 simulate(until = 10.0)
198 assert R2.n == 0, 'Should be 0, it is ' + str(R2.n)
199 lenW = len(R2.waitQ)
200 lenA = len(R2.activeQ)
201 assert lenW == 0, 'lenW Should be 0, it is ' + str(lenW)
202 assert lenA == 1, 'lenA Should be 1, it is ' + str(lenA)
203
205 """Test request3 with capacity = 1 several requests"""
206
207 initialize()
208 R3 = Resource(capacity = 1, name = '3 - version', unitName = 'blobs')
209 J2 = Job(name = 'job', server = R3)
210 J3 = Job(name = 'job', server = R3)
211 J4 = Job(name = 'job', server = R3)
212 activate(J2, J2.execute(), at = 0.0)
213 activate(J3, J3.execute(), at = 0.0)
214 activate(J4, J4.execute(), at = 0.0)
215
216 simulate(until = 10.0)
217 assert R3.n == 0, 'Should be 0, it is ' + str(R3.n)
218 lenW = len(R3.waitQ)
219 lenA = len(R3.activeQ)
220 assert lenW == 2, 'lenW Should be 2, it is ' + str(lenW)
221 assert R3.waitQ == [J3, J4],'WaitQ wrong' + str(R3.waitQ)
222 assert lenA == 1, 'lenA Should be 1, it is ' + str(lenA)
223 assert R3.activeQ == [J2],'activeQ wrong, it is ' + str(R3.activeQ[0])
224
226 """Test request4 with capacity = 2 several requests"""
227
228 initialize()
229 R3 = Resource(capacity = 2, name = '4 - version', unitName = 'blobs')
230 J2 = Job(name = 'job', server = R3)
231 J3 = Job(name = 'job', server = R3)
232 J4 = Job(name = 'job', server = R3)
233 activate(J2, J2.execute(), at = 0.0)
234 activate(J3, J3.execute(), at = 0.0)
235 activate(J4, J4.execute(), at = 0.0)
236
237 simulate(until = 10.0)
238 assert R3.n == 0, 'Should be 0, it is ' + str(R3.n)
239 lenW = len(R3.waitQ)
240 lenA = len(R3.activeQ)
241 assert lenW == 1, 'lenW Should be 1, it is ' + str(lenW)
242 assert R3.waitQ == [J4],'WaitQ wrong' + str(R3.waitQ)
243 assert lenA == 2, 'lenA Should be 2, it is ' + str(lenA)
244 assert R3.activeQ == [J2, J3],'activeQ wrong, it is ' + str(R3.activeQ[0])
245
246
247
249 """Test PriorityQ, with no preemption, 0 capacity"""
250 class Job(Process):
251 """ Job class for testing"""
252 def __init__(self, server = None, name = ''):
253 Process.__init__(self)
254 self.name = name
255 self.R = server
256
257 def execute(self, priority):
258 yield request, self, self.R, priority
259
260 initialize()
261 Rp = Resource(capacity = 0, qType = PriorityQ)
262 J5 = Job(name = 'job 5', server = Rp)
263 J6 = Job(name = 'job 6', server = Rp)
264 J7 = Job(name = 'job 7', server = Rp)
265 activate(J5, J5.execute(priority = 3))
266 activate(J6, J6.execute(priority = 0))
267 activate(J7, J7.execute(priority = 1))
268 simulate(until = 100)
269 assert Rp.waitQ == [J5, J7, J6],'WaitQ wrong' + str([(x.name, x.priority[Rp]) for x in Rp.waitQ])
270
271 """Test PriorityQ mechanism"""
272
273 def sorted(q):
274 if not q or len(q) == 1:
275 sortok = 1
276 return sortok
277 sortok = q[0] >= q[1] and sorted(q[2:])
278 return sortok
279
280 initialize()
281 Rp = Resource(capacity = 0, qType = PriorityQ)
282 for i in range(10):
283 J = Job(name = 'job ' + str(i),server = Rp)
284 activate(J, J.execute(priority = random()))
285 simulate(until = 1000)
286 qp = [x._priority[Rp] for x in Rp.waitQ]
287 assert sorted(qp),'waitQ not sorted by priority: ' + str([(x.name, x._priority[Rp]) for x in Rp.waitQ])
288
289
291 """Test PriorityQ, with no preemption, capacity == 1"""
292 class Job(Process):
293 """ Job class for testing"""
294 def __init__(self, server = None, name = ''):
295 Process.__init__(self)
296 self.name = name
297 self.R = server
298
299 def execute(self, priority):
300 yield request, self, self.R, priority
301
302 initialize()
303 Rp = Resource(capacity = 1, qType = PriorityQ)
304 J5 = Job(name = 'job 5', server = Rp)
305 J6 = Job(name = 'job 6', server = Rp)
306 J7 = Job(name = 'job 7', server = Rp)
307 activate(J5, J5.execute(priority = 2))
308 activate(J6, J6.execute(priority = 4))
309 activate(J7, J7.execute(priority = 3))
310 simulate(until = 100)
311 assert Rp.waitQ == [J6, J7],'WaitQ wrong ' + str([(x.name, x._priority[Rp]) for x in Rp.waitQ])
312
314 """Test PriorityQ, with preemption, capacity == 1"""
315 class nuJob(Process):
316 def __init__(self, name):
317 Process.__init__(self, name)
318
319 def execute(self, res, priority):
320 self.preempt = len(res.activeQ) > 0 and priority > res.activeQ[-1]._priority[res]
321 t = now()
322 yield request, self, res, priority
323 if self.preempt:
324 assert len(res.waitQ) == 1, 'No preemption ' + 'activeQ = ' + str(res.activeQ[0].name)
325 yield hold, self, 30
326 t1 = now()
327 if self.preempt:
328 assert t + 30 == t1, 'Wrong completion time for preemptor ' + self.name
329 else:
330 assert t + 60 == t1, 'Wrong completion time for preempted ' + self.name + ' ' + str(now())
331 yield release, self, res
332
333 initialize()
334 res = Resource(name = 'server', capacity = 1, qType = PriorityQ, preemptable = 1)
335 n1 = nuJob(name = 'nuJob 1')
336 n2 = nuJob(name = 'nuJob 2')
337 activate(n1, n1.execute(res, priority = 0))
338 activate(n2, n2.execute(res, priority = 1),at = 15)
339 simulate(until = 100)
340
342 """Test preemption of preemptor"""
343 class nuJob(Process):
344 seqOut = []
345 def __init__(self, name):
346 Process.__init__(self, name)
347 self.serviceTime = 30
348
349 def execute(self, res, priority):
350 self.preempt = len(res.activeQ) > 0 and priority > res.activeQ[-1]._priority[res]
351 nrwaiting = len(res.waitQ)
352 yield request, self, res, priority
353 if self.preempt:
354 assert len(res.waitQ) == nrwaiting + 1, 'No preemption ' + 'activeQ = ' + str(res.activeQ[0].name)
355 yield hold, self, self.serviceTime
356 yield release, self, res
357 nuJob.seqOut.append((self, now()))
358
359
360
361 initialize()
362 res = Resource(name = 'server', capacity = 1, qType = PriorityQ, preemptable = 1)
363 n1 = nuJob(name = 'nuJob 1')
364 n2 = nuJob(name = 'nuJob 2')
365 n3 = nuJob(name = 'nuJob 3')
366 activate(n1, n1.execute(res, priority=-1))
367 start2 = 10
368 activate(n2, n2.execute(res, priority = 0),at = start2)
369 start3 = 20
370 activate(n3, n3.execute(res, priority = 1),at = start3)
371 simulate(until = 100)
372 assert [x[1] for x in nuJob.seqOut] == [start3 + n3.serviceTime, start2 + 2 * n2.serviceTime, 90],\
373 'Wrong service sequence / times: ' + str([x for x in nuJob.seqOut])
374
376 """Test that a process can preempt another process holding multiple resources
377 """
378 class Requestor(Process):
379 def run(self, res1, res2, res3, priority = 1):
380 yield request, self, res1, priority
381 yield request, self, res2, priority
382 yield request, self, res3, priority
383 record.observe(y = self.name)
384 yield hold, self, 100
385 record.observe(y = self.name)
386 yield release, self, res3
387 yield release, self, res2
388 yield release, self, res1
389
390 initialize()
391 outer = Resource(name = 'outer', qType = PriorityQ, preemptable = True)
392 inner = Resource(name = 'inner', qType = PriorityQ, preemptable = True)
393 innermost = Resource(name = 'innermost', qType = PriorityQ, preemptable = True)
394 record = Monitor()
395 r1 = Requestor('r1')
396 activate(r1, r1.run(res1 = outer, res2 = inner, res3 = innermost, priority = 1))
397 r2 = Requestor('r2')
398 activate(r2, r2.run(res1 = outer, res2 = inner, res3 = innermost, priority = 10),at = 50)
399 simulate(until = 200)
400 assert record == [[0, 'r1'],[50, 'r2'],[150, 'r2'],[200, 'r1']],\
401 'was %s; preempt did not work'%record
402
403
405 """ test monitoring of number in the two queues, waitQ and activeQ
406 """
407 class Job(Process):
408 def __init__(self, name):
409 Process.__init__(self, name)
410
411 def execute(self, res):
412 yield request, self, res
413 yield hold, self, 2
414 yield release, self, res
415
416 initialize()
417 res = Resource(name = 'server', capacity = 1, monitored = 1)
418 n1 = Job(name = 'Job 1')
419 n2 = Job(name = 'Job 2')
420 n3 = Job(name = 'Job 3')
421 activate(n1, n1.execute(res),at = 2)
422 activate(n2, n2.execute(res),at = 2)
423 activate(n3, n3.execute(res),at = 2)
424 simulate(until = 100)
425 assert res.waitMon == [[2, 1], [2, 2], [4, 1], [6, 0]],'Wrong waitMon:%s'%res.waitMon
426 assert res.actMon == [[2, 1], [4, 0], [4, 1], [6, 0], [6, 1], [8, 0]],'Wrong actMon:%s'%res.actMon
427
428 assert res.waitMon.timeAverage() == (0 * 2 + 2 * 2 + 1 * 2) / 8.0, 'Wrong waitMon.timeAverage:%s'%res.waitMon.timeAverage()
429
430
432 suite = unittest.TestSuite()
433 testInit = makeResourcetestcase('testInit')
434 testrequest = makeResourcetestcase('testrequest')
435 testrequest2 = makeResourcetestcase('testrequest2')
436 testrequest3 = makeResourcetestcase('testrequest3')
437 testrequest4 = makeResourcetestcase('testrequest4')
438 testrequestPriority = makeResourcetestcase('testrequestPriority')
439 testrequestPriority1 = makeResourcetestcase('testrequestPriority1')
440 testrequestPriority2 = makeResourcetestcase('testrequestPriority2')
441 testrequestPriority3 = makeResourcetestcase('testrequestPriority3')
442 testrequestNestedPreempt = makeResourcetestcase('testrequestNestedPreempt')
443 testmonitored = makeResourcetestcase('testmonitored')
444 suite.addTests([testInit, testrequest, testrequest2, testrequest3, testrequest4, testrequestPriority,
445 testrequestPriority1, testrequestPriority2, testrequestPriority3,
446 testrequestNestedPreempt, testmonitored])
447 return suite
448
449
450
451
452
453
454
458
459 - def breakin(self, waitbefore, howoften = 1):
460 for i in range(howoften):
461 yield hold, self, waitbefore
462 self.interrupt(victim)
463
467
469 global igothit
470 igothit={}
471 while now() <= theEnd:
472 yield hold, self, howlong
473 if self.interrupted():
474 byWhom = self.interruptCause
475 igothit[now()] = byWhom
476 else:
477 pass
478
480 """
481 Tests interrupts as defined in SEP001v17
482 """
484 """
485 Test single interrupt during victim activity
486 """
487 global victim
488 initialize()
489 breaker = Interruptor()
490 activate(breaker, breaker.breakin(10))
491 victim = Interrupted()
492 activate(victim, victim.myActivity(100))
493 simulate(until = 200)
494 assert igothit[10] == breaker, 'Not interrupted at 10 by breaker'
495 assert len(igothit) == 1, 'Interrupted more than once'
496
498 """
499 Test multiple interrupts during victim activity
500 """
501 global victim
502 initialize()
503 breaker = Interruptor()
504 activate(breaker, breaker.breakin(10, howoften = 3))
505 victim = Interrupted()
506 activate(victim, victim.myActivity(100))
507 simulate(until = 200)
508 for i in (10, 20, 30):
509 assert igothit[i] == breaker, 'Not interrupted at %s by breaker' %i
510 assert len(igothit) == 3, 'Interrupted wrong number of times'
511
513 """
514 Test interrupts after victim activity
515 """
516 global victim
517 initialize()
518 breaker = Interruptor()
519 activate(breaker, breaker.breakin(50, howoften = 5))
520 victim = Interrupted()
521 activate(victim, victim.myActivity(10, theEnd = 10))
522 simulate(until = 200)
523 assert len(igothit) == 0, 'There has been an interrupt after victim lifetime'
524
526 """
527 Test multiple interrupts by multiple processes during victim activity
528 """
529 global victim
530 initialize()
531 breaker1 = Interruptor()
532 activate(breaker1, breaker1.breakin(15, howoften = 3))
533 breaker2 = Interruptor()
534 activate(breaker2, breaker2.breakin(20, howoften = 3))
535 victim = Interrupted()
536 activate(victim, victim.myActivity(100))
537 simulate(until = 200)
538 for i in (15, 30, 45):
539 assert igothit[i] == breaker1, 'Not interrupted at %s by breaker1' %i
540 for i in (20, 40, 60):
541 assert igothit[i] == breaker2, 'Not interrupted at %s by breaker2' %i
542 assert len(igothit) == 6, 'Interrupted wrong number of times'
543
560
561 victim.newProcess = newProcess
562 activate(victim, newProcess(victim))
563 activate(breaker, breaker.breakin(10, howoften = 3))
564 simulate(until = 1000)
565
575
576
577
578
579
591
595
597 assert p.active(),'p not active'
598 assert not p.passive(), 'p passive'
599 assert not p.terminated(),'p terminated'
600 assert not p.interrupted(),'p interrupted'
601 yield hold, self, 11
602 assert not p.active(),'p active'
603 assert not p.passive(),'p passive'
604 assert p.terminated(),'p not terminated'
605 assert not p.interrupted(),'p interrupted'
606
608 assert not p.active(),'p active'
609 assert p.passive(),'p not passive'
610 assert not p.terminated(),'p not terminated'
611 assert not p.interrupted(),'p interrupted'
612 activate(p, p.life1())
613 yield hold, self, 11
614 assert not p.active(),'p active'
615 assert not p.passive(),'p not passive'
616 assert p.terminated(),'p not terminated'
617 assert not p.interrupted(),'p interrupted'
618
620 assert not p.active(),'p active'
621 assert p.passive(),'p not passive'
622 assert not p.terminated(),'p not terminated'
623 assert not p.interrupted(),'p interrupted'
624 activate(p, p.life2())
625 yield hold, self, 11
626 assert not p.active(),'p active'
627 assert p.passive(),'p not passive'
628 assert not p.terminated(),'p terminated'
629 assert not p.interrupted(),'p interrupted'
630
632 yield hold, self, 5
633 assert p.active(),'p not active'
634 assert not p.passive(),'p passive'
635 assert not p.terminated(),'p terminated'
636 assert not p.interrupted(),'p interrupted'
637 self.cancel(p)
638 assert not p.active(),'p active'
639 assert p.passive(),'p not passive'
640 assert not p.terminated(),'p terminated'
641 assert not p.interrupted(),'p interrupted'
642 reactivate(p)
643 assert p.active(),'p not active'
644 assert not p.passive(),'p passive'
645 assert not p.terminated(),'p terminated'
646 assert not p.interrupted(),'p interrupted'
647 yield hold, self
648 assert not p.active(),'p active'
649 assert not p.passive(),'p passive'
650 assert p.terminated(),'p terminated'
651 assert not p.interrupted(),'p interrupted'
652
654 yield hold, self, 11
655 assert not p.active(),'p active'
656 assert p.passive(),'p not passive'
657 assert not p.terminated(),'p terminated'
658 assert not p.interrupted(),'p interrupted'
659 self.cancel(p)
660 assert not p.active(),'p active'
661 assert p.passive(),'p not passive'
662 assert not p.terminated(),'p terminated'
663 assert not p.interrupted(),'p interrupted'
664
682
686
687 - def look1(self, p1, p2, res):
688 assert p1.active(), 'p1 not active'
689 assert not p1.queuing(res), 'p1 queuing'
690 assert p2.active(), 'p2 noit active'
691 assert not p2.queuing(res), 'p2 queuing'
692 yield hold, self, 2
693 assert p1.active(), 'p1 not active'
694 assert not p1.queuing(res), 'p1 queuing'
695 assert p2.passive(), 'p2 active'
696 assert p2.queuing(res), 'p2 not queuing'
697
706
708 """
709 Tests states and state transitions as defined in SEP003
710 """
711
723
740
760
784
785
786
795
796
797
798
799
802 yield hold, self, 1
803 ev1.signal('from SignalProcess')
804 while ev2.queues:
805 nq0 = len(ev2.queues)
806 ev2.signal('from SignalProcess')
807 assert len(ev2.queues) == (nq0 - 1),'wrong number of processes dequeued'
808
811 yield waitevent, self, ev1
812 assert ev1.waits == [],'not all processes waiting for event out of waiting list'
813 assert ev1 in self.eventsFired, 'did not record firing event'
814
817 yield queueevent, self, ev2
818 assert ev2 in self.eventsFired, 'did not record firing event'
819
822 yield hold, self, 1
823 ev1.signal('from SignalProcess')
824 yield hold, self, 3
825 assert len(ev2.queues) == QueueProcessOR.nrProcesses, 'wrong number of processes queuing for event ev2'
826 while ev2.queues:
827 nq0 = len(ev2.queues)
828 ev2.signal('from SignalProcess')
829 assert len(ev2.queues) == (nq0 - 1),'wrong number of processes dequeued'
830 assert not ev2.queues, 'not all processes queuing for ev2 dequeued'
831
834 yield waitevent, self, evset
835 for e in evset:
836 assert e.waits == [],'process not out of waiting list for all events in OR'
837
840 e1 = SimEvent()
841 e1.signal()
842 e2 = SimEvent()
843 e2.signal()
844 yield waitevent, self,[e1, e2]
845 assert self.eventsFired == [e1, e2],'eventsFired does not report all events'
846
847
849 nrProcesses = 0
854 yield queueevent, self, evset
855 occurred = False
856 for e in evset:
857 occurred = occurred or (e in self.eventsFired)
858 assert occurred, 'queuing process activated by wrong event(s)'
859
862 e1 = SimEvent()
863 e1.signal()
864 e2 = SimEvent()
865 e2.signal()
866 yield queueevent, self,[e1, e2]
867 assert self.eventsFired == [e1, e2],\
868 '(queueevent) eventsFired does not report all fired events'
869
871 """
872 Test SimEvent / signal as introduced with SimPy 1.5
873 """
874
876 """
877 Tests basic signal semantics
878 """
879 e = SimEvent()
880 e.signal('param')
881 assert e.occurred, 'signal does not set \'occurred\' to True'
882 assert e.signalparam == 'param', 'signal parameter wrong'
883 e.signal()
884 assert e.signalparam is None, 'signal with no parameter did not overwrite signalparam'
885 e.signal()
886 assert e.occurred, 'multiple calls to signal do not set \'occurred\''
887
903
920
928
936
946
947
948
949
950
953 global a, b,c
954 a = True
955 yield hold, self, 1
956 b = True
957 yield hold, self, 1
958 c = True
959 yield hold, self, 1
960 assert waiter.terminated(),'waituntil did not fire'
961
964 def waitcond():
965 return a and b and c
966 yield waituntil, self, waitcond
967
969 """
970 Test waituntil as introduced with SimPy 1.5
971 """
972
982
988
989
990
991
992
993
994
995
996
997
998
1000 """ Job class for testing timeout reneging
1001 """
1002 - def __init__(self, server = None, name = ''):
1003 Process.__init__(self, name)
1004 self.res = server
1005 self.gotResource = None
1006
1007 - def execute(self, timeout, usetime):
1008 yield (request, self, self.res),(hold, self, timeout)
1009 if self.acquired(self.res):
1010 self.gotResource = True
1011 yield hold, self, usetime
1012 yield release, self, self.res
1013 else:
1014 self.gotResource = False
1015
1017 """ Job class for testing timeout reneging with priorities
1018 """
1019 - def __init__(self, server = None, name = ''):
1020 Process.__init__(self, name)
1021 self.res = server
1022 self.gotResource = None
1023
1024 - def execute(self, timeout, usetime, priority):
1025 yield (request, self, self.res, priority),(hold, self, timeout)
1026 if self.acquired(self.res):
1027 self.gotResource = True
1028 yield hold, self, usetime
1029 yield release, self, self.res
1030 else:
1031 self.gotResource = False
1032
1034 """ Tests of 'yield (request, self, res),(hold, self, delay)'
1035 timeout reneging command
1036 """
1038 """Test that resource gets acquired without timeout
1039 """
1040 res = Resource(name = 'Server', capacity = 1)
1041 initialize()
1042 usetime = 5
1043 timeout = 1000000
1044 j1 = JobTO(server = res, name = 'Job_1')
1045 activate(j1, j1.execute(timeout = timeout, usetime = usetime))
1046 j2 = JobTO(server = res, name = 'Job_2')
1047 activate(j2, j2.execute(timeout = timeout, usetime = usetime))
1048 simulate(until = 2 * usetime)
1049 assert now() == 2 * usetime, 'time not == 2 * usetime'
1050 assert j1.gotResource and j2.gotResource,\
1051 'at least one job failed to get resource'
1052 assert not (res.waitQ or res.activeQ),\
1053 'job waiting or using resource'
1054
1056 """Test that resource gets acquired without timeout.
1057 Resource monitored.
1058 """
1059 res = Resource(name = 'Server', capacity = 1, monitored = True)
1060 initialize()
1061 usetime = 5
1062 timeout = 1000000
1063 j1 = JobTO(server = res, name = 'Job_1')
1064 activate(j1, j1.execute(timeout = timeout, usetime = usetime))
1065 j2 = JobTO(server = res, name = 'Job_2')
1066 activate(j2, j2.execute(timeout = timeout, usetime = usetime))
1067 simulate(until = 2 * usetime)
1068 assert now() == 2 * usetime, 'time not == 2 * usetime'
1069 assert j1.gotResource and j2.gotResource,\
1070 'at least one job failed to get resource'
1071 assert not (res.waitQ or res.activeQ),\
1072 'job waiting or using resource'
1073 assert res.waitMon == [[0, 1],[usetime, 0]],'res.waitMon wrong: %s'%res.waitMon
1074
1076 """Test that timeout occurs when resource busy
1077 """
1078 res = Resource(name = 'Server', capacity = 1)
1079 initialize()
1080 usetime = 5
1081 timeout = 3
1082 j1 = JobTO(server = res, name = 'Job_1')
1083 activate(j1, j1.execute(timeout = timeout, usetime = usetime))
1084 j2 = JobTO(server = res, name = 'Job_2')
1085 activate(j2, j2.execute(timeout = timeout, usetime = usetime))
1086 simulate(until = 2 * usetime)
1087 assert(now() == usetime),'time not == usetime'
1088 assert(j1.gotResource),'Job_1 did not get resource'
1089 assert(not j2.gotResource),'Job_2 did not renege'
1090 assert not (res.waitQ or res.activeQ),\
1091 'job waiting or using resource'
1092
1094 """Test that timeout occurs when resource busy.
1095 Resource monitored.
1096 """
1097 res = Resource(name = 'Server', capacity = 1, monitored = True)
1098 initialize()
1099 usetime = 5
1100 timeout = 3
1101 j1 = JobTO(server = res, name = 'Job_1')
1102 activate(j1, j1.execute(timeout = timeout, usetime = usetime))
1103 j2 = JobTO(server = res, name = 'Job_2')
1104 activate(j2, j2.execute(timeout = timeout, usetime = usetime))
1105 simulate(until = 2 * usetime)
1106 assert(now() == usetime),'time not == usetime'
1107 assert(j1.gotResource),'Job_1 did not get resource'
1108 assert(not j2.gotResource),'Job_2 did not renege'
1109 assert not (res.waitQ or res.activeQ),\
1110 'job waiting or using resource'
1111 assert res.waitMon == [[0, 1],[timeout, 0]],'res.waitMon wrong: %s'%res.waitMon
1112
1114 """Test that timeout occurs when resource busy.
1115 Resource monitored. Requests with priority and preemption.
1116 """
1117 res = Resource(name = 'Server', capacity = 1, monitored = True, qType = PriorityQ, preemptable = True)
1118 initialize()
1119 usetime = 5
1120 timeout = 3
1121 j1 = JobTO_P(server = res, name = 'Job_1')
1122 activate(j1, j1.execute(timeout = timeout, usetime = usetime, priority = 1))
1123 j2 = JobTO_P(server = res, name = 'Job_2')
1124 j2_arrival = 1
1125 activate(j2, j2.execute(timeout = timeout, usetime = usetime, priority = 5),at = j2_arrival)
1126 j3 = JobTO_P(server = res, name = 'Job_2')
1127 j3_arrival = 2
1128 activate(j3, j3.execute(timeout = timeout, usetime = usetime, priority = 10),at = j3_arrival)
1129 simulate(until = 3 * usetime)
1130 assert(now() == 3 * usetime),'time not == 2 * usetime, but %s'%now()
1131 assert(j1.gotResource),'Job_1 did not get resource'
1132 assert(j2.gotResource),'Job_2 did renege'
1133 assert(j2.gotResource),'Job_3 did renege'
1134 assert not (res.waitQ or res.activeQ),\
1135 'job waiting or using resource'
1136 assert res.waitMon == [[j2_arrival, 1],[j3_arrival, 2],[usetime + j3_arrival, 1],[usetime + j2_arrival + usetime, 0]],\
1137 'res.waitMon wrong: %s'%res.waitMon
1138
1140 """Test that timeout occurs when resource has no capacity free
1141 """
1142 res = Resource(name = 'Server', capacity = 0)
1143 initialize()
1144 usetime = 5
1145 timeout = 3
1146 j1 = JobTO(server = res, name = 'Job_1')
1147 activate(j1, j1.execute(timeout = timeout, usetime = usetime))
1148 j2 = JobTO(server = res, name = 'Job_2')
1149 activate(j2, j2.execute(timeout = timeout, usetime = usetime))
1150 simulate(until = 2 * usetime)
1151 assert now() == timeout, 'time %s not == timeout'%now()
1152 assert not j1.gotResource, 'Job_1 got resource'
1153 assert not j2.gotResource, 'Job_2 got resource'
1154 assert not (res.waitQ or res.activeQ),\
1155 'job waiting or using resource'
1156
1158 """Test that timeout occurs when resource has no capacity free.
1159 Resource monitored.
1160 """
1161 res = Resource(name = 'Server', capacity = 0, monitored = True)
1162 initialize()
1163 usetime = 5
1164 timeout = 3
1165 j1 = JobTO(server = res, name = 'Job_1')
1166 activate(j1, j1.execute(timeout = timeout, usetime = usetime))
1167 j2 = JobTO(server = res, name = 'Job_2')
1168 activate(j2, j2.execute(timeout = timeout, usetime = usetime))
1169 simulate(until = 2 * usetime)
1170 assert now() == timeout, 'time %s not == timeout'%now()
1171 assert not j1.gotResource, 'Job_1 got resource'
1172 assert not j2.gotResource, 'Job_2 got resource'
1173 assert not (res.waitQ or res.activeQ),\
1174 'job waiting or using resource'
1175 assert res.waitMon == [[0, 1],[0, 2],[timeout, 1],[timeout, 0]],\
1176 'res.waitMon is wrong: %s'%res.waitMon
1177
1191
1192
1193
1194
1195
1196
1197
1198
1200 """ Job class for testing event reneging
1201 """
1202 - def __init__(self, server = None, name = ''):
1203 Process.__init__(self, name)
1204 self.res = server
1205 self.gotResource = None
1206
1207 - def execute(self, event, usetime):
1208 yield (request, self, self.res),(waitevent, self, event)
1209 if self.acquired(self.res):
1210 self.gotResource = True
1211 yield hold, self, usetime
1212 yield release, self, self.res
1213 else:
1214 self.gotResource = False
1215
1217 """ Job class for testing event reneging with multi - event lists
1218 """
1219 - def __init__(self, server = None, name = ''):
1220 Process.__init__(self, name)
1221 self.res = server
1222 self.gotResource = None
1223
1224 - def execute(self, eventlist, usetime):
1225 yield (request, self, self.res),(waitevent, self, eventlist)
1226 if self.acquired(self.res):
1227 self.gotResource = True
1228 yield hold, self, usetime
1229 yield release, self, self.res
1230 else:
1231 self.gotResource = False
1232
1234 """Fires reneging event
1235 """
1236 - def fire(self, fireDelay, event):
1237 yield hold, self, fireDelay
1238 event.signal()
1239
1241 """Tests of 'yield (request, self, res),(waiteevent, self, event)'
1242 event reneging command
1243 """
1245 """Test that processes acquire resource normally if no event fires
1246 """
1247 res = Resource(name = 'Server', capacity = 1)
1248 event = SimEvent('Renege_trigger')
1249 initialize()
1250 usetime = 5
1251 j1 = JobEvt(server = res, name = 'Job_1')
1252 activate(j1, j1.execute(event = event, usetime = usetime))
1253 j2 = JobEvt(server = res, name = 'Job_2')
1254 activate(j2, j2.execute(event = event, usetime = usetime))
1255 simulate(until = 2 * usetime)
1256
1257 assert now() == 2 * usetime, 'time not == 2 * usetime'
1258 assert j1.gotResource and j2.gotResource,\
1259 'at least one job failed to get resource'
1260 assert not (res.waitQ or res.activeQ),\
1261 'job waiting or using resource'
1262
1264 """Test that processes acquire resource normally if no event fires.
1265 Resource monitored.
1266 """
1267 res = Resource(name = 'Server', capacity = 1, monitored = True)
1268 event = SimEvent('Renege_trigger')
1269 initialize()
1270 usetime = 5
1271 j1 = JobEvt(server = res, name = 'Job_1')
1272 activate(j1, j1.execute(event = event, usetime = usetime))
1273 j2 = JobEvt(server = res, name = 'Job_2')
1274 activate(j2, j2.execute(event = event, usetime = usetime))
1275 simulate(until = 2 * usetime)
1276
1277 assert now() == 2 * usetime, 'time not == 2 * usetime'
1278 assert j1.gotResource and j2.gotResource,\
1279 'at least one job failed to get resource'
1280 assert not (res.waitQ or res.activeQ),\
1281 'job waiting or using resource'
1282 assert res.waitMon == [[0, 1],[usetime, 0]],'res.waitMoni is wrong: %s'%res.waitMon
1283
1285 """Test that signalled event leads to renege when resource busy
1286 """
1287 res = Resource(name = 'Server', capacity = 1)
1288 initialize()
1289 event = SimEvent('Renege_trigger')
1290 usetime = 5
1291 eventtime = 1
1292 j1 = JobEvt(server = res, name = 'Job_1')
1293 activate(j1, j1.execute(event = event, usetime = usetime))
1294 j2 = JobEvt(server = res, name = 'Job_2')
1295 activate(j2, j2.execute(event = event, usetime = usetime))
1296 f = FireEvent(name = 'FireEvent')
1297 activate(f, f.fire(fireDelay = eventtime, event = event))
1298 simulate(until = 2 * usetime)
1299
1300 assert(now() == usetime),'time not == usetime'
1301 assert(j1.gotResource),'Job_1 did not get resource'
1302 assert(not j2.gotResource),'Job_2 did not renege'
1303 assert not (res.waitQ or res.activeQ),\
1304 'job waiting or using resource'
1305
1307 """Test that signalled event leads to renege when resource busy.
1308 Resource monitored.
1309 """
1310 res = Resource(name = 'Server', capacity = 1, monitored = True)
1311 initialize()
1312 event = SimEvent('Renege_trigger')
1313 usetime = 5
1314 eventtime = 1
1315 j1 = JobEvt(server = res, name = 'Job_1')
1316 activate(j1, j1.execute(event = event, usetime = usetime))
1317 j2 = JobEvt(server = res, name = 'Job_2')
1318 activate(j2, j2.execute(event = event, usetime = usetime))
1319 f = FireEvent(name = 'FireEvent')
1320 activate(f, f.fire(fireDelay = eventtime, event = event))
1321 simulate(until = 2 * usetime)
1322
1323 assert(now() == usetime),'time not == usetime'
1324 assert(j1.gotResource),'Job_1 did not get resource'
1325 assert(not j2.gotResource),'Job_2 did not renege'
1326 assert not (res.waitQ or res.activeQ),\
1327 'job waiting or using resource'
1328 assert res.waitMon == [[0, 1],[eventtime, 0]],'res.waitMon is wrong: %s'%res.waitMon
1329
1331 """Test that renege - triggering event can be one of an event list
1332 """
1333 res = Resource(name = 'Server', capacity = 1)
1334 initialize()
1335 event1 = SimEvent('Renege_trigger_1')
1336 event2 = SimEvent('Renege_trigger_2')
1337 usetime = 5
1338 eventtime = 1
1339 j1 = JobEvtMulti(server = res, name = 'Job_1')
1340 activate(j1, j1.execute(eventlist = [event1, event2],usetime = usetime))
1341 j2 = JobEvtMulti(server = res, name = 'Job_2')
1342 activate(j2, j2.execute(eventlist = [event1, event2],usetime = usetime))
1343 f1 = FireEvent(name = 'FireEvent_1')
1344 activate(f1, f1.fire(fireDelay = eventtime, event = event1))
1345 f2 = FireEvent(name = 'FireEvent_2')
1346 activate(f2, f2.fire(fireDelay = eventtime, event = event2))
1347 simulate(until = 2 * usetime)
1348
1349 assert(now() == usetime),'time not == usetime'
1350 assert(j1.gotResource),'Job_1 did not get resource'
1351 assert(not j2.gotResource),'Job_2 did not renege'
1352 assert not (res.waitQ or res.activeQ),\
1353 'job waiting or using resource'
1354
1356 """Test that renege - triggering event can be one of an event list.
1357 Resource monitored.
1358 """
1359 res = Resource(name = 'Server', capacity = 1, monitored = True)
1360 initialize()
1361 event1 = SimEvent('Renege_trigger_1')
1362 event2 = SimEvent('Renege_trigger_2')
1363 usetime = 5
1364 eventtime = 1
1365 j1 = JobEvtMulti(server = res, name = 'Job_1')
1366 activate(j1, j1.execute(eventlist = [event1, event2],usetime = usetime))
1367 j2 = JobEvtMulti(server = res, name = 'Job_2')
1368 activate(j2, j2.execute(eventlist = [event1, event2],usetime = usetime))
1369 f1 = FireEvent(name = 'FireEvent_1')
1370 activate(f1, f1.fire(fireDelay = eventtime, event = event1))
1371 f2 = FireEvent(name = 'FireEvent_2')
1372 activate(f2, f2.fire(fireDelay = eventtime, event = event2))
1373 simulate(until = 2 * usetime)
1374
1375 assert(now() == usetime),'time not == usetime'
1376 assert(j1.gotResource),'Job_1 did not get resource'
1377 assert(not j2.gotResource),'Job_2 did not renege'
1378 assert not (res.waitQ or res.activeQ),\
1379 'job waiting or using resource'
1380 assert res.waitMon == [[0, 1],[eventtime, 0]],'res.waitMon is wrong: %s'%res.waitMon
1381
1394
1395
1396
1397
1398
1399
1400
1402 produced = 0
1409 """PriorityQ for Producers"""
1410 Producer.produced += 4
1411 yield put, self, buffer, 4,priority
1412 yield hold, self, 1
1413 self.done = now()
1414 doneList.append(self.name)
1416 for i in range(4):
1417 yield put, self, buffer, 4
1418 yield hold, self, 1
1420 consumed = 0
1422 """FIFO"""
1423 yield get, self, buffer
1424 Consumer.consumed += 1
1425 assert self.got == 1, 'wrong self.got: %s'%self.got
1426 yield get, self, buffer, 3
1427 Consumer.consumed += 3
1428 assert self.got == 3, 'wrong self.got: %s'%self.got
1429
1431 """producer PriorityQ, consumer FIFO"""
1432 while True:
1433 yield get, self, buffer, 2
1434 yield hold, self, 1
1436 """PriorityQ for Consumers"""
1437 yield get, self, buffer, 4,priority
1438 doneList.append(self.name)
1439
1440
1442 - def produce(self, buffer, productionTime):
1443 while True:
1444 assert not(buffer.amount > 0 and len(buffer.getQ) > 0),\
1445 'Consumer(s) waiting while buffer not empty'
1446 yield hold, self, productionTime
1447 yield put, self, buffer, 1
1448
1450 - def consume(self, buffer, consumptionTime):
1451 while True:
1452 assert not(buffer.amount == 0 and len(buffer.putQ) > 0),\
1453 'Producer(s) waiting while buffer empty'
1454 yield get, self, buffer, 1
1455 yield hold, self, consumptionTime
1456
1457
1458
1461 """Tests initialization of Level instances
1462 """
1463 a = Level()
1464 assert a.capacity == sys.maxint, 'wrong capacity:%s'%a
1465 assert a.amount == 0, 'wrong buffer content: %s'%a
1466 assert a.name == 'a_level', 'wrong name: %s'%a
1467 assert not a.monitored, 'should not be monitored: %s'%a
1468 assert a.putQMon is None, 'should not have putQMon: %s'%a
1469 assert a.getQMon is None, 'should not have getQMon: %s'%a
1470 assert a.bufferMon is None, 'should not have bufferMon: %s'%a
1471 assert a.putQType.__name__ == 'FIFO' and a.getQType.__name__ == 'FIFO',\
1472 'putQType and getQType should be FIFO: %s'%a
1473
1474 b = Level(name = 'b', initialBuffered = 10.0, monitored = True, capacity = 12,
1475 putQType = PriorityQ)
1476 a = Level()
1477 assert b.capacity == 12, 'wrong capacity:%s'%b
1478 assert b.amount == 10, 'wrong buffer content: %s'%b
1479 assert b.name == 'b', 'wrong name: %s'%b
1480 assert b.monitored, 'should be monitored: %s'%b
1481 assert not (b.putQMon is None),'should have putQMon: %s'%b
1482 assert not (b.getQMon is None),'should have getQMon: %s'%b
1483 assert not (b.bufferMon is None),'should have bufferMon: %s'%b
1484 assert b.putQType.__name__ == 'PriorityQ',\
1485 'putQType should be PriorityQ: %s'%b
1486 assert b.getQType.__name__ == 'FIFO',\
1487 'getQType should be PriorityQ: %s'%b
1488
1490 """Level: tests basic Producer / Consumer principles:
1491 - Consumers must not be waiting while Level buffer value > 0,
1492 - Producers must not be waiting while Level buffer value == 0
1493 """
1494 bufferSize = 1
1495 productionTime = 1
1496 consumptionTime = 5
1497 endtime = 50
1498
1499 initialize()
1500 buffer = Level(capacity = bufferSize)
1501 consumer = ConsumerPrincL()
1502 activate(consumer, consumer.consume(buffer, consumptionTime))
1503 producer = ProducerPrincL()
1504 activate(producer, producer.produce(buffer, productionTime))
1505 simulate(until = endtime)
1506
1519
1536
1538 """Level: tests put / get in multiple Producer / Consumer scenario,
1539 with Producers having different priorities.
1540 How: Producers forced to queue; all after first should be done in
1541 priority order
1542 """
1543 global doneList
1544 doneList = []
1545 initialize()
1546 buffer = Level(capacity = 7, putQType = PriorityQ, monitored = True)
1547 for i in range(4):
1548 p = Producer(i)
1549 pPriority = i
1550 activate(p, p.producePriority(buffer = buffer, priority = pPriority))
1551 c = Consumer()
1552 activate(c, c.consume1(buffer = buffer))
1553 simulate(until = 100)
1554 assert doneList == [0, 3,2, 1],'puts were not done in priority order: %s'\
1555 %doneList
1556
1558 """Level: tests put / get in multiple Producer / Consumer scenario, with
1559 Consumers having different priorities.
1560 How: Consumers forced to queue; all after first should be done in
1561 priority order
1562 """
1563 global doneList
1564 doneList = []
1565 initialize()
1566 buffer = Level(capacity = 7, getQType = PriorityQ, monitored = True)
1567 for i in range(4):
1568 c = Consumer(i)
1569 cPriority = i
1570 activate(c, c.consumePriority(buffer = buffer, priority = cPriority))
1571 p = Producer()
1572 activate(p, p.produce1(buffer = buffer))
1573 simulate(until = 100)
1574 assert doneList == [3, 2,1, 0],'gets were not done in priority order: %s'\
1575 %doneList
1576
1589
1590
1591
1592
1593
1594
1595
1618
1644
1648
1650 """Sorts Widget instances by weight attribute."""
1651 tmplist = [(x.weight, x) for x in par]
1652 tmplist.sort()
1653 return [x for (key, x) in tmplist]
1654
1655
1657 - def produce(self, buffer, productionTime):
1658 while True:
1659 assert not(buffer.nrBuffered > 0 and len(buffer.getQ) > 0),\
1660 'Consumer(s) waiting while buffer not empty'
1661 yield hold, self, productionTime
1662 product = WidgetPrinc()
1663 yield put, self, buffer,[product]
1664
1666 - def consume(self, buffer, consumptionTime):
1667 while True:
1668 assert not(buffer.nrBuffered == 0 and buffer.putQ),\
1669 'Producer(s) waiting while buffer empty'
1670 yield get, self, buffer, 1
1671 yield hold, self, consumptionTime
1672
1675
1677 """Used in testBufferFilter"""
1681
1683 """get all items with weight between a and b"""
1684 def between_a_and_b(buf):
1685 res = []
1686 for item in buf:
1687 if a < item.weight < b:
1688 res.append(item)
1689
1690 all = store.buffered
1691 yield get, self, store, between_a_and_b
1692 'All retrieved items weight in range?'
1693 for it in self.got:
1694 assert a < it.weight < b, 'weight %s not in range %s..%s'\
1695 %(it.weight, a,b)
1696 'Any item fitting filter pred left in buffer?'
1697 for it in store.buffer:
1698 assert not (a < it.weight < b),\
1699 'item left in buffer which fits filter (%s<%s<%s)'\
1700 %(a, it.weight, b)
1701 'All items either in store.buffer of self.got?'
1702 for it in all:
1703 assert (it in self.buffer) or (it in self.got),\
1704 'item w. weight %s neither in store nor in got'%it.weight
1705
1706
1707
1710 """Store: tests initialization of Store instances
1711 """
1712 a = Store()
1713 assert a.capacity == sys.maxint, 'wrong capacity:%s'%a
1714 assert a.nrBuffered == 0, 'wrong buffer content: %s'%a
1715 assert a.name == 'a_store', 'wrong name: %s'%a
1716 assert not a.monitored, 'should not be monitored: %s'%a
1717 assert a.putQMon is None, 'should not have putQMon: %s'%a
1718 assert a.getQMon is None, 'should not have getQMon: %s'%a
1719 assert a.bufferMon is None, 'should not have bufferMon: %s'%a
1720 assert a.putQType.__name__ == 'FIFO' and a.getQType.__name__ == 'FIFO',\
1721 'putQType and getQType should be FIFO: %s'%a
1722
1723 stored = [Widget(weight = 5)] * 10
1724 b = Store(name = 'b', initialBuffered = stored, monitored = True, capacity = 12,
1725 putQType = PriorityQ)
1726 assert b.capacity == 12, 'wrong capacity:%s'%b
1727 assert b.nrBuffered == 10, 'wrong buffer content: %s'%b
1728 assert b.name == 'b', 'wrong name: %s'%b
1729 assert b.monitored, 'should be monitored: %s'%b
1730 assert not (b.putQMon is None),'should have putQMon: %s'%b
1731 assert not (b.getQMon is None),'should have getQMon: %s'%b
1732 assert not (b.bufferMon is None),'should have bufferMon: %s'%b
1733 assert b.putQType.__name__ == 'PriorityQ',\
1734 'putQType should be PriorityQ: %s'%b
1735 assert b.getQType.__name__ == 'FIFO',\
1736 'getQType should be PriorityQ: %s'%b
1737
1739 """Store: tests basic Producer / Consumer principles:
1740 - Consumers must not be waiting while items in Store buffer,
1741 - Producers must not be waiting while space available in Store buffer
1742 """
1743 bufferSize = 1
1744 productionTime = 1
1745 consumptionTime = 5
1746 endtime = 50
1747
1748 initialize()
1749 buffer = Store(capacity = bufferSize)
1750 consumer = ConsumerPrincS()
1751 activate(consumer, consumer.consume(buffer, consumptionTime))
1752 producer = ProducerPrincS()
1753 activate(producer, producer.produce(buffer, productionTime))
1754 simulate(until = endtime)
1755
1769
1786
1788 """Store: Tests put / get in multiple Producer / Consumer scenario,
1789 with Producers having different priorities.
1790 How; Producers forced to queue; all after first should be done in
1791 priority order
1792 """
1793 global doneList
1794 doneList = []
1795 initialize()
1796 buffer = Store(capacity = 7, putQType = PriorityQ, monitored = True)
1797 for i in range(4):
1798 p = ProducerWidget(i)
1799 pPriority = i
1800 activate(p, p.producePriority(buffer = buffer, priority = pPriority))
1801 c = ConsumerWidget()
1802 activate(c, c.consume1(buffer = buffer))
1803 simulate(until = 100)
1804 assert doneList == [0, 3,2, 1],'puts were not done in priority order: %s'\
1805 %doneList
1806
1808 """Tests put / get in multiple Producer / Consumer scenario, with
1809 Consumers having different priorities.
1810 How; Consumers forced to queue; all after first should be done in
1811 priority order
1812 """
1813 global doneList
1814 doneList = []
1815 initialize()
1816 buffer = Store(capacity = 7, getQType = PriorityQ, monitored = True)
1817 for i in range(4):
1818 c = ConsumerWidget(str(i))
1819 cPriority = i
1820 activate(c, c.consumePriority(buffer = buffer, priority = cPriority))
1821 p = ProducerWidget()
1822 activate(p, p.produce1(buffer = buffer))
1823 simulate(until = 100)
1824 assert doneList == ['3', '2', '1', '0'],\
1825 'gets were not done in priority order: %s'%doneList
1826
1828 """Tests the optional sorting of theBuffer by applying a user - defined
1829 sort function."""
1830 initialize()
1831 gotten = []
1832 sortedStore = Store()
1833 sortedStore.addSort(mySortFunc)
1834 p = ProducerWidget()
1835 activate(p, p.produceUnordered(sortedStore))
1836 for i in range(9):
1837 c = ConsumerWidget()
1838 activate(c, c.consumeSorted(buffer = sortedStore, gotten = gotten),at = 1)
1839 simulate(until = 10)
1840 assert gotten == [1, 2,3, 4,5, 6,7, 8,9],'sort wrong: %s'%gotten
1841
1853
1869
1870
1871
1872
1873
1874
1875 -class TBT(Process):
1876 """Store: For testBasicTime"""
1877 - def tbt(self, store):
1878 yield get, self, store, 1
1879 assert self.got, 'Did not get Item'
1880 yield (get, self, store, 1),(hold, self, 5)
1881 if self.acquired(store):
1882 assert len(self.got) == 1, 'did not get 1 Item'
1883 else:
1884 assert not self.got and now() == 5 and not store.getQ,\
1885 'time renege not working'
1886
1887 -class TBE(Process):
1888 """Store: For testBasicEvent"""
1889 - def tbe(self, store, trigger):
1890 yield get, self, store, 1
1891 assert self.got, 'Did not get Item'
1892 yield (get, self, store, 1),(waitevent, self, trigger)
1893 if self.acquired(store):
1894 assert False, 'should have reneged'
1895 else:
1896 assert self.eventsFired[0] == trigger and now() == 5 \
1897 and not store.getQ, 'event renege not working'
1898
1900 """Store: For testBasicEvent"""
1901 - def fire(self, trigger):
1904
1906 """Store: for testBasicTimePut"""
1907 - def tbt(self, store):
1908 class Item:pass
1909 yield (put, self, store,[Item()]),(hold, self, 4)
1910 if self.stored(store):
1911 assert store.nrBuffered == 1 and not store.putQ,\
1912 'put did not execute'
1913 else:
1914 assert False, 'should not have reneged'
1915 yield (put, self, store,[Item()]),(hold, self, 5)
1916 if self.stored(store):
1917 assert False, 'should have reneged'
1918 else:
1919 assert store.nrBuffered == 1 and not store.putQ,\
1920 'renege not working correctly'
1921
1923 """Store: for testBasicEventPut"""
1924 - def tbe(self, store, trigger):
1925 class Item:pass
1926 yield (put, self, store,[Item()]),(waitevent, self, trigger)
1927 if self.stored(store):
1928 assert store.nrBuffered == 1 and not store.putQ,\
1929 'put did not execute'
1930 else:
1931 assert False, 'should have not have reneged'
1932 yield (put, self, store,[Item()]),(waitevent, self, trigger)
1933 if self.stored(store):
1934 assert False, 'should have reneged'
1935 else:
1936 assert now() == 5 and self.eventsFired[0] == trigger\
1937 and not store.putQ, 'renege not working correctly'
1938
1940 """Store: For testBasicEventPut"""
1941 - def fire(self, trigger):
1944
1946 """Store: Testcase for compound get statements"""
1947
1948
1949
1950
1951
1952
1954 """Store (unmonitored):
1955 test 'yield (get, self, store),(hold, self, timeout)"""
1956 class Item:pass
1957 initialize()
1958 st = Store(initialBuffered = [Item()])
1959 t = TBT()
1960 activate(t, t.tbt(store = st))
1961 simulate(until = 10)
1962
1963
1964
1965
1966
1967
1968
1970 """Store (unmonitored):
1971 test 'yield (put, self, store),(hold, self, time)"""
1972 initialize()
1973 st = Store(capacity = 1)
1974 t = TBTput()
1975 activate(t, t.tbt(store = st))
1976 simulate(until = 10)
1977
1979 """Store (monitored):
1980 test monitors with 'yield (put, self, store),(hold, self, time)"""
1981 initialize()
1982 st = Store(capacity = 1, monitored = True)
1983 t = TBTput()
1984 activate(t, t.tbt(store = st))
1985 simulate(until = 10)
1986
1987 assert st.putQMon == [[0, 0],[0, 1],[5, 0]],'putQMon wrong: %s'\
1988 %st.putQMon
1989
1990 assert st.bufferMon == [[0, 0],[0, 1]],'bufferMon wrong: %s'%st.bufferMon
1991
1992
1993
1994
1995
1996
1997
1999 """Store (unmonitored):
2000 test 'yield (get, self, store),(waitevent, self, event)"""
2001 class Item:pass
2002 initialize()
2003 st = Store(initialBuffered = [Item()])
2004 trig = SimEvent()
2005 t = TBE()
2006 activate(t, t.tbe(store = st, trigger = trig))
2007 tr = TBEtrigger()
2008 activate(tr, tr.fire(trigger = trig))
2009 simulate(until = 10)
2010
2011
2012
2013
2014
2015
2016
2028
2030 """Store (monitored):
2031 test monitors with 'yield (put, self, store),(waitevent, self, event)"""
2032 initialize()
2033 s = SimEvent()
2034 st = Store(capacity = 1, monitored = True)
2035 t = TBEtriggerPut()
2036 activate(t, t.fire(trigger = s))
2037 tb = TBEput()
2038 activate(tb, tb.tbe(store = st, trigger = s))
2039 simulate(until = 10)
2040
2041 assert st.putQMon == [[0, 0],[0, 1],[5, 0]],'putQMon wrong: %s'\
2042 %st.putQMon
2043
2044 assert st.bufferMon == [[0, 0],[0, 1]],'bufferMon wrong: %s'%st.bufferMon
2045
2064
2065
2066
2067
2068
2069
2071 """Level: For testBasicTime"""
2072 - def tbt(self, level):
2073 yield get, self, level, 1
2074 assert self.got, 'did not get 1 unit'
2075 yield (get, self, level, 1),(hold, self, 5)
2076 if self.acquired(level):
2077 assert self.got == 1, 'did not get 1 unit'
2078 else:
2079 assert not self.got and now() == 5, 'time renege not working'
2080
2082 """Level: For testBasicEvent"""
2083 - def tbe(self, level, trigger):
2084 yield get, self, level, 1
2085 assert self.got, 'did not get 1 unit'
2086 yield (get, self, level, 1),(waitevent, self, trigger)
2087 if self.acquired(level):
2088 assert self.got == 1, 'did not get 1 Item'
2089 else:
2090 assert now() == 5.5 and self.eventsFired[0] == trigger,\
2091 'event renege not working'
2092
2094 """Level: For testBasicEvent"""
2095 - def fire(self, trigger):
2098
2100 """Level: For testBasicTimePut"""
2101 - def tbt(self, level):
2102 yield put, self, level, 1
2103 assert level.amount, 'did not put 1 unit'
2104 yield (put, self, level, 1),(hold, self, 5)
2105 if self.stored(level):
2106 assert False, 'should have reneged'
2107 else:
2108 assert level.amount == 1 and now() == 5, 'time renege not working'
2109
2111 """Level: For testBasicEventPut and testBasicEventPutM"""
2112 - def tbe(self, level, trigger):
2113 yield (put, self, level, 1),(waitevent, self, trigger)
2114 if self.stored(level):
2115 assert level.amount == 1, 'did not put 1 unit'
2116 else:
2117 assert False, 'should not have reneged'
2118 yield (put, self, level, 1),(waitevent, self, trigger)
2119 if self.stored(level):
2120 assert False, 'should have reneged'
2121 else:
2122 assert now() == 5.5 and self.eventsFired[0] == trigger ,\
2123 'renege not working'
2124
2126 """Level: For testBasicEventPut"""
2127 - def fire(self, trigger):
2130
2132 """Level: Testcase for compound get and put statements"""
2133
2134
2135
2136
2137
2138
2140 """Level (unmonitored): test 'yield (get, self, level),(hold, self, timeout)"""
2141 initialize()
2142 l = Level(initialBuffered = 1)
2143 t = TBTLev()
2144 activate(t, t.tbt(level = l))
2145 simulate(until = 10)
2146
2147
2148
2149
2150
2151
2153 """Level (unmonitored):
2154 test 'yield (put, self, level),(hold, self, timeout)"""
2155 initialize()
2156 l = Level(capacity = 1)
2157 t = TBTLevPut()
2158 activate(t, t.tbt(level = l))
2159 simulate(until = 10)
2160
2161
2162
2163
2164
2165
2166
2178
2180 """Level (monitored):
2181 test monitors with 'yield (get, self, level),(waitevent, self, event)"""
2182 initialize()
2183 l = Level(initialBuffered = 1, monitored = True)
2184 trig = SimEvent()
2185 t = TBELev()
2186 activate(t, t.tbe(level = l, trigger = trig))
2187 tr = TBEtriggerLev()
2188 activate(tr, tr.fire(trigger = trig))
2189 simulate(until = 10)
2190
2191 assert l.getQMon == [[0, 0],[0, 1],[5.5, 0]],'getQMon not working: %s'\
2192 %l.getQMon
2193
2194 assert l.bufferMon == [[0, 1],[0, 0]],\
2195 'bufferMon not working: %s'%l.bufferMon
2196
2197
2198
2199
2200
2201
2213
2215 """Level (monitored):
2216 test monitors with 'yield (put, self, level),(waitevent, self, event)"""
2217 initialize()
2218 l = Level(capacity = 1, monitored = True)
2219 trig = SimEvent()
2220 t = TBELevPut()
2221 activate(t, t.tbe(level = l, trigger = trig))
2222 tr = TBEtriggerLevPut()
2223 activate(tr, tr.fire(trigger = trig))
2224 simulate(until = 10)
2225 'First put succeeds, second reneges at t = 5.5?'
2226 assert l.putQMon == [[0, 0],[0, 1],[5.5, 0]],'putQMon wrong: %s'\
2227 %l.putQMon
2228 '1 unit added at t = 0, renege at t = 5 before 2nd unit added?'
2229 assert l.bufferMon == [[0, 0],[0, 1]],'bufferMon wrong: %s'%l.bufferMon
2230
2249
2250 if __name__ == '__main__':
2251 alltests = unittest.TestSuite((makeSSuite(),makeRSuite(),
2252 makeMSuite(),
2253 makeISuite(),makePSuite(),
2254 makeESuite(),makeWSuite(),
2255 makeTOSuite(),makeEvtRenegeSuite(),
2256 makeLevelSuite(),
2257 makeStoreSuite(),
2258 makeStoreCompSuite(),
2259 makeLevelCompSuite()
2260 ))
2261 runner = unittest.TextTestRunner()
2262 runner.run(alltests)
2263