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