1
2 from SimPy.SimulationStep import *
3 from SimPy.MonitorTest import *
4 import unittest
5 from random import random
6
7 """testSimPyStep.py
8 SimPy version 1.9
9 Unit tests for SimulationStep.
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 15 first version of testSimPyStep; just
22 # tests compatibility with Simulation.py
23 # 2004 09 17 added tests for waitevent, queueevent, waituntil (new in 1.5)
24 # 2005 05 19 added tests for compound yield statements (reneging)
25 # 2006 01 15 added tests for Store and Level and the get/put yield statements
26 # 2006 02 02 removed histogram plotting suite
27 # 2006 05 10 changed test testStatic for Level to test that float type
28 supported for initialBuffered
29 # 2006 05 16 added tests for Store and Level to test basic Producer/Consumer
30 principles
31 # 2006 10 16 added tests for compound get statement (Unmonitored Store/Level)
32 # 2006 10 17 added tests for compound put statement (Unmonitored Store/Level)
33 # 2007 01 08 added tests for monitoring of Store/Level with compound get/put
34 # 2007 01 08 added test for Store with filter function
35 # 2007 12 05 added tests for start method (Process)
36
37 #'$Revision: 1.1.1.15 $ $Date: 2007/12/07 14:07:51 $ kgm'
38
39 """
40 __version__ = '1.9 $Revision: 1.1.1.15 $ $Date: 2007/12/07 14:07:51 $ '
41 print "testSimPyStep.py %s"%__version__
42
43
44
45
47 """ P class for testing"""
52
54 yield hold,self,self.T
55
57 """ PActions class for testing"""
62
64 yield hold,self,self.T
65
67 """ Tests of simulation
68 """
75
84
86 """Test start method
87 """
88 P1 = P(name="P1",T=100.0)
89 initialize()
90 P1.start(P1.execute(),0)
91 simulate(until=5)
92 assert(now()==5),"Simulate stopped at %s not %s"%(now(),5)
93
95 """Test start method with ACTIONS PEM
96 """
97 P1 = PActions(name="P1",T=100.0)
98 initialize()
99 P1.start()
100 simulate(until=5)
101 assert(now()==5),"Simulate stopped at %s not %s"%(now(),5)
102
104 """Test yield hold and simulate(until)
105 """
106 P1 = P(name="P1",T=10)
107 initialize()
108 activate(P1,P1.execute(),0)
109 simulate(until=5)
110 assert(now()==5),"Simulate stopped at %s not %s"%(now(),5)
111
112 P2 = P(name="P2",T=10)
113 initialize()
114 activate(P2,P2.execute(),0)
115 simulate(until=20)
116 assert(now()==10),"P1 hold to %s not %s"%(now(),10)
117
118
130
131
132
133
134
136 """ Job class for testing"""
137 - def __init__(self,server=None,name=""):
141
143 yield request,self,self.R
144
145
147 """ First simple tests of Resources
148 """
150 """Test initialisation"""
151 R = Resource()
152 assert R.name == "a_resource", "Not null name"
153 assert R.capacity == 1, "Not unit capacity"
154 assert R.unitName =="units", "Not the correct unit name"
155 R = Resource(name='',capacity=1)
156 assert R.name == "", "Not null name"
157 assert R.capacity == 1, "Not unit capacity"
158 assert R.unitName =="units", "Not the correct unit name"
159 R = Resource(capacity=3,name="3-version",unitName="blobs")
160 assert R.name =="3-version" , "Wrong name, it is"+R.name
161 assert R.capacity == 3, "Not capacity 3, it is "+`R.capacity`
162 assert R.unitName =="blobs", "Not the correct unit name"
163
164 R = Resource(capacity=0,name="0-version")
165 assert R.capacity ==0, "Not capacity 0, it is "+`R.capacity`
166
168 """Test request"""
169
170
171 R0 = Resource(name='',capacity=0)
172 assert R0.name == "", "Not null name"
173 assert R0.capacity == 0, "Not capacity 0, it is "+`R0.capacity`
174
175 initialize()
176 R1 = Resource(capacity=0,name="3-version",unitName="blobs")
177 J= Job(name="job",server=R1)
178 activate(J,J.execute(), at=0.0)
179
180 simulate(until=10.0)
181 assert R1.n == 0 , "Should be 0, it is "+str(R1.n)
182 lenW = len(R1.waitQ)
183 assert lenW==1,"Should be 1, it is "+str(lenW)
184 assert len(R1.activeQ)==0,"len activeQ Should be 0, it is "+\
185 str(len(R1.activeQ))
186
188 """Test request2 with capacity = 1"""
189
190 initialize()
191 R2 = Resource(capacity=1,name="3-version",unitName="blobs")
192 J2= Job(name="job",server=R2)
193 activate(J2,J2.execute(), at=0.0)
194
195 simulate(until = 10.0)
196 assert R2.n == 0 , "Should be 0, it is "+str(R2.n)
197 lenW = len(R2.waitQ)
198 lenA = len(R2.activeQ)
199 assert lenW==0,"lenW Should be 0, it is "+str(lenW)
200 assert lenA==1,"lenA Should be 1, it is "+str(lenA)
201
203 """Test request3 with capacity = 1 several requests"""
204
205 initialize()
206 R3 = Resource(capacity=1,name="3-version",unitName="blobs")
207 J2= Job(name="job",server=R3)
208 J3= Job(name="job",server=R3)
209 J4= Job(name="job",server=R3)
210 activate(J2,J2.execute(), at=0.0)
211 activate(J3,J3.execute(), at=0.0)
212 activate(J4,J4.execute(), at=0.0)
213
214 simulate(until = 10.0)
215 assert R3.n == 0 , "Should be 0, it is "+str(R3.n)
216 lenW = len(R3.waitQ)
217 lenA = len(R3.activeQ)
218 assert lenW==2,"lenW Should be 2, it is "+str(lenW)
219 assert R3.waitQ==[J3,J4],"WaitQ wrong"+str(R3.waitQ)
220 assert lenA==1,"lenA Should be 1, it is "+str(lenA)
221 assert R3.activeQ==[J2],"activeQ wrong, it is "+str(R3.activeQ[0])
222
224 """Test request4 with capacity = 2 several requests"""
225
226 initialize()
227 R3 = Resource(capacity=2,name="4-version",unitName="blobs")
228 J2= Job(name="job",server=R3)
229 J3= Job(name="job",server=R3)
230 J4= Job(name="job",server=R3)
231 activate(J2,J2.execute(), at=0.0)
232 activate(J3,J3.execute(), at=0.0)
233 activate(J4,J4.execute(), at=0.0)
234
235 simulate(until = 10.0)
236 assert R3.n == 0 , "Should be 0, it is "+str(R3.n)
237 lenW = len(R3.waitQ)
238 lenA = len(R3.activeQ)
239 assert lenW==1,"lenW Should be 1, it is "+str(lenW)
240 assert R3.waitQ==[J4],"WaitQ wrong"+str(R3.waitQ)
241 assert lenA==2,"lenA Should be 2, it is "+str(lenA)
242 assert R3.activeQ==[J2,J3],"activeQ wrong, it is "+str(R3.activeQ[0])
243
244
245
247 """Test PriorityQ, with no preemption, 0 capacity"""
248 class Job(Process):
249 """ Job class for testing"""
250 def __init__(self,server=None,name=""):
251 Process.__init__(self)
252 self.name=name
253 self.R=server
254
255 def execute(self,priority):
256 yield request,self,self.R,priority
257
258 initialize()
259 Rp = Resource(capacity=0,qType=PriorityQ)
260 J5 = Job(name="job 5",server=Rp)
261 J6 = Job(name="job 6",server=Rp)
262 J7 = Job(name="job 7",server=Rp)
263 activate(J5,J5.execute(priority=3))
264 activate(J6,J6.execute(priority=0))
265 activate(J7,J7.execute(priority=1))
266 simulate(until=100)
267 assert Rp.waitQ == [J5,J7,J6],"WaitQ wrong"+str([(x.name,x.priority[Rp]) for x in Rp.waitQ])
268
269 """Test PriorityQ mechanism"""
270
271 def sorted(q):
272 if not q or len(q) == 1:
273 sortok=1
274 return sortok
275 sortok = q[0] >= q[1] and sorted(q[2:])
276 return sortok
277
278 initialize()
279 Rp=Resource(capacity=0,qType=PriorityQ)
280 for i in range(10):
281 J=Job(name="job "+str(i),server=Rp)
282 activate(J,J.execute(priority=random()))
283 simulate(until=1000)
284 qp=[x._priority[Rp] for x in Rp.waitQ]
285 assert sorted(qp),"waitQ not sorted by priority: "+str([(x.name,x._priority[Rp]) for x in Rp.waitQ])
286
287
289 """Test PriorityQ, with no preemption, capacity == 1"""
290 class Job(Process):
291 """ Job class for testing"""
292 def __init__(self,server=None,name=""):
293 Process.__init__(self)
294 self.name=name
295 self.R=server
296
297 def execute(self,priority):
298 yield request,self,self.R,priority
299
300 initialize()
301 Rp = Resource(capacity=1,qType=PriorityQ)
302 J5 = Job(name="job 5",server=Rp)
303 J6 = Job(name="job 6",server=Rp)
304 J7 = Job(name="job 7",server=Rp)
305 activate(J5,J5.execute(priority=2))
306 activate(J6,J6.execute(priority=4))
307 activate(J7,J7.execute(priority=3))
308 simulate(until=100)
309 assert Rp.waitQ == [J6,J7],"WaitQ wrong "+str([(x.name,x._priority[Rp]) for x in Rp.waitQ])
310
312 """Test PriorityQ, with preemption, capacity == 1"""
313 class nuJob(Process):
314 def __init__(self,name):
315 Process.__init__(self,name)
316
317 def execute(self,res,priority):
318 self.preempt=len(res.activeQ) > 0 and priority > res.activeQ[-1]._priority[res]
319 t=now()
320 yield request,self,res,priority
321 if self.preempt:
322 assert len(res.waitQ) == 1, "No preemption "+"activeQ= "+str(res.activeQ[0].name)
323 yield hold,self,30
324 t1=now()
325 if self.preempt:
326 assert t+30 == t1,"Wrong completion time for preemptor "+self.name
327 else:
328 assert t+60 == t1, "Wrong completion time for preempted "+self.name+" "+str(now())
329 yield release,self,res
330
331 initialize()
332 res=Resource(name="server",capacity=1,qType=PriorityQ,preemptable=1)
333 n1=nuJob(name="nuJob 1")
334 n2=nuJob(name="nuJob 2")
335 activate(n1,n1.execute(res,priority=0))
336 activate(n2,n2.execute(res,priority=1),at=15)
337 simulate(until=100)
338
340 """Test preemption of preemptor"""
341 class nuJob(Process):
342 seqOut=[]
343 def __init__(self,name):
344 Process.__init__(self,name)
345 self.serviceTime=30
346
347 def execute(self,res,priority):
348 self.preempt=len(res.activeQ) > 0 and priority > res.activeQ[-1]._priority[res]
349 nrwaiting=len(res.waitQ)
350 yield request,self,res,priority
351 if self.preempt:
352 assert len(res.waitQ) == nrwaiting + 1, "No preemption "+"activeQ= "+str(res.activeQ[0].name)
353 yield hold,self,self.serviceTime
354 yield release,self,res
355 nuJob.seqOut.append((self,now()))
356
357 initialize()
358 res=Resource(name="server",capacity=1,qType=PriorityQ,preemptable=1)
359 n1=nuJob(name="nuJob 1")
360 n2=nuJob(name="nuJob 2")
361 n3=nuJob(name="nuJob 3")
362 activate(n1,n1.execute(res,priority=-1))
363 start2=10
364 activate(n2,n2.execute(res,priority=0),at=start2)
365 start3=20
366 activate(n3,n3.execute(res,priority=1),at=start3)
367 simulate(until=100)
368 assert [x[1] for x in nuJob.seqOut] == [start3+n3.serviceTime,start2+2*n2.serviceTime,90], "Wrong service sequence/times: "+str([x for x in nuJob.seqOut])
369
370
372 """ test monitoring of number in the two queues, waitQ and activeQ
373 """
374 class Job(Process):
375 def __init__(self,name):
376 Process.__init__(self,name)
377
378 def execute(self,res):
379 yield request,self,res
380 yield hold,self,2
381 yield release,self,res
382
383 initialize()
384 res=Resource(name="server",capacity=1,monitored=1)
385 n1=Job(name="Job 1")
386 n2=Job(name="Job 2")
387 n3=Job(name="Job 3")
388 activate(n1,n1.execute(res),at=2)
389 activate(n2,n2.execute(res),at=2)
390 activate(n3,n3.execute(res),at=2)
391 simulate(until=100)
392 assert res.waitMon == [[2, 1], [2, 2], [4, 1], [6, 0]],'Wrong waitMon:%s'%res.waitMon
393 assert res.actMon == [[2, 1], [4, 0], [4, 1], [6, 0], [6, 1], [8, 0]],'Wrong actMon:%s'%res.actMon
394
395 assert res.waitMon.timeAverage() == (0*2+2*2+1*2)/8.0,'Wrong waitMon.timeAverage:%s'%res.waitMon.timeAverage()
396
397
414
415
416
417
418
419
420
424
425 - def breakin(self,waitbefore,howoften=1):
426 for i in range(howoften):
427 yield hold,self,waitbefore
428 self.interrupt(victim)
429
433
435 global igothit
436 igothit={}
437 while now()<=theEnd:
438 yield hold,self,howlong
439 if self.interrupted():
440 byWhom=self.interruptCause
441 igothit[now()]=byWhom
442 else:
443 pass
444
446 """
447 Tests interrupts as defined in SEP001v17
448 """
450 """
451 Test single interrupt during victim activity
452 """
453 global victim
454 initialize()
455 breaker=Interruptor()
456 activate(breaker,breaker.breakin(10))
457 victim=Interrupted()
458 activate(victim,victim.myActivity(100))
459 simulate(until=200)
460 assert igothit[10] == breaker, "Not interrupted at 10 by breaker"
461 assert len(igothit) == 1 , "Interrupted more than once"
462
464 """
465 Test multiple interrupts during victim activity
466 """
467 global victim
468 initialize()
469 breaker=Interruptor()
470 activate(breaker,breaker.breakin(10,howoften=3))
471 victim=Interrupted()
472 activate(victim,victim.myActivity(100))
473 simulate(until=200)
474 for i in (10,20,30):
475 assert igothit[i] == breaker, "Not interrupted at %s by breaker" %i
476 assert len(igothit) == 3 , "Interrupted wrong number of times"
477
490
492 """
493 Test multiple interrupts by multiple processes during victim activity
494 """
495 global victim
496 initialize()
497 breaker1=Interruptor()
498 activate(breaker1,breaker1.breakin(15,howoften=3))
499 breaker2=Interruptor()
500 activate(breaker2,breaker2.breakin(20,howoften=3))
501 victim=Interrupted()
502 activate(victim,victim.myActivity(100))
503 simulate(until=200)
504 for i in (15,30,45):
505 assert igothit[i] == breaker1, "Not interrupted at %s by breaker1" %i
506 for i in (20,40,60):
507 assert igothit[i] == breaker2, "Not interrupted at %s by breaker2" %i
508 assert len(igothit) == 6 , "Interrupted wrong number of times"
509
526
527 victim.newProcess=newProcess
528 activate(victim,newProcess(victim))
529 activate(breaker,breaker.breakin(10,howoften=3))
530 simulate(until=1000)
531
541
542
543
544
545
557
561
563 assert p.active(),"p not active"
564 assert not p.passive(), "p passive"
565 assert not p.terminated(),"p terminated"
566 assert not p.interrupted(),"p interrupted"
567 yield hold,self,11
568 assert not p.active(),"p active"
569 assert not p.passive(),"p passive"
570 assert p.terminated(),"p not terminated"
571 assert not p.interrupted(),"p interrupted"
572
574 assert not p.active(),"p active"
575 assert p.passive(),"p not passive"
576 assert not p.terminated(),"p not terminated"
577 assert not p.interrupted(),"p interrupted"
578 activate(p,p.life1())
579 yield hold,self,11
580 assert not p.active(),"p active"
581 assert not p.passive(),"p not passive"
582 assert p.terminated(),"p not terminated"
583 assert not p.interrupted(),"p interrupted"
584
586 assert not p.active(),"p active"
587 assert p.passive(),"p not passive"
588 assert not p.terminated(),"p not terminated"
589 assert not p.interrupted(),"p interrupted"
590 activate(p,p.life2())
591 yield hold,self,11
592 assert not p.active(),"p active"
593 assert p.passive(),"p not passive"
594 assert not p.terminated(),"p terminated"
595 assert not p.interrupted(),"p interrupted"
596
598 yield hold,self,5
599 assert p.active(),"p not active"
600 assert not p.passive(),"p passive"
601 assert not p.terminated(),"p terminated"
602 assert not p.interrupted(),"p interrupted"
603 self.cancel(p)
604 assert not p.active(),"p active"
605 assert p.passive(),"p not passive"
606 assert not p.terminated(),"p terminated"
607 assert not p.interrupted(),"p interrupted"
608 reactivate(p)
609 assert p.active(),"p not active"
610 assert not p.passive(),"p passive"
611 assert not p.terminated(),"p terminated"
612 assert not p.interrupted(),"p interrupted"
613 yield hold,self
614 assert not p.active(),"p active"
615 assert not p.passive(),"p passive"
616 assert p.terminated(),"p terminated"
617 assert not p.interrupted(),"p interrupted"
618
620 yield hold,self,11
621 assert not p.active(),"p active"
622 assert p.passive(),"p not passive"
623 assert not p.terminated(),"p terminated"
624 assert not p.interrupted(),"p interrupted"
625 self.cancel(p)
626 assert not p.active(),"p active"
627 assert p.passive(),"p not passive"
628 assert not p.terminated(),"p terminated"
629 assert not p.interrupted(),"p interrupted"
630
648
652
653 - def look1(self,p1,p2,res):
654 assert p1.active(), "p1 not active"
655 assert not p1.queuing(res), "p1 queuing"
656 assert p2.active(), "p2 noit active"
657 assert not p2.queuing(res), "p2 queuing"
658 yield hold,self,2
659 assert p1.active(), "p1 not active"
660 assert not p1.queuing(res), "p1 queuing"
661 assert p2.passive(), "p2 active"
662 assert p2.queuing(res), "p2 not queuing"
663
672
674 """
675 Tests states and state transitions as defined in SEP003
676 """
677
689
706
726
750
751
752
761
762
763
764
765
768 yield hold,self,1
769 ev1.signal("from SignalProcess")
770 while ev2.queues:
771 nq0=len(ev2.queues)
772 ev2.signal("from SignalProcess")
773 assert len(ev2.queues)==(nq0-1),"wrong number of processes dequeued"
774
777 yield waitevent,self,ev1
778 assert ev1.waits==[],"not all processes waiting for event out of waiting list"
779 assert ev1 in self.eventsFired,"did not record firing event"
780
783 yield queueevent,self,ev2
784 assert ev2 in self.eventsFired,"did not record firing event"
785
788 yield hold,self,1
789 ev1.signal("from SignalProcess")
790 yield hold,self,3
791 assert len(ev2.queues)==QueueProcessOR.nrProcesses,"wrong number of processes queuing for event ev2"
792 while ev2.queues:
793 nq0=len(ev2.queues)
794 ev2.signal("from SignalProcess")
795 assert len(ev2.queues)==(nq0-1),"wrong number of processes dequeued"
796 assert not ev2.queues,"not all processes queuing for ev2 dequeued"
797
800 yield waitevent,self,evset
801 for e in evset:
802 assert e.waits==[],"process not out of waiting list for all events in OR"
803
812
813
815 nrProcesses=0
820 yield queueevent,self,evset
821 occurred=False
822 for e in evset:
823 occurred=occurred or (e in self.eventsFired)
824 assert occurred,"queuing process activated by wrong event(s)"
825
828 e1=SimEvent()
829 e1.signal()
830 e2=SimEvent()
831 e2.signal()
832 yield queueevent,self,[e1,e2]
833 assert self.eventsFired==[e1,e2],\
834 "(queueevent) eventsFired does not report all fired events"
835
837 """
838 Test SimEvent/signal as introduced with SimPy 1.5
839 """
840
842 """
843 Tests basic signal semantics
844 """
845 e=SimEvent()
846 e.signal("param")
847 assert e.occurred,"signal does not set 'occurred' to True"
848 assert e.signalparam=="param","signal parameter wrong"
849 e.signal()
850 assert e.signalparam is None,"signal with no parameter did not overwrite signalparam"
851 e.signal()
852 assert e.occurred,"multiple calls to signal do not set 'occurred'"
853
869
886
894
902
912
913
914
915
916
919 global a,b,c
920 a=True
921 yield hold,self,1
922 b=True
923 yield hold,self,1
924 c=True
925 yield hold,self,1
926 assert waiter.terminated(),"waituntil did not fire"
927
930 def waitcond():
931 return a and b and c
932 yield waituntil,self,waitcond
933
935 """
936 Test waituntil as introduced with SimPy 1.5
937 """
938
948
954
955
956
957
958
959
960
961
962
963
964
966 """ Job class for testing timeout reneging
967 """
968 - def __init__(self,server=None,name=""):
969 Process.__init__(self,name)
970 self.res=server
971 self.gotResource=None
972
973 - def execute(self,timeout,usetime):
974 yield (request,self,self.res),(hold,self,timeout)
975 if self.acquired(self.res):
976 self.gotResource=True
977 yield hold,self,usetime
978 yield release,self,self.res
979 else:
980 self.gotResource=False
981
983 """ Job class for testing timeout reneging with priorities
984 """
985 - def __init__(self,server=None,name=""):
986 Process.__init__(self,name)
987 self.res=server
988 self.gotResource=None
989
990 - def execute(self,timeout,usetime,priority):
991 yield (request,self,self.res,priority),(hold,self,timeout)
992 if self.acquired(self.res):
993 self.gotResource=True
994 yield hold,self,usetime
995 yield release,self,self.res
996 else:
997 self.gotResource=False
998
1000 """ Tests of "yield (request,self,res),(hold,self,delay)"
1001 timeout reneging command
1002 """
1004 """Test that resource gets acquired without timeout
1005 """
1006 res=Resource(name="Server",capacity=1)
1007 initialize()
1008 usetime=5
1009 timeout=1000000
1010 j1=JobTO(server=res,name="Job_1")
1011 activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1012 j2=JobTO(server=res,name="Job_2")
1013 activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1014 simulate(until=2*usetime)
1015 assert now()==2*usetime,"time not ==2*usetime"
1016 assert j1.gotResource and j2.gotResource,\
1017 "at least one job failed to get resource"
1018 assert not (res.waitQ or res.activeQ),\
1019 "job waiting or using resource"
1020
1022 """Test that resource gets acquired without timeout.
1023 Resource monitored.
1024 """
1025 res=Resource(name="Server",capacity=1,monitored=True)
1026 initialize()
1027 usetime=5
1028 timeout=1000000
1029 j1=JobTO(server=res,name="Job_1")
1030 activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1031 j2=JobTO(server=res,name="Job_2")
1032 activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1033 simulate(until=2*usetime)
1034 assert now()==2*usetime,"time not ==2*usetime"
1035 assert j1.gotResource and j2.gotResource,\
1036 "at least one job failed to get resource"
1037 assert not (res.waitQ or res.activeQ),\
1038 "job waiting or using resource"
1039 assert res.waitMon==[[0,1],[usetime,0]],"res.waitMon wrong: %s"%res.waitMon
1040
1042 """Test that timeout occurs when resource busy
1043 """
1044 res=Resource(name="Server",capacity=1)
1045 initialize()
1046 usetime=5
1047 timeout=3
1048 j1=JobTO(server=res,name="Job_1")
1049 activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1050 j2=JobTO(server=res,name="Job_2")
1051 activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1052 simulate(until=2*usetime)
1053 assert(now()==usetime),"time not ==usetime"
1054 assert(j1.gotResource),"Job_1 did not get resource"
1055 assert(not j2.gotResource),"Job_2 did not renege"
1056 assert not (res.waitQ or res.activeQ),\
1057 "job waiting or using resource"
1058
1060 """Test that timeout occurs when resource busy.
1061 Resource monitored.
1062 """
1063 res=Resource(name="Server",capacity=1,monitored=True)
1064 initialize()
1065 usetime=5
1066 timeout=3
1067 j1=JobTO(server=res,name="Job_1")
1068 activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1069 j2=JobTO(server=res,name="Job_2")
1070 activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1071 simulate(until=2*usetime)
1072 assert(now()==usetime),"time not == usetime"
1073 assert(j1.gotResource),"Job_1 did not get resource"
1074 assert(not j2.gotResource),"Job_2 did not renege"
1075 assert not (res.waitQ or res.activeQ),\
1076 "job waiting or using resource"
1077 assert res.waitMon==[[0,1],[timeout,0]],"res.waitMon wrong: %s"%res.waitMon
1078
1080 """Test that timeout occurs when resource busy.
1081 Resource monitored. Requests with priority and preemption.
1082 """
1083 res=Resource(name="Server",capacity=1,monitored=True,qType=PriorityQ,preemptable=True)
1084 initialize()
1085 usetime=5
1086 timeout=3
1087 j1=JobTO_P(server=res,name="Job_1")
1088 activate(j1,j1.execute(timeout=timeout,usetime=usetime,priority=1))
1089 j2=JobTO_P(server=res,name="Job_2")
1090 j2_arrival=1
1091 activate(j2,j2.execute(timeout=timeout,usetime=usetime,priority=5),at=j2_arrival)
1092 j3=JobTO_P(server=res,name="Job_2")
1093 j3_arrival=2
1094 activate(j3,j3.execute(timeout=timeout,usetime=usetime,priority=10),at=j3_arrival)
1095 simulate(until=3*usetime)
1096 assert(now()== 3*usetime),"time not == 2* usetime, but %s"%now()
1097 assert(j1.gotResource),"Job_1 did not get resource"
1098 assert(j2.gotResource),"Job_2 did renege"
1099 assert(j2.gotResource),"Job_3 did renege"
1100 assert not (res.waitQ or res.activeQ),\
1101 "job waiting or using resource"
1102 assert res.waitMon==[[j2_arrival,1],[j3_arrival,2],[usetime+j3_arrival,1],[usetime+j2_arrival+usetime,0]],\
1103 "res.waitMon wrong: %s"%res.waitMon
1104
1106 """Test that timeout occurs when resource has no capacity free
1107 """
1108 res=Resource(name="Server",capacity=0)
1109 initialize()
1110 usetime=5
1111 timeout=3
1112 j1=JobTO(server=res,name="Job_1")
1113 activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1114 j2=JobTO(server=res,name="Job_2")
1115 activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1116 simulate(until=2*usetime)
1117 assert now()==timeout,"time %s not == timeout"%now()
1118 assert not j1.gotResource,"Job_1 got resource"
1119 assert not j2.gotResource,"Job_2 got resource"
1120 assert not (res.waitQ or res.activeQ),\
1121 "job waiting or using resource"
1122
1124 """Test that timeout occurs when resource has no capacity free.
1125 Resource monitored.
1126 """
1127 res=Resource(name="Server",capacity=0,monitored=True)
1128 initialize()
1129 usetime=5
1130 timeout=3
1131 j1=JobTO(server=res,name="Job_1")
1132 activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1133 j2=JobTO(server=res,name="Job_2")
1134 activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1135 simulate(until=2*usetime)
1136 assert now()==timeout,"time %s not == timeout"%now()
1137 assert not j1.gotResource,"Job_1 got resource"
1138 assert not j2.gotResource,"Job_2 got resource"
1139 assert not (res.waitQ or res.activeQ),\
1140 "job waiting or using resource"
1141 assert res.waitMon==[[0,1],[0,2],[timeout,1],[timeout,0]],\
1142 "res.waitMon is wrong: %s"%res.waitMon
1143
1157
1158
1159
1160
1161
1162
1163
1164
1166 """ Job class for testing event reneging
1167 """
1168 - def __init__(self,server=None,name=""):
1169 Process.__init__(self,name)
1170 self.res=server
1171 self.gotResource=None
1172
1174 yield (request,self,self.res),(waitevent,self,event)
1175 if self.acquired(self.res):
1176 self.gotResource=True
1177 yield hold,self,usetime
1178 yield release,self,self.res
1179 else:
1180 self.gotResource=False
1181
1183 """ Job class for testing event reneging with multi-event lists
1184 """
1185 - def __init__(self,server=None,name=""):
1186 Process.__init__(self,name)
1187 self.res=server
1188 self.gotResource=None
1189
1190 - def execute(self,eventlist,usetime):
1191 yield (request,self,self.res),(waitevent,self,eventlist)
1192 if self.acquired(self.res):
1193 self.gotResource=True
1194 yield hold,self,usetime
1195 yield release,self,self.res
1196 else:
1197 self.gotResource=False
1198
1200 """Fires reneging event
1201 """
1202 - def fire(self,fireDelay,event):
1203 yield hold,self,fireDelay
1204 event.signal()
1205
1207 """Tests of "yield (request,self,res),(waiteevent,self,event)"
1208 event reneging command
1209 """
1211 """Test that processes acquire resource normally if no event fires
1212 """
1213 res=Resource(name="Server",capacity=1)
1214 event=SimEvent("Renege_trigger")
1215 initialize()
1216 usetime=5
1217 j1=JobEvt(server=res,name="Job_1")
1218 activate(j1,j1.execute(event=event,usetime=usetime))
1219 j2=JobEvt(server=res,name="Job_2")
1220 activate(j2,j2.execute(event=event,usetime=usetime))
1221 simulate(until=2*usetime)
1222
1223 assert now()==2*usetime,"time not ==2*usetime"
1224 assert j1.gotResource and j2.gotResource,\
1225 "at least one job failed to get resource"
1226 assert not (res.waitQ or res.activeQ),\
1227 "job waiting or using resource"
1228
1230 """Test that processes acquire resource normally if no event fires.
1231 Resource monitored.
1232 """
1233 res=Resource(name="Server",capacity=1,monitored=True)
1234 event=SimEvent("Renege_trigger")
1235 initialize()
1236 usetime=5
1237 j1=JobEvt(server=res,name="Job_1")
1238 activate(j1,j1.execute(event=event,usetime=usetime))
1239 j2=JobEvt(server=res,name="Job_2")
1240 activate(j2,j2.execute(event=event,usetime=usetime))
1241 simulate(until=2*usetime)
1242
1243 assert now()==2*usetime,"time not ==2*usetime"
1244 assert j1.gotResource and j2.gotResource,\
1245 "at least one job failed to get resource"
1246 assert not (res.waitQ or res.activeQ),\
1247 "job waiting or using resource"
1248 assert res.waitMon==[[0,1],[usetime,0]],"res.waitMoni is wrong: %s"%res.waitMon
1249
1251 """Test that signalled event leads to renege when resource busy
1252 """
1253 res=Resource(name="Server",capacity=1)
1254 initialize()
1255 event=SimEvent("Renege_trigger")
1256 usetime=5
1257 eventtime=1
1258 j1=JobEvt(server=res,name="Job_1")
1259 activate(j1,j1.execute(event=event,usetime=usetime))
1260 j2=JobEvt(server=res,name="Job_2")
1261 activate(j2,j2.execute(event=event,usetime=usetime))
1262 f=FireEvent(name="FireEvent")
1263 activate(f,f.fire(fireDelay=eventtime,event=event))
1264 simulate(until=2*usetime)
1265
1266 assert(now()==usetime),"time not ==usetime"
1267 assert(j1.gotResource),"Job_1 did not get resource"
1268 assert(not j2.gotResource),"Job_2 did not renege"
1269 assert not (res.waitQ or res.activeQ),\
1270 "job waiting or using resource"
1271
1273 """Test that signalled event leads to renege when resource busy.
1274 Resource monitored.
1275 """
1276 res=Resource(name="Server",capacity=1,monitored=True)
1277 initialize()
1278 event=SimEvent("Renege_trigger")
1279 usetime=5
1280 eventtime=1
1281 j1=JobEvt(server=res,name="Job_1")
1282 activate(j1,j1.execute(event=event,usetime=usetime))
1283 j2=JobEvt(server=res,name="Job_2")
1284 activate(j2,j2.execute(event=event,usetime=usetime))
1285 f=FireEvent(name="FireEvent")
1286 activate(f,f.fire(fireDelay=eventtime,event=event))
1287 simulate(until=2*usetime)
1288
1289 assert(now()==usetime),"time not ==usetime"
1290 assert(j1.gotResource),"Job_1 did not get resource"
1291 assert(not j2.gotResource),"Job_2 did not renege"
1292 assert not (res.waitQ or res.activeQ),\
1293 "job waiting or using resource"
1294 assert res.waitMon==[[0,1],[eventtime,0]],"res.waitMon is wrong: %s"%res.waitMon
1295
1297 """Test that renege-triggering event can be one of an event list
1298 """
1299 res=Resource(name="Server",capacity=1)
1300 initialize()
1301 event1=SimEvent("Renege_trigger_1")
1302 event2=SimEvent("Renege_trigger_2")
1303 usetime=5
1304 eventtime=1
1305 j1=JobEvtMulti(server=res,name="Job_1")
1306 activate(j1,j1.execute(eventlist=[event1,event2],usetime=usetime))
1307 j2=JobEvtMulti(server=res,name="Job_2")
1308 activate(j2,j2.execute(eventlist=[event1,event2],usetime=usetime))
1309 f1=FireEvent(name="FireEvent_1")
1310 activate(f1,f1.fire(fireDelay=eventtime,event=event1))
1311 f2=FireEvent(name="FireEvent_2")
1312 activate(f2,f2.fire(fireDelay=eventtime,event=event2))
1313 simulate(until=2*usetime)
1314
1315 assert(now()==usetime),"time not ==usetime"
1316 assert(j1.gotResource),"Job_1 did not get resource"
1317 assert(not j2.gotResource),"Job_2 did not renege"
1318 assert not (res.waitQ or res.activeQ),\
1319 "job waiting or using resource"
1320
1322 """Test that renege-triggering event can be one of an event list.
1323 Resource monitored.
1324 """
1325 res=Resource(name="Server",capacity=1,monitored=True)
1326 initialize()
1327 event1=SimEvent("Renege_trigger_1")
1328 event2=SimEvent("Renege_trigger_2")
1329 usetime=5
1330 eventtime=1
1331 j1=JobEvtMulti(server=res,name="Job_1")
1332 activate(j1,j1.execute(eventlist=[event1,event2],usetime=usetime))
1333 j2=JobEvtMulti(server=res,name="Job_2")
1334 activate(j2,j2.execute(eventlist=[event1,event2],usetime=usetime))
1335 f1=FireEvent(name="FireEvent_1")
1336 activate(f1,f1.fire(fireDelay=eventtime,event=event1))
1337 f2=FireEvent(name="FireEvent_2")
1338 activate(f2,f2.fire(fireDelay=eventtime,event=event2))
1339 simulate(until=2*usetime)
1340
1341 assert(now()==usetime),"time not ==usetime"
1342 assert(j1.gotResource),"Job_1 did not get resource"
1343 assert(not j2.gotResource),"Job_2 did not renege"
1344 assert not (res.waitQ or res.activeQ),\
1345 "job waiting or using resource"
1346 assert res.waitMon==[[0,1],[eventtime,0]],"res.waitMon is wrong: %s"%res.waitMon
1347
1360
1361
1362
1363
1364
1365
1366
1368 produced=0
1375 """PriorityQ for Producers"""
1376 Producer.produced+=4
1377 yield put,self,buffer,4,priority
1378 yield hold,self,1
1379 self.done=now()
1380 doneList.append(self.name)
1382 for i in range(4):
1383 yield put,self,buffer,4
1384 yield hold,self,1
1386 consumed=0
1388 """FIFO"""
1389 yield get,self,buffer
1390 Consumer.consumed+=1
1391 assert self.got==1,"wrong self.got: %s"%self.got
1392 yield get,self,buffer,3
1393 Consumer.consumed+=3
1394 assert self.got==3,"wrong self.got: %s"%self.got
1395
1397 """producer PriorityQ, consumer FIFO"""
1398 while True:
1399 yield get,self,buffer,2
1400 yield hold,self,1
1402 """PriorityQ for Consumers"""
1403 yield get,self,buffer,4,priority
1404 doneList.append(self.name)
1405
1406
1408 - def produce(self,buffer,productionTime):
1409 while True:
1410 assert not(buffer.amount>0 and len(buffer.getQ)>0),\
1411 "Consumer(s) waiting while buffer not empty"
1412 yield hold,self,productionTime
1413 yield put,self,buffer,1
1414
1416 - def consume(self,buffer,consumptionTime):
1417 while True:
1418 assert not(buffer.amount==0 and len(buffer.putQ)>0),\
1419 "Producer(s) waiting while buffer empty"
1420 yield get,self,buffer,1
1421 yield hold,self,consumptionTime
1422
1423
1424
1427 """Tests initialization of Level instances
1428 """
1429 a=Level()
1430 assert a.capacity==sys.maxint,"wrong capacity:%s"%a
1431 assert a.amount==0,"wrong buffer content: %s"%a
1432 assert a.name=="a_level","wrong name: %s"%a
1433 assert not a.monitored,"should not be monitored: %s"%a
1434 assert a.putQMon is None,"should not have putQMon: %s"%a
1435 assert a.getQMon is None,"should not have getQMon: %s"%a
1436 assert a.bufferMon is None,"should not have bufferMon: %s"%a
1437 assert a.putQType.__name__=="FIFO" and a.getQType.__name__=="FIFO",\
1438 "putQType and getQType should be FIFO: %s"%a
1439
1440 b=Level(name="b",initialBuffered=10.0,monitored=True,capacity=12,
1441 putQType=PriorityQ)
1442 a=Level()
1443 assert b.capacity==12,"wrong capacity:%s"%b
1444 assert b.amount==10,"wrong buffer content: %s"%b
1445 assert b.name=="b","wrong name: %s"%b
1446 assert b.monitored,"should be monitored: %s"%b
1447 assert not (b.putQMon is None),"should have putQMon: %s"%b
1448 assert not (b.getQMon is None),"should have getQMon: %s"%b
1449 assert not (b.bufferMon is None),"should have bufferMon: %s"%b
1450 assert b.putQType.__name__=="PriorityQ",\
1451 "putQType should be PriorityQ: %s"%b
1452 assert b.getQType.__name__=="FIFO",\
1453 "getQType should be PriorityQ: %s"%b
1454
1456 """Level: tests basic Producer/Consumer principles:
1457 - Consumers must not be waiting while Level buffer value > 0,
1458 - Producers must not be waiting while Level buffer value == 0
1459 """
1460 bufferSize=1
1461 productionTime=1
1462 consumptionTime=5
1463 endtime=50
1464
1465 initialize()
1466 buffer=Level(capacity=bufferSize)
1467 consumer=ConsumerPrincL()
1468 activate(consumer,consumer.consume(buffer,consumptionTime))
1469 producer=ProducerPrincL()
1470 activate(producer,producer.produce(buffer,productionTime))
1471 simulate(until=endtime)
1472
1485
1502
1504 """Level: tests put/get in multiple Producer/Consumer scenario,
1505 with Producers having different priorities.
1506 How: Producers forced to queue; all after first should be done in
1507 priority order
1508 """
1509 global doneList
1510 doneList=[]
1511 initialize()
1512 buffer=Level(capacity=7,putQType=PriorityQ,monitored=True)
1513 for i in range(4):
1514 p=Producer(i)
1515 pPriority=i
1516 activate(p,p.producePriority(buffer=buffer,priority=pPriority))
1517 c=Consumer()
1518 activate(c,c.consume1(buffer=buffer))
1519 simulate(until=100)
1520 assert doneList==[0,3,2,1],"puts were not done in priority order: %s"\
1521 %doneList
1522
1524 """Level: tests put/get in multiple Producer/Consumer scenario, with
1525 Consumers having different priorities.
1526 How: Consumers forced to queue; all after first should be done in
1527 priority order
1528 """
1529 global doneList
1530 doneList=[]
1531 initialize()
1532 buffer=Level(capacity=7,getQType=PriorityQ,monitored=True)
1533 for i in range(4):
1534 c=Consumer(i)
1535 cPriority=i
1536 activate(c,c.consumePriority(buffer=buffer,priority=cPriority))
1537 p=Producer()
1538 activate(p,p.produce1(buffer=buffer))
1539 simulate(until=100)
1540 assert doneList==[3,2,1,0],"gets were not done in priority order: %s"\
1541 %doneList
1542
1555
1556
1557
1558
1559
1560
1561
1584
1610
1614
1616 """Sorts Widget instances by weight attribute."""
1617 tmplist=[(x.weight,x) for x in par]
1618 tmplist.sort()
1619 return [x for (key,x) in tmplist]
1620
1621
1623 - def produce(self,buffer,productionTime):
1624 while True:
1625 assert not(buffer.nrBuffered>0 and len(buffer.getQ)>0),\
1626 "Consumer(s) waiting while buffer not empty"
1627 yield hold,self,productionTime
1628 product=WidgetPrinc()
1629 yield put,self,buffer,[product]
1630
1632 - def consume(self,buffer,consumptionTime):
1633 while True:
1634 assert not(buffer.nrBuffered==0 and buffer.putQ),\
1635 "Producer(s) waiting while buffer empty"
1636 yield get,self,buffer,1
1637 yield hold,self,consumptionTime
1638
1640 pass
1641
1643 """Used in testBufferFilter"""
1647
1649 """get all items with weight between a and b"""
1650 def between_a_and_b(buf):
1651 res=[]
1652 for item in buf:
1653 if a<item.weight<b:
1654 res.append(item)
1655
1656 all=store.buffered
1657 yield get,self,store,between_a_and_b
1658 "All retrieved items weight in range?"
1659 for it in self.got:
1660 assert a<it.weight<b,"weight %s not in range %s..%s"\
1661 %(it.weight,a,b)
1662 "Any item fitting filter pred left in buffer?"
1663 for it in store.buffer:
1664 assert not (a<it.weight<b),\
1665 "item left in buffer which fits filter (%s<%s<%s)"\
1666 %(a,it.weight,b)
1667 "All items either in store.buffer of self.got?"
1668 for it in all:
1669 assert (it in self.buffer) or (it in self.got),\
1670 "item w. weight %s neither in store nor in got"%it.weight
1671
1672
1673
1676 """Store: tests initialization of Store instances
1677 """
1678 a=Store()
1679 assert a.capacity==sys.maxint,"wrong capacity:%s"%a
1680 assert a.nrBuffered==0,"wrong buffer content: %s"%a
1681 assert a.name=="a_store","wrong name: %s"%a
1682 assert not a.monitored,"should not be monitored: %s"%a
1683 assert a.putQMon is None,"should not have putQMon: %s"%a
1684 assert a.getQMon is None,"should not have getQMon: %s"%a
1685 assert a.bufferMon is None,"should not have bufferMon: %s"%a
1686 assert a.putQType.__name__=="FIFO" and a.getQType.__name__=="FIFO",\
1687 "putQType and getQType should be FIFO: %s"%a
1688
1689 stored=[Widget(weight=5)]*10
1690 b=Store(name="b",initialBuffered=stored,monitored=True,capacity=12,
1691 putQType=PriorityQ)
1692 assert b.capacity==12,"wrong capacity:%s"%b
1693 assert b.nrBuffered==10,"wrong buffer content: %s"%b
1694 assert b.name=="b","wrong name: %s"%b
1695 assert b.monitored,"should be monitored: %s"%b
1696 assert not (b.putQMon is None),"should have putQMon: %s"%b
1697 assert not (b.getQMon is None),"should have getQMon: %s"%b
1698 assert not (b.bufferMon is None),"should have bufferMon: %s"%b
1699 assert b.putQType.__name__=="PriorityQ",\
1700 "putQType should be PriorityQ: %s"%b
1701 assert b.getQType.__name__=="FIFO",\
1702 "getQType should be PriorityQ: %s"%b
1703
1705 """Store: tests basic Producer/Consumer principles:
1706 - Consumers must not be waiting while items in Store buffer,
1707 - Producers must not be waiting while space available in Store buffer
1708 """
1709 bufferSize=1
1710 productionTime=1
1711 consumptionTime=5
1712 endtime=50
1713
1714 initialize()
1715 buffer=Store(capacity=bufferSize)
1716 consumer=ConsumerPrincS()
1717 activate(consumer,consumer.consume(buffer,consumptionTime))
1718 producer=ProducerPrincS()
1719 activate(producer,producer.produce(buffer,productionTime))
1720 simulate(until=endtime)
1721
1735
1752
1754 """Store: Tests put/get in multiple Producer/Consumer scenario,
1755 with Producers having different priorities.
1756 How; Producers forced to queue; all after first should be done in
1757 priority order
1758 """
1759 global doneList
1760 doneList=[]
1761 initialize()
1762 buffer=Store(capacity=7,putQType=PriorityQ,monitored=True)
1763 for i in range(4):
1764 p=ProducerWidget(i)
1765 pPriority=i
1766 activate(p,p.producePriority(buffer=buffer,priority=pPriority))
1767 c=ConsumerWidget()
1768 activate(c,c.consume1(buffer=buffer))
1769 simulate(until=100)
1770 assert doneList==[0,3,2,1],"puts were not done in priority order: %s"\
1771 %doneList
1772
1774 """Tests put/get in multiple Producer/Consumer scenario, with
1775 Consumers having different priorities.
1776 How; Consumers forced to queue; all after first should be done in
1777 priority order
1778 """
1779 global doneList
1780 doneList=[]
1781 initialize()
1782 buffer=Store(capacity=7,getQType=PriorityQ,monitored=True)
1783 for i in range(4):
1784 c=ConsumerWidget(str(i))
1785 cPriority=i
1786 activate(c,c.consumePriority(buffer=buffer,priority=cPriority))
1787 p=ProducerWidget()
1788 activate(p,p.produce1(buffer=buffer))
1789 simulate(until=100)
1790 assert doneList==["3","2","1","0"],\
1791 "gets were not done in priority order: %s"%doneList
1792
1794 """Tests the optional sorting of theBuffer by applying a user-defined
1795 sort function."""
1796 initialize()
1797 gotten=[]
1798 sortedStore=Store()
1799 sortedStore.addSort(mySortFunc)
1800 p=ProducerWidget()
1801 activate(p,p.produceUnordered(sortedStore))
1802 for i in range(9):
1803 c=ConsumerWidget()
1804 activate(c,c.consumeSorted(buffer=sortedStore,gotten=gotten),at=1)
1805 simulate(until=10)
1806 assert gotten==[1,2,3,4,5,6,7,8,9],"sort wrong: %s"%gotten
1807
1819
1835
1836
1837
1838
1839
1840
1841 -class TBT(Process):
1842 """Store: For testBasicTime"""
1843 - def tbt(self,store):
1844 yield get,self,store,1
1845 assert self.got,"Did not get Item"
1846 yield (get,self,store,1),(hold,self,5)
1847 if self.acquired(store):
1848 assert len(self.got)==1,"did not get 1 Item"
1849 else:
1850 assert not self.got and now()==5 and not store.getQ,\
1851 "time renege not working"
1852
1853 -class TBE(Process):
1854 """Store: For testBasicEvent"""
1855 - def tbe(self,store,trigger):
1856 yield get,self,store,1
1857 assert self.got,"Did not get Item"
1858 yield (get,self,store,1),(waitevent,self,trigger)
1859 if self.acquired(store):
1860 assert False, "should have reneged"
1861 else:
1862 assert self.eventsFired[0]==trigger and now()==5 \
1863 and not store.getQ,"event renege not working"
1864
1866 """Store: For testBasicEvent"""
1867 - def fire(self,trigger):
1870
1872 """Store: Testcase for compound get statements"""
1873
1875 """Store: for testBasicTimePut"""
1876 - def tbt(self,store):
1877 class Item:pass
1878 yield (put,self,store,[Item()]),(hold,self,4)
1879 if self.stored(store):
1880 assert store.nrBuffered==1 and not store.putQ,\
1881 "put did not execute"
1882 else:
1883 assert False,"should not have reneged"
1884 yield (put,self,store,[Item()]),(hold,self,5)
1885 if self.stored(store):
1886 assert False,"should have reneged"
1887 else:
1888 assert store.nrBuffered==1 and not store.putQ,\
1889 "renege not working correctly"
1890
1892 """Store: for testBasicEventPut"""
1893 - def tbe(self,store,trigger):
1894 class Item:pass
1895 yield (put,self,store,[Item()]),(waitevent,self,trigger)
1896 if self.stored(store):
1897 assert store.nrBuffered==1 and not store.putQ,\
1898 "put did not execute"
1899 else:
1900 assert False,"should have not have reneged"
1901 yield (put,self,store,[Item()]),(waitevent,self,trigger)
1902 if self.stored(store):
1903 assert False,"should have reneged"
1904 else:
1905 assert now()==5 and self.eventsFired[0]==trigger\
1906 and not store.putQ,"renege not working correctly"
1907
1909 """Store: For testBasicEventPut"""
1910 - def fire(self,trigger):
1913
1915 """Store: Testcase for compound get statements"""
1916
1917
1918
1919
1920
1921
1923 """Store (unmonitored):
1924 test 'yield (get,self,store),(hold,self,timeout)"""
1925 class Item:pass
1926 initialize()
1927 st=Store(initialBuffered=[Item()])
1928 t=TBT()
1929 activate(t,t.tbt(store=st))
1930 simulate(until=10)
1931
1932
1933
1934
1935
1936
1937
1946
1948 """Store (monitored):
1949 test monitors with 'yield (put,self,store),(hold,self,time)"""
1950 initialize()
1951 st=Store(capacity=1,monitored=True)
1952 t=TBTput()
1953 activate(t,t.tbt(store=st))
1954 simulate(until=10)
1955
1956 assert st.putQMon==[[0,0],[0,1],[5,0]],"putQMon wrong: %s"\
1957 %st.putQMon
1958
1959 assert st.bufferMon==[[0,0],[0,1]],"bufferMon wrong: %s"%st.bufferMon
1960
1961
1962
1963
1964
1965
1966
1979
1980
1981
1982
1983
1984
1985
1997
1999 """Store (monitored):
2000 test monitors with 'yield (put,self,store),(waitevent,self,event)"""
2001 initialize()
2002 s=SimEvent()
2003 st=Store(capacity=1,monitored=True)
2004 t=TBEtriggerPut()
2005 activate(t,t.fire(trigger=s))
2006 tb=TBEput()
2007 activate(tb,tb.tbe(store=st,trigger=s))
2008 simulate(until=10)
2009
2010 assert st.putQMon==[[0,0],[0,1],[5,0]],"putQMon wrong: %s"\
2011 %st.putQMon
2012
2013 assert st.bufferMon==[[0,0],[0,1]],"bufferMon wrong: %s"%st.bufferMon
2014
2033
2034
2035
2036
2037
2038
2040 """Level: For testBasicTime"""
2041 - def tbt(self,level):
2042 yield get,self,level,1
2043 assert self.got,"did not get 1 unit"
2044 yield (get,self,level,1),(hold,self,5)
2045 if self.acquired(level):
2046 assert self.got==1,"did not get 1 unit"
2047 else:
2048 assert not self.got and now()==5,"time renege not working"
2049
2051 """Level: For testBasicEvent"""
2052 - def tbe(self,level,trigger):
2053 yield get,self,level,1
2054 assert self.got,"did not get 1 unit"
2055 yield (get,self,level,1),(waitevent,self,trigger)
2056 if self.acquired(level):
2057 assert self.got==1,"did not get 1 Item"
2058 else:
2059 assert now()==5.5 and self.eventsFired[0]==trigger,\
2060 "event renege not working"
2061
2063 """Level: For testBasicEvent"""
2064 - def fire(self,trigger):
2067
2069 """Level: For testBasicTimePut"""
2070 - def tbt(self,level):
2071 yield put,self,level,1
2072 assert level.amount,"did not put 1 unit"
2073 yield (put,self,level,1),(hold,self,5)
2074 if self.stored(level):
2075 assert False,"should have reneged"
2076 else:
2077 assert level.amount==1 and now()==5,"time renege not working"
2078
2080 """Level: For testBasicEventPut and testBasicEventPutM"""
2081 - def tbe(self,level,trigger):
2082 yield (put,self,level,1),(waitevent,self,trigger)
2083 if self.stored(level):
2084 assert level.amount==1,"did not put 1 unit"
2085 else:
2086 assert False,"should not have reneged"
2087 yield (put,self,level,1),(waitevent,self,trigger)
2088 if self.stored(level):
2089 assert False, "should have reneged"
2090 else:
2091 assert now()==5.5 and self.eventsFired[0]==trigger ,\
2092 "renege not working"
2093
2095 """Level: For testBasicEventPut"""
2096 - def fire(self,trigger):
2099
2101 """Level: Testcase for compound get and put statements"""
2102
2103
2104
2105
2106
2107
2109 """Level (unmonitored): test 'yield (get,self,level),(hold,self,timeout)"""
2110 initialize()
2111 l=Level(initialBuffered=1)
2112 t=TBTLev()
2113 activate(t,t.tbt(level=l))
2114 simulate(until=10)
2115
2116
2117
2118
2119
2120
2129
2130
2131
2132
2133
2134
2135
2147
2149 """Level (monitored):
2150 test monitors with 'yield (get,self,level),(waitevent,self,event)"""
2151 initialize()
2152 l=Level(initialBuffered=1,monitored=True)
2153 trig=SimEvent()
2154 t=TBELev()
2155 activate(t,t.tbe(level=l,trigger=trig))
2156 tr=TBEtriggerLev()
2157 activate(tr,tr.fire(trigger=trig))
2158 simulate(until=10)
2159
2160 assert l.getQMon==[[0,0],[0,1],[5.5,0]],"getQMon not working: %s"\
2161 %l.getQMon
2162
2163 assert l.bufferMon==[[0,1],[0,0]],\
2164 "bufferMon not working: %s"%l.bufferMon
2165
2166
2167
2168
2169
2170
2182
2184 """Level (monitored):
2185 test monitors with 'yield (put,self,level),(waitevent,self,event)"""
2186 initialize()
2187 l=Level(capacity=1,monitored=True)
2188 trig=SimEvent()
2189 t=TBELevPut()
2190 activate(t,t.tbe(level=l,trigger=trig))
2191 tr=TBEtriggerLevPut()
2192 activate(tr,tr.fire(trigger=trig))
2193 simulate(until=10)
2194 "First put succeeds, second reneges at t=5.5?"
2195 assert l.putQMon==[[0,0],[0,1],[5.5,0]],"putQMon wrong: %s"\
2196 %l.putQMon
2197 "1 unit added at t=0, renege at t=5 before 2nd unit added?"
2198 assert l.bufferMon==[[0,0],[0,1]],"bufferMon wrong: %s"%l.bufferMon
2199
2218
2219 if __name__ == '__main__':
2220 alltests = unittest.TestSuite((makeSSuite(),makeRSuite(),
2221 makeMSuite(),
2222 makeISuite(),makePSuite(),
2223 makeESuite(),makeWSuite(),
2224 makeTOSuite(),makeEvtRenegeSuite(),
2225 makeLevelSuite(),
2226 makeStoreSuite(),
2227 makeStoreCompSuite(),
2228 makeLevelCompSuite()
2229 ))
2230 runner = unittest.TextTestRunner()
2231 runner.run(alltests)
2232