1
2
3 from SimPy.Simulation import *
4 from SimPy.MonitorTest import *
5 import unittest
6 from random import random
7
8 """testSimPy.py
9 SimPy version 2.1
10 Unit tests for Simulation.py.
11
12 #'$Revision: 437 $ $Date: 2010-04-02 05:48:28 +0200 (Fri, 02 Apr 2010) $ kgm'
13
14 """
15
16 simulationVersion=version
17 print "Under test: Simulation.py %s"%simulationVersion
18 __version__ = '2.1 $Revision: 437 $ $Date: 2010-04-02 05:48:28 +0200 (Fri, 02 Apr 2010) $ '
19 print 'testSimpy.py %s'%__version__
20
21
22
24 """ P class for testing"""
29
31 yield hold, self, self.T
32
34 """ PActions class for testing"""
39
41 yield hold, self, self.T
42
44 """For testing stopSimulation
45 """
46 - def run(self,stopTime):
50
52 """For testing startCollection
53 """
54 - def run(self,mon1,mon2,tal1,tal2):
61
63 """For testing allEventTimes
64 """
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
121
122
123
124
126 """Test stopSimulation function/method
127 """
128 timeToStop = 7
129 initialize()
130 ts = ToStop()
131 activate(ts,ts.run(stopTime = timeToStop))
132 simulate(until = 50)
133 assert(now()==timeToStop),\
134 "stopSimulation not working; now = %s instead of %s"%(now(),timeToStop)
135
137 """Test startCollection function/method
138 """
139 initialize()
140 tStart = 9
141 mon1 = Monitor("mon1")
142 mon2 = Monitor("mon2")
143 tal1 = Tally("tal1")
144 tal2 = Tally("tal2")
145 startCollection(when = tStart,monitors=[mon1,mon2],tallies=[tal1,tal2])
146 tc = ToCollect()
147 activate(tc,tc.run(mon1,mon2,tal1,tal2))
148 simulate(until=50)
149 assert(mon1[0]==mon2[0]==[tStart,tStart]),\
150 "startCollection not working correctly for Monitors"
151 assert(tal1.count()==tal2.count()==50-tStart+1),\
152 "startCollection not working for Tally"
153
163
164
165
166
183
184
185
186
187
189 """ Job class for testing"""
190 - def __init__(self, server = None, name = ''):
194
196 yield request, self, self.R
197
198
200 """ First simple tests of Resources
201 """
203 """Test initialisation"""
204 R = Resource()
205 assert R.name == 'a_resource', 'Not null name'
206 assert R.capacity == 1, 'Not unit capacity'
207 assert R.unitName == 'units', 'Not the correct unit name'
208 R = Resource(name = '', capacity = 1)
209 assert R.name == '', 'Not null name'
210 assert R.capacity == 1, 'Not unit capacity'
211 assert R.unitName == 'units', 'Not the correct unit name'
212 R = Resource(capacity = 3, name = '3 - version', unitName = 'blobs')
213 assert R.name == '3 - version', 'Wrong name, it is' + R.name
214 assert R.capacity == 3, 'Not capacity 3, it is '+`R.capacity`
215 assert R.unitName == 'blobs', 'Not the correct unit name'
216
217 R = Resource(capacity = 0, name = '0 - version')
218 assert R.capacity == 0, 'Not capacity 0, it is '+`R.capacity`
219
221 """Test request"""
222
223
224 R0 = Resource(name = '', capacity = 0)
225 assert R0.name == '', 'Not null name'
226 assert R0.capacity == 0, 'Not capacity 0, it is ' + 'R0.capacity'
227
228 initialize()
229 R1 = Resource(capacity = 0, name = '3 - version', unitName = 'blobs')
230 J = Job(name = 'job', server = R1)
231 activate(J, J.execute(), at = 0.0)
232
233 simulate(until = 10.0)
234 assert R1.n == 0, 'Should be 0, it is ' + str(R1.n)
235 lenW = len(R1.waitQ)
236 assert lenW == 1, 'Should be 1, it is ' + str(lenW)
237 assert len(R1.activeQ) == 0, 'len activeQ Should be 0, it is '+\
238 str(len(R1.activeQ))
239
241 """Test request2 with capacity = 1"""
242
243 initialize()
244 R2 = Resource(capacity = 1, name = '3 - version', unitName = 'blobs')
245 J2 = Job(name = 'job', server = R2)
246 activate(J2, J2.execute(), at = 0.0)
247
248 simulate(until = 10.0)
249 assert R2.n == 0, 'Should be 0, it is ' + str(R2.n)
250 lenW = len(R2.waitQ)
251 lenA = len(R2.activeQ)
252 assert lenW == 0, 'lenW Should be 0, it is ' + str(lenW)
253 assert lenA == 1, 'lenA Should be 1, it is ' + str(lenA)
254
256 """Test request3 with capacity = 1 several requests"""
257
258 initialize()
259 R3 = Resource(capacity = 1, name = '3 - version', unitName = 'blobs')
260 J2 = Job(name = 'job', server = R3)
261 J3 = Job(name = 'job', server = R3)
262 J4 = Job(name = 'job', server = R3)
263 activate(J2, J2.execute(), at = 0.0)
264 activate(J3, J3.execute(), at = 0.0)
265 activate(J4, J4.execute(), at = 0.0)
266
267 simulate(until = 10.0)
268 assert R3.n == 0, 'Should be 0, it is ' + str(R3.n)
269 lenW = len(R3.waitQ)
270 lenA = len(R3.activeQ)
271 assert lenW == 2, 'lenW Should be 2, it is ' + str(lenW)
272 assert R3.waitQ == [J3, J4],'WaitQ wrong' + str(R3.waitQ)
273 assert lenA == 1, 'lenA Should be 1, it is ' + str(lenA)
274 assert R3.activeQ == [J2],'activeQ wrong, it is ' + str(R3.activeQ[0])
275
277 """Test request4 with capacity = 2 several requests"""
278
279 initialize()
280 R3 = Resource(capacity = 2, name = '4 - version', unitName = 'blobs')
281 J2 = Job(name = 'job', server = R3)
282 J3 = Job(name = 'job', server = R3)
283 J4 = Job(name = 'job', server = R3)
284 activate(J2, J2.execute(), at = 0.0)
285 activate(J3, J3.execute(), at = 0.0)
286 activate(J4, J4.execute(), at = 0.0)
287
288 simulate(until = 10.0)
289 assert R3.n == 0, 'Should be 0, it is ' + str(R3.n)
290 lenW = len(R3.waitQ)
291 lenA = len(R3.activeQ)
292 assert lenW == 1, 'lenW Should be 1, it is ' + str(lenW)
293 assert R3.waitQ == [J4],'WaitQ wrong' + str(R3.waitQ)
294 assert lenA == 2, 'lenA Should be 2, it is ' + str(lenA)
295 assert R3.activeQ == [J2, J3],'activeQ wrong, it is ' + str(R3.activeQ[0])
296
297
298
300 """Test PriorityQ, with no preemption, 0 capacity"""
301 class Job(Process):
302 """ Job class for testing"""
303 def __init__(self, server = None, name = ''):
304 Process.__init__(self)
305 self.name = name
306 self.R = server
307
308 def execute(self, priority):
309 yield request, self, self.R, priority
310
311 initialize()
312 Rp = Resource(capacity = 0, qType = PriorityQ)
313 J5 = Job(name = 'job 5', server = Rp)
314 J6 = Job(name = 'job 6', server = Rp)
315 J7 = Job(name = 'job 7', server = Rp)
316 activate(J5, J5.execute(priority = 3))
317 activate(J6, J6.execute(priority = 0))
318 activate(J7, J7.execute(priority = 1))
319 simulate(until = 100)
320 assert Rp.waitQ == [J5, J7, J6],'WaitQ wrong' + str([(x.name, x.priority[Rp]) for x in Rp.waitQ])
321
322 """Test PriorityQ mechanism"""
323
324 def sorted(q):
325 if not q or len(q) == 1:
326 sortok = 1
327 return sortok
328 sortok = q[0] >= q[1] and sorted(q[2:])
329 return sortok
330
331 initialize()
332 Rp = Resource(capacity = 0, qType = PriorityQ)
333 for i in range(10):
334 J = Job(name = 'job ' + str(i),server = Rp)
335 activate(J, J.execute(priority = random()))
336 simulate(until = 1000)
337 qp = [x._priority[Rp] for x in Rp.waitQ]
338 assert sorted(qp),'waitQ not sorted by priority: ' + str([(x.name, x._priority[Rp]) for x in Rp.waitQ])
339
340
342 """Test PriorityQ, with no preemption, capacity == 1"""
343 class Job(Process):
344 """ Job class for testing"""
345 def __init__(self, server = None, name = ''):
346 Process.__init__(self)
347 self.name = name
348 self.R = server
349
350 def execute(self, priority):
351 yield request, self, self.R, priority
352
353 initialize()
354 Rp = Resource(capacity = 1, qType = PriorityQ)
355 J5 = Job(name = 'job 5', server = Rp)
356 J6 = Job(name = 'job 6', server = Rp)
357 J7 = Job(name = 'job 7', server = Rp)
358 activate(J5, J5.execute(priority = 2))
359 activate(J6, J6.execute(priority = 4))
360 activate(J7, J7.execute(priority = 3))
361 simulate(until = 100)
362 assert Rp.waitQ == [J6, J7],'WaitQ wrong ' + str([(x.name, x._priority[Rp]) for x in Rp.waitQ])
363
365 """Test PriorityQ, with preemption, capacity == 1"""
366 class nuJob(Process):
367 def __init__(self, name):
368 Process.__init__(self, name)
369
370 def execute(self, res, priority):
371 self.preempt = len(res.activeQ) > 0 and priority > res.activeQ[-1]._priority[res]
372 t = now()
373 yield request, self, res, priority
374 if self.preempt:
375 assert len(res.waitQ) == 1, 'No preemption ' + 'activeQ = ' + str(res.activeQ[0].name)
376 yield hold, self, 30
377 t1 = now()
378 if self.preempt:
379 assert t + 30 == t1, 'Wrong completion time for preemptor ' + self.name
380 else:
381 assert t + 60 == t1, 'Wrong completion time for preempted ' + self.name + ' ' + str(now())
382 yield release, self, res
383
384 initialize()
385 res = Resource(name = 'server', capacity = 1, qType = PriorityQ, preemptable = 1)
386 n1 = nuJob(name = 'nuJob 1')
387 n2 = nuJob(name = 'nuJob 2')
388 activate(n1, n1.execute(res, priority = 0))
389 activate(n2, n2.execute(res, priority = 1),at = 15)
390 simulate(until = 100)
391
393 """Test preemption of preemptor"""
394 class nuJob(Process):
395 seqOut = []
396 def __init__(self, name):
397 Process.__init__(self, name)
398 self.serviceTime = 30
399
400 def execute(self, res, priority):
401 self.preempt = len(res.activeQ) > 0 and priority > res.activeQ[-1]._priority[res]
402 nrwaiting = len(res.waitQ)
403 yield request, self, res, priority
404 if self.preempt:
405 assert len(res.waitQ) == nrwaiting + 1, 'No preemption ' + 'activeQ = ' + str(res.activeQ[0].name)
406 yield hold, self, self.serviceTime
407 yield release, self, res
408 nuJob.seqOut.append((self, now()))
409
410
411
412 initialize()
413 res = Resource(name = 'server', capacity = 1, qType = PriorityQ, preemptable = 1)
414 n1 = nuJob(name = 'nuJob 1')
415 n2 = nuJob(name = 'nuJob 2')
416 n3 = nuJob(name = 'nuJob 3')
417 activate(n1, n1.execute(res, priority=-1))
418 start2 = 10
419 activate(n2, n2.execute(res, priority = 0),at = start2)
420 start3 = 20
421 activate(n3, n3.execute(res, priority = 1),at = start3)
422 simulate(until = 100)
423 assert [x[1] for x in nuJob.seqOut] == [start3 + n3.serviceTime, start2 + 2 * n2.serviceTime, 90],\
424 'Wrong service sequence / times: ' + str([x for x in nuJob.seqOut])
425
427 """Test that a process can preempt another process holding multiple resources
428 """
429 class Requestor(Process):
430 def run(self, res1, res2, res3, priority = 1):
431 yield request, self, res1, priority
432 yield request, self, res2, priority
433 yield request, self, res3, priority
434 record.observe(y = self.name)
435 yield hold, self, 100
436 record.observe(y = self.name)
437 yield release, self, res3
438 yield release, self, res2
439 yield release, self, res1
440
441 initialize()
442 outer = Resource(name = 'outer', qType = PriorityQ, preemptable = True)
443 inner = Resource(name = 'inner', qType = PriorityQ, preemptable = True)
444 innermost = Resource(name = 'innermost', qType = PriorityQ, preemptable = True)
445 record = Monitor()
446 r1 = Requestor('r1')
447 activate(r1, r1.run(res1 = outer, res2 = inner, res3 = innermost, priority = 1))
448 r2 = Requestor('r2')
449 activate(r2, r2.run(res1 = outer, res2 = inner, res3 = innermost, priority = 10),at = 50)
450 simulate(until = 200)
451 assert record == [[0, 'r1'],[50, 'r2'],[150, 'r2'],[200, 'r1']],\
452 'was %s; preempt did not work'%record
453
454
456 """ test monitoring of number in the two queues, waitQ and activeQ
457 """
458 class Job(Process):
459 def __init__(self, name):
460 Process.__init__(self, name)
461
462 def execute(self, res):
463 yield request, self, res
464 yield hold, self, 2
465 yield release, self, res
466
467 initialize()
468 res = Resource(name = 'server', capacity = 1, monitored = 1)
469 n1 = Job(name = 'Job 1')
470 n2 = Job(name = 'Job 2')
471 n3 = Job(name = 'Job 3')
472 activate(n1, n1.execute(res),at = 2)
473 activate(n2, n2.execute(res),at = 2)
474 activate(n3, n3.execute(res),at = 2)
475 simulate(until = 100)
476 assert res.waitMon == [[2, 1], [2, 2], [4, 1], [6, 0]],'Wrong waitMon:%s'%res.waitMon
477 assert res.actMon == [[2, 1], [4, 0], [4, 1], [6, 0], [6, 1], [8, 0]],'Wrong actMon:%s'%res.actMon
478
479 assert res.waitMon.timeAverage() == (0 * 2 + 2 * 2 + 1 * 2) / 6.0, 'Wrong waitMon.timeAverage:%s'%res.waitMon.timeAverage()
480
481
483 suite = unittest.TestSuite()
484 testInit = makeResourcetestcase('testInit')
485 testrequest = makeResourcetestcase('testrequest')
486 testrequest2 = makeResourcetestcase('testrequest2')
487 testrequest3 = makeResourcetestcase('testrequest3')
488 testrequest4 = makeResourcetestcase('testrequest4')
489 testrequestPriority = makeResourcetestcase('testrequestPriority')
490 testrequestPriority1 = makeResourcetestcase('testrequestPriority1')
491 testrequestPriority2 = makeResourcetestcase('testrequestPriority2')
492 testrequestPriority3 = makeResourcetestcase('testrequestPriority3')
493 testrequestNestedPreempt = makeResourcetestcase('testrequestNestedPreempt')
494 testmonitored = makeResourcetestcase('testmonitored')
495 suite.addTests([testInit, testrequest, testrequest2, testrequest3, testrequest4, testrequestPriority,
496 testrequestPriority1, testrequestPriority2, testrequestPriority3,
497 testrequestNestedPreempt, testmonitored])
498 return suite
499
500
501
502
503
504
505
509
510 - def breakin(self, waitbefore, howoften = 1):
511 for i in range(howoften):
512 yield hold, self, waitbefore
513 self.interrupt(victim)
514
518
520 global igothit
521 igothit={}
522 while now() <= theEnd:
523 yield hold, self, howlong
524 if self.interrupted():
525 byWhom = self.interruptCause
526 igothit[now()] = byWhom
527 else:
528 pass
529
531 """
532 Tests interrupts as defined in SEP001v17
533 """
535 """
536 Test single interrupt during victim activity
537 """
538 global victim
539 initialize()
540 breaker = Interruptor()
541 activate(breaker, breaker.breakin(10))
542 victim = Interrupted()
543 activate(victim, victim.myActivity(100))
544 simulate(until = 200)
545 assert igothit[10] == breaker, 'Not interrupted at 10 by breaker'
546 assert len(igothit) == 1, 'Interrupted more than once'
547
549 """
550 Test multiple interrupts during victim activity
551 """
552 global victim
553 initialize()
554 breaker = Interruptor()
555 activate(breaker, breaker.breakin(10, howoften = 3))
556 victim = Interrupted()
557 activate(victim, victim.myActivity(100))
558 simulate(until = 200)
559 for i in (10, 20, 30):
560 assert igothit[i] == breaker, 'Not interrupted at %s by breaker' %i
561 assert len(igothit) == 3, 'Interrupted wrong number of times'
562
564 """
565 Test interrupts after victim activity
566 """
567 global victim
568 initialize()
569 breaker = Interruptor()
570 activate(breaker, breaker.breakin(50, howoften = 5))
571 victim = Interrupted()
572 activate(victim, victim.myActivity(10, theEnd = 10))
573 simulate(until = 200)
574 assert len(igothit) == 0, 'There has been an interrupt after victim lifetime'
575
577 """
578 Test multiple interrupts by multiple processes during victim activity
579 """
580 global victim
581 initialize()
582 breaker1 = Interruptor()
583 activate(breaker1, breaker1.breakin(15, howoften = 3))
584 breaker2 = Interruptor()
585 activate(breaker2, breaker2.breakin(20, howoften = 3))
586 victim = Interrupted()
587 activate(victim, victim.myActivity(100))
588 simulate(until = 200)
589 for i in (15, 30, 45):
590 assert igothit[i] == breaker1, 'Not interrupted at %s by breaker1' %i
591 for i in (20, 40, 60):
592 assert igothit[i] == breaker2, 'Not interrupted at %s by breaker2' %i
593 assert len(igothit) == 6, 'Interrupted wrong number of times'
594
611
612 victim.newProcess = newProcess
613 activate(victim, newProcess(victim))
614 activate(breaker, breaker.breakin(10, howoften = 3))
615 simulate(until = 1000)
616
626
627
628
629
630
642
646
648 assert p.active(),'p not active'
649 assert not p.passive(), 'p passive'
650 assert not p.terminated(),'p terminated'
651 assert not p.interrupted(),'p interrupted'
652 yield hold, self, 11
653 assert not p.active(),'p active'
654 assert not p.passive(),'p passive'
655 assert p.terminated(),'p not terminated'
656 assert not p.interrupted(),'p interrupted'
657
659 assert not p.active(),'p active'
660 assert p.passive(),'p not passive'
661 assert not p.terminated(),'p not terminated'
662 assert not p.interrupted(),'p interrupted'
663 activate(p, p.life1())
664 yield hold, self, 11
665 assert not p.active(),'p active'
666 assert not p.passive(),'p not passive'
667 assert p.terminated(),'p not terminated'
668 assert not p.interrupted(),'p interrupted'
669
671 assert not p.active(),'p active'
672 assert p.passive(),'p not passive'
673 assert not p.terminated(),'p not terminated'
674 assert not p.interrupted(),'p interrupted'
675 activate(p, p.life2())
676 yield hold, self, 11
677 assert not p.active(),'p active'
678 assert p.passive(),'p not passive'
679 assert not p.terminated(),'p terminated'
680 assert not p.interrupted(),'p interrupted'
681
683 yield hold, self, 5
684 assert p.active(),'p not active'
685 assert not p.passive(),'p passive'
686 assert not p.terminated(),'p terminated'
687 assert not p.interrupted(),'p interrupted'
688 self.cancel(p)
689 assert not p.active(),'p active'
690 assert p.passive(),'p not passive'
691 assert not p.terminated(),'p terminated'
692 assert not p.interrupted(),'p interrupted'
693 reactivate(p)
694 assert p.active(),'p not active'
695 assert not p.passive(),'p passive'
696 assert not p.terminated(),'p terminated'
697 assert not p.interrupted(),'p interrupted'
698 yield hold, self
699 assert not p.active(),'p active'
700 assert not p.passive(),'p passive'
701 assert p.terminated(),'p terminated'
702 assert not p.interrupted(),'p interrupted'
703
705 yield hold, self, 11
706 assert not p.active(),'p active'
707 assert p.passive(),'p not passive'
708 assert not p.terminated(),'p terminated'
709 assert not p.interrupted(),'p interrupted'
710 self.cancel(p)
711 assert not p.active(),'p active'
712 assert p.passive(),'p not passive'
713 assert not p.terminated(),'p terminated'
714 assert not p.interrupted(),'p interrupted'
715
733
737
738 - def look1(self, p1, p2, res):
739 assert p1.active(), 'p1 not active'
740 assert not p1.queuing(res), 'p1 queuing'
741 assert p2.active(), 'p2 noit active'
742 assert not p2.queuing(res), 'p2 queuing'
743 yield hold, self, 2
744 assert p1.active(), 'p1 not active'
745 assert not p1.queuing(res), 'p1 queuing'
746 assert p2.passive(), 'p2 active'
747 assert p2.queuing(res), 'p2 not queuing'
748
757
759 """
760 Tests states and state transitions as defined in SEP003
761 """
762
774
791
811
835
836
837
846
847
848
849
850
853 yield hold, self, 1
854 ev1.signal('from SignalProcess')
855 while ev2.queues:
856 nq0 = len(ev2.queues)
857 ev2.signal('from SignalProcess')
858 assert len(ev2.queues) == (nq0 - 1),'wrong number of processes dequeued'
859
862 yield waitevent, self, ev1
863 assert ev1.waits == [],'not all processes waiting for event out of waiting list'
864 assert ev1 in self.eventsFired, 'did not record firing event'
865
868 yield queueevent, self, ev2
869 assert ev2 in self.eventsFired, 'did not record firing event'
870
873 yield hold, self, 1
874 ev1.signal('from SignalProcess')
875 yield hold, self, 3
876 assert len(ev2.queues) == QueueProcessOR.nrProcesses, 'wrong number of processes queuing for event ev2'
877 while ev2.queues:
878 nq0 = len(ev2.queues)
879 ev2.signal('from SignalProcess')
880 assert len(ev2.queues) == (nq0 - 1),'wrong number of processes dequeued'
881 assert not ev2.queues, 'not all processes queuing for ev2 dequeued'
882
885 yield waitevent, self, evset
886 for e in evset:
887 assert e.waits == [],'process not out of waiting list for all events in OR'
888
891 e1 = SimEvent()
892 e1.signal()
893 e2 = SimEvent()
894 e2.signal()
895 yield waitevent, self,[e1, e2]
896 assert self.eventsFired == [e1, e2],'eventsFired does not report all events'
897
898
900 nrProcesses = 0
905 yield queueevent, self, evset
906 occurred = False
907 for e in evset:
908 occurred = occurred or (e in self.eventsFired)
909 assert occurred, 'queuing process activated by wrong event(s)'
910
913 e1 = SimEvent()
914 e1.signal()
915 e2 = SimEvent()
916 e2.signal()
917 yield queueevent, self,[e1, e2]
918 assert self.eventsFired == [e1, e2],\
919 '(queueevent) eventsFired does not report all fired events'
920
922 """
923 Test SimEvent / signal as introduced with SimPy 1.5
924 """
925
927 """
928 Tests basic signal semantics
929 """
930 e = SimEvent()
931 e.signal('param')
932 assert e.occurred, 'signal does not set \'occurred\' to True'
933 assert e.signalparam == 'param', 'signal parameter wrong'
934 e.signal()
935 assert e.signalparam is None, 'signal with no parameter did not overwrite signalparam'
936 e.signal()
937 assert e.occurred, 'multiple calls to signal do not set \'occurred\''
938
954
971
979
987
997
998
999
1000
1001
1004 global a, b,c
1005 a = True
1006 yield hold, self, 1
1007 b = True
1008 yield hold, self, 1
1009 c = True
1010 yield hold, self, 1
1011 assert waiter.terminated(),'waituntil did not fire'
1012
1015 def waitcond():
1016 return a and b and c
1017 yield waituntil, self, waitcond
1018
1020 """
1021 Test waituntil as introduced with SimPy 1.5
1022 """
1023
1033
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1051 """ Job class for testing timeout reneging
1052 """
1053 - def __init__(self, server = None, name = ''):
1054 Process.__init__(self, name)
1055 self.res = server
1056 self.gotResource = None
1057
1058 - def execute(self, timeout, usetime):
1059 yield (request, self, self.res),(hold, self, timeout)
1060 if self.acquired(self.res):
1061 self.gotResource = True
1062 yield hold, self, usetime
1063 yield release, self, self.res
1064 else:
1065 self.gotResource = False
1066
1068 """ Job class for testing timeout reneging with priorities
1069 """
1070 - def __init__(self, server = None, name = ''):
1071 Process.__init__(self, name)
1072 self.res = server
1073 self.gotResource = None
1074
1075 - def execute(self, timeout, usetime, priority):
1076 yield (request, self, self.res, priority),(hold, self, timeout)
1077 if self.acquired(self.res):
1078 self.gotResource = True
1079 yield hold, self, usetime
1080 yield release, self, self.res
1081 else:
1082 self.gotResource = False
1083
1085 """ Tests of 'yield (request, self, res),(hold, self, delay)'
1086 timeout reneging command
1087 """
1089 """Test that resource gets acquired without timeout
1090 """
1091 res = Resource(name = 'Server', capacity = 1)
1092 initialize()
1093 usetime = 5
1094 timeout = 1000000
1095 j1 = JobTO(server = res, name = 'Job_1')
1096 activate(j1, j1.execute(timeout = timeout, usetime = usetime))
1097 j2 = JobTO(server = res, name = 'Job_2')
1098 activate(j2, j2.execute(timeout = timeout, usetime = usetime))
1099 simulate(until = 2 * usetime)
1100 assert now() == 2 * usetime, 'time not == 2 * usetime'
1101 assert j1.gotResource and j2.gotResource,\
1102 'at least one job failed to get resource'
1103 assert not (res.waitQ or res.activeQ),\
1104 'job waiting or using resource'
1105
1107 """Test that resource gets acquired without timeout.
1108 Resource monitored.
1109 """
1110 res = Resource(name = 'Server', capacity = 1, monitored = True)
1111 initialize()
1112 usetime = 5
1113 timeout = 1000000
1114 j1 = JobTO(server = res, name = 'Job_1')
1115 activate(j1, j1.execute(timeout = timeout, usetime = usetime))
1116 j2 = JobTO(server = res, name = 'Job_2')
1117 activate(j2, j2.execute(timeout = timeout, usetime = usetime))
1118 simulate(until = 2 * usetime)
1119 assert now() == 2 * usetime, 'time not == 2 * usetime'
1120 assert j1.gotResource and j2.gotResource,\
1121 'at least one job failed to get resource'
1122 assert not (res.waitQ or res.activeQ),\
1123 'job waiting or using resource'
1124 assert res.waitMon == [[0, 1],[usetime, 0]],'res.waitMon wrong: %s'%res.waitMon
1125
1127 """Test that timeout occurs when resource busy
1128 """
1129 res = Resource(name = 'Server', capacity = 1)
1130 initialize()
1131 usetime = 5
1132 timeout = 3
1133 j1 = JobTO(server = res, name = 'Job_1')
1134 activate(j1, j1.execute(timeout = timeout, usetime = usetime))
1135 j2 = JobTO(server = res, name = 'Job_2')
1136 activate(j2, j2.execute(timeout = timeout, usetime = usetime))
1137 simulate(until = 2 * usetime)
1138 assert(now() == usetime),'time not == usetime'
1139 assert(j1.gotResource),'Job_1 did not get resource'
1140 assert(not j2.gotResource),'Job_2 did not renege'
1141 assert not (res.waitQ or res.activeQ),\
1142 'job waiting or using resource'
1143
1145 """Test that timeout occurs when resource busy.
1146 Resource monitored.
1147 """
1148 res = Resource(name = 'Server', capacity = 1, monitored = True)
1149 initialize()
1150 usetime = 5
1151 timeout = 3
1152 j1 = JobTO(server = res, name = 'Job_1')
1153 activate(j1, j1.execute(timeout = timeout, usetime = usetime))
1154 j2 = JobTO(server = res, name = 'Job_2')
1155 activate(j2, j2.execute(timeout = timeout, usetime = usetime))
1156 simulate(until = 2 * usetime)
1157 assert(now() == usetime),'time not == usetime'
1158 assert(j1.gotResource),'Job_1 did not get resource'
1159 assert(not j2.gotResource),'Job_2 did not renege'
1160 assert not (res.waitQ or res.activeQ),\
1161 'job waiting or using resource'
1162 assert res.waitMon == [[0, 1],[timeout, 0]],'res.waitMon wrong: %s'%res.waitMon
1163
1165 """Test that timeout occurs when resource busy.
1166 Resource monitored. Requests with priority and preemption.
1167 """
1168 res = Resource(name = 'Server', capacity = 1, monitored = True, qType = PriorityQ, preemptable = True)
1169 initialize()
1170 usetime = 5
1171 timeout = 3
1172 j1 = JobTO_P(server = res, name = 'Job_1')
1173 activate(j1, j1.execute(timeout = timeout, usetime = usetime, priority = 1))
1174 j2 = JobTO_P(server = res, name = 'Job_2')
1175 j2_arrival = 1
1176 activate(j2, j2.execute(timeout = timeout, usetime = usetime, priority = 5),at = j2_arrival)
1177 j3 = JobTO_P(server = res, name = 'Job_2')
1178 j3_arrival = 2
1179 activate(j3, j3.execute(timeout = timeout, usetime = usetime, priority = 10),at = j3_arrival)
1180 simulate(until = 3 * usetime)
1181 assert(now() == 3 * usetime),'time not == 2 * usetime, but %s'%now()
1182 assert(j1.gotResource),'Job_1 did not get resource'
1183 assert(j2.gotResource),'Job_2 did renege'
1184 assert(j2.gotResource),'Job_3 did renege'
1185 assert not (res.waitQ or res.activeQ),\
1186 'job waiting or using resource'
1187 assert res.waitMon == [[j2_arrival, 1],[j3_arrival, 2],[usetime + j3_arrival, 1],[usetime + j2_arrival + usetime, 0]],\
1188 'res.waitMon wrong: %s'%res.waitMon
1189
1191 """Test that timeout occurs when resource has no capacity free
1192 """
1193 res = Resource(name = 'Server', capacity = 0)
1194 initialize()
1195 usetime = 5
1196 timeout = 3
1197 j1 = JobTO(server = res, name = 'Job_1')
1198 activate(j1, j1.execute(timeout = timeout, usetime = usetime))
1199 j2 = JobTO(server = res, name = 'Job_2')
1200 activate(j2, j2.execute(timeout = timeout, usetime = usetime))
1201 simulate(until = 2 * usetime)
1202 assert now() == timeout, 'time %s not == timeout'%now()
1203 assert not j1.gotResource, 'Job_1 got resource'
1204 assert not j2.gotResource, 'Job_2 got resource'
1205 assert not (res.waitQ or res.activeQ),\
1206 'job waiting or using resource'
1207
1209 """Test that timeout occurs when resource has no capacity free.
1210 Resource monitored.
1211 """
1212 res = Resource(name = 'Server', capacity = 0, monitored = True)
1213 initialize()
1214 usetime = 5
1215 timeout = 3
1216 j1 = JobTO(server = res, name = 'Job_1')
1217 activate(j1, j1.execute(timeout = timeout, usetime = usetime))
1218 j2 = JobTO(server = res, name = 'Job_2')
1219 activate(j2, j2.execute(timeout = timeout, usetime = usetime))
1220 simulate(until = 2 * usetime)
1221 assert now() == timeout, 'time %s not == timeout'%now()
1222 assert not j1.gotResource, 'Job_1 got resource'
1223 assert not j2.gotResource, 'Job_2 got resource'
1224 assert not (res.waitQ or res.activeQ),\
1225 'job waiting or using resource'
1226 assert res.waitMon == [[0, 1],[0, 2],[timeout, 1],[timeout, 0]],\
1227 'res.waitMon is wrong: %s'%res.waitMon
1228
1242
1243
1244
1245
1246
1247
1248
1249
1251 """ Job class for testing event reneging
1252 """
1253 - def __init__(self, server = None, name = ''):
1254 Process.__init__(self, name)
1255 self.res = server
1256 self.gotResource = None
1257
1258 - def execute(self, event, usetime):
1259 yield (request, self, self.res),(waitevent, self, event)
1260 if self.acquired(self.res):
1261 self.gotResource = True
1262 yield hold, self, usetime
1263 yield release, self, self.res
1264 else:
1265 self.gotResource = False
1266
1268 """ Job class for testing event reneging with multi - event lists
1269 """
1270 - def __init__(self, server = None, name = ''):
1271 Process.__init__(self, name)
1272 self.res = server
1273 self.gotResource = None
1274
1275 - def execute(self, eventlist, usetime):
1276 yield (request, self, self.res),(waitevent, self, eventlist)
1277 if self.acquired(self.res):
1278 self.gotResource = True
1279 yield hold, self, usetime
1280 yield release, self, self.res
1281 else:
1282 self.gotResource = False
1283
1285 """Fires reneging event
1286 """
1287 - def fire(self, fireDelay, event):
1288 yield hold, self, fireDelay
1289 event.signal()
1290
1292 """Tests of 'yield (request, self, res),(waiteevent, self, event)'
1293 event reneging command
1294 """
1296 """Test that processes acquire resource normally if no event fires
1297 """
1298 res = Resource(name = 'Server', capacity = 1)
1299 event = SimEvent('Renege_trigger')
1300 initialize()
1301 usetime = 5
1302 j1 = JobEvt(server = res, name = 'Job_1')
1303 activate(j1, j1.execute(event = event, usetime = usetime))
1304 j2 = JobEvt(server = res, name = 'Job_2')
1305 activate(j2, j2.execute(event = event, usetime = usetime))
1306 simulate(until = 2 * usetime)
1307
1308 assert now() == 2 * usetime, 'time not == 2 * usetime'
1309 assert j1.gotResource and j2.gotResource,\
1310 'at least one job failed to get resource'
1311 assert not (res.waitQ or res.activeQ),\
1312 'job waiting or using resource'
1313
1315 """Test that processes acquire resource normally if no event fires.
1316 Resource monitored.
1317 """
1318 res = Resource(name = 'Server', capacity = 1, monitored = True)
1319 event = SimEvent('Renege_trigger')
1320 initialize()
1321 usetime = 5
1322 j1 = JobEvt(server = res, name = 'Job_1')
1323 activate(j1, j1.execute(event = event, usetime = usetime))
1324 j2 = JobEvt(server = res, name = 'Job_2')
1325 activate(j2, j2.execute(event = event, usetime = usetime))
1326 simulate(until = 2 * usetime)
1327
1328 assert now() == 2 * usetime, 'time not == 2 * usetime'
1329 assert j1.gotResource and j2.gotResource,\
1330 'at least one job failed to get resource'
1331 assert not (res.waitQ or res.activeQ),\
1332 'job waiting or using resource'
1333 assert res.waitMon == [[0, 1],[usetime, 0]],'res.waitMoni is wrong: %s'%res.waitMon
1334
1336 """Test that signalled event leads to renege when resource busy
1337 """
1338 res = Resource(name = 'Server', capacity = 1)
1339 initialize()
1340 event = SimEvent('Renege_trigger')
1341 usetime = 5
1342 eventtime = 1
1343 j1 = JobEvt(server = res, name = 'Job_1')
1344 activate(j1, j1.execute(event = event, usetime = usetime))
1345 j2 = JobEvt(server = res, name = 'Job_2')
1346 activate(j2, j2.execute(event = event, usetime = usetime))
1347 f = FireEvent(name = 'FireEvent')
1348 activate(f, f.fire(fireDelay = eventtime, event = event))
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 signalled event leads to renege when resource busy.
1359 Resource monitored.
1360 """
1361 res = Resource(name = 'Server', capacity = 1, monitored = True)
1362 initialize()
1363 event = SimEvent('Renege_trigger')
1364 usetime = 5
1365 eventtime = 1
1366 j1 = JobEvt(server = res, name = 'Job_1')
1367 activate(j1, j1.execute(event = event, usetime = usetime))
1368 j2 = JobEvt(server = res, name = 'Job_2')
1369 activate(j2, j2.execute(event = event, usetime = usetime))
1370 f = FireEvent(name = 'FireEvent')
1371 activate(f, f.fire(fireDelay = eventtime, event = event))
1372 simulate(until = 2 * usetime)
1373
1374 assert(now() == usetime),'time not == usetime'
1375 assert(j1.gotResource),'Job_1 did not get resource'
1376 assert(not j2.gotResource),'Job_2 did not renege'
1377 assert not (res.waitQ or res.activeQ),\
1378 'job waiting or using resource'
1379 assert res.waitMon == [[0, 1],[eventtime, 0]],'res.waitMon is wrong: %s'%res.waitMon
1380
1382 """Test that renege - triggering event can be one of an event list
1383 """
1384 res = Resource(name = 'Server', capacity = 1)
1385 initialize()
1386 event1 = SimEvent('Renege_trigger_1')
1387 event2 = SimEvent('Renege_trigger_2')
1388 usetime = 5
1389 eventtime = 1
1390 j1 = JobEvtMulti(server = res, name = 'Job_1')
1391 activate(j1, j1.execute(eventlist = [event1, event2],usetime = usetime))
1392 j2 = JobEvtMulti(server = res, name = 'Job_2')
1393 activate(j2, j2.execute(eventlist = [event1, event2],usetime = usetime))
1394 f1 = FireEvent(name = 'FireEvent_1')
1395 activate(f1, f1.fire(fireDelay = eventtime, event = event1))
1396 f2 = FireEvent(name = 'FireEvent_2')
1397 activate(f2, f2.fire(fireDelay = eventtime, event = event2))
1398 simulate(until = 2 * usetime)
1399
1400 assert(now() == usetime),'time not == usetime'
1401 assert(j1.gotResource),'Job_1 did not get resource'
1402 assert(not j2.gotResource),'Job_2 did not renege'
1403 assert not (res.waitQ or res.activeQ),\
1404 'job waiting or using resource'
1405
1407 """Test that renege - triggering event can be one of an event list.
1408 Resource monitored.
1409 """
1410 res = Resource(name = 'Server', capacity = 1, monitored = True)
1411 initialize()
1412 event1 = SimEvent('Renege_trigger_1')
1413 event2 = SimEvent('Renege_trigger_2')
1414 usetime = 5
1415 eventtime = 1
1416 j1 = JobEvtMulti(server = res, name = 'Job_1')
1417 activate(j1, j1.execute(eventlist = [event1, event2],usetime = usetime))
1418 j2 = JobEvtMulti(server = res, name = 'Job_2')
1419 activate(j2, j2.execute(eventlist = [event1, event2],usetime = usetime))
1420 f1 = FireEvent(name = 'FireEvent_1')
1421 activate(f1, f1.fire(fireDelay = eventtime, event = event1))
1422 f2 = FireEvent(name = 'FireEvent_2')
1423 activate(f2, f2.fire(fireDelay = eventtime, event = event2))
1424 simulate(until = 2 * usetime)
1425
1426 assert(now() == usetime),'time not == usetime'
1427 assert(j1.gotResource),'Job_1 did not get resource'
1428 assert(not j2.gotResource),'Job_2 did not renege'
1429 assert not (res.waitQ or res.activeQ),\
1430 'job waiting or using resource'
1431 assert res.waitMon == [[0, 1],[eventtime, 0]],'res.waitMon is wrong: %s'%res.waitMon
1432
1445
1446
1447
1448
1449
1450
1451
1453 produced = 0
1460 """PriorityQ for Producers"""
1461 Producer.produced += 4
1462 yield put, self, buffer, 4,priority
1463 yield hold, self, 1
1464 self.done = now()
1465 doneList.append(self.name)
1467 for i in range(4):
1468 yield put, self, buffer, 4
1469 yield hold, self, 1
1471 consumed = 0
1473 """FIFO"""
1474 yield get, self, buffer
1475 Consumer.consumed += 1
1476 assert self.got == 1, 'wrong self.got: %s'%self.got
1477 yield get, self, buffer, 3
1478 Consumer.consumed += 3
1479 assert self.got == 3, 'wrong self.got: %s'%self.got
1480
1482 """producer PriorityQ, consumer FIFO"""
1483 while True:
1484 yield get, self, buffer, 2
1485 yield hold, self, 1
1487 """PriorityQ for Consumers"""
1488 yield get, self, buffer, 4,priority
1489 doneList.append(self.name)
1490
1491
1493 - def produce(self, buffer, productionTime):
1494 while True:
1495 assert not(buffer.amount > 0 and len(buffer.getQ) > 0),\
1496 'Consumer(s) waiting while buffer not empty'
1497 yield hold, self, productionTime
1498 yield put, self, buffer, 1
1499
1501 - def consume(self, buffer, consumptionTime):
1502 while True:
1503 assert not(buffer.amount == 0 and len(buffer.putQ) > 0),\
1504 'Producer(s) waiting while buffer empty'
1505 yield get, self, buffer, 1
1506 yield hold, self, consumptionTime
1507
1508
1509
1512 """Tests initialization of Level instances
1513 """
1514 a = Level()
1515 assert a.capacity == sys.maxint, 'wrong capacity:%s'%a
1516 assert a.amount == 0, 'wrong buffer content: %s'%a
1517 assert a.name == 'a_level', 'wrong name: %s'%a
1518 assert not a.monitored, 'should not be monitored: %s'%a
1519 assert a.putQMon is None, 'should not have putQMon: %s'%a
1520 assert a.getQMon is None, 'should not have getQMon: %s'%a
1521 assert a.bufferMon is None, 'should not have bufferMon: %s'%a
1522 assert a.putQType.__name__ == 'FIFO' and a.getQType.__name__ == 'FIFO',\
1523 'putQType and getQType should be FIFO: %s'%a
1524
1525 b = Level(name = 'b', initialBuffered = 10.0, monitored = True, capacity = 12,
1526 putQType = PriorityQ)
1527 a = Level()
1528 assert b.capacity == 12, 'wrong capacity:%s'%b
1529 assert b.amount == 10, 'wrong buffer content: %s'%b
1530 assert b.name == 'b', 'wrong name: %s'%b
1531 assert b.monitored, 'should be monitored: %s'%b
1532 assert not (b.putQMon is None),'should have putQMon: %s'%b
1533 assert not (b.getQMon is None),'should have getQMon: %s'%b
1534 assert not (b.bufferMon is None),'should have bufferMon: %s'%b
1535 assert b.putQType.__name__ == 'PriorityQ',\
1536 'putQType should be PriorityQ: %s'%b
1537 assert b.getQType.__name__ == 'FIFO',\
1538 'getQType should be PriorityQ: %s'%b
1539
1541 """Level: tests basic Producer / Consumer principles:
1542 - Consumers must not be waiting while Level buffer value > 0,
1543 - Producers must not be waiting while Level buffer value == 0
1544 """
1545 bufferSize = 1
1546 productionTime = 1
1547 consumptionTime = 5
1548 endtime = 50
1549
1550 initialize()
1551 buffer = Level(capacity = bufferSize)
1552 consumer = ConsumerPrincL()
1553 activate(consumer, consumer.consume(buffer, consumptionTime))
1554 producer = ProducerPrincL()
1555 activate(producer, producer.produce(buffer, productionTime))
1556 simulate(until = endtime)
1557
1570
1587
1589 """Level: tests put / get in multiple Producer / Consumer scenario,
1590 with Producers having different priorities.
1591 How: Producers forced to queue; all after first should be done in
1592 priority order
1593 """
1594 global doneList
1595 doneList = []
1596 initialize()
1597 buffer = Level(capacity = 7, putQType = PriorityQ, monitored = True)
1598 for i in range(4):
1599 p = Producer(str(i))
1600 pPriority = i
1601 activate(p, p.producePriority(buffer = buffer, priority = pPriority))
1602 c = Consumer()
1603 activate(c, c.consume1(buffer = buffer))
1604 simulate(until = 100)
1605 assert doneList == ["0","3","2","1"],'puts were not done in priority order: %s'\
1606 %doneList
1607
1609 """Level: tests put / get in multiple Producer / Consumer scenario, with
1610 Consumers having different priorities.
1611 How: Consumers forced to queue; all after first should be done in
1612 priority order
1613 """
1614 global doneList
1615 doneList = []
1616 initialize()
1617 buffer = Level(capacity = 7, getQType = PriorityQ, monitored = True)
1618 for i in range(4):
1619 c = Consumer(str(i))
1620 cPriority = i
1621 activate(c, c.consumePriority(buffer = buffer, priority = cPriority))
1622 p = Producer()
1623 activate(p, p.produce1(buffer = buffer))
1624 simulate(until = 100)
1625 assert doneList == ["3","2","1","0"],'gets were not done in priority order: %s'\
1626 %doneList
1627
1640
1641
1642
1643
1644
1645
1646
1669
1695
1699
1701 """Sorts Widget instances by weight attribute."""
1702 tmplist = [(x.weight, x) for x in par]
1703 tmplist.sort()
1704 return [x for (key, x) in tmplist]
1705
1706
1708 - def produce(self, buffer, productionTime):
1709 while True:
1710 assert not(buffer.nrBuffered > 0 and len(buffer.getQ) > 0),\
1711 'Consumer(s) waiting while buffer not empty'
1712 yield hold, self, productionTime
1713 product = WidgetPrinc()
1714 yield put, self, buffer,[product]
1715
1717 - def consume(self, buffer, consumptionTime):
1718 while True:
1719 assert not(buffer.nrBuffered == 0 and buffer.putQ),\
1720 'Producer(s) waiting while buffer empty'
1721 yield get, self, buffer, 1
1722 yield hold, self, consumptionTime
1723
1726
1728 """Used in testBufferFilter"""
1732
1734 """get all items with weight between a and b"""
1735 def between_a_and_b(buf):
1736 res = []
1737 for item in buf:
1738 if a < item.weight < b:
1739 res.append(item)
1740
1741 all = store.buffered
1742 yield get, self, store, between_a_and_b
1743 'All retrieved items weight in range?'
1744 for it in self.got:
1745 assert a < it.weight < b, 'weight %s not in range %s..%s'\
1746 %(it.weight, a,b)
1747 'Any item fitting filter pred left in buffer?'
1748 for it in store.buffer:
1749 assert not (a < it.weight < b),\
1750 'item left in buffer which fits filter (%s<%s<%s)'\
1751 %(a, it.weight, b)
1752 'All items either in store.buffer of self.got?'
1753 for it in all:
1754 assert (it in self.buffer) or (it in self.got),\
1755 'item w. weight %s neither in store nor in got'%it.weight
1756
1757
1758
1761 """Store: tests initialization of Store instances
1762 """
1763 a = Store()
1764 assert a.capacity == sys.maxint, 'wrong capacity:%s'%a
1765 assert a.nrBuffered == 0, 'wrong buffer content: %s'%a
1766 assert a.name == 'a_store', 'wrong name: %s'%a
1767 assert not a.monitored, 'should not be monitored: %s'%a
1768 assert a.putQMon is None, 'should not have putQMon: %s'%a
1769 assert a.getQMon is None, 'should not have getQMon: %s'%a
1770 assert a.bufferMon is None, 'should not have bufferMon: %s'%a
1771 assert a.putQType.__name__ == 'FIFO' and a.getQType.__name__ == 'FIFO',\
1772 'putQType and getQType should be FIFO: %s'%a
1773
1774 stored = [Widget(weight = 5)] * 10
1775 b = Store(name = 'b', initialBuffered = stored, monitored = True, capacity = 12,
1776 putQType = PriorityQ)
1777 assert b.capacity == 12, 'wrong capacity:%s'%b
1778 assert b.nrBuffered == 10, 'wrong buffer content: %s'%b
1779 assert b.name == 'b', 'wrong name: %s'%b
1780 assert b.monitored, 'should be monitored: %s'%b
1781 assert not (b.putQMon is None),'should have putQMon: %s'%b
1782 assert not (b.getQMon is None),'should have getQMon: %s'%b
1783 assert not (b.bufferMon is None),'should have bufferMon: %s'%b
1784 assert b.putQType.__name__ == 'PriorityQ',\
1785 'putQType should be PriorityQ: %s'%b
1786 assert b.getQType.__name__ == 'FIFO',\
1787 'getQType should be PriorityQ: %s'%b
1788
1790 """Store: tests basic Producer / Consumer principles:
1791 - Consumers must not be waiting while items in Store buffer,
1792 - Producers must not be waiting while space available in Store buffer
1793 """
1794 bufferSize = 1
1795 productionTime = 1
1796 consumptionTime = 5
1797 endtime = 50
1798
1799 initialize()
1800 buffer = Store(capacity = bufferSize)
1801 consumer = ConsumerPrincS()
1802 activate(consumer, consumer.consume(buffer, consumptionTime))
1803 producer = ProducerPrincS()
1804 activate(producer, producer.produce(buffer, productionTime))
1805 simulate(until = endtime)
1806
1820
1837
1839 """Store: Tests put / get in multiple Producer / Consumer scenario,
1840 with Producers having different priorities.
1841 How; Producers forced to queue; all after first should be done in
1842 priority order
1843 """
1844 global doneList
1845 doneList = []
1846 initialize()
1847 buffer = Store(capacity = 7, putQType = PriorityQ, monitored = True)
1848 for i in range(4):
1849 p = ProducerWidget(str(i))
1850 pPriority = i
1851 activate(p, p.producePriority(buffer = buffer, priority = pPriority))
1852 c = ConsumerWidget()
1853 activate(c, c.consume1(buffer = buffer))
1854 simulate(until = 100)
1855 assert doneList == ["0","3","2","1"],'puts were not done in priority order: %s'\
1856 %doneList
1857
1859 """Tests put / get in multiple Producer / Consumer scenario, with
1860 Consumers having different priorities.
1861 How; Consumers forced to queue; all after first should be done in
1862 priority order
1863 """
1864 global doneList
1865 doneList = []
1866 initialize()
1867 buffer = Store(capacity = 7, getQType = PriorityQ, monitored = True)
1868 for i in range(4):
1869 c = ConsumerWidget(str(i))
1870 cPriority = i
1871 activate(c, c.consumePriority(buffer = buffer, priority = cPriority))
1872 p = ProducerWidget()
1873 activate(p, p.produce1(buffer = buffer))
1874 simulate(until = 100)
1875 assert doneList == ['3', '2', '1', '0'],\
1876 'gets were not done in priority order: %s'%doneList
1877
1879 """Tests the optional sorting of theBuffer by applying a user - defined
1880 sort function."""
1881 initialize()
1882 gotten = []
1883 sortedStore = Store()
1884 sortedStore.addSort(mySortFunc)
1885 p = ProducerWidget()
1886 activate(p, p.produceUnordered(sortedStore))
1887 for i in range(9):
1888 c = ConsumerWidget()
1889 activate(c, c.consumeSorted(buffer = sortedStore, gotten = gotten),at = 1)
1890 simulate(until = 10)
1891 assert gotten == [1, 2,3, 4,5, 6,7, 8,9],'sort wrong: %s'%gotten
1892
1904
1920
1921
1922
1923
1924
1925
1926 -class TBT(Process):
1927 """Store: For testBasicTime"""
1928 - def tbt(self, store):
1929 yield get, self, store, 1
1930 assert self.got, 'Did not get Item'
1931 yield (get, self, store, 1),(hold, self, 5)
1932 if self.acquired(store):
1933 assert len(self.got) == 1, 'did not get 1 Item'
1934 else:
1935 assert not self.got and now() == 5 and not store.getQ,\
1936 'time renege not working'
1937
1938 -class TBE(Process):
1939 """Store: For testBasicEvent"""
1940 - def tbe(self, store, trigger):
1941 yield get, self, store, 1
1942 assert self.got, 'Did not get Item'
1943 yield (get, self, store, 1),(waitevent, self, trigger)
1944 if self.acquired(store):
1945 assert False, 'should have reneged'
1946 else:
1947 assert self.eventsFired[0] == trigger and now() == 5 \
1948 and not store.getQ, 'event renege not working'
1949
1951 """Store: For testBasicEvent"""
1952 - def fire(self, trigger):
1955
1957 """Store: for testBasicTimePut"""
1958 - def tbt(self, store):
1959 class Item:pass
1960 yield (put, self, store,[Item()]),(hold, self, 4)
1961 if self.stored(store):
1962 assert store.nrBuffered == 1 and not store.putQ,\
1963 'put did not execute'
1964 else:
1965 assert False, 'should not have reneged'
1966 yield (put, self, store,[Item()]),(hold, self, 5)
1967 if self.stored(store):
1968 assert False, 'should have reneged'
1969 else:
1970 assert store.nrBuffered == 1 and not store.putQ,\
1971 'renege not working correctly'
1972
1974 """Store: for testBasicEventPut"""
1975 - def tbe(self, store, trigger):
1976 class Item:pass
1977 yield (put, self, store,[Item()]),(waitevent, self, trigger)
1978 if self.stored(store):
1979 assert store.nrBuffered == 1 and not store.putQ,\
1980 'put did not execute'
1981 else:
1982 assert False, 'should have not have reneged'
1983 yield (put, self, store,[Item()]),(waitevent, self, trigger)
1984 if self.stored(store):
1985 assert False, 'should have reneged'
1986 else:
1987 assert now() == 5 and self.eventsFired[0] == trigger\
1988 and not store.putQ, 'renege not working correctly'
1989
1991 """Store: For testBasicEventPut"""
1992 - def fire(self, trigger):
1995
1997 """Store: Testcase for compound get statements"""
1998
1999
2000
2001
2002
2003
2005 """Store (unmonitored):
2006 test 'yield (get, self, store),(hold, self, timeout)"""
2007 class Item:pass
2008 initialize()
2009 st = Store(initialBuffered = [Item()])
2010 t = TBT()
2011 activate(t, t.tbt(store = st))
2012 simulate(until = 10)
2013
2014
2015
2016
2017
2018
2019
2028
2030 """Store (monitored):
2031 test monitors with 'yield (put, self, store),(hold, self, time)"""
2032 initialize()
2033 st = Store(capacity = 1, monitored = True)
2034 t = TBTput()
2035 activate(t, t.tbt(store = st))
2036 simulate(until = 10)
2037
2038 assert st.putQMon == [[0, 0],[0, 1],[5, 0]],'putQMon wrong: %s'\
2039 %st.putQMon
2040
2041 assert st.bufferMon == [[0, 0],[0, 1]],'bufferMon wrong: %s'%st.bufferMon
2042
2043
2044
2045
2046
2047
2048
2050 """Store (unmonitored):
2051 test 'yield (get, self, store),(waitevent, self, event)"""
2052 class Item:pass
2053 initialize()
2054 st = Store(initialBuffered = [Item()])
2055 trig = SimEvent()
2056 t = TBE()
2057 activate(t, t.tbe(store = st, trigger = trig))
2058 tr = TBEtrigger()
2059 activate(tr, tr.fire(trigger = trig))
2060 simulate(until = 10)
2061
2062
2063
2064
2065
2066
2067
2079
2081 """Store (monitored):
2082 test monitors with 'yield (put, self, store),(waitevent, self, event)"""
2083 initialize()
2084 s = SimEvent()
2085 st = Store(capacity = 1, monitored = True)
2086 t = TBEtriggerPut()
2087 activate(t, t.fire(trigger = s))
2088 tb = TBEput()
2089 activate(tb, tb.tbe(store = st, trigger = s))
2090 simulate(until = 10)
2091
2092 assert st.putQMon == [[0, 0],[0, 1],[5, 0]],'putQMon wrong: %s'\
2093 %st.putQMon
2094
2095 assert st.bufferMon == [[0, 0],[0, 1]],'bufferMon wrong: %s'%st.bufferMon
2096
2115
2116
2117
2118
2119
2120
2122 """Level: For testBasicTime"""
2123 - def tbt(self, level):
2124 yield get, self, level, 1
2125 assert self.got, 'did not get 1 unit'
2126 yield (get, self, level, 1),(hold, self, 5)
2127 if self.acquired(level):
2128 assert self.got == 1, 'did not get 1 unit'
2129 else:
2130 assert not self.got and now() == 5, 'time renege not working'
2131
2133 """Level: For testBasicEvent"""
2134 - def tbe(self, level, trigger):
2135 yield get, self, level, 1
2136 assert self.got, 'did not get 1 unit'
2137 yield (get, self, level, 1),(waitevent, self, trigger)
2138 if self.acquired(level):
2139 assert self.got == 1, 'did not get 1 Item'
2140 else:
2141 assert now() == 5.5 and self.eventsFired[0] == trigger,\
2142 'event renege not working'
2143
2145 """Level: For testBasicEvent"""
2146 - def fire(self, trigger):
2149
2151 """Level: For testBasicTimePut"""
2152 - def tbt(self, level):
2153 yield put, self, level, 1
2154 assert level.amount, 'did not put 1 unit'
2155 yield (put, self, level, 1),(hold, self, 5)
2156 if self.stored(level):
2157 assert False, 'should have reneged'
2158 else:
2159 assert level.amount == 1 and now() == 5, 'time renege not working'
2160
2162 """Level: For testBasicEventPut and testBasicEventPutM"""
2163 - def tbe(self, level, trigger):
2164 yield (put, self, level, 1),(waitevent, self, trigger)
2165 if self.stored(level):
2166 assert level.amount == 1, 'did not put 1 unit'
2167 else:
2168 assert False, 'should not have reneged'
2169 yield (put, self, level, 1),(waitevent, self, trigger)
2170 if self.stored(level):
2171 assert False, 'should have reneged'
2172 else:
2173 assert now() == 5.5 and self.eventsFired[0] == trigger ,\
2174 'renege not working'
2175
2177 """Level: For testBasicEventPut"""
2178 - def fire(self, trigger):
2181
2183 """Level: Testcase for compound get and put statements"""
2184
2185
2186
2187
2188
2189
2191 """Level (unmonitored): test 'yield (get, self, level),(hold, self, timeout)"""
2192 initialize()
2193 l = Level(initialBuffered = 1)
2194 t = TBTLev()
2195 activate(t, t.tbt(level = l))
2196 simulate(until = 10)
2197
2198
2199
2200
2201
2202
2211
2212
2213
2214
2215
2216
2217
2229
2231 """Level (monitored):
2232 test monitors with 'yield (get, self, level),(waitevent, self, event)"""
2233 initialize()
2234 l = Level(initialBuffered = 1, monitored = True)
2235 trig = SimEvent()
2236 t = TBELev()
2237 activate(t, t.tbe(level = l, trigger = trig))
2238 tr = TBEtriggerLev()
2239 activate(tr, tr.fire(trigger = trig))
2240 simulate(until = 10)
2241
2242 assert l.getQMon == [[0, 0],[0, 1],[5.5, 0]],'getQMon not working: %s'\
2243 %l.getQMon
2244
2245 assert l.bufferMon == [[0, 1],[0, 0]],\
2246 'bufferMon not working: %s'%l.bufferMon
2247
2248
2249
2250
2251
2252
2264
2266 """Level (monitored):
2267 test monitors with 'yield (put, self, level),(waitevent, self, event)"""
2268 initialize()
2269 l = Level(capacity = 1, monitored = True)
2270 trig = SimEvent()
2271 t = TBELevPut()
2272 activate(t, t.tbe(level = l, trigger = trig))
2273 tr = TBEtriggerLevPut()
2274 activate(tr, tr.fire(trigger = trig))
2275 simulate(until = 10)
2276 'First put succeeds, second reneges at t = 5.5?'
2277 assert l.putQMon == [[0, 0],[0, 1],[5.5, 0]],'putQMon wrong: %s'\
2278 %l.putQMon
2279 '1 unit added at t = 0, renege at t = 5 before 2nd unit added?'
2280 assert l.bufferMon == [[0, 0],[0, 1]],'bufferMon wrong: %s'%l.bufferMon
2281
2300
2301 if __name__ == '__main__':
2302 alltests = unittest.TestSuite((makeSSuite(),makeRSuite(),
2303 makeMSuite(),
2304 makeISuite(),makePSuite(),
2305 makeESuite(),makeWSuite(),
2306 makeTOSuite(),makeEvtRenegeSuite(),
2307 makeLevelSuite(),
2308 makeStoreSuite(),
2309 makeStoreCompSuite(),
2310 makeLevelCompSuite()
2311 ))
2312 runner = unittest.TextTestRunner()
2313 runner.run(alltests)
2314