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