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 2.0
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 # 2007 12 05 added tests for start method (Process)
38 # 2008 03 03 added test for nested preempts
39 # 2009 03 19 added SimulationRT OO API testing
40
41 #'$Revision: 265 $ $Date: 2009-03-22 22:13:56 +0100 (So, 22 Mrz 2009) $ kgm'
42
43 """
44 simulationRTVersion=version
45 print "Under test: SimulationRT.py %s"%simulationRTVersion
46 __version__ = '2.0 $Revision: 265 $ $Date: 2009-03-22 22:13:56 +0100 (So, 22 Mrz 2009) $ '
47 print 'testSimPyRTOO.py %s'%__version__
48
49
50
51
53 """ P class for testing"""
54 - def __init__(self,name="",T = 0,sim=None):
58
60 yield hold,self,self.T
61
63 """ PActions class for testing"""
64 - def __init__(self,name="",T = 0,sim=None):
67
69 yield hold,self,self.T
70
72 """ Tests of simulation
73 """
75 """Test initialisation
76 """
77 s=SimulationRT()
78 s.initialize()
79 result=s.simulate(until=10)
80 assert result=="SimPy: No activities scheduled",\
81 "There should have been no activities."
82 assert(s.now()==0),"time not 0"
83
93
103
113
115 """Test yield hold and simulate(until)
116 """
117 s=SimulationRT()
118 s.initialize()
119 P1 = P(name="P1",T=10,sim=s)
120 s.initialize()
121 s.activate(P1,P1.execute(),0)
122 s.simulate(until=5)
123 assert(s.now()==5),"Simulate stopped at %s not %s"%(s.now(),5)
124
125 P2 = P(name="P2",T=10,sim=s)
126 s.initialize()
127 s.activate(P2,P2.execute(),0)
128 s.simulate(until=20)
129 assert(s.now()==10),"P1 hold to %s not %s"%(s.now(),10)
130
141
142
143
144
145
147 """ Job class for testing"""
148 - def __init__(self,server=None,name="",sim=None):
151
154
156 """ First simple tests of Resources
157 """
159 """Test initialisation"""
160 s=SimulationRT()
161 s.initialize()
162 R = Resource(sim=s)
163 assert R.name == "a_resource", "Not null name"
164 assert R.capacity == 1, "Not unit capacity"
165 assert R.unitName =="units", "Not the correct unit name"
166 R = Resource(name='',capacity=1,sim=s)
167 assert R.name == "", "Not null name"
168 assert R.capacity == 1, "Not unit capacity"
169 assert R.unitName =="units", "Not the correct unit name"
170 R = Resource(capacity=3,name="3-version",unitName="blobs",sim=s)
171 assert R.name =="3-version" , "Wrong name, it is"+R.name
172 assert R.capacity == 3, "Not capacity 3, it is "+`R.capacity`
173 assert R.unitName =="blobs", "Not the correct unit name"
174
175 R = Resource(capacity=0,name="0-version",sim=s)
176 assert R.capacity ==0, "Not capacity 0, it is "+`R.capacity`
177
179 """Test request"""
180
181
182 s=SimulationRT()
183 s.initialize()
184 R0 = Resource(name='',capacity=0,sim=s)
185 assert R0.name == "", "Not null name"
186 assert R0.capacity == 0, "Not capacity 0, it is "+`R0.capacity`
187 R1 = Resource(capacity=0,name="3-version",unitName="blobs",sim=s)
188 J= Job(name="job",server=R1,sim=s)
189 s.activate(J,J.execute(), at=0.0)
190
191 s.simulate(until=10.0)
192 assert R1.n == 0 , "Should be 0, it is "+str(R1.n)
193 lenW = len(R1.waitQ)
194 assert lenW==1,"Should be 1, it is "+str(lenW)
195 assert len(R1.activeQ)==0,"len activeQ Should be 0, it is "+\
196 str(len(R1.activeQ))
197
199 """Test request2 with capacity = 1"""
200
201 s=SimulationRT()
202 s.initialize()
203 R2 = Resource(capacity=1,name="3-version",unitName="blobs",sim=s)
204 J2= Job(name="job",server=R2,sim=s)
205 s.activate(J2,J2.execute(), at=0.0)
206
207 s.simulate(until = 10.0)
208 assert R2.n == 0 , "Should be 0, it is "+str(R2.n)
209 lenW = len(R2.waitQ)
210 lenA = len(R2.activeQ)
211 assert lenW==0,"lenW Should be 0, it is "+str(lenW)
212 assert lenA==1,"lenA Should be 1, it is "+str(lenA)
213
215 """Test request3 with capacity = 1 several requests"""
216
217 s=SimulationRT()
218 s.initialize()
219 R3 = Resource(capacity=1,name="3-version",unitName="blobs",sim=s)
220 J2= Job(name="job",server=R3,sim=s)
221 J3= Job(name="job",server=R3,sim=s)
222 J4= Job(name="job",server=R3,sim=s)
223 s.activate(J2,J2.execute(), at=0.0)
224 s.activate(J3,J3.execute(), at=0.0)
225 s.activate(J4,J4.execute(), at=0.0)
226
227 s.simulate(until = 10.0)
228 assert R3.n == 0 , "Should be 0, it is "+str(R3.n)
229 lenW = len(R3.waitQ)
230 lenA = len(R3.activeQ)
231 assert lenW==2,"lenW Should be 2, it is "+str(lenW)
232 assert R3.waitQ==[J3,J4],"WaitQ wrong"+str(R3.waitQ)
233 assert lenA==1,"lenA Should be 1, it is "+str(lenA)
234 assert R3.activeQ==[J2],"activeQ wrong, it is %s"%str(R3.activeQ[0])
235
237 """Test request4 with capacity = 2 several requests"""
238
239 s=SimulationRT()
240 s.initialize()
241 R3 = Resource(capacity=2,name="4-version",unitName="blobs",sim=s)
242 J2= Job(name="job",server=R3,sim=s)
243 J3= Job(name="job",server=R3,sim=s)
244 J4= Job(name="job",server=R3,sim=s)
245 s.activate(J2,J2.execute(), at=0.0)
246 s.activate(J3,J3.execute(), at=0.0)
247 s.activate(J4,J4.execute(), at=0.0)
248
249 s.simulate(until = 10.0)
250 assert R3.n == 0 , "Should be 0, it is "+str(R3.n)
251 lenW = len(R3.waitQ)
252 lenA = len(R3.activeQ)
253 assert lenW==1,"lenW Should be 1, it is "+str(lenW)
254 assert R3.waitQ==[J4],"WaitQ wrong"+str(R3.waitQ)
255 assert lenA==2,"lenA Should be 2, it is "+str(lenA)
256 assert R3.activeQ==[J2,J3],"activeQ wrong, it is %s"%str(R3.activeQ[0])
257
258
259
261 """Test PriorityQ, with no preemption, 0 capacity"""
262 class Job(Process):
263 """ Job class for testing"""
264 def __init__(self,server=None,name="",sim=None):
265 Process.__init__(self,name=name,sim=sim)
266 self.R=server
267
268 def execute(self,priority):
269 yield request,self,self.R,priority
270
271 s=SimulationRT()
272 s.initialize()
273 Rp = Resource(capacity=0,qType=PriorityQ,sim=s)
274 J5 = Job(name="job 5",server=Rp,sim=s)
275 J6 = Job(name="job 6",server=Rp,sim=s)
276 J7 = Job(name="job 7",server=Rp,sim=s)
277 s.activate(J5,J5.execute(priority=3))
278 s.activate(J6,J6.execute(priority=0))
279 s.activate(J7,J7.execute(priority=1))
280 s.simulate(until=100)
281 assert Rp.waitQ == [J5,J7,J6],"WaitQ wrong: %s"\
282 %str([(x.name,x.priority[Rp]) for x in Rp.waitQ])
283
284 """Test PriorityQ mechanism"""
285
286 def sorted(q):
287 if not q or len(q) == 1:
288 sortok=1
289 return sortok
290 sortok = q[0] >= q[1] and sorted(q[2:])
291 return sortok
292
293 s=SimulationRT()
294 s.initialize()
295 Rp=Resource(capacity=0,qType=PriorityQ,sim=s)
296 for i in range(10):
297 J=Job(name="job "+str(i),server=Rp,sim=s)
298 s.activate(J,J.execute(priority=random()))
299 s.simulate(until=1000)
300 qp=[x._priority[Rp] for x in Rp.waitQ]
301 assert sorted(qp),"waitQ not sorted by priority: %s"\
302 %str([(x.name,x._priority[Rp]) for x in Rp.waitQ])
303
305 """Test PriorityQ, with no preemption, capacity == 1"""
306 class Job(Process):
307 """ Job class for testing"""
308 def __init__(self,server=None,name="",sim=None):
309 Process.__init__(self,name=name,sim=sim)
310 self.R=server
311
312 def execute(self,priority):
313 yield request,self,self.R,priority
314
315 s=SimulationRT()
316 s.initialize()
317 Rp = Resource(capacity=1,qType=PriorityQ,sim=s)
318 J5 = Job(name="job 5",server=Rp,sim=s)
319 J6 = Job(name="job 6",server=Rp,sim=s)
320 J7 = Job(name="job 7",server=Rp,sim=s)
321 s.activate(J5,J5.execute(priority=2))
322 s.activate(J6,J6.execute(priority=4))
323 s.activate(J7,J7.execute(priority=3))
324 s.simulate(until=100)
325 assert Rp.waitQ == [J6,J7],"WaitQ wrong: %s"\
326 %[(x.name,x._priority[Rp]) for x in Rp.waitQ]
327
329 """Test PriorityQ, with preemption, capacity == 1"""
330 class nuJob(Process):
331 def __init__(self,name="",sim=None):
332 Process.__init__(self,name=name,sim=sim)
333
334 def execute(self,res,priority):
335 self.preempt=len(res.activeQ) > 0\
336 and priority > res.activeQ[-1]._priority[res]
337 t=self.sim.now()
338 yield request,self,res,priority
339 if self.preempt:
340 assert len(res.waitQ) == 1, \
341 "No preemption activeQ= %s"%res.activeQ[0].name
342 yield hold,self,30
343 t1=self.sim.now()
344 if self.preempt:
345 assert t+30 == t1,\
346 "Wrong completion time for preemptor %s"%self.name
347 else:
348 assert t+60 == t1,\
349 "Wrong completion time for preempted %s %s:"\
350 %(self.name,self.sim.now())
351 yield release,self,res
352
353 s = SimulationRT()
354 s.initialize()
355 res=Resource(name="server",capacity=1,qType=PriorityQ,preemptable=1,
356 sim=s)
357 n1=nuJob(name="nuJob 1",sim=s)
358 n2=nuJob(name="nuJob 2",sim=s)
359 s.activate(n1,n1.execute(res,priority=0))
360 s.activate(n2,n2.execute(res,priority=1),at=15)
361 s.simulate(until=100)
362
364 """Test preemption of preemptor"""
365 class nuJob(Process):
366 seqOut=[]
367 def __init__(self,name="",sim=None):
368 Process.__init__(self,name=name,sim=sim)
369 self.serviceTime=30
370
371 def execute(self,res,priority):
372 self.preempt=len(res.activeQ) > 0\
373 and priority > res.activeQ[-1]._priority[res]
374 nrwaiting=len(res.waitQ)
375 yield request,self,res,priority
376 if self.preempt:
377 assert len(res.waitQ) == nrwaiting + 1,\
378 "No preemption activeQ= %s"%res.activeQ[0].name
379 yield hold,self,self.serviceTime
380 yield release,self,res
381 nuJob.seqOut.append((self,self.sim.now()))
382
383 s=SimulationRT()
384 s.initialize()
385 res=Resource(name="server",capacity=1,qType=PriorityQ,preemptable=1,
386 sim=s)
387 n1=nuJob(name="nuJob 1",sim=s)
388 n2=nuJob(name="nuJob 2",sim=s)
389 n3=nuJob(name="nuJob 3",sim=s)
390 s.activate(n1,n1.execute(res,priority=-1))
391 start2=10
392 s.activate(n2,n2.execute(res,priority=0),at=start2)
393 start3=20
394 s.activate(n3,n3.execute(res,priority=1),at=start3)
395 s.simulate(until=100)
396 assert [x[1] for x in nuJob.seqOut]\
397 == [start3+n3.serviceTime,start2+2*n2.serviceTime,90],\
398 "Wrong service sequence/times: %s"%[x[1] for x in nuJob.seqOut]
399
401 """Test that a process can preempt another process holding multiple resources
402 """
403 class Requestor(Process):
404 def run(self,res1,res2,res3,priority=1):
405 yield request,self,res1,priority
406 yield request,self,res2,priority
407 yield request,self,res3,priority
408 record.observe(t=s.now(),y=self.name)
409 yield hold,self,100
410 record.observe(t=s.now(),y=self.name)
411 yield release,self,res3
412 yield release,self,res2
413 yield release,self,res1
414
415 s=SimulationRT()
416 s.initialize()
417 outer=Resource(name="outer",qType=PriorityQ,preemptable=True,sim=s)
418 inner=Resource(name="inner",qType=PriorityQ,preemptable=True,sim=s)
419 innermost=Resource(name="innermost",qType=PriorityQ,preemptable=True,
420 sim=s)
421 record=Monitor(sim=s)
422 r1=Requestor("r1",sim=s)
423 s.activate(r1,r1.run(res1=outer,res2=inner,res3=innermost,priority=1))
424 r2=Requestor("r2",sim=s)
425 s.activate(r2,r2.run(res1=outer,res2=inner,res3=innermost,priority=10),
426 at=50)
427 s.simulate(until=200)
428 assert record==[[0,"r1"],[50,"r2"],[150,"r2"],[200,"r1"]],\
429 "was %s; preempt did not work"%record
430
432 """ test monitoring of number in the two queues, waitQ and activeQ
433 """
434 class Job(Process):
435 def __init__(self,name="",sim=None):
436 Process.__init__(self,name=name,sim=sim)
437
438 def execute(self,res):
439 yield request,self,res
440 yield hold,self,2
441 yield release,self,res
442
443 s=SimulationRT()
444 s.initialize()
445 res=Resource(name="server",capacity=1,monitored=1,sim=s)
446 n1=Job(name="Job 1",sim=s)
447 n2=Job(name="Job 2",sim=s)
448 n3=Job(name="Job 3",sim=s)
449 s.activate(n1,n1.execute(res),at=2)
450 s.activate(n2,n2.execute(res),at=2)
451 s.activate(n3,n3.execute(res),at=2)
452 s.simulate(until=100)
453 assert res.waitMon == [[2, 1], [2, 2], [4, 1], [6, 0]],\
454 'Wrong waitMon:%s'%res.waitMon
455 assert res.actMon == [[2, 1], [4, 0], [4, 1], [6, 0], [6, 1], [8, 0]],\
456 'Wrong actMon:%s'%res.actMon
457 self.assertAlmostEqual( res.waitMon.timeAverage(t=s.now()), (0*2+2*2+1*2)/8.0,2,
458 'Wrong waitMon.timeAverage:%s'%res.waitMon.timeAverage(t=s.now()))
459
461 suite = unittest.TestSuite()
462 testInit = makeResourcetestcase("testInit")
463 testrequest = makeResourcetestcase("testrequest")
464 testrequest2 = makeResourcetestcase("testrequest2")
465 testrequest3 = makeResourcetestcase("testrequest3")
466 testrequest4 = makeResourcetestcase("testrequest4")
467 testrequestPriority = makeResourcetestcase("testrequestPriority")
468 testrequestPriority1 = makeResourcetestcase("testrequestPriority1")
469 testrequestPriority2 = makeResourcetestcase("testrequestPriority2")
470 testrequestPriority3 = makeResourcetestcase("testrequestPriority3")
471 testrequestNestedPreempt = makeResourcetestcase("testrequestNestedPreempt")
472 testmonitored = makeResourcetestcase("testmonitored")
473
474 suite.addTests([testInit,testrequest,testrequest2,testrequest3,testrequest4,
475 testrequestPriority,testrequestPriority1,
476 testrequestPriority2,testrequestPriority3,
477 testrequestNestedPreempt,
478 testmonitored])
479 return suite
480
481
482
483
484
488
489 - def breakin(self,waitbefore,howoften=1):
490 for i in range(howoften):
491 yield hold,self,waitbefore
492 self.interrupt(victim)
493
497
499 global igothit
500 igothit={}
501 while self.sim.now()<=theEnd:
502 yield hold,self,howlong
503 if self.interrupted():
504 byWhom=self.interruptCause
505 igothit[self.sim.now()]=byWhom
506 else:
507 pass
508
510 """
511 Tests interrupts as defined in SEP001v17
512 """
527
528
529
545
559
561 """
562 Test multiple interrupts by multiple processes during victim activity
563 """
564 global victim
565 s=SimulationRT()
566 s.initialize()
567 breaker1=Interruptor(sim=s)
568 s.activate(breaker1,breaker1.breakin(15,howoften=3))
569 breaker2=Interruptor(sim=s)
570 s.activate(breaker2,breaker2.breakin(20,howoften=3))
571 victim=Interrupted(sim=s)
572 s.activate(victim,victim.myActivity(100))
573 s.simulate(until=200)
574 for i in (15,30,45):
575 assert igothit[i] == breaker1, "Not interrupted at %s by breaker1" %i
576 for i in (20,40,60):
577 assert igothit[i] == breaker2, "Not interrupted at %s by breaker2" %i
578 assert len(igothit) == 6 , "Interrupted wrong number of times"
579
597
598 victim.newProcess=newProcess
599 s.activate(victim,newProcess(victim))
600 s.activate(breaker,breaker.breakin(10,howoften=3))
601 s.simulate(until=1000)
602
613
614
615
616
617
629
633
635 assert p.active(),"p not active"
636 assert not p.passive(), "p passive"
637 assert not p.terminated(),"p terminated"
638 assert not p.interrupted(),"p interrupted"
639 yield hold,self,11
640 assert not p.active(),"p active"
641 assert not p.passive(),"p passive"
642 assert p.terminated(),"p not terminated"
643 assert not p.interrupted(),"p interrupted"
644
646 assert not p.active(),"p active"
647 assert p.passive(),"p not passive"
648 assert not p.terminated(),"p not terminated"
649 assert not p.interrupted(),"p interrupted"
650 self.sim.activate(p,p.life1())
651 yield hold,self,11
652 assert not p.active(),"p active"
653 assert not p.passive(),"p not passive"
654 assert p.terminated(),"p not terminated"
655 assert not p.interrupted(),"p interrupted"
656
658 assert not p.active(),"p active"
659 assert p.passive(),"p not passive"
660 assert not p.terminated(),"p not terminated"
661 assert not p.interrupted(),"p interrupted"
662 self.sim.activate(p,p.life2())
663 yield hold,self,11
664 assert not p.active(),"p active"
665 assert p.passive(),"p not passive"
666 assert not p.terminated(),"p terminated"
667 assert not p.interrupted(),"p interrupted"
668
670 yield hold,self,5
671 assert p.active(),"p not active"
672 assert not p.passive(),"p passive"
673 assert not p.terminated(),"p terminated"
674 assert not p.interrupted(),"p interrupted"
675 self.cancel(p)
676 assert not p.active(),"p active"
677 assert p.passive(),"p not passive"
678 assert not p.terminated(),"p terminated"
679 assert not p.interrupted(),"p interrupted"
680 self.sim.reactivate(p)
681 assert p.active(),"p not active"
682 assert not p.passive(),"p passive"
683 assert not p.terminated(),"p terminated"
684 assert not p.interrupted(),"p interrupted"
685 yield hold,self
686 assert not p.active(),"p active"
687 assert not p.passive(),"p passive"
688 assert p.terminated(),"p terminated"
689 assert not p.interrupted(),"p interrupted"
690
692 yield hold,self,11
693 assert not p.active(),"p active"
694 assert p.passive(),"p not passive"
695 assert not p.terminated(),"p terminated"
696 assert not p.interrupted(),"p interrupted"
697 self.cancel(p)
698 assert not p.active(),"p active"
699 assert p.passive(),"p not passive"
700 assert not p.terminated(),"p terminated"
701 assert not p.interrupted(),"p interrupted"
702
720
724
725 - def look1(self,p1,p2,res):
726 assert p1.active(), "p1 not active"
727 assert not p1.queuing(res), "p1 queuing"
728 assert p2.active(), "p2 not active"
729 assert not p2.queuing(res), "p2 queuing"
730 yield hold,self,2
731 assert p1.active(), "p1 not active"
732 assert not p1.queuing(res), "p1 queuing"
733 assert p2.passive(), "p2 active"
734 assert p2.queuing(res), "p2 not queuing"
735
744
746 """
747 Tests states and state transitions as defined in SEP003
748 """
749
762
781
803
805 """
806 Test request/release state transitions
807 """
808
809 s=SimulationRT()
810 s.initialize()
811 res=Resource(capacity=1,sim=s)
812 pq1=PS2(sim=s)
813 s.activate(pq1,pq1.life1(res))
814 pq2=PS2(sim=s)
815 s.activate(pq2,pq2.life1(res))
816 obq1=Observer2(sim=s)
817 s.activate(obq1,obq1.look1(pq1,pq2,res))
818 s.simulate(until=12)
819
820
821 s=SimulationRT()
822 s.initialize()
823 res=Resource(capacity=1,sim=s)
824 pq3=PS2(sim=s)
825 s.activate(pq3,pq3.life2(res))
826 obq2=Observer2(sim=s)
827 s.activate(obq2,obq2.look2(pq3,res),prior=True)
828 s.simulate(until=12)
829
839
840
841
842
843
848 yield hold,self,1
849 ev1.signal("from SignalProcess")
850 while ev2.queues:
851 nq0=len(ev2.queues)
852 ev2.signal("from SignalProcess")
853 assert len(ev2.queues)==(nq0-1),"wrong number of processes dequeued"
854
859 yield waitevent,self,ev1
860 assert ev1.waits==[],"not all processes waiting for event out of waiting list"
861 assert ev1 in self.eventsFired,"did not record firing event"
862
867 yield queueevent,self,ev2
868 assert ev2 in self.eventsFired,"did not record firing event"
869
872 yield hold,self,1
873 ev1.signal("from SignalProcess")
874 yield hold,self,3
875 assert len(ev2.queues)==QueueProcessOR.nrProcesses,"wrong number of processes queuing for event ev2"
876 while ev2.queues:
877 nq0=len(ev2.queues)
878 ev2.signal("from SignalProcess")
879 assert len(ev2.queues)==(nq0-1),"wrong number of processes dequeued"
880 assert not ev2.queues,"not all processes queuing for ev2 dequeued"
881
886 yield waitevent,self,evset
887 for e in evset:
888 assert e.waits==[],"process not out of waiting list for all events in OR"
889
900
901
903 nrProcesses=0
908 yield queueevent,self,evset
909 occurred=False
910 for e in evset:
911 occurred=occurred or (e in self.eventsFired)
912 assert occurred,"queuing process activated by wrong event(s)"
913
925
927 """
928 Test SimEvent/signal as introduced with SimPy 1.5
929 """
930
932 """
933 Tests basic signal semantics
934 """
935 s=SimulationRT()
936 s.initialize()
937 e=SimEvent(sim=s)
938 e.signal("param")
939 assert e.occurred,"signal does not set 'occurred' to True"
940 assert e.signalparam=="param","signal parameter wrong"
941 e.signal()
942 assert e.signalparam is None,"signal with no parameter did not overwrite signalparam"
943 e.signal()
944 assert e.occurred,"multiple calls to signal do not set 'occurred'"
945
962
964 """
965 Tests waiting, queuing for at least one event out of a list/tuple.
966 """
967 si=SimulationRT()
968 si.initialize()
969 e1=SimEvent("e1",sim=si)
970 e2=SimEvent("e2",sim=si)
971 e3=SimEvent("e3",sim=si)
972 s=SignalProcessOR(sim=si)
973 si.activate(s,s.makeSignal(e1,e3))
974 w=WaitProcessOR(sim=si)
975 si.activate(w,w.waitForSig([e1,e2]))
976 for i in range(5):
977 q=QueueProcessOR(sim=si)
978 si.activate(q,q.queueForSig([e2,e3]))
979 si.simulate(until=10)
980
989
998
1009
1010
1011
1012
1013
1018 global a,b,c
1019 a=True
1020 yield hold,self,1
1021 b=True
1022 yield hold,self,1
1023 c=True
1024 yield hold,self,1
1025 assert waiter.terminated(),"waituntil did not fire"
1026
1031 def waitcond():
1032 return a and b and c
1033 yield waituntil,self,waitcond
1034
1036 """
1037 Test waituntil as introduced with SimPy 1.5
1038 """
1039
1050
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1068 """ Job class for testing timeout reneging
1069 """
1070 - def __init__(self,server=None,name="",sim=None):
1074
1075 - def execute(self,timeout,usetime):
1076 yield (request,self,self.res),(hold,self,timeout)
1077 if self.acquired(self.res):
1078 self.gotResource=True
1079 yield hold,self,usetime
1080 yield release,self,self.res
1081 else:
1082 self.gotResource=False
1083
1085 """ Job class for testing timeout reneging with priorities
1086 """
1087 - def __init__(self,server=None,name="",sim=None):
1091
1092 - def execute(self,timeout,usetime,priority):
1093 yield (request,self,self.res,priority),(hold,self,timeout)
1094 if self.acquired(self.res):
1095 self.gotResource=True
1096 yield hold,self,usetime
1097 yield release,self,self.res
1098 else:
1099 self.gotResource=False
1100
1102 """ Tests of "yield (request,self,res),(hold,self,delay)"
1103 timeout reneging command
1104 """
1106 """Test that resource gets acquired without timeout
1107 """
1108
1109 s=SimulationRT()
1110 s.initialize()
1111 res=Resource(name="Server",capacity=1,sim=s)
1112 usetime=5
1113 timeout=1000000
1114 j1=JobTO(server=res,name="Job_1",sim=s)
1115 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1116 j2=JobTO(server=res,name="Job_2",sim=s)
1117 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1118 s.simulate(until=2*usetime)
1119 assert s.now()==2*usetime,"time not ==2*usetime"
1120 assert j1.gotResource and j2.gotResource,\
1121 "at least one job failed to get resource"
1122 assert not (res.waitQ or res.activeQ),\
1123 "job waiting or using resource"
1124
1126 """Test that resource gets acquired without timeout.
1127 Resource monitored.
1128 """
1129
1130 s=SimulationRT()
1131 s.initialize()
1132 res=Resource(name="Server",capacity=1,monitored=True,sim=s)
1133 usetime=5
1134 timeout=1000000
1135 j1=JobTO(server=res,name="Job_1",sim=s)
1136 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1137 j2=JobTO(server=res,name="Job_2",sim=s)
1138 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1139 s.simulate(until=2*usetime)
1140 assert s.now()==2*usetime,"time not ==2*usetime"
1141 assert j1.gotResource and j2.gotResource,\
1142 "at least one job failed to get resource"
1143 assert not (res.waitQ or res.activeQ),\
1144 "job waiting or using resource"
1145 assert res.waitMon==[[0,1],[usetime,0]],"res.waitMon wrong: %s"%res.waitMon
1146
1148 """Test that timeout occurs when resource busy
1149 """
1150
1151 s=SimulationRT()
1152 s.initialize()
1153 res=Resource(name="Server",capacity=1,sim=s)
1154 usetime=5
1155 timeout=3
1156 j1=JobTO(server=res,name="Job_1",sim=s)
1157 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1158 j2=JobTO(server=res,name="Job_2",sim=s)
1159 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1160 s.simulate(until=2*usetime)
1161 assert(s.now()==usetime),"time not ==usetime"
1162 assert(j1.gotResource),"Job_1 did not get resource"
1163 assert(not j2.gotResource),"Job_2 did not renege"
1164 assert not (res.waitQ or res.activeQ),\
1165 "job waiting or using resource"
1166
1168 """Test that timeout occurs when resource busy.
1169 Resource monitored.
1170 """
1171 s=SimulationRT()
1172 s.initialize()
1173 res=Resource(name="Server",capacity=1,monitored=True,sim=s)
1174 usetime=5
1175 timeout=3
1176 j1=JobTO(server=res,name="Job_1",sim=s)
1177 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1178 j2=JobTO(server=res,name="Job_2",sim=s)
1179 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1180 s.simulate(until=2*usetime)
1181 assert(s.now()==usetime),"time not == usetime"
1182 assert(j1.gotResource),"Job_1 did not get resource"
1183 assert(not j2.gotResource),"Job_2 did not renege"
1184 assert not (res.waitQ or res.activeQ),\
1185 "job waiting or using resource"
1186 assert res.waitMon==[[0,1],[timeout,0]],"res.waitMon wrong: %s"%res.waitMon
1187
1189 """Test that timeout occurs when resource busy.
1190 Resource monitored. Requests with priority and preemption.
1191 """
1192 s=SimulationRT()
1193 s.initialize()
1194 res=Resource(name="Server",capacity=1,monitored=True,
1195 qType=PriorityQ,preemptable=True,sim=s)
1196 usetime=5
1197 timeout=3
1198 j1=JobTO_P(server=res,name="Job_1",sim=s)
1199 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime,priority=1))
1200 j2=JobTO_P(server=res,name="Job_2",sim=s)
1201 j2_arrival=1
1202 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime,priority=5),
1203 at=j2_arrival)
1204 j3=JobTO_P(server=res,name="Job_2",sim=s)
1205 j3_arrival=2
1206 s.activate(j3,j3.execute(timeout=timeout,usetime=usetime,priority=10),
1207 at=j3_arrival)
1208 s.simulate(until=3*usetime)
1209 assert(s.now()== 3*usetime),"time not == 2* usetime, but %s"%now()
1210 assert(j1.gotResource),"Job_1 did not get resource"
1211 assert(j2.gotResource),"Job_2 did renege"
1212 assert(j2.gotResource),"Job_3 did renege"
1213 assert not (res.waitQ or res.activeQ),\
1214 "job waiting or using resource"
1215 assert res.waitMon==[[j2_arrival,1],[j3_arrival,2],[usetime+j3_arrival,1],[usetime+j2_arrival+usetime,0]],\
1216 "res.waitMon wrong: %s"%res.waitMon
1217
1219 """Test that timeout occurs when resource has no capacity free
1220 """
1221
1222 s=SimulationRT()
1223 s.initialize()
1224 res=Resource(name="Server",capacity=0,sim=s)
1225 usetime=5
1226 timeout=3
1227 j1=JobTO(server=res,name="Job_1",sim=s)
1228 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1229 j2=JobTO(server=res,name="Job_2",sim=s)
1230 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1231 s.simulate(until=2*usetime)
1232 assert s.now()==timeout,"time %s not == timeout"%s.now()
1233 assert not j1.gotResource,"Job_1 got resource"
1234 assert not j2.gotResource,"Job_2 got resource"
1235 assert not (res.waitQ or res.activeQ),\
1236 "job waiting or using resource"
1237
1239 """Test that timeout occurs when resource has no capacity free.
1240 Resource monitored.
1241 """
1242
1243 s=SimulationRT()
1244 s.initialize()
1245 res=Resource(name="Server",capacity=0,monitored=True,sim=s)
1246 usetime=5
1247 timeout=3
1248 j1=JobTO(server=res,name="Job_1",sim=s)
1249 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1250 j2=JobTO(server=res,name="Job_2",sim=s)
1251 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1252 s.simulate(until=2*usetime)
1253 assert s.now()==timeout,"time %s not == timeout"%s.now()
1254 assert not j1.gotResource,"Job_1 got resource"
1255 assert not j2.gotResource,"Job_2 got resource"
1256 assert not (res.waitQ or res.activeQ),\
1257 "job waiting or using resource"
1258 assert res.waitMon==[[0,1],[0,2],[timeout,1],[timeout,0]],\
1259 "res.waitMon is wrong: %s"%res.waitMon
1260
1274
1275
1276
1277
1278
1279
1280
1281
1283 """ Job class for testing event reneging
1284 """
1285 - def __init__(self,server=None,name="",sim=None):
1289
1291 yield (request,self,self.res),(waitevent,self,event)
1292 if self.acquired(self.res):
1293 self.gotResource=True
1294 yield hold,self,usetime
1295 yield release,self,self.res
1296 else:
1297 self.gotResource=False
1298
1300 """ Job class for testing event reneging with multi-event lists
1301 """
1302 - def __init__(self,server=None,name="",sim=None):
1306
1307 - def execute(self,eventlist,usetime):
1308 yield (request,self,self.res),(waitevent,self,eventlist)
1309 if self.acquired(self.res):
1310 self.gotResource=True
1311 yield hold,self,usetime
1312 yield release,self,self.res
1313 else:
1314 self.gotResource=False
1315
1317 """Fires reneging event
1318 """
1321 - def fire(self,fireDelay,event):
1322 yield hold,self,fireDelay
1323 event.signal()
1324
1326 """Tests of "yield (request,self,res),(waiteevent,self,event)"
1327 event reneging command
1328 """
1330 """Test that processes acquire resource normally if no event fires
1331 """
1332 s=SimulationRT()
1333 s.initialize()
1334 event=SimEvent("Renege_trigger",sim=s)
1335 res=Resource(name="Server",capacity=1,sim=s)
1336 usetime=5
1337 j1=JobEvt(server=res,name="Job_1",sim=s)
1338 s.activate(j1,j1.execute(event=event,usetime=usetime))
1339 j2=JobEvt(server=res,name="Job_2",sim=s)
1340 s.activate(j2,j2.execute(event=event,usetime=usetime))
1341 s.simulate(until=2*usetime)
1342
1343 assert s.now()==2*usetime,"time not ==2*usetime"
1344 assert j1.gotResource and j2.gotResource,\
1345 "at least one job failed to get resource"
1346 assert not (res.waitQ or res.activeQ),\
1347 "job waiting or using resource"
1348
1350 """Test that processes acquire resource normally if no event fires.
1351 Resource monitored.
1352 """
1353 s=SimulationRT()
1354 s.initialize()
1355 res=Resource(name="Server",capacity=1,monitored=True,sim=s)
1356 event=SimEvent("Renege_trigger",sim=s)
1357 usetime=5
1358 j1=JobEvt(server=res,name="Job_1",sim=s)
1359 s.activate(j1,j1.execute(event=event,usetime=usetime))
1360 j2=JobEvt(server=res,name="Job_2",sim=s)
1361 s.activate(j2,j2.execute(event=event,usetime=usetime))
1362 s.simulate(until=2*usetime)
1363
1364 assert s.now()==2*usetime,"time not ==2*usetime"
1365 assert j1.gotResource and j2.gotResource,\
1366 "at least one job failed to get resource"
1367 assert not (res.waitQ or res.activeQ),\
1368 "job waiting or using resource"
1369 assert res.waitMon==[[0,1],[usetime,0]],"res.waitMoni is wrong: %s"%res.waitMon
1370
1372 """Test that signalled event leads to renege when resource busy
1373 """
1374
1375 s=SimulationRT()
1376 s.initialize()
1377 res=Resource(name="Server",capacity=1,sim=s)
1378 event=SimEvent("Renege_trigger",sim=s)
1379 usetime=5
1380 eventtime=1
1381 j1=JobEvt(server=res,name="Job_1",sim=s)
1382 s.activate(j1,j1.execute(event=event,usetime=usetime))
1383 j2=JobEvt(server=res,name="Job_2",sim=s)
1384 s.activate(j2,j2.execute(event=event,usetime=usetime))
1385 f=FireEvent(name="FireEvent",sim=s)
1386 s.activate(f,f.fire(fireDelay=eventtime,event=event))
1387 s.simulate(until=2*usetime)
1388
1389 assert(s.now()==usetime),"time not ==usetime"
1390 assert(j1.gotResource),"Job_1 did not get resource"
1391 assert(not j2.gotResource),"Job_2 did not renege"
1392 assert not (res.waitQ or res.activeQ),\
1393 "job waiting or using resource"
1394
1396 """Test that signalled event leads to renege when resource busy.
1397 Resource monitored.
1398 """
1399
1400 s=SimulationRT()
1401 s.initialize()
1402 res=Resource(name="Server",capacity=1,monitored=True,sim=s)
1403 event=SimEvent("Renege_trigger",sim=s)
1404 usetime=5
1405 eventtime=1
1406 j1=JobEvt(server=res,name="Job_1",sim=s)
1407 s.activate(j1,j1.execute(event=event,usetime=usetime))
1408 j2=JobEvt(server=res,name="Job_2",sim=s)
1409 s.activate(j2,j2.execute(event=event,usetime=usetime))
1410 f=FireEvent(name="FireEvent",sim=s)
1411 s.activate(f,f.fire(fireDelay=eventtime,event=event))
1412 s.simulate(until=2*usetime)
1413
1414 assert(s.now()==usetime),"time not == usetime"
1415 assert(j1.gotResource),"Job_1 did not get resource"
1416 assert(not j2.gotResource),"Job_2 did not renege"
1417 assert not (res.waitQ or res.activeQ),\
1418 "job waiting or using resource"
1419 assert res.waitMon==[[0,1],[eventtime,0]],"res.waitMon is wrong: %s"%res.waitMon
1420
1422 """Test that renege-triggering event can be one of an event list
1423 """
1424
1425 s=SimulationRT()
1426 s.initialize()
1427 res=Resource(name="Server",capacity=1,sim=s)
1428 event1=SimEvent("Renege_trigger_1",sim=s)
1429 event2=SimEvent("Renege_trigger_2",sim=s)
1430 usetime=5
1431 eventtime=1
1432 j1=JobEvtMulti(server=res,name="Job_1",sim=s)
1433 s.activate(j1,j1.execute(eventlist=[event1,event2],usetime=usetime))
1434 j2=JobEvtMulti(server=res,name="Job_2",sim=s)
1435 s.activate(j2,j2.execute(eventlist=[event1,event2],usetime=usetime))
1436 f1=FireEvent(name="FireEvent_1",sim=s)
1437 s.activate(f1,f1.fire(fireDelay=eventtime,event=event1))
1438 f2=FireEvent(name="FireEvent_2",sim=s)
1439 s.activate(f2,f2.fire(fireDelay=eventtime,event=event2))
1440 s.simulate(until=2*usetime)
1441
1442 assert(s.now()==usetime),"time not ==usetime"
1443 assert(j1.gotResource),"Job_1 did not get resource"
1444 assert(not j2.gotResource),"Job_2 did not renege"
1445 assert not (res.waitQ or res.activeQ),\
1446 "job waiting or using resource"
1447
1449 """Test that renege-triggering event can be one of an event list.
1450 Resource monitored.
1451 """
1452
1453 s=SimulationRT()
1454 s.initialize()
1455 res=Resource(name="Server",capacity=1,monitored=True,sim=s)
1456 event1=SimEvent("Renege_trigger_1",sim=s)
1457 event2=SimEvent("Renege_trigger_2",sim=s)
1458 usetime=5
1459 eventtime=1
1460 j1=JobEvtMulti(server=res,name="Job_1",sim=s)
1461 s.activate(j1,j1.execute(eventlist=[event1,event2],usetime=usetime))
1462 j2=JobEvtMulti(server=res,name="Job_2",sim=s)
1463 s.activate(j2,j2.execute(eventlist=[event1,event2],usetime=usetime))
1464 f1=FireEvent(name="FireEvent_1",sim=s)
1465 s.activate(f1,f1.fire(fireDelay=eventtime,event=event1))
1466 f2=FireEvent(name="FireEvent_2",sim=s)
1467 s.activate(f2,f2.fire(fireDelay=eventtime,event=event2))
1468 s.simulate(until=2*usetime)
1469
1470 assert(s.now()==usetime),"time not ==usetime"
1471 assert(j1.gotResource),"Job_1 did not get resource"
1472 assert(not j2.gotResource),"Job_2 did not renege"
1473 assert not (res.waitQ or res.activeQ),\
1474 "job waiting or using resource"
1475 assert res.waitMon==[[0,1],[eventtime,0]],"res.waitMon is wrong: %s"%res.waitMon
1476
1489
1490
1491
1492
1493
1494
1496 produced=0
1505 """PriorityQ for Producers"""
1506 Producer.produced+=4
1507 yield put,self,buffer,4,priority
1508 yield hold,self,1
1509 self.done=self.sim.now()
1510 doneList.append(self.name)
1512 for i in range(4):
1513 yield put,self,buffer,4
1514 yield hold,self,1
1516 consumed=0
1520 """FIFO"""
1521 yield get,self,buffer
1522 Consumer.consumed+=1
1523 assert self.got==1,"wrong self.got: %s"%self.got
1524 yield get,self,buffer,3
1525 Consumer.consumed+=3
1526 assert self.got==3,"wrong self.got: %s"%self.got
1527
1529 """producer PriorityQ, consumer FIFO"""
1530 while True:
1531 yield get,self,buffer,2
1532 yield hold,self,1
1534 """PriorityQ for Consumers"""
1535 yield get,self,buffer,4,priority
1536 doneList.append(self.name)
1537
1538
1542 - def produce(self,buffer,productionTime):
1543 while True:
1544 assert not(buffer.amount>0 and len(buffer.getQ)>0),\
1545 "Consumer(s) waiting while buffer not empty"
1546 yield hold,self,productionTime
1547 yield put,self,buffer,1
1548
1552 - def consume(self,buffer,consumptionTime):
1553 while True:
1554 assert not(buffer.amount==0 and len(buffer.putQ)>0),\
1555 "Producer(s) waiting while buffer empty"
1556 yield get,self,buffer,1
1557 yield hold,self,consumptionTime
1558
1559
1560
1563 """Tests initialization of Level instances
1564 """
1565 s=SimulationRT()
1566 s.initialize()
1567 a=Level(sim=s)
1568 assert a.capacity==sys.maxint,"wrong capacity:%s"%a
1569 assert a.amount==0,"wrong buffer content: %s"%a
1570 assert a.name=="a_level","wrong name: %s"%a
1571 assert not a.monitored,"should not be monitored: %s"%a
1572 assert a.putQMon is None,"should not have putQMon: %s"%a
1573 assert a.getQMon is None,"should not have getQMon: %s"%a
1574 assert a.bufferMon is None,"should not have bufferMon: %s"%a
1575 assert a.putQType.__name__=="FIFO" and a.getQType.__name__=="FIFO",\
1576 "putQType and getQType should be FIFO: %s"%a
1577
1578 b=Level(name="b",initialBuffered=10.0,monitored=True,capacity=12,
1579 putQType=PriorityQ,sim=s)
1580 a=Level(sim=s)
1581 assert b.capacity==12,"wrong capacity:%s"%b
1582 assert b.amount==10,"wrong buffer content: %s"%b
1583 assert b.name=="b","wrong name: %s"%b
1584 assert b.monitored,"should be monitored: %s"%b
1585 assert not (b.putQMon is None),"should have putQMon: %s"%b
1586 assert not (b.getQMon is None),"should have getQMon: %s"%b
1587 assert not (b.bufferMon is None),"should have bufferMon: %s"%b
1588 assert b.putQType.__name__=="PriorityQ",\
1589 "putQType should be PriorityQ: %s"%b
1590 assert b.getQType.__name__=="FIFO",\
1591 "getQType should be PriorityQ: %s"%b
1592
1594 """Level: tests basic Producer/Consumer principles:
1595 - Consumers must not be waiting while Level buffer value > 0,
1596 - Producers must not be waiting while Level buffer value == 0
1597 """
1598 s=SimulationRT()
1599 s.initialize()
1600 bufferSize=1
1601 productionTime=1
1602 consumptionTime=5
1603 endtime=50
1604 buffer=Level(capacity=bufferSize,sim=s)
1605 consumer=ConsumerPrincL(sim=s)
1606 s.activate(consumer,consumer.consume(buffer,consumptionTime))
1607 producer=ProducerPrincL(sim=s)
1608 s.activate(producer,producer.produce(buffer,productionTime))
1609 s.simulate(until=endtime)
1610
1624
1642
1644 """Level: tests put/get in multiple Producer/Consumer scenario,
1645 with Producers having different priorities.
1646 How: Producers forced to queue; all after first should be done in
1647 priority order
1648 """
1649 global doneList
1650 doneList=[]
1651 s=SimulationRT()
1652 s.initialize()
1653 buffer=Level(capacity=7,putQType=PriorityQ,monitored=True,sim=s)
1654 for i in range(4):
1655 p=Producer(i,sim=s)
1656 pPriority=i
1657 s.activate(p,p.producePriority(buffer=buffer,priority=pPriority))
1658 c=Consumer(sim=s)
1659 s.activate(c,c.consume1(buffer=buffer))
1660 s.simulate(until=100)
1661 assert doneList==[0,3,2,1],"puts were not done in priority order: %s"\
1662 %doneList
1663
1665 """Level: tests put/get in multiple Producer/Consumer scenario, with
1666 Consumers having different priorities.
1667 How: Consumers forced to queue; all after first should be done in
1668 priority order
1669 """
1670 global doneList
1671 doneList=[]
1672 s=SimulationRT()
1673 s.initialize()
1674 buffer=Level(capacity=7,getQType=PriorityQ,monitored=True,sim=s)
1675 for i in range(4):
1676 c=Consumer(i,sim=s)
1677 cPriority=i
1678 s.activate(c,c.consumePriority(buffer=buffer,priority=cPriority))
1679 p=Producer(sim=s)
1680 s.activate(p,p.produce1(buffer=buffer))
1681 s.simulate(until=100)
1682 assert doneList==[3,2,1,0],"gets were not done in priority order: %s"\
1683 %doneList
1684
1696
1697
1698
1699
1700
1701
1702
1727
1755
1759
1761 """Sorts Widget instances by weight attribute."""
1762 tmplist=[(x.weight,x) for x in par]
1763 tmplist.sort()
1764 return [x for (key,x) in tmplist]
1765
1766
1770 - def produce(self,buffer,productionTime):
1771 while True:
1772 assert not(buffer.nrBuffered>0 and len(buffer.getQ)>0),\
1773 "Consumer(s) waiting while buffer not empty"
1774 yield hold,self,productionTime
1775 product=WidgetPrinc()
1776 yield put,self,buffer,[product]
1777
1781 - def consume(self,buffer,consumptionTime):
1782 while True:
1783 assert not(buffer.nrBuffered==0 and buffer.putQ),\
1784 "Producer(s) waiting while buffer empty"
1785 yield get,self,buffer,1
1786 yield hold,self,consumptionTime
1787
1790
1792 """Used in testBufferFilter"""
1798
1800 """get all items with weight between a and b"""
1801 def between_a_and_b(buf):
1802 res=[]
1803 for item in buf:
1804 if a<item.weight<b:
1805 res.append(item)
1806
1807 all=store.buffered
1808 yield get,self,store,between_a_and_b
1809 "All retrieved items weight in range?"
1810 for it in self.got:
1811 assert a<it.weight<b,"weight %s not in range %s..%s"\
1812 %(it.weight,a,b)
1813 "Any item fitting filter pred left in buffer?"
1814 for it in store.buffer:
1815 assert not (a<it.weight<b),\
1816 "item left in buffer which fits filter (%s<%s<%s)"\
1817 %(a,it.weight,b)
1818 "All items either in store.buffer of self.got?"
1819 for it in all:
1820 assert (it in self.buffer) or (it in self.got),\
1821 "item w. weight %s neither in store nor in got"%it.weight
1822
1823
1824
1827 """Store: tests initialization of Store instances
1828 """
1829 s=SimulationRT()
1830 s.initialize()
1831 a=Store(sim=s)
1832 assert a.capacity==sys.maxint,"wrong capacity:%s"%a
1833 assert a.nrBuffered==0,"wrong buffer content: %s"%a
1834 assert a.name=="a_store","wrong name: %s"%a
1835 assert not a.monitored,"should not be monitored: %s"%a
1836 assert a.putQMon is None,"should not have putQMon: %s"%a
1837 assert a.getQMon is None,"should not have getQMon: %s"%a
1838 assert a.bufferMon is None,"should not have bufferMon: %s"%a
1839 assert a.putQType.__name__=="FIFO" and a.getQType.__name__=="FIFO",\
1840 "putQType and getQType should be FIFO: %s"%a
1841
1842 stored=[Widget(weight=5)]*10
1843 b=Store(name="b",initialBuffered=stored,monitored=True,capacity=12,
1844 putQType=PriorityQ,sim=s)
1845 assert b.capacity==12,"wrong capacity:%s"%b
1846 assert b.nrBuffered==10,"wrong buffer content: %s"%b
1847 assert b.name=="b","wrong name: %s"%b
1848 assert b.monitored,"should be monitored: %s"%b
1849 assert not (b.putQMon is None),"should have putQMon: %s"%b
1850 assert not (b.getQMon is None),"should have getQMon: %s"%b
1851 assert not (b.bufferMon is None),"should have bufferMon: %s"%b
1852 assert b.putQType.__name__=="PriorityQ",\
1853 "putQType should be PriorityQ: %s"%b
1854 assert b.getQType.__name__=="FIFO",\
1855 "getQType should be PriorityQ: %s"%b
1856
1858 """Store: tests basic Producer/Consumer principles:
1859 - Consumers must not be waiting while items in Store buffer,
1860 - Producers must not be waiting while space available in Store buffer
1861 """
1862 bufferSize=1
1863 productionTime=1
1864 consumptionTime=5
1865 endtime=50
1866 s=SimulationRT()
1867 s.initialize()
1868 buffer=Store(capacity=bufferSize,sim=s)
1869 consumer=ConsumerPrincS(sim=s)
1870 s.activate(consumer,consumer.consume(buffer,consumptionTime))
1871 producer=ProducerPrincS(sim=s)
1872 s.activate(producer,producer.produce(buffer,productionTime))
1873 s.simulate(until=endtime)
1874
1889
1907
1909 """Store: Tests put/get in multiple Producer/Consumer scenario,
1910 with Producers having different priorities.
1911 How; Producers forced to queue; all after first should be done in
1912 priority order
1913 """
1914 global doneList
1915 doneList=[]
1916 s=SimulationRT()
1917 s.initialize()
1918 buffer=Store(capacity=7,putQType=PriorityQ,monitored=True,sim=s)
1919 for i in range(4):
1920 p=ProducerWidget(name=i,sim=s)
1921 pPriority=i
1922 s.activate(p,p.producePriority(buffer=buffer,priority=pPriority))
1923 c=ConsumerWidget(sim=s)
1924 s.activate(c,c.consume1(buffer=buffer))
1925 s.simulate(until=100)
1926 assert doneList==[0,3,2,1],"puts were not done in priority order: %s"\
1927 %doneList
1928
1930 """Tests put/get in multiple Producer/Consumer scenario, with
1931 Consumers having different priorities.
1932 How; Consumers forced to queue; all after first should be done in
1933 priority order
1934 """
1935 global doneList
1936 doneList=[]
1937 s=SimulationRT()
1938 s.initialize()
1939 buffer=Store(capacity=7,getQType=PriorityQ,monitored=True,sim=s)
1940 for i in range(4):
1941 c=ConsumerWidget(name=str(i),sim=s)
1942 cPriority=i
1943 s.activate(c,c.consumePriority(buffer=buffer,priority=cPriority))
1944 p=ProducerWidget(sim=s)
1945 s.activate(p,p.produce1(buffer=buffer))
1946 s.simulate(until=100)
1947 assert doneList==["3","2","1","0"],\
1948 "gets were not done in priority order: %s"%doneList
1949
1951 """Tests the optional sorting of theBuffer by applying a user-defined
1952 sort function."""
1953 s=SimulationRT()
1954 s.initialize()
1955 gotten=[]
1956 sortedStore=Store(sim=s)
1957 sortedStore.addSort(mySortFunc)
1958 p=ProducerWidget(sim=s)
1959 s.activate(p,p.produceUnordered(sortedStore))
1960 for i in range(9):
1961 c=ConsumerWidget(sim=s)
1962 s.activate(c,c.consumeSorted(buffer=sortedStore,gotten=gotten),at=1)
1963 s.simulate(until=10)
1964 assert gotten==[1,2,3,4,5,6,7,8,9],"sort wrong: %s"%gotten
1965
1978
1993
1994
1995
1996
1997
1998
1999 -class TBT(Process):
2000 """Store: For testBasicTime"""
2003 - def tbt(self,store):
2004 yield get,self,store,1
2005 assert self.got,"Did not get Item"
2006 yield (get,self,store,1),(hold,self,5)
2007 if self.acquired(store):
2008 assert len(self.got)==1,"did not get 1 Item"
2009 else:
2010 assert not self.got and self.sim.now()==5 and not store.getQ,\
2011 "time renege not working"
2012
2013 -class TBE(Process):
2014 """Store: For testBasicEvent"""
2017 - def tbe(self,store,trigger):
2018 yield get,self,store,1
2019 assert self.got,"Did not get Item"
2020 yield (get,self,store,1),(waitevent,self,trigger)
2021 if self.acquired(store):
2022 assert False, "should have reneged"
2023 else:
2024 assert self.eventsFired[0]==trigger and self.sim.now()==5 \
2025 and not store.getQ,"event renege not working"
2026
2028 """Store: For testBasicEvent"""
2031 - def fire(self,trigger):
2034
2035
2037 """Store: for testBasicTimePut"""
2040 - def tbt(self,store):
2041 class Item:pass
2042 yield (put,self,store,[Item()]),(hold,self,4)
2043 if self.stored(store):
2044 assert store.nrBuffered==1 and not store.putQ,\
2045 "put did not execute"
2046 else:
2047 assert False,"should not have reneged"
2048 yield (put,self,store,[Item()]),(hold,self,5)
2049 if self.stored(store):
2050 assert False,"should have reneged"
2051 else:
2052 assert store.nrBuffered==1 and not store.putQ,\
2053 "renege not working correctly"
2054
2056 """Store: for testBasicEventPut"""
2059 - def tbe(self,store,trigger):
2060 class Item:pass
2061 yield (put,self,store,[Item()]),(waitevent,self,trigger)
2062 if self.stored(store):
2063 assert store.nrBuffered==1 and not store.putQ,\
2064 "put did not execute"
2065 else:
2066 assert False,"should have not have reneged"
2067 yield (put,self,store,[Item()]),(waitevent,self,trigger)
2068 if self.stored(store):
2069 assert False,"should have reneged"
2070 else:
2071 assert self.sim.now()==5 and self.eventsFired[0]==trigger\
2072 and not store.putQ,"renege not working correctly"
2073
2075 """Store: For testBasicEventPut"""
2078 - def fire(self,trigger):
2081
2083 """Store: Testcase for compound get statements"""
2084
2085
2086
2087
2088
2089
2100
2101
2102
2103
2104
2105
2115
2117 """Store (monitored):
2118 test monitors with 'yield (put,self,store),(hold,self,time)"""
2119 s=SimulationRT()
2120 s.initialize()
2121 st=Store(capacity=1,monitored=True,sim=s)
2122 t=TBTput(sim=s)
2123 s.activate(t,t.tbt(store=st))
2124 s.simulate(until=10)
2125
2126 assert st.putQMon==[[0,0],[0,1],[5,0]],"putQMon wrong: %s"\
2127 %st.putQMon
2128
2129 assert st.bufferMon==[[0,0],[0,1]],"bufferMon wrong: %s"%st.bufferMon
2130
2131
2132
2133
2134
2135
2149
2150
2151
2152
2153
2154
2167
2169 """Store (monitored):
2170 test monitors with 'yield (put,self,store),(waitevent,self,event)"""
2171 si=SimulationRT()
2172 si.initialize()
2173 s=SimEvent(sim=si)
2174 st=Store(capacity=1,monitored=True,sim=si)
2175 t=TBEtriggerPut(sim=si)
2176 si.activate(t,t.fire(trigger=s))
2177 tb=TBEput(sim=si)
2178 si.activate(tb,tb.tbe(store=st,trigger=s))
2179 si.simulate(until=10)
2180
2181 assert st.putQMon==[[0,0],[0,1],[5,0]],"putQMon wrong: %s"\
2182 %st.putQMon
2183
2184 assert st.bufferMon==[[0,0],[0,1]],"bufferMon wrong: %s"%st.bufferMon
2185
2201
2202
2203
2204
2205
2206
2208 """Level: For testBasicTime"""
2211 - def tbt(self,level):
2212 yield get,self,level,1
2213 assert self.got,"did not get 1 unit"
2214 yield (get,self,level,1),(hold,self,5)
2215 if self.acquired(level):
2216 assert self.got==1,"did not get 1 unit"
2217 else:
2218 assert not self.got and self.sim.now()==5,\
2219 "time renege not working"
2220
2222 """Level: For testBasicEvent"""
2225 - def tbe(self,level,trigger):
2226 yield get,self,level,1
2227 assert self.got,"did not get 1 unit"
2228 yield (get,self,level,1),(waitevent,self,trigger)
2229 if self.acquired(level):
2230 assert self.got==1,"did not get 1 Item"
2231 else:
2232 assert self.sim.now()==5.5 and self.eventsFired[0]==trigger,\
2233 "event renege not working"
2234
2236 """Level: For testBasicEvent"""
2239 - def fire(self,trigger):
2242
2244 """Level: For testBasicTimePut"""
2247 - def tbt(self,level):
2248 yield put,self,level,1
2249 assert level.amount,"did not put 1 unit"
2250 yield (put,self,level,1),(hold,self,5)
2251 if self.stored(level):
2252 assert False,"should have reneged"
2253 else:
2254 assert level.amount==1 and self.sim.now()==5,\
2255 "time renege not working"
2256
2258 """Level: For testBasicEventPut and testBasicEventPutM"""
2261 - def tbe(self,level,trigger):
2262 yield (put,self,level,1),(waitevent,self,trigger)
2263 if self.stored(level):
2264 assert level.amount==1,"did not put 1 unit"
2265 else:
2266 assert False,"should not have reneged"
2267 yield (put,self,level,1),(waitevent,self,trigger)
2268 if self.stored(level):
2269 assert False, "should have reneged"
2270 else:
2271 assert self.sim.now()==5.5 and self.eventsFired[0]==trigger ,\
2272 "renege not working"
2273
2275 """Level: For testBasicEventPut"""
2278 - def fire(self,trigger):
2281
2283 """Level: Testcase for compound get and put statements"""
2284
2285
2286
2287
2288
2289
2300
2301
2302
2303
2304
2305
2315
2316
2317
2318
2319
2320
2333
2335 """Level (monitored):
2336 test monitors with 'yield (get,self,level),(waitevent,self,event)"""
2337 s=SimulationRT()
2338 s.initialize()
2339 l=Level(initialBuffered=1,monitored=True,sim=s)
2340 trig=SimEvent(sim=s)
2341 t=TBELev(sim=s)
2342 s.activate(t,t.tbe(level=l,trigger=trig))
2343 tr=TBEtriggerLev(sim=s)
2344 s.activate(tr,tr.fire(trigger=trig))
2345 s.simulate(until=10)
2346
2347 assert l.getQMon==[[0,0],[0,1],[5.5,0]],"getQMon not working: %s"\
2348 %l.getQMon
2349
2350 assert l.bufferMon==[[0,1],[0,0]],\
2351 "bufferMon not working: %s"%l.bufferMon
2352
2353
2354
2355
2356
2357
2370
2372 """Level (monitored):
2373 test monitors with 'yield (put,self,level),(waitevent,self,event)"""
2374 s=SimulationRT()
2375 s.initialize()
2376 l=Level(capacity=1,monitored=True,sim=s)
2377 trig=SimEvent(sim=s)
2378 t=TBELevPut(sim=s)
2379 s.activate(t,t.tbe(level=l,trigger=trig))
2380 tr=TBEtriggerLevPut(sim=s)
2381 s.activate(tr,tr.fire(trigger=trig))
2382 s.simulate(until=10)
2383 "First put succeeds, second reneges at t=5.5?"
2384 assert l.putQMon==[[0,0],[0,1],[5.5,0]],"putQMon wrong: %s"\
2385 %l.putQMon
2386 "1 unit added at t=0, renege at t=5 before 2nd unit added?"
2387 assert l.bufferMon==[[0,0],[0,1]],"bufferMon wrong: %s"%l.bufferMon
2388
2403
2404 if __name__ == '__main__':
2405 alltests = unittest.TestSuite((
2406 makeSSuite(),
2407 makeRSuite(),
2408 makeISuite(),
2409 makePSuite(),
2410 makeESuite(),
2411 makeWSuite(),
2412 makeTOSuite(),
2413 makeEvtRenegeSuite(),
2414 makeLevelSuite(),
2415 makeStoreSuite(),
2416 makeStoreCompSuite(),
2417 makeLevelCompSuite(),
2418 makeMSuite()
2419 ))
2420
2421 runner = unittest.TextTestRunner()
2422 runner.run(alltests)
2423
2424