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