1
2 from SimPy.MonitorTest import *
3 from SimPy.SimulationStep import *
4 import unittest
5 from random import random
6
7 """testSimPyStep.py
8 SimPy version 1.8
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
36 #'$Revision: 1.1.1.14 $ $Date: 2007/01/08 14:07:33 $ kgm'
37
38 """
39 __version__ = '1.8 $Revision: 1.1.1.14 $ $Date: 2007/01/08 14:07:33 $ '
40 print "testSimPyStep.py %s"%__version__
41
42
43
44
46 """ P class for testing"""
51
53 yield hold,self,self.T
54
56 """ Tests of simulation
57 """
64
73
75 """Test yield hold and simulate(until)
76 """
77 P1 = P(name="P1",T=10)
78 initialize()
79 activate(P1,P1.execute(),0)
80 simulate(until=5)
81 assert(now()==5),"Simulate stopped at %s not %s"%(now(),5)
82
83 P2 = P(name="P2",T=10)
84 initialize()
85 activate(P2,P2.execute(),0)
86 simulate(until=20)
87 assert(now()==10),"P1 hold to %s not %s"%(now(),10)
88
89
99
100
101
102
103
105 """ Job class for testing"""
106 - def __init__(self,server=None,name=""):
110
112 yield request,self,self.R
113
114
116 """ First simple tests of Resources
117 """
119 """Test initialisation"""
120 R = Resource()
121 assert R.name == "a_resource", "Not null name"
122 assert R.capacity == 1, "Not unit capacity"
123 assert R.unitName =="units", "Not the correct unit name"
124 R = Resource(name='',capacity=1)
125 assert R.name == "", "Not null name"
126 assert R.capacity == 1, "Not unit capacity"
127 assert R.unitName =="units", "Not the correct unit name"
128 R = Resource(capacity=3,name="3-version",unitName="blobs")
129 assert R.name =="3-version" , "Wrong name, it is"+R.name
130 assert R.capacity == 3, "Not capacity 3, it is "+`R.capacity`
131 assert R.unitName =="blobs", "Not the correct unit name"
132
133 R = Resource(capacity=0,name="0-version")
134 assert R.capacity ==0, "Not capacity 0, it is "+`R.capacity`
135
137 """Test request"""
138
139
140 R0 = Resource(name='',capacity=0)
141 assert R0.name == "", "Not null name"
142 assert R0.capacity == 0, "Not capacity 0, it is "+`R0.capacity`
143
144 initialize()
145 R1 = Resource(capacity=0,name="3-version",unitName="blobs")
146 J= Job(name="job",server=R1)
147 activate(J,J.execute(), at=0.0)
148
149 simulate(until=10.0)
150 assert R1.n == 0 , "Should be 0, it is "+str(R1.n)
151 lenW = len(R1.waitQ)
152 assert lenW==1,"Should be 1, it is "+str(lenW)
153 assert len(R1.activeQ)==0,"len activeQ Should be 0, it is "+\
154 str(len(R1.activeQ))
155
157 """Test request2 with capacity = 1"""
158
159 initialize()
160 R2 = Resource(capacity=1,name="3-version",unitName="blobs")
161 J2= Job(name="job",server=R2)
162 activate(J2,J2.execute(), at=0.0)
163
164 simulate(until = 10.0)
165 assert R2.n == 0 , "Should be 0, it is "+str(R2.n)
166 lenW = len(R2.waitQ)
167 lenA = len(R2.activeQ)
168 assert lenW==0,"lenW Should be 0, it is "+str(lenW)
169 assert lenA==1,"lenA Should be 1, it is "+str(lenA)
170
172 """Test request3 with capacity = 1 several requests"""
173
174 initialize()
175 R3 = Resource(capacity=1,name="3-version",unitName="blobs")
176 J2= Job(name="job",server=R3)
177 J3= Job(name="job",server=R3)
178 J4= Job(name="job",server=R3)
179 activate(J2,J2.execute(), at=0.0)
180 activate(J3,J3.execute(), at=0.0)
181 activate(J4,J4.execute(), at=0.0)
182
183 simulate(until = 10.0)
184 assert R3.n == 0 , "Should be 0, it is "+str(R3.n)
185 lenW = len(R3.waitQ)
186 lenA = len(R3.activeQ)
187 assert lenW==2,"lenW Should be 2, it is "+str(lenW)
188 assert R3.waitQ==[J3,J4],"WaitQ wrong"+str(R3.waitQ)
189 assert lenA==1,"lenA Should be 1, it is "+str(lenA)
190 assert R3.activeQ==[J2],"activeQ wrong, it is "+str(R3.activeQ[0])
191
193 """Test request4 with capacity = 2 several requests"""
194
195 initialize()
196 R3 = Resource(capacity=2,name="4-version",unitName="blobs")
197 J2= Job(name="job",server=R3)
198 J3= Job(name="job",server=R3)
199 J4= Job(name="job",server=R3)
200 activate(J2,J2.execute(), at=0.0)
201 activate(J3,J3.execute(), at=0.0)
202 activate(J4,J4.execute(), at=0.0)
203
204 simulate(until = 10.0)
205 assert R3.n == 0 , "Should be 0, it is "+str(R3.n)
206 lenW = len(R3.waitQ)
207 lenA = len(R3.activeQ)
208 assert lenW==1,"lenW Should be 1, it is "+str(lenW)
209 assert R3.waitQ==[J4],"WaitQ wrong"+str(R3.waitQ)
210 assert lenA==2,"lenA Should be 2, it is "+str(lenA)
211 assert R3.activeQ==[J2,J3],"activeQ wrong, it is "+str(R3.activeQ[0])
212
213
214
216 """Test PriorityQ, with no preemption, 0 capacity"""
217 class Job(Process):
218 """ Job class for testing"""
219 def __init__(self,server=None,name=""):
220 Process.__init__(self)
221 self.name=name
222 self.R=server
223
224 def execute(self,priority):
225 yield request,self,self.R,priority
226
227 initialize()
228 Rp = Resource(capacity=0,qType=PriorityQ)
229 J5 = Job(name="job 5",server=Rp)
230 J6 = Job(name="job 6",server=Rp)
231 J7 = Job(name="job 7",server=Rp)
232 activate(J5,J5.execute(priority=3))
233 activate(J6,J6.execute(priority=0))
234 activate(J7,J7.execute(priority=1))
235 simulate(until=100)
236 assert Rp.waitQ == [J5,J7,J6],"WaitQ wrong"+str([(x.name,x.priority[Rp]) for x in Rp.waitQ])
237
238 """Test PriorityQ mechanism"""
239
240 def sorted(q):
241 if not q or len(q) == 1:
242 sortok=1
243 return sortok
244 sortok = q[0] >= q[1] and sorted(q[2:])
245 return sortok
246
247 initialize()
248 Rp=Resource(capacity=0,qType=PriorityQ)
249 for i in range(10):
250 J=Job(name="job "+str(i),server=Rp)
251 activate(J,J.execute(priority=random()))
252 simulate(until=1000)
253 qp=[x._priority[Rp] for x in Rp.waitQ]
254 assert sorted(qp),"waitQ not sorted by priority: "+str([(x.name,x._priority[Rp]) for x in Rp.waitQ])
255
256
258 """Test PriorityQ, with no preemption, capacity == 1"""
259 class Job(Process):
260 """ Job class for testing"""
261 def __init__(self,server=None,name=""):
262 Process.__init__(self)
263 self.name=name
264 self.R=server
265
266 def execute(self,priority):
267 yield request,self,self.R,priority
268
269 initialize()
270 Rp = Resource(capacity=1,qType=PriorityQ)
271 J5 = Job(name="job 5",server=Rp)
272 J6 = Job(name="job 6",server=Rp)
273 J7 = Job(name="job 7",server=Rp)
274 activate(J5,J5.execute(priority=2))
275 activate(J6,J6.execute(priority=4))
276 activate(J7,J7.execute(priority=3))
277 simulate(until=100)
278 assert Rp.waitQ == [J6,J7],"WaitQ wrong "+str([(x.name,x._priority[Rp]) for x in Rp.waitQ])
279
281 """Test PriorityQ, with preemption, capacity == 1"""
282 class nuJob(Process):
283 def __init__(self,name):
284 Process.__init__(self,name)
285
286 def execute(self,res,priority):
287 self.preempt=len(res.activeQ) > 0 and priority > res.activeQ[-1]._priority[res]
288 t=now()
289 yield request,self,res,priority
290 if self.preempt:
291 assert len(res.waitQ) == 1, "No preemption "+"activeQ= "+str(res.activeQ[0].name)
292 yield hold,self,30
293 t1=now()
294 if self.preempt:
295 assert t+30 == t1,"Wrong completion time for preemptor "+self.name
296 else:
297 assert t+60 == t1, "Wrong completion time for preempted "+self.name+" "+str(now())
298 yield release,self,res
299
300 initialize()
301 res=Resource(name="server",capacity=1,qType=PriorityQ,preemptable=1)
302 n1=nuJob(name="nuJob 1")
303 n2=nuJob(name="nuJob 2")
304 activate(n1,n1.execute(res,priority=0))
305 activate(n2,n2.execute(res,priority=1),at=15)
306 simulate(until=100)
307
309 """Test preemption of preemptor"""
310 class nuJob(Process):
311 seqOut=[]
312 def __init__(self,name):
313 Process.__init__(self,name)
314 self.serviceTime=30
315
316 def execute(self,res,priority):
317 self.preempt=len(res.activeQ) > 0 and priority > res.activeQ[-1]._priority[res]
318 nrwaiting=len(res.waitQ)
319 yield request,self,res,priority
320 if self.preempt:
321 assert len(res.waitQ) == nrwaiting + 1, "No preemption "+"activeQ= "+str(res.activeQ[0].name)
322 yield hold,self,self.serviceTime
323 yield release,self,res
324 nuJob.seqOut.append((self,now()))
325
326 initialize()
327 res=Resource(name="server",capacity=1,qType=PriorityQ,preemptable=1)
328 n1=nuJob(name="nuJob 1")
329 n2=nuJob(name="nuJob 2")
330 n3=nuJob(name="nuJob 3")
331 activate(n1,n1.execute(res,priority=-1))
332 start2=10
333 activate(n2,n2.execute(res,priority=0),at=start2)
334 start3=20
335 activate(n3,n3.execute(res,priority=1),at=start3)
336 simulate(until=100)
337 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])
338
339
341 """ test monitoring of number in the two queues, waitQ and activeQ
342 """
343 class Job(Process):
344 def __init__(self,name):
345 Process.__init__(self,name)
346
347 def execute(self,res):
348 yield request,self,res
349 yield hold,self,2
350 yield release,self,res
351
352 initialize()
353 res=Resource(name="server",capacity=1,monitored=1)
354 n1=Job(name="Job 1")
355 n2=Job(name="Job 2")
356 n3=Job(name="Job 3")
357 activate(n1,n1.execute(res),at=2)
358 activate(n2,n2.execute(res),at=2)
359 activate(n3,n3.execute(res),at=2)
360 simulate(until=100)
361 assert res.waitMon == [[2, 1], [2, 2], [4, 1], [6, 0]],'Wrong waitMon:%s'%res.waitMon
362 assert res.actMon == [[2, 1], [4, 0], [4, 1], [6, 0], [6, 1], [8, 0]],'Wrong actMon:%s'%res.actMon
363
364 assert res.waitMon.timeAverage() == (0*2+2*2+1*2)/8.0,'Wrong waitMon.timeAverage:%s'%res.waitMon.timeAverage()
365
366
383
384
385
386
387
388
389
393
394 - def breakin(self,waitbefore,howoften=1):
395 for i in range(howoften):
396 yield hold,self,waitbefore
397 self.interrupt(victim)
398
402
404 global igothit
405 igothit={}
406 while now()<=theEnd:
407 yield hold,self,howlong
408 if self.interrupted():
409 byWhom=self.interruptCause
410 igothit[now()]=byWhom
411 else:
412 pass
413
415 """
416 Tests interrupts as defined in SEP001v17
417 """
419 """
420 Test single interrupt during victim activity
421 """
422 global victim
423 initialize()
424 breaker=Interruptor()
425 activate(breaker,breaker.breakin(10))
426 victim=Interrupted()
427 activate(victim,victim.myActivity(100))
428 simulate(until=200)
429 assert igothit[10] == breaker, "Not interrupted at 10 by breaker"
430 assert len(igothit) == 1 , "Interrupted more than once"
431
433 """
434 Test multiple interrupts during victim activity
435 """
436 global victim
437 initialize()
438 breaker=Interruptor()
439 activate(breaker,breaker.breakin(10,howoften=3))
440 victim=Interrupted()
441 activate(victim,victim.myActivity(100))
442 simulate(until=200)
443 for i in (10,20,30):
444 assert igothit[i] == breaker, "Not interrupted at %s by breaker" %i
445 assert len(igothit) == 3 , "Interrupted wrong number of times"
446
459
461 """
462 Test multiple interrupts by multiple processes during victim activity
463 """
464 global victim
465 initialize()
466 breaker1=Interruptor()
467 activate(breaker1,breaker1.breakin(15,howoften=3))
468 breaker2=Interruptor()
469 activate(breaker2,breaker2.breakin(20,howoften=3))
470 victim=Interrupted()
471 activate(victim,victim.myActivity(100))
472 simulate(until=200)
473 for i in (15,30,45):
474 assert igothit[i] == breaker1, "Not interrupted at %s by breaker1" %i
475 for i in (20,40,60):
476 assert igothit[i] == breaker2, "Not interrupted at %s by breaker2" %i
477 assert len(igothit) == 6 , "Interrupted wrong number of times"
478
495
496 victim.newProcess=newProcess
497 activate(victim,newProcess(victim))
498 activate(breaker,breaker.breakin(10,howoften=3))
499 simulate(until=1000)
500
510
511
512
513
514
526
530
532 assert p.active(),"p not active"
533 assert not p.passive(), "p passive"
534 assert not p.terminated(),"p terminated"
535 assert not p.interrupted(),"p interrupted"
536 yield hold,self,11
537 assert not p.active(),"p active"
538 assert not p.passive(),"p passive"
539 assert p.terminated(),"p not terminated"
540 assert not p.interrupted(),"p interrupted"
541
543 assert not p.active(),"p active"
544 assert p.passive(),"p not passive"
545 assert not p.terminated(),"p not terminated"
546 assert not p.interrupted(),"p interrupted"
547 activate(p,p.life1())
548 yield hold,self,11
549 assert not p.active(),"p active"
550 assert not p.passive(),"p not passive"
551 assert p.terminated(),"p not terminated"
552 assert not p.interrupted(),"p interrupted"
553
555 assert not p.active(),"p active"
556 assert p.passive(),"p not passive"
557 assert not p.terminated(),"p not terminated"
558 assert not p.interrupted(),"p interrupted"
559 activate(p,p.life2())
560 yield hold,self,11
561 assert not p.active(),"p active"
562 assert p.passive(),"p not passive"
563 assert not p.terminated(),"p terminated"
564 assert not p.interrupted(),"p interrupted"
565
567 yield hold,self,5
568 assert p.active(),"p not active"
569 assert not p.passive(),"p passive"
570 assert not p.terminated(),"p terminated"
571 assert not p.interrupted(),"p interrupted"
572 self.cancel(p)
573 assert not p.active(),"p active"
574 assert p.passive(),"p not passive"
575 assert not p.terminated(),"p terminated"
576 assert not p.interrupted(),"p interrupted"
577 reactivate(p)
578 assert p.active(),"p not active"
579 assert not p.passive(),"p passive"
580 assert not p.terminated(),"p terminated"
581 assert not p.interrupted(),"p interrupted"
582 yield hold,self
583 assert not p.active(),"p active"
584 assert not p.passive(),"p passive"
585 assert p.terminated(),"p terminated"
586 assert not p.interrupted(),"p interrupted"
587
589 yield hold,self,11
590 assert not p.active(),"p active"
591 assert p.passive(),"p not passive"
592 assert not p.terminated(),"p terminated"
593 assert not p.interrupted(),"p interrupted"
594 self.cancel(p)
595 assert not p.active(),"p active"
596 assert p.passive(),"p not passive"
597 assert not p.terminated(),"p terminated"
598 assert not p.interrupted(),"p interrupted"
599
617
621
622 - def look1(self,p1,p2,res):
623 assert p1.active(), "p1 not active"
624 assert not p1.queuing(res), "p1 queuing"
625 assert p2.active(), "p2 noit active"
626 assert not p2.queuing(res), "p2 queuing"
627 yield hold,self,2
628 assert p1.active(), "p1 not active"
629 assert not p1.queuing(res), "p1 queuing"
630 assert p2.passive(), "p2 active"
631 assert p2.queuing(res), "p2 not queuing"
632
641
643 """
644 Tests states and state transitions as defined in SEP003
645 """
646
658
675
695
719
720
721
730
731
732
733
734
737 yield hold,self,1
738 ev1.signal("from SignalProcess")
739 while ev2.queues:
740 nq0=len(ev2.queues)
741 ev2.signal("from SignalProcess")
742 assert len(ev2.queues)==(nq0-1),"wrong number of processes dequeued"
743
746 yield waitevent,self,ev1
747 assert ev1.waits==[],"not all processes waiting for event out of waiting list"
748 assert ev1 in self.eventsFired,"did not record firing event"
749
752 yield queueevent,self,ev2
753 assert ev2 in self.eventsFired,"did not record firing event"
754
757 yield hold,self,1
758 ev1.signal("from SignalProcess")
759 yield hold,self,3
760 assert len(ev2.queues)==QueueProcessOR.nrProcesses,"wrong number of processes queuing for event ev2"
761 while ev2.queues:
762 nq0=len(ev2.queues)
763 ev2.signal("from SignalProcess")
764 assert len(ev2.queues)==(nq0-1),"wrong number of processes dequeued"
765 assert not ev2.queues,"not all processes queuing for ev2 dequeued"
766
769 yield waitevent,self,evset
770 for e in evset:
771 assert e.waits==[],"process not out of waiting list for all events in OR"
772
781
782
784 nrProcesses=0
789 yield queueevent,self,evset
790 occurred=False
791 for e in evset:
792 occurred=occurred or (e in self.eventsFired)
793 assert occurred,"queuing process activated by wrong event(s)"
794
797 e1=SimEvent()
798 e1.signal()
799 e2=SimEvent()
800 e2.signal()
801 yield queueevent,self,[e1,e2]
802 assert self.eventsFired==[e1,e2],\
803 "(queueevent) eventsFired does not report all fired events"
804
806 """
807 Test SimEvent/signal as introduced with SimPy 1.5
808 """
809
811 """
812 Tests basic signal semantics
813 """
814 e=SimEvent()
815 e.signal("param")
816 assert e.occurred,"signal does not set 'occurred' to True"
817 assert e.signalparam=="param","signal parameter wrong"
818 e.signal()
819 assert e.signalparam is None,"signal with no parameter did not overwrite signalparam"
820 e.signal()
821 assert e.occurred,"multiple calls to signal do not set 'occurred'"
822
838
855
863
871
881
882
883
884
885
896
899 def waitcond():
900 return a and b and c
901 yield waituntil,self,waitcond
902
904 """
905 Test waituntil as introduced with SimPy 1.5
906 """
907
917
923
924
925
926
927
928
929
930
931
932
933
935 """ Job class for testing timeout reneging
936 """
937 - def __init__(self,server=None,name=""):
938 Process.__init__(self,name)
939 self.res=server
940 self.gotResource=None
941
942 - def execute(self,timeout,usetime):
943 yield (request,self,self.res),(hold,self,timeout)
944 if self.acquired(self.res):
945 self.gotResource=True
946 yield hold,self,usetime
947 yield release,self,self.res
948 else:
949 self.gotResource=False
950
952 """ Job class for testing timeout reneging with priorities
953 """
954 - def __init__(self,server=None,name=""):
955 Process.__init__(self,name)
956 self.res=server
957 self.gotResource=None
958
959 - def execute(self,timeout,usetime,priority):
960 yield (request,self,self.res,priority),(hold,self,timeout)
961 if self.acquired(self.res):
962 self.gotResource=True
963 yield hold,self,usetime
964 yield release,self,self.res
965 else:
966 self.gotResource=False
967
969 """ Tests of "yield (request,self,res),(hold,self,delay)"
970 timeout reneging command
971 """
973 """Test that resource gets acquired without timeout
974 """
975 res=Resource(name="Server",capacity=1)
976 initialize()
977 usetime=5
978 timeout=1000000
979 j1=JobTO(server=res,name="Job_1")
980 activate(j1,j1.execute(timeout=timeout,usetime=usetime))
981 j2=JobTO(server=res,name="Job_2")
982 activate(j2,j2.execute(timeout=timeout,usetime=usetime))
983 simulate(until=2*usetime)
984 assert now()==2*usetime,"time not ==2*usetime"
985 assert j1.gotResource and j2.gotResource,\
986 "at least one job failed to get resource"
987 assert not (res.waitQ or res.activeQ),\
988 "job waiting or using resource"
989
991 """Test that resource gets acquired without timeout.
992 Resource monitored.
993 """
994 res=Resource(name="Server",capacity=1,monitored=True)
995 initialize()
996 usetime=5
997 timeout=1000000
998 j1=JobTO(server=res,name="Job_1")
999 activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1000 j2=JobTO(server=res,name="Job_2")
1001 activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1002 simulate(until=2*usetime)
1003 assert now()==2*usetime,"time not ==2*usetime"
1004 assert j1.gotResource and j2.gotResource,\
1005 "at least one job failed to get resource"
1006 assert not (res.waitQ or res.activeQ),\
1007 "job waiting or using resource"
1008 assert res.waitMon==[[0,1],[usetime,0]],"res.waitMon wrong: %s"%res.waitMon
1009
1011 """Test that timeout occurs when resource busy
1012 """
1013 res=Resource(name="Server",capacity=1)
1014 initialize()
1015 usetime=5
1016 timeout=3
1017 j1=JobTO(server=res,name="Job_1")
1018 activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1019 j2=JobTO(server=res,name="Job_2")
1020 activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1021 simulate(until=2*usetime)
1022 assert(now()==usetime),"time not ==usetime"
1023 assert(j1.gotResource),"Job_1 did not get resource"
1024 assert(not j2.gotResource),"Job_2 did not renege"
1025 assert not (res.waitQ or res.activeQ),\
1026 "job waiting or using resource"
1027
1029 """Test that timeout occurs when resource busy.
1030 Resource monitored.
1031 """
1032 res=Resource(name="Server",capacity=1,monitored=True)
1033 initialize()
1034 usetime=5
1035 timeout=3
1036 j1=JobTO(server=res,name="Job_1")
1037 activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1038 j2=JobTO(server=res,name="Job_2")
1039 activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1040 simulate(until=2*usetime)
1041 assert(now()==usetime),"time not == usetime"
1042 assert(j1.gotResource),"Job_1 did not get resource"
1043 assert(not j2.gotResource),"Job_2 did not renege"
1044 assert not (res.waitQ or res.activeQ),\
1045 "job waiting or using resource"
1046 assert res.waitMon==[[0,1],[timeout,0]],"res.waitMon wrong: %s"%res.waitMon
1047
1049 """Test that timeout occurs when resource busy.
1050 Resource monitored. Requests with priority and preemption.
1051 """
1052 res=Resource(name="Server",capacity=1,monitored=True,qType=PriorityQ,preemptable=True)
1053 initialize()
1054 usetime=5
1055 timeout=3
1056 j1=JobTO_P(server=res,name="Job_1")
1057 activate(j1,j1.execute(timeout=timeout,usetime=usetime,priority=1))
1058 j2=JobTO_P(server=res,name="Job_2")
1059 j2_arrival=1
1060 activate(j2,j2.execute(timeout=timeout,usetime=usetime,priority=5),at=j2_arrival)
1061 j3=JobTO_P(server=res,name="Job_2")
1062 j3_arrival=2
1063 activate(j3,j3.execute(timeout=timeout,usetime=usetime,priority=10),at=j3_arrival)
1064 simulate(until=3*usetime)
1065 assert(now()== 3*usetime),"time not == 2* usetime, but %s"%now()
1066 assert(j1.gotResource),"Job_1 did not get resource"
1067 assert(j2.gotResource),"Job_2 did renege"
1068 assert(j2.gotResource),"Job_3 did renege"
1069 assert not (res.waitQ or res.activeQ),\
1070 "job waiting or using resource"
1071 assert res.waitMon==[[j2_arrival,1],[j3_arrival,2],[usetime+j3_arrival,1],[usetime+j2_arrival+usetime,0]],\
1072 "res.waitMon wrong: %s"%res.waitMon
1073
1075 """Test that timeout occurs when resource has no capacity free
1076 """
1077 res=Resource(name="Server",capacity=0)
1078 initialize()
1079 usetime=5
1080 timeout=3
1081 j1=JobTO(server=res,name="Job_1")
1082 activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1083 j2=JobTO(server=res,name="Job_2")
1084 activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1085 simulate(until=2*usetime)
1086 assert now()==timeout,"time %s not == timeout"%now()
1087 assert not j1.gotResource,"Job_1 got resource"
1088 assert not j2.gotResource,"Job_2 got resource"
1089 assert not (res.waitQ or res.activeQ),\
1090 "job waiting or using resource"
1091
1093 """Test that timeout occurs when resource has no capacity free.
1094 Resource monitored.
1095 """
1096 res=Resource(name="Server",capacity=0,monitored=True)
1097 initialize()
1098 usetime=5
1099 timeout=3
1100 j1=JobTO(server=res,name="Job_1")
1101 activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1102 j2=JobTO(server=res,name="Job_2")
1103 activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1104 simulate(until=2*usetime)
1105 assert now()==timeout,"time %s not == timeout"%now()
1106 assert not j1.gotResource,"Job_1 got resource"
1107 assert not j2.gotResource,"Job_2 got resource"
1108 assert not (res.waitQ or res.activeQ),\
1109 "job waiting or using resource"
1110 assert res.waitMon==[[0,1],[0,2],[timeout,1],[timeout,0]],\
1111 "res.waitMon is wrong: %s"%res.waitMon
1112
1126
1127
1128
1129
1130
1131
1132
1133
1135 """ Job class for testing event reneging
1136 """
1137 - def __init__(self,server=None,name=""):
1138 Process.__init__(self,name)
1139 self.res=server
1140 self.gotResource=None
1141
1143 yield (request,self,self.res),(waitevent,self,event)
1144 if self.acquired(self.res):
1145 self.gotResource=True
1146 yield hold,self,usetime
1147 yield release,self,self.res
1148 else:
1149 self.gotResource=False
1150
1152 """ Job class for testing event reneging with multi-event lists
1153 """
1154 - def __init__(self,server=None,name=""):
1155 Process.__init__(self,name)
1156 self.res=server
1157 self.gotResource=None
1158
1159 - def execute(self,eventlist,usetime):
1160 yield (request,self,self.res),(waitevent,self,eventlist)
1161 if self.acquired(self.res):
1162 self.gotResource=True
1163 yield hold,self,usetime
1164 yield release,self,self.res
1165 else:
1166 self.gotResource=False
1167
1169 """Fires reneging event
1170 """
1171 - def fire(self,fireDelay,event):
1172 yield hold,self,fireDelay
1173 event.signal()
1174
1176 """Tests of "yield (request,self,res),(waiteevent,self,event)"
1177 event reneging command
1178 """
1180 """Test that processes acquire resource normally if no event fires
1181 """
1182 res=Resource(name="Server",capacity=1)
1183 event=SimEvent("Renege_trigger")
1184 initialize()
1185 usetime=5
1186 j1=JobEvt(server=res,name="Job_1")
1187 activate(j1,j1.execute(event=event,usetime=usetime))
1188 j2=JobEvt(server=res,name="Job_2")
1189 activate(j2,j2.execute(event=event,usetime=usetime))
1190 simulate(until=2*usetime)
1191
1192 assert now()==2*usetime,"time not ==2*usetime"
1193 assert j1.gotResource and j2.gotResource,\
1194 "at least one job failed to get resource"
1195 assert not (res.waitQ or res.activeQ),\
1196 "job waiting or using resource"
1197
1199 """Test that processes acquire resource normally if no event fires.
1200 Resource monitored.
1201 """
1202 res=Resource(name="Server",capacity=1,monitored=True)
1203 event=SimEvent("Renege_trigger")
1204 initialize()
1205 usetime=5
1206 j1=JobEvt(server=res,name="Job_1")
1207 activate(j1,j1.execute(event=event,usetime=usetime))
1208 j2=JobEvt(server=res,name="Job_2")
1209 activate(j2,j2.execute(event=event,usetime=usetime))
1210 simulate(until=2*usetime)
1211
1212 assert now()==2*usetime,"time not ==2*usetime"
1213 assert j1.gotResource and j2.gotResource,\
1214 "at least one job failed to get resource"
1215 assert not (res.waitQ or res.activeQ),\
1216 "job waiting or using resource"
1217 assert res.waitMon==[[0,1],[usetime,0]],"res.waitMoni is wrong: %s"%res.waitMon
1218
1220 """Test that signalled event leads to renege when resource busy
1221 """
1222 res=Resource(name="Server",capacity=1)
1223 initialize()
1224 event=SimEvent("Renege_trigger")
1225 usetime=5
1226 eventtime=1
1227 j1=JobEvt(server=res,name="Job_1")
1228 activate(j1,j1.execute(event=event,usetime=usetime))
1229 j2=JobEvt(server=res,name="Job_2")
1230 activate(j2,j2.execute(event=event,usetime=usetime))
1231 f=FireEvent(name="FireEvent")
1232 activate(f,f.fire(fireDelay=eventtime,event=event))
1233 simulate(until=2*usetime)
1234
1235 assert(now()==usetime),"time not ==usetime"
1236 assert(j1.gotResource),"Job_1 did not get resource"
1237 assert(not j2.gotResource),"Job_2 did not renege"
1238 assert not (res.waitQ or res.activeQ),\
1239 "job waiting or using resource"
1240
1242 """Test that signalled event leads to renege when resource busy.
1243 Resource monitored.
1244 """
1245 res=Resource(name="Server",capacity=1,monitored=True)
1246 initialize()
1247 event=SimEvent("Renege_trigger")
1248 usetime=5
1249 eventtime=1
1250 j1=JobEvt(server=res,name="Job_1")
1251 activate(j1,j1.execute(event=event,usetime=usetime))
1252 j2=JobEvt(server=res,name="Job_2")
1253 activate(j2,j2.execute(event=event,usetime=usetime))
1254 f=FireEvent(name="FireEvent")
1255 activate(f,f.fire(fireDelay=eventtime,event=event))
1256 simulate(until=2*usetime)
1257
1258 assert(now()==usetime),"time not ==usetime"
1259 assert(j1.gotResource),"Job_1 did not get resource"
1260 assert(not j2.gotResource),"Job_2 did not renege"
1261 assert not (res.waitQ or res.activeQ),\
1262 "job waiting or using resource"
1263 assert res.waitMon==[[0,1],[eventtime,0]],"res.waitMon is wrong: %s"%res.waitMon
1264
1266 """Test that renege-triggering event can be one of an event list
1267 """
1268 res=Resource(name="Server",capacity=1)
1269 initialize()
1270 event1=SimEvent("Renege_trigger_1")
1271 event2=SimEvent("Renege_trigger_2")
1272 usetime=5
1273 eventtime=1
1274 j1=JobEvtMulti(server=res,name="Job_1")
1275 activate(j1,j1.execute(eventlist=[event1,event2],usetime=usetime))
1276 j2=JobEvtMulti(server=res,name="Job_2")
1277 activate(j2,j2.execute(eventlist=[event1,event2],usetime=usetime))
1278 f1=FireEvent(name="FireEvent_1")
1279 activate(f1,f1.fire(fireDelay=eventtime,event=event1))
1280 f2=FireEvent(name="FireEvent_2")
1281 activate(f2,f2.fire(fireDelay=eventtime,event=event2))
1282 simulate(until=2*usetime)
1283
1284 assert(now()==usetime),"time not ==usetime"
1285 assert(j1.gotResource),"Job_1 did not get resource"
1286 assert(not j2.gotResource),"Job_2 did not renege"
1287 assert not (res.waitQ or res.activeQ),\
1288 "job waiting or using resource"
1289
1291 """Test that renege-triggering event can be one of an event list.
1292 Resource monitored.
1293 """
1294 res=Resource(name="Server",capacity=1,monitored=True)
1295 initialize()
1296 event1=SimEvent("Renege_trigger_1")
1297 event2=SimEvent("Renege_trigger_2")
1298 usetime=5
1299 eventtime=1
1300 j1=JobEvtMulti(server=res,name="Job_1")
1301 activate(j1,j1.execute(eventlist=[event1,event2],usetime=usetime))
1302 j2=JobEvtMulti(server=res,name="Job_2")
1303 activate(j2,j2.execute(eventlist=[event1,event2],usetime=usetime))
1304 f1=FireEvent(name="FireEvent_1")
1305 activate(f1,f1.fire(fireDelay=eventtime,event=event1))
1306 f2=FireEvent(name="FireEvent_2")
1307 activate(f2,f2.fire(fireDelay=eventtime,event=event2))
1308 simulate(until=2*usetime)
1309
1310 assert(now()==usetime),"time not ==usetime"
1311 assert(j1.gotResource),"Job_1 did not get resource"
1312 assert(not j2.gotResource),"Job_2 did not renege"
1313 assert not (res.waitQ or res.activeQ),\
1314 "job waiting or using resource"
1315 assert res.waitMon==[[0,1],[eventtime,0]],"res.waitMon is wrong: %s"%res.waitMon
1316
1329
1330
1331
1332
1333
1334
1335
1337 produced=0
1344 """PriorityQ for Producers"""
1345 Producer.produced+=4
1346 yield put,self,buffer,4,priority
1347 yield hold,self,1
1348 self.done=now()
1349 doneList.append(self.name)
1351 for i in range(4):
1352 yield put,self,buffer,4
1353 yield hold,self,1
1355 consumed=0
1357 """FIFO"""
1358 yield get,self,buffer
1359 Consumer.consumed+=1
1360 assert self.got==1,"wrong self.got: %s"%self.got
1361 yield get,self,buffer,3
1362 Consumer.consumed+=3
1363 assert self.got==3,"wrong self.got: %s"%self.got
1364
1366 """producer PriorityQ, consumer FIFO"""
1367 while True:
1368 yield get,self,buffer,2
1369 yield hold,self,1
1371 """PriorityQ for Consumers"""
1372 yield get,self,buffer,4,priority
1373 doneList.append(self.name)
1374
1375
1377 - def produce(self,buffer,productionTime):
1378 while True:
1379 assert not(buffer.amount>0 and len(buffer.getQ)>0),\
1380 "Consumer(s) waiting while buffer not empty"
1381 yield hold,self,productionTime
1382 yield put,self,buffer,1
1383
1385 - def consume(self,buffer,consumptionTime):
1386 while True:
1387 assert not(buffer.amount==0 and len(buffer.putQ)>0),\
1388 "Producer(s) waiting while buffer empty"
1389 yield get,self,buffer,1
1390 yield hold,self,consumptionTime
1391
1392
1393
1396 """Tests initialization of Level instances
1397 """
1398 a=Level()
1399 assert a.capacity==sys.maxint,"wrong capacity:%s"%a
1400 assert a.amount==0,"wrong buffer content: %s"%a
1401 assert a.name=="a_level","wrong name: %s"%a
1402 assert not a.monitored,"should not be monitored: %s"%a
1403 assert a.putQMon is None,"should not have putQMon: %s"%a
1404 assert a.getQMon is None,"should not have getQMon: %s"%a
1405 assert a.bufferMon is None,"should not have bufferMon: %s"%a
1406 assert a.putQType.__name__=="FIFO" and a.getQType.__name__=="FIFO",\
1407 "putQType and getQType should be FIFO: %s"%a
1408
1409 b=Level(name="b",initialBuffered=10.0,monitored=True,capacity=12,
1410 putQType=PriorityQ)
1411 a=Level()
1412 assert b.capacity==12,"wrong capacity:%s"%b
1413 assert b.amount==10,"wrong buffer content: %s"%b
1414 assert b.name=="b","wrong name: %s"%b
1415 assert b.monitored,"should be monitored: %s"%b
1416 assert not (b.putQMon is None),"should have putQMon: %s"%b
1417 assert not (b.getQMon is None),"should have getQMon: %s"%b
1418 assert not (b.bufferMon is None),"should have bufferMon: %s"%b
1419 assert b.putQType.__name__=="PriorityQ",\
1420 "putQType should be PriorityQ: %s"%b
1421 assert b.getQType.__name__=="FIFO",\
1422 "getQType should be PriorityQ: %s"%b
1423
1425 """Level: tests basic Producer/Consumer principles:
1426 - Consumers must not be waiting while Level buffer value > 0,
1427 - Producers must not be waiting while Level buffer value == 0
1428 """
1429 bufferSize=1
1430 productionTime=1
1431 consumptionTime=5
1432 endtime=50
1433
1434 initialize()
1435 buffer=Level(capacity=bufferSize)
1436 consumer=ConsumerPrincL()
1437 activate(consumer,consumer.consume(buffer,consumptionTime))
1438 producer=ProducerPrincL()
1439 activate(producer,producer.produce(buffer,productionTime))
1440 simulate(until=endtime)
1441
1454
1471
1473 """Level: tests put/get in multiple Producer/Consumer scenario,
1474 with Producers having different priorities.
1475 How: Producers forced to queue; all after first should be done in
1476 priority order
1477 """
1478 global doneList
1479 doneList=[]
1480 initialize()
1481 buffer=Level(capacity=7,putQType=PriorityQ,monitored=True)
1482 for i in range(4):
1483 p=Producer(i)
1484 pPriority=i
1485 activate(p,p.producePriority(buffer=buffer,priority=pPriority))
1486 c=Consumer()
1487 activate(c,c.consume1(buffer=buffer))
1488 simulate(until=100)
1489 assert doneList==[0,3,2,1],"puts were not done in priority order: %s"\
1490 %doneList
1491
1493 """Level: tests put/get in multiple Producer/Consumer scenario, with
1494 Consumers having different priorities.
1495 How: Consumers forced to queue; all after first should be done in
1496 priority order
1497 """
1498 global doneList
1499 doneList=[]
1500 initialize()
1501 buffer=Level(capacity=7,getQType=PriorityQ,monitored=True)
1502 for i in range(4):
1503 c=Consumer(i)
1504 cPriority=i
1505 activate(c,c.consumePriority(buffer=buffer,priority=cPriority))
1506 p=Producer()
1507 activate(p,p.produce1(buffer=buffer))
1508 simulate(until=100)
1509 assert doneList==[3,2,1,0],"gets were not done in priority order: %s"\
1510 %doneList
1511
1524
1525
1526
1527
1528
1529
1530
1553
1579
1583
1585 """Sorts Widget instances by weight attribute."""
1586 tmplist=[(x.weight,x) for x in par]
1587 tmplist.sort()
1588 return [x for (key,x) in tmplist]
1589
1590
1592 - def produce(self,buffer,productionTime):
1593 while True:
1594 assert not(buffer.nrBuffered>0 and len(buffer.getQ)>0),\
1595 "Consumer(s) waiting while buffer not empty"
1596 yield hold,self,productionTime
1597 product=WidgetPrinc()
1598 yield put,self,buffer,[product]
1599
1601 - def consume(self,buffer,consumptionTime):
1602 while True:
1603 assert not(buffer.nrBuffered==0 and buffer.putQ),\
1604 "Producer(s) waiting while buffer empty"
1605 yield get,self,buffer,1
1606 yield hold,self,consumptionTime
1607
1609 pass
1610
1612 """Used in testBufferFilter"""
1616
1618 """get all items with weight between a and b"""
1619 def between_a_and_b(buf):
1620 res=[]
1621 for item in buf:
1622 if a<item.weight<b:
1623 res.append(item)
1624
1625 all=store.buffered
1626 yield get,self,store,between_a_and_b
1627 "All retrieved items weight in range?"
1628 for it in self.got:
1629 assert a<it.weight<b,"weight %s not in range %s..%s"\
1630 %(it.weight,a,b)
1631 "Any item fitting filter pred left in buffer?"
1632 for it in store.buffer:
1633 assert not (a<it.weight<b),\
1634 "item left in buffer which fits filter (%s<%s<%s)"\
1635 %(a,it.weight,b)
1636 "All items either in store.buffer of self.got?"
1637 for it in all:
1638 assert (it in self.buffer) or (it in self.got),\
1639 "item w. weight %s neither in store nor in got"%it.weight
1640
1641
1642
1645 """Store: tests initialization of Store instances
1646 """
1647 a=Store()
1648 assert a.capacity==sys.maxint,"wrong capacity:%s"%a
1649 assert a.nrBuffered==0,"wrong buffer content: %s"%a
1650 assert a.name=="a_store","wrong name: %s"%a
1651 assert not a.monitored,"should not be monitored: %s"%a
1652 assert a.putQMon is None,"should not have putQMon: %s"%a
1653 assert a.getQMon is None,"should not have getQMon: %s"%a
1654 assert a.bufferMon is None,"should not have bufferMon: %s"%a
1655 assert a.putQType.__name__=="FIFO" and a.getQType.__name__=="FIFO",\
1656 "putQType and getQType should be FIFO: %s"%a
1657
1658 stored=[Widget(weight=5)]*10
1659 b=Store(name="b",initialBuffered=stored,monitored=True,capacity=12,
1660 putQType=PriorityQ)
1661 assert b.capacity==12,"wrong capacity:%s"%b
1662 assert b.nrBuffered==10,"wrong buffer content: %s"%b
1663 assert b.name=="b","wrong name: %s"%b
1664 assert b.monitored,"should be monitored: %s"%b
1665 assert not (b.putQMon is None),"should have putQMon: %s"%b
1666 assert not (b.getQMon is None),"should have getQMon: %s"%b
1667 assert not (b.bufferMon is None),"should have bufferMon: %s"%b
1668 assert b.putQType.__name__=="PriorityQ",\
1669 "putQType should be PriorityQ: %s"%b
1670 assert b.getQType.__name__=="FIFO",\
1671 "getQType should be PriorityQ: %s"%b
1672
1674 """Store: tests basic Producer/Consumer principles:
1675 - Consumers must not be waiting while items in Store buffer,
1676 - Producers must not be waiting while space available in Store buffer
1677 """
1678 bufferSize=1
1679 productionTime=1
1680 consumptionTime=5
1681 endtime=50
1682
1683 initialize()
1684 buffer=Store(capacity=bufferSize)
1685 consumer=ConsumerPrincS()
1686 activate(consumer,consumer.consume(buffer,consumptionTime))
1687 producer=ProducerPrincS()
1688 activate(producer,producer.produce(buffer,productionTime))
1689 simulate(until=endtime)
1690
1704
1721
1723 """Store: Tests put/get in multiple Producer/Consumer scenario,
1724 with Producers having different priorities.
1725 How; Producers forced to queue; all after first should be done in
1726 priority order
1727 """
1728 global doneList
1729 doneList=[]
1730 initialize()
1731 buffer=Store(capacity=7,putQType=PriorityQ,monitored=True)
1732 for i in range(4):
1733 p=ProducerWidget(i)
1734 pPriority=i
1735 activate(p,p.producePriority(buffer=buffer,priority=pPriority))
1736 c=ConsumerWidget()
1737 activate(c,c.consume1(buffer=buffer))
1738 simulate(until=100)
1739 assert doneList==[0,3,2,1],"puts were not done in priority order: %s"\
1740 %doneList
1741
1743 """Tests put/get in multiple Producer/Consumer scenario, with
1744 Consumers having different priorities.
1745 How; Consumers forced to queue; all after first should be done in
1746 priority order
1747 """
1748 global doneList
1749 doneList=[]
1750 initialize()
1751 buffer=Store(capacity=7,getQType=PriorityQ,monitored=True)
1752 for i in range(4):
1753 c=ConsumerWidget(str(i))
1754 cPriority=i
1755 activate(c,c.consumePriority(buffer=buffer,priority=cPriority))
1756 p=ProducerWidget()
1757 activate(p,p.produce1(buffer=buffer))
1758 simulate(until=100)
1759 assert doneList==["3","2","1","0"],\
1760 "gets were not done in priority order: %s"%doneList
1761
1763 """Tests the optional sorting of theBuffer by applying a user-defined
1764 sort function."""
1765 initialize()
1766 gotten=[]
1767 sortedStore=Store()
1768 sortedStore.addSort(mySortFunc)
1769 p=ProducerWidget()
1770 activate(p,p.produceUnordered(sortedStore))
1771 for i in range(9):
1772 c=ConsumerWidget()
1773 activate(c,c.consumeSorted(buffer=sortedStore,gotten=gotten),at=1)
1774 simulate(until=10)
1775 assert gotten==[1,2,3,4,5,6,7,8,9],"sort wrong: %s"%gotten
1776
1788
1804
1805
1806
1807
1808
1809
1810 -class TBT(Process):
1811 """Store: For testBasicTime"""
1812 - def tbt(self,store):
1813 yield get,self,store,1
1814 assert self.got,"Did not get Item"
1815 yield (get,self,store,1),(hold,self,5)
1816 if self.acquired(store):
1817 assert len(self.got)==1,"did not get 1 Item"
1818 else:
1819 assert not self.got and now()==5 and not store.getQ,\
1820 "time renege not working"
1821
1822 -class TBE(Process):
1823 """Store: For testBasicEvent"""
1824 - def tbe(self,store,trigger):
1825 yield get,self,store,1
1826 assert self.got,"Did not get Item"
1827 yield (get,self,store,1),(waitevent,self,trigger)
1828 if self.acquired(store):
1829 assert False, "should have reneged"
1830 else:
1831 assert self.eventsFired[0]==trigger and now()==5 \
1832 and not store.getQ,"event renege not working"
1833
1835 """Store: For testBasicEvent"""
1836 - def fire(self,trigger):
1839
1841 """Store: Testcase for compound get statements"""
1842
1844 """Store: for testBasicTimePut"""
1845 - def tbt(self,store):
1846 class Item:pass
1847 yield (put,self,store,[Item()]),(hold,self,4)
1848 if self.stored(store):
1849 assert store.nrBuffered==1 and not store.putQ,\
1850 "put did not execute"
1851 else:
1852 assert False,"should not have reneged"
1853 yield (put,self,store,[Item()]),(hold,self,5)
1854 if self.stored(store):
1855 assert False,"should have reneged"
1856 else:
1857 assert store.nrBuffered==1 and not store.putQ,\
1858 "renege not working correctly"
1859
1861 """Store: for testBasicEventPut"""
1862 - def tbe(self,store,trigger):
1863 class Item:pass
1864 yield (put,self,store,[Item()]),(waitevent,self,trigger)
1865 if self.stored(store):
1866 assert store.nrBuffered==1 and not store.putQ,\
1867 "put did not execute"
1868 else:
1869 assert False,"should have not have reneged"
1870 yield (put,self,store,[Item()]),(waitevent,self,trigger)
1871 if self.stored(store):
1872 assert False,"should have reneged"
1873 else:
1874 assert now()==5 and self.eventsFired[0]==trigger\
1875 and not store.putQ,"renege not working correctly"
1876
1878 """Store: For testBasicEventPut"""
1879 - def fire(self,trigger):
1882
1884 """Store: Testcase for compound get statements"""
1885
1886
1887
1888
1889
1890
1892 """Store (unmonitored):
1893 test 'yield (get,self,store),(hold,self,timeout)"""
1894 class Item:pass
1895 initialize()
1896 st=Store(initialBuffered=[Item()])
1897 t=TBT()
1898 activate(t,t.tbt(store=st))
1899 simulate(until=10)
1900
1901
1902
1903
1904
1905
1906
1915
1917 """Store (monitored):
1918 test monitors with 'yield (put,self,store),(hold,self,time)"""
1919 initialize()
1920 st=Store(capacity=1,monitored=True)
1921 t=TBTput()
1922 activate(t,t.tbt(store=st))
1923 simulate(until=10)
1924
1925 assert st.putQMon==[[0,0],[0,1],[5,0]],"putQMon wrong: %s"\
1926 %st.putQMon
1927
1928 assert st.bufferMon==[[0,0],[0,1]],"bufferMon wrong: %s"%st.bufferMon
1929
1930
1931
1932
1933
1934
1935
1948
1949
1950
1951
1952
1953
1954
1966
1968 """Store (monitored):
1969 test monitors with 'yield (put,self,store),(waitevent,self,event)"""
1970 initialize()
1971 s=SimEvent()
1972 st=Store(capacity=1,monitored=True)
1973 t=TBEtriggerPut()
1974 activate(t,t.fire(trigger=s))
1975 tb=TBEput()
1976 activate(tb,tb.tbe(store=st,trigger=s))
1977 simulate(until=10)
1978
1979 assert st.putQMon==[[0,0],[0,1],[5,0]],"putQMon wrong: %s"\
1980 %st.putQMon
1981
1982 assert st.bufferMon==[[0,0],[0,1]],"bufferMon wrong: %s"%st.bufferMon
1983
2002
2003
2004
2005
2006
2007
2009 """Level: For testBasicTime"""
2010 - def tbt(self,level):
2011 yield get,self,level,1
2012 assert self.got,"did not get 1 unit"
2013 yield (get,self,level,1),(hold,self,5)
2014 if self.acquired(level):
2015 assert self.got==1,"did not get 1 unit"
2016 else:
2017 assert not self.got and now()==5,"time renege not working"
2018
2020 """Level: For testBasicEvent"""
2021 - def tbe(self,level,trigger):
2022 yield get,self,level,1
2023 assert self.got,"did not get 1 unit"
2024 yield (get,self,level,1),(waitevent,self,trigger)
2025 if self.acquired(level):
2026 assert self.got==1,"did not get 1 Item"
2027 else:
2028 assert now()==5.5 and self.eventsFired[0]==trigger,\
2029 "event renege not working"
2030
2032 """Level: For testBasicEvent"""
2033 - def fire(self,trigger):
2036
2038 """Level: For testBasicTimePut"""
2039 - def tbt(self,level):
2040 yield put,self,level,1
2041 assert level.amount,"did not put 1 unit"
2042 yield (put,self,level,1),(hold,self,5)
2043 if self.stored(level):
2044 assert False,"should have reneged"
2045 else:
2046 assert level.amount==1 and now()==5,"time renege not working"
2047
2049 """Level: For testBasicEventPut and testBasicEventPutM"""
2050 - def tbe(self,level,trigger):
2051 yield (put,self,level,1),(waitevent,self,trigger)
2052 if self.stored(level):
2053 assert level.amount==1,"did not put 1 unit"
2054 else:
2055 assert False,"should not have reneged"
2056 yield (put,self,level,1),(waitevent,self,trigger)
2057 if self.stored(level):
2058 assert False, "should have reneged"
2059 else:
2060 assert now()==5.5 and self.eventsFired[0]==trigger ,\
2061 "renege not working"
2062
2064 """Level: For testBasicEventPut"""
2065 - def fire(self,trigger):
2068
2070 """Level: Testcase for compound get and put statements"""
2071
2072
2073
2074
2075
2076
2078 """Level (unmonitored): test 'yield (get,self,level),(hold,self,timeout)"""
2079 initialize()
2080 l=Level(initialBuffered=1)
2081 t=TBTLev()
2082 activate(t,t.tbt(level=l))
2083 simulate(until=10)
2084
2085
2086
2087
2088
2089
2098
2099
2100
2101
2102
2103
2104
2116
2118 """Level (monitored):
2119 test monitors with 'yield (get,self,level),(waitevent,self,event)"""
2120 initialize()
2121 l=Level(initialBuffered=1,monitored=True)
2122 trig=SimEvent()
2123 t=TBELev()
2124 activate(t,t.tbe(level=l,trigger=trig))
2125 tr=TBEtriggerLev()
2126 activate(tr,tr.fire(trigger=trig))
2127 simulate(until=10)
2128
2129 assert l.getQMon==[[0,0],[0,1],[5.5,0]],"getQMon not working: %s"\
2130 %l.getQMon
2131
2132 assert l.bufferMon==[[0,1],[0,0]],\
2133 "bufferMon not working: %s"%l.bufferMon
2134
2135
2136
2137
2138
2139
2151
2153 """Level (monitored):
2154 test monitors with 'yield (put,self,level),(waitevent,self,event)"""
2155 initialize()
2156 l=Level(capacity=1,monitored=True)
2157 trig=SimEvent()
2158 t=TBELevPut()
2159 activate(t,t.tbe(level=l,trigger=trig))
2160 tr=TBEtriggerLevPut()
2161 activate(tr,tr.fire(trigger=trig))
2162 simulate(until=10)
2163 "First put succeeds, second reneges at t=5.5?"
2164 assert l.putQMon==[[0,0],[0,1],[5.5,0]],"putQMon wrong: %s"\
2165 %l.putQMon
2166 "1 unit added at t=0, renege at t=5 before 2nd unit added?"
2167 assert l.bufferMon==[[0,0],[0,1]],"bufferMon wrong: %s"%l.bufferMon
2168
2187
2188 if __name__ == '__main__':
2189 alltests = unittest.TestSuite((makeSSuite(),makeRSuite(),
2190 makeMSuite(),
2191 makeISuite(),makePSuite(),
2192 makeESuite(),makeWSuite(),
2193 makeTOSuite(),makeEvtRenegeSuite(),
2194 makeLevelSuite(),
2195 makeStoreSuite(),
2196 makeStoreCompSuite(),
2197 makeLevelCompSuite()
2198 ))
2199 runner = unittest.TextTestRunner()
2200 runner.run(alltests)
2201