1
2
3 from SimPy.MonitorTest import *
4 from SimPy.SimulationTrace import *
5 import unittest
6 from random import random
7
8 """testSimPyTraceOO.py
9 SimPy version 2.1
10 Unit tests for SimulationTrace (OO mode).
11
12 #'$Revision: 504 $ $Date: 2010-05-11 08:29:10 +0200 (Tue, 11 May 2010) $ kgm'
13
14 """
15 simulationTraceVersion=version
16 print "Under test: SimulationTrace.py %s"%simulationTraceVersion
17 __version__ = '2.1.0 $Revision: 504 $ $Date: 2010-05-11 08:29:10 +0200 (Tue, 11 May 2010) $ '
18 print 'testSimPyTraceOO.py %s'%__version__
19
20
21
22
24 """ P class for testing"""
25 - def __init__(self,name="",T = 0,sim=None):
29
31 yield hold,self,self.T
32
34 """ PActions class for testing"""
35 - def __init__(self,name="",T = 0,sim=None):
39
41 yield hold,self,self.T
42
44 """For testing stopSimulation
45 """
46 - def run(self,stopTime):
50
52 """For testing startCollection
53 """
54 - def run(self,mon1,mon2,tal1,tal2):
61
63 """For testing allEventTimes
64 """
67
68
70 """ Tests of simulation
71 """
73 """Test initialisation
74 """
75 s=SimulationTrace()
76 s.initialize()
77 result=s.simulate(until=10)
78 assert result=="SimPy: No activities scheduled",\
79 "There should have been no activities."
80 assert(s.now()==0),"time not 0"
81
91
101
111
113 """Test yield hold and simulate(until)
114 """
115 s=SimulationTrace()
116 s.initialize()
117 P1 = P(name="P1",T=10,sim=s)
118 s.initialize()
119 s.activate(P1,P1.execute(),0)
120 s.simulate(until=5)
121 assert(s.now()==5),"Simulate stopped at %s not %s"%(s.now(),5)
122
123 P2 = P(name="P2",T=10,sim=s)
124 s.initialize()
125 s.activate(P2,P2.execute(),0)
126 s.simulate(until=20)
127 assert(s.now()==10),"P1 hold to %s not %s"%(s.now(),10)
128
129
130
131
132
134 """Test stopSimulation function/method
135 """
136 timeToStop = 7
137 s = SimulationTrace()
138 ts = ToStop(sim = s)
139 s.activate(ts,ts.run(stopTime = timeToStop))
140 s.simulate(until = 50)
141 assert(s.now()==timeToStop),\
142 "stopSimulation not working; now = %s instead of %s"%(now(),timeToStop)
143
145 """Test startCollection function/method
146 """
147 s = SimulationTrace()
148 tStart = 9
149 mon1 = Monitor("mon1",sim = s)
150 mon2 = Monitor("mon2",sim = s)
151 tal1 = Tally("tal1",sim = s)
152 tal2 = Tally("tal2",sim = s)
153 s.startCollection(when = tStart,monitors=[mon1,mon2],tallies=[tal1,tal2])
154 tc = ToCollect(sim = s)
155 s.activate(tc,tc.run(mon1,mon2,tal1,tal2))
156 s.simulate(until=50)
157 assert(mon1[0]==mon2[0]==[tStart,tStart]),\
158 "startCollection not working correctly for Monitors"
159 assert(tal1.count()==tal2.count()==50-tStart+1),\
160 "startCollection not working for Tally"
161
171
172
187
188
189
190
191
193 """ Job class for testing"""
194 - def __init__(self,server=None,name="",sim=None):
198
201
203 """ First simple tests of Resources
204 """
206 """Test initialisation"""
207 s=SimulationTrace()
208 s.initialize()
209 R = Resource(sim=s)
210 assert R.name == "a_resource", "Not null name"
211 assert R.capacity == 1, "Not unit capacity"
212 assert R.unitName =="units", "Not the correct unit name"
213 R = Resource(name='',capacity=1,sim=s)
214 assert R.name == "", "Not null name"
215 assert R.capacity == 1, "Not unit capacity"
216 assert R.unitName =="units", "Not the correct unit name"
217 R = Resource(capacity=3,name="3-version",unitName="blobs",sim=s)
218 assert R.name =="3-version" , "Wrong name, it is"+R.name
219 assert R.capacity == 3, "Not capacity 3, it is "+`R.capacity`
220 assert R.unitName =="blobs", "Not the correct unit name"
221
222 R = Resource(capacity=0,name="0-version",sim=s)
223 assert R.capacity ==0, "Not capacity 0, it is "+`R.capacity`
224
226 """Test request"""
227
228 s=SimulationTrace()
229 s.initialize()
230 R0 = Resource(name='',capacity=0,sim=s)
231 assert R0.name == "", "Not null name"
232 assert R0.capacity == 0, "Not capacity 0, it is "+`R0.capacity`
233 R1 = Resource(capacity=0,name="3-version",unitName="blobs", sim = s)
234 J= Job(name="job",server=R1, sim = s)
235 s.activate(J,J.execute(), at=0.0)
236
237 s.simulate(until=10.0)
238 assert R1.n == 0 , "Should be 0, it is "+str(R1.n)
239 lenW = len(R1.waitQ)
240 assert lenW==1,"Should be 1, it is "+str(lenW)
241 assert len(R1.activeQ)==0,"len activeQ Should be 0, it is "+\
242 str(len(R1.activeQ))
243
245 """Test request2 with capacity = 1"""
246
247 s=SimulationTrace()
248 s.initialize()
249 R2 = Resource(capacity=1,name="3-version",unitName="blobs", sim = s)
250 J2= Job(name="job",server=R2, sim = s)
251 s.activate(J2,J2.execute(), at=0.0)
252
253 s.simulate(until = 10.0)
254 assert R2.n == 0 , "Should be 0, it is "+str(R2.n)
255 lenW = len(R2.waitQ)
256 lenA = len(R2.activeQ)
257 assert lenW==0,"lenW Should be 0, it is "+str(lenW)
258 assert lenA==1,"lenA Should be 1, it is "+str(lenA)
259
261 """Test request3 with capacity = 1 several requests"""
262
263 s=SimulationTrace()
264 s.initialize()
265 R3 = Resource(capacity=1,name="3-version",unitName="blobs", sim = s)
266 J2= Job(name="job",server=R3, sim = s)
267 J3= Job(name="job",server=R3, sim = s)
268 J4= Job(name="job",server=R3, sim = s)
269 s.activate(J2,J2.execute(), at=0.0)
270 s.activate(J3,J3.execute(), at=0.0)
271 s.activate(J4,J4.execute(), at=0.0)
272
273 s.simulate(until = 10.0)
274 assert R3.n == 0 , "Should be 0, it is "+str(R3.n)
275 lenW = len(R3.waitQ)
276 lenA = len(R3.activeQ)
277 assert lenW==2,"lenW Should be 2, it is "+str(lenW)
278 assert R3.waitQ==[J3,J4],"WaitQ wrong"+str(R3.waitQ)
279 assert lenA==1,"lenA Should be 1, it is "+str(lenA)
280 assert R3.activeQ==[J2],"activeQ wrong, it is %s"%str(R3.activeQ[0])
281
283 """Test request4 with capacity = 2 several requests"""
284
285 s=SimulationTrace()
286 s.initialize()
287 R3 = Resource(capacity=2,name="4-version",unitName="blobs", sim = s)
288 J2= Job(name="job",server=R3, sim = s)
289 J3= Job(name="job",server=R3, sim = s)
290 J4= Job(name="job",server=R3, sim = s)
291 s.activate(J2,J2.execute(), at=0.0)
292 s.activate(J3,J3.execute(), at=0.0)
293 s.activate(J4,J4.execute(), at=0.0)
294
295 s.simulate(until = 10.0)
296 assert R3.n == 0 , "Should be 0, it is "+str(R3.n)
297 lenW = len(R3.waitQ)
298 lenA = len(R3.activeQ)
299 assert lenW==1,"lenW Should be 1, it is "+str(lenW)
300 assert R3.waitQ==[J4],"WaitQ wrong"+str(R3.waitQ)
301 assert lenA==2,"lenA Should be 2, it is "+str(lenA)
302 assert R3.activeQ==[J2,J3],"activeQ wrong, it is %s"%str(R3.activeQ[0])
303
304
305
307 """Test PriorityQ, with no preemption, 0 capacity"""
308 class Job(Process):
309 """ Job class for testing"""
310 def __init__(self,server=None,name="",sim=None):
311 Process.__init__(self,name = name,sim = sim)
312
313 self.R=server
314
315 def execute(self,priority):
316 yield request,self,self.R,priority
317
318 s=SimulationTrace()
319 s.initialize()
320 Rp = Resource(capacity=0,qType=PriorityQ,sim=s)
321 J5 = Job(name="job 5",server=Rp,sim=s)
322 J6 = Job(name="job 6",server=Rp,sim=s)
323 J7 = Job(name="job 7",server=Rp,sim=s)
324 s.activate(J5,J5.execute(priority=3))
325 s.activate(J6,J6.execute(priority=0))
326 s.activate(J7,J7.execute(priority=1))
327 s.simulate(until=100)
328 assert Rp.waitQ == [J5,J7,J6],"WaitQ wrong: %s"\
329 %str([(x.name,x.priority[Rp]) for x in Rp.waitQ])
330
331 """Test PriorityQ mechanism"""
332
333 def sorted(q):
334 if not q or len(q) == 1:
335 sortok=1
336 return sortok
337 sortok = q[0] >= q[1] and sorted(q[2:])
338 return sortok
339
340 s=SimulationTrace()
341 s.initialize()
342 Rp=Resource(capacity=0,qType=PriorityQ,sim=s)
343 for i in range(10):
344 J=Job(name="job "+str(i),server=Rp,sim=s)
345 s.activate(J,J.execute(priority=random()))
346 s.simulate(until=1000)
347 qp=[x._priority[Rp] for x in Rp.waitQ]
348 assert sorted(qp),"waitQ not sorted by priority: %s"\
349 %str([(x.name,x._priority[Rp]) for x in Rp.waitQ])
350
352 """Test PriorityQ, with no preemption, capacity == 1"""
353 class Job(Process):
354 """ Job class for testing"""
355 def __init__(self,server=None,name="",sim=None):
356 Process.__init__(self, name = name, sim = sim)
357
358 self.R=server
359
360 def execute(self,priority):
361 yield request,self,self.R,priority
362
363 s=SimulationTrace()
364 s.initialize()
365 Rp = Resource(capacity=1,qType=PriorityQ,sim=s)
366 J5 = Job(name="job 5",server=Rp,sim=s)
367 J6 = Job(name="job 6",server=Rp,sim=s)
368 J7 = Job(name="job 7",server=Rp,sim=s)
369 s.activate(J5,J5.execute(priority=2))
370 s.activate(J6,J6.execute(priority=4))
371 s.activate(J7,J7.execute(priority=3))
372 s.simulate(until=100)
373 assert Rp.waitQ == [J6,J7],"WaitQ wrong: %s"\
374 %[(x.name,x._priority[Rp]) for x in Rp.waitQ]
375
377 """Test PriorityQ, with preemption, capacity == 1"""
378 class nuJob(Process):
379 def __init__(self,name = "", sim=None):
380 Process.__init__(self, name = name, sim = sim)
381
382 def execute(self,res,priority):
383 self.preempt=len(res.activeQ) > 0\
384 and priority > res.activeQ[-1]._priority[res]
385 t=self.sim.now()
386 yield request,self,res,priority
387 if self.preempt:
388 assert len(res.waitQ) == 1, \
389 "No preemption activeQ= %s"%res.activeQ[0].name
390 yield hold,self,30
391 t1=self.sim.now()
392 if self.preempt:
393 assert t+30 == t1,\
394 "Wrong completion time for preemptor %s"%self.name
395 else:
396 assert t+60 == t1,\
397 "Wrong completion time for preempted %s %s:"\
398 %(self.name, self.sim.now())
399 yield release,self,res
400
401 s = SimulationTrace()
402 s.initialize()
403 res=Resource(name="server",capacity=1,qType=PriorityQ,preemptable=1,
404 sim=s)
405 n1=nuJob(name="nuJob 1",sim=s)
406 n2=nuJob(name="nuJob 2",sim=s)
407 s.activate(n1,n1.execute(res,priority=0))
408 s.activate(n2,n2.execute(res,priority=1),at=15)
409 s.simulate(until=100)
410
412 """Test preemption of preemptor"""
413 class nuJob(Process):
414 seqOut=[]
415 def __init__(self,name="",sim=None):
416 Process.__init__(self, name = name, sim = sim)
417 self.serviceTime=30
418
419 def execute(self,res,priority):
420 self.preempt=len(res.activeQ) > 0\
421 and priority > res.activeQ[-1]._priority[res]
422 nrwaiting=len(res.waitQ)
423 yield request,self,res,priority
424 if self.preempt:
425 assert len(res.waitQ) == nrwaiting + 1,\
426 "No preemption activeQ= %s"%res.activeQ[0].name
427 yield hold,self,self.serviceTime
428 yield release,self,res
429 nuJob.seqOut.append((self,self.sim.now()))
430
431 s=SimulationTrace()
432 s.initialize()
433 res=Resource(name="server",capacity=1,qType=PriorityQ,preemptable=1,
434 sim=s)
435 n1=nuJob(name="nuJob 1",sim=s)
436 n2=nuJob(name="nuJob 2",sim=s)
437 n3=nuJob(name="nuJob 3",sim=s)
438 s.activate(n1,n1.execute(res,priority=-1))
439 start2=10
440 s.activate(n2,n2.execute(res,priority=0),at=start2)
441 start3=20
442 s.activate(n3,n3.execute(res,priority=1),at=start3)
443 s.simulate(until=100)
444 assert [x[1] for x in nuJob.seqOut]\
445 == [start3+n3.serviceTime,start2+2*n2.serviceTime,90],\
446 "Wrong service sequence/times: %s"%[x[1] for x in nuJob.seqOut]
447
449 """Test that a process can preempt another process holding multiple resources
450 """
451 class Requestor(Process):
452 def run(self,res1,res2,res3,priority=1):
453 yield request,self,res1,priority
454 yield request,self,res2,priority
455 yield request,self,res3,priority
456 record.observe(t=s.now(),y=self.name)
457 yield hold,self,100
458 record.observe(t=s.now(),y=self.name)
459 yield release,self,res3
460 yield release,self,res2
461 yield release,self,res1
462
463 s=SimulationTrace()
464 s.initialize()
465 outer=Resource(name="outer",qType=PriorityQ,preemptable=True,sim=s)
466 inner=Resource(name="inner",qType=PriorityQ,preemptable=True,sim=s)
467 innermost=Resource(name="innermost",qType=PriorityQ,preemptable=True,
468 sim=s)
469 record=Monitor(sim=s)
470 r1=Requestor("r1",sim=s)
471 s.activate(r1,r1.run(res1=outer,res2=inner,res3=innermost,priority=1))
472 r2=Requestor("r2",sim=s)
473 s.activate(r2,r2.run(res1=outer,res2=inner,res3=innermost,priority=10),
474 at=50)
475 s.simulate(until=200)
476 assert record==[[0,"r1"],[50,"r2"],[150,"r2"],[200,"r1"]],\
477 "was %s; preempt did not work"%record
478
480 """ test monitoring of number in the two queues, waitQ and activeQ
481 """
482 class Job(Process):
483 def __init__(self,name='',sim=None):
484 Process.__init__(self,name = name,sim = sim)
485
486 def execute(self,res):
487 yield request,self,res
488 yield hold,self,2
489 yield release,self,res
490
491 s=SimulationTrace()
492 s.initialize()
493 res=Resource(name="server",capacity=1,monitored=1,sim=s)
494 n1=Job(name="Job 1",sim=s)
495 n2=Job(name="Job 2",sim=s)
496 n3=Job(name="Job 3",sim=s)
497 s.activate(n1,n1.execute(res),at=2)
498 s.activate(n2,n2.execute(res),at=2)
499 s.activate(n3,n3.execute(res),at=2)
500 s.simulate(until=100)
501 assert res.waitMon == [[2, 1], [2, 2], [4, 1], [6, 0]],\
502 'Wrong waitMon:%s'%res.waitMon
503 assert res.actMon == [[2, 1], [4, 0], [4, 1], [6, 0], [6, 1], [8, 0]],\
504 'Wrong actMon:%s'%res.actMon
505 self.assertAlmostEqual( res.waitMon.timeAverage(t=s.now()), (0*2+2*2+1*2)/6.0,2,
506 'Wrong waitMon.timeAverage:%s'%res.waitMon.timeAverage(t=s.now()))
507
509 suite = unittest.TestSuite()
510 testInit = makeResourcetestcase("testInit")
511 testrequest = makeResourcetestcase("testrequest")
512 testrequest2 = makeResourcetestcase("testrequest2")
513 testrequest3 = makeResourcetestcase("testrequest3")
514 testrequest4 = makeResourcetestcase("testrequest4")
515 testrequestPriority = makeResourcetestcase("testrequestPriority")
516 testrequestPriority1 = makeResourcetestcase("testrequestPriority1")
517 testrequestPriority2 = makeResourcetestcase("testrequestPriority2")
518 testrequestPriority3 = makeResourcetestcase("testrequestPriority3")
519 testrequestNestedPreempt = makeResourcetestcase("testrequestNestedPreempt")
520 testmonitored = makeResourcetestcase("testmonitored")
521
522 suite.addTests([testInit,testrequest,testrequest2,testrequest3,testrequest4,
523 testrequestPriority,testrequestPriority1,
524 testrequestPriority2,testrequestPriority3,
525 testrequestNestedPreempt,
526 testmonitored])
527 return suite
528
529
530
531
532
536
537 - def breakin(self,waitbefore,howoften=1):
538 for i in range(howoften):
539 yield hold,self,waitbefore
540 self.interrupt(victim)
541
545
547 global igothit
548 igothit={}
549 while self.sim.now()<=theEnd:
550 yield hold,self,howlong
551 if self.interrupted():
552 byWhom=self.interruptCause
553 igothit[self.sim.now()]=byWhom
554 else:
555 pass
556
558 """
559 Tests interrupts as defined in SEP001v17
560 """
575
576
577
593
607
609 """
610 Test multiple interrupts by multiple processes during victim activity
611 """
612 global victim
613 s=SimulationTrace()
614 s.initialize()
615 breaker1=Interruptor(sim=s)
616 s.activate(breaker1,breaker1.breakin(15,howoften=3))
617 breaker2=Interruptor(sim=s)
618 s.activate(breaker2,breaker2.breakin(20,howoften=3))
619 victim=Interrupted(sim=s)
620 s.activate(victim,victim.myActivity(100))
621 s.simulate(until=200)
622 for i in (15,30,45):
623 assert igothit[i] == breaker1, "Not interrupted at %s by breaker1" %i
624 for i in (20,40,60):
625 assert igothit[i] == breaker2, "Not interrupted at %s by breaker2" %i
626 assert len(igothit) == 6 , "Interrupted wrong number of times"
627
645
646 victim.newProcess=newProcess
647 s.activate(victim,newProcess(victim))
648 s.activate(breaker,breaker.breakin(10,howoften=3))
649 s.simulate(until=1000)
650
661
662
663
664
665
677
681
683 assert p.active(),"p not active"
684 assert not p.passive(), "p passive"
685 assert not p.terminated(),"p terminated"
686 assert not p.interrupted(),"p interrupted"
687 yield hold,self,11
688 assert not p.active(),"p active"
689 assert not p.passive(),"p passive"
690 assert p.terminated(),"p not terminated"
691 assert not p.interrupted(),"p interrupted"
692
694 assert not p.active(),"p active"
695 assert p.passive(),"p not passive"
696 assert not p.terminated(),"p not terminated"
697 assert not p.interrupted(),"p interrupted"
698 self.sim.activate(p,p.life1())
699 yield hold,self,11
700 assert not p.active(),"p active"
701 assert not p.passive(),"p not passive"
702 assert p.terminated(),"p not terminated"
703 assert not p.interrupted(),"p interrupted"
704
706 assert not p.active(),"p active"
707 assert p.passive(),"p not passive"
708 assert not p.terminated(),"p not terminated"
709 assert not p.interrupted(),"p interrupted"
710 self.sim.activate(p,p.life2())
711 yield hold,self,11
712 assert not p.active(),"p active"
713 assert p.passive(),"p not passive"
714 assert not p.terminated(),"p terminated"
715 assert not p.interrupted(),"p interrupted"
716
718 yield hold,self,5
719 assert p.active(),"p not active"
720 assert not p.passive(),"p passive"
721 assert not p.terminated(),"p terminated"
722 assert not p.interrupted(),"p interrupted"
723 self.cancel(p)
724 assert not p.active(),"p active"
725 assert p.passive(),"p not passive"
726 assert not p.terminated(),"p terminated"
727 assert not p.interrupted(),"p interrupted"
728 self.sim.reactivate(p)
729 assert p.active(),"p not active"
730 assert not p.passive(),"p passive"
731 assert not p.terminated(),"p terminated"
732 assert not p.interrupted(),"p interrupted"
733 yield hold,self
734 assert not p.active(),"p active"
735 assert not p.passive(),"p passive"
736 assert p.terminated(),"p terminated"
737 assert not p.interrupted(),"p interrupted"
738
740 yield hold,self,11
741 assert not p.active(),"p active"
742 assert p.passive(),"p not passive"
743 assert not p.terminated(),"p terminated"
744 assert not p.interrupted(),"p interrupted"
745 self.cancel(p)
746 assert not p.active(),"p active"
747 assert p.passive(),"p not passive"
748 assert not p.terminated(),"p terminated"
749 assert not p.interrupted(),"p interrupted"
750
768
772
773 - def look1(self,p1,p2,res):
774 assert p1.active(), "p1 not active"
775 assert not p1.queuing(res), "p1 queuing"
776 assert p2.active(), "p2 not active"
777 assert not p2.queuing(res), "p2 queuing"
778 yield hold,self,2
779 assert p1.active(), "p1 not active"
780 assert not p1.queuing(res), "p1 queuing"
781 assert p2.passive(), "p2 active"
782 assert p2.queuing(res), "p2 not queuing"
783
792
794 """
795 Tests states and state transitions as defined in SEP003
796 """
797
810
829
851
853 """
854 Test request/release state transitions
855 """
856
857 s=SimulationTrace()
858 s.initialize()
859 res=Resource(capacity=1,sim=s)
860 pq1=PS2(sim=s)
861 s.activate(pq1,pq1.life1(res))
862 pq2=PS2(sim=s)
863 s.activate(pq2,pq2.life1(res))
864 obq1=Observer2(sim=s)
865 s.activate(obq1,obq1.look1(pq1,pq2,res))
866 s.simulate(until=12)
867
868
869 s=SimulationTrace()
870 s.initialize()
871 res=Resource(capacity=1,sim=s)
872 pq3=PS2(sim=s)
873 s.activate(pq3,pq3.life2(res))
874 obq2=Observer2(sim=s)
875 s.activate(obq2,obq2.look2(pq3,res),prior=True)
876 s.simulate(until=12)
877
887
888
889
890
891
896 yield hold,self,1
897 ev1.signal("from SignalProcess")
898 while ev2.queues:
899 nq0=len(ev2.queues)
900 ev2.signal("from SignalProcess")
901 assert len(ev2.queues)==(nq0-1),"wrong number of processes dequeued"
902
907 yield waitevent,self,ev1
908 assert ev1.waits==[],"not all processes waiting for event out of waiting list"
909 assert ev1 in self.eventsFired,"did not record firing event"
910
915 yield queueevent,self,ev2
916 assert ev2 in self.eventsFired,"did not record firing event"
917
920 yield hold,self,1
921 ev1.signal("from SignalProcess")
922 yield hold,self,3
923 assert len(ev2.queues)==QueueProcessOR.nrProcesses,"wrong number of processes queuing for event ev2"
924 while ev2.queues:
925 nq0=len(ev2.queues)
926 ev2.signal("from SignalProcess")
927 assert len(ev2.queues)==(nq0-1),"wrong number of processes dequeued"
928 assert not ev2.queues,"not all processes queuing for ev2 dequeued"
929
934 yield waitevent,self,evset
935 for e in evset:
936 assert e.waits==[],"process not out of waiting list for all events in OR"
937
948
949
951 nrProcesses=0
956 yield queueevent,self,evset
957 occurred=False
958 for e in evset:
959 occurred=occurred or (e in self.eventsFired)
960 assert occurred,"queuing process activated by wrong event(s)"
961
973
975 """
976 Test SimEvent/signal as introduced with SimPy 1.5
977 """
978
980 """
981 Tests basic signal semantics
982 """
983 s=SimulationTrace()
984 s.initialize()
985 e=SimEvent(sim=s)
986 e.signal("param")
987 assert e.occurred,"signal does not set 'occurred' to True"
988 assert e.signalparam=="param","signal parameter wrong"
989 e.signal()
990 assert e.signalparam is None,"signal with no parameter did not overwrite signalparam"
991 e.signal()
992 assert e.occurred,"multiple calls to signal do not set 'occurred'"
993
1010
1012 """
1013 Tests waiting, queuing for at least one event out of a list/tuple.
1014 """
1015 si=SimulationTrace()
1016 si.initialize()
1017 e1=SimEvent("e1",sim=si)
1018 e2=SimEvent("e2",sim=si)
1019 e3=SimEvent("e3",sim=si)
1020 s=SignalProcessOR(sim=si)
1021 si.activate(s,s.makeSignal(e1,e3))
1022 w=WaitProcessOR(sim=si)
1023 si.activate(w,w.waitForSig([e1,e2]))
1024 for i in range(5):
1025 q=QueueProcessOR(sim=si)
1026 si.activate(q,q.queueForSig([e2,e3]))
1027 si.simulate(until=10)
1028
1037
1046
1057
1058
1059
1060
1061
1066 global a,b,c
1067 a=True
1068 yield hold,self,1
1069 b=True
1070 yield hold,self,1
1071 c=True
1072 yield hold,self,1
1073 assert waiter.terminated(),"waituntil did not fire"
1074
1079 def waitcond():
1080 return a and b and c
1081 yield waituntil,self,waitcond
1082
1084 """
1085 Test waituntil as introduced with SimPy 1.5
1086 """
1087
1098
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1116 """ Job class for testing timeout reneging
1117 """
1118 - def __init__(self,server=None,name="",sim=None):
1122
1123 - def execute(self,timeout,usetime):
1124 yield (request,self,self.res),(hold,self,timeout)
1125 if self.acquired(self.res):
1126 self.gotResource=True
1127 yield hold,self,usetime
1128 yield release,self,self.res
1129 else:
1130 self.gotResource=False
1131
1133 """ Job class for testing timeout reneging with priorities
1134 """
1135 - def __init__(self,server=None,name="",sim=None):
1139
1140 - def execute(self,timeout,usetime,priority):
1141 yield (request,self,self.res,priority),(hold,self,timeout)
1142 if self.acquired(self.res):
1143 self.gotResource=True
1144 yield hold,self,usetime
1145 yield release,self,self.res
1146 else:
1147 self.gotResource=False
1148
1150 """ Tests of "yield (request,self,res),(hold,self,delay)"
1151 timeout reneging command
1152 """
1154 """Test that resource gets acquired without timeout
1155 """
1156
1157 s=SimulationTrace()
1158 s.initialize()
1159 res=Resource(name="Server",capacity=1,sim=s)
1160 usetime=5
1161 timeout=1000000
1162 j1=JobTO(server=res,name="Job_1",sim=s)
1163 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1164 j2=JobTO(server=res,name="Job_2",sim=s)
1165 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1166 s.simulate(until=2*usetime)
1167 assert s.now()==2*usetime,"time not ==2*usetime"
1168 assert j1.gotResource and j2.gotResource,\
1169 "at least one job failed to get resource"
1170 assert not (res.waitQ or res.activeQ),\
1171 "job waiting or using resource"
1172
1174 """Test that resource gets acquired without timeout.
1175 Resource monitored.
1176 """
1177
1178 s=SimulationTrace()
1179 s.initialize()
1180 res=Resource(name="Server",capacity=1,monitored=True,sim=s)
1181 usetime=5
1182 timeout=1000000
1183 j1=JobTO(server=res,name="Job_1",sim=s)
1184 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1185 j2=JobTO(server=res,name="Job_2",sim=s)
1186 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1187 s.simulate(until=2*usetime)
1188 assert s.now()==2*usetime,"time not ==2*usetime"
1189 assert j1.gotResource and j2.gotResource,\
1190 "at least one job failed to get resource"
1191 assert not (res.waitQ or res.activeQ),\
1192 "job waiting or using resource"
1193 assert res.waitMon==[[0,1],[usetime,0]],"res.waitMon wrong: %s"%res.waitMon
1194
1196 """Test that timeout occurs when resource busy
1197 """
1198
1199 s=SimulationTrace()
1200 s.initialize()
1201 res=Resource(name="Server",capacity=1,sim=s)
1202 usetime=5
1203 timeout=3
1204 j1=JobTO(server=res,name="Job_1",sim=s)
1205 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1206 j2=JobTO(server=res,name="Job_2",sim=s)
1207 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1208 s.simulate(until=2*usetime)
1209 assert(s.now()==usetime),"time not ==usetime"
1210 assert(j1.gotResource),"Job_1 did not get resource"
1211 assert(not j2.gotResource),"Job_2 did not renege"
1212 assert not (res.waitQ or res.activeQ),\
1213 "job waiting or using resource"
1214
1216 """Test that timeout occurs when resource busy.
1217 Resource monitored.
1218 """
1219 s=SimulationTrace()
1220 s.initialize()
1221 res=Resource(name="Server",capacity=1,monitored=True,sim=s)
1222 usetime=5
1223 timeout=3
1224 j1=JobTO(server=res,name="Job_1",sim=s)
1225 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1226 j2=JobTO(server=res,name="Job_2",sim=s)
1227 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1228 s.simulate(until=2*usetime)
1229 assert(s.now()==usetime),"time not == usetime"
1230 assert(j1.gotResource),"Job_1 did not get resource"
1231 assert(not j2.gotResource),"Job_2 did not renege"
1232 assert not (res.waitQ or res.activeQ),\
1233 "job waiting or using resource"
1234 assert res.waitMon==[[0,1],[timeout,0]],"res.waitMon wrong: %s"%res.waitMon
1235
1237 """Test that timeout occurs when resource busy.
1238 Resource monitored. Requests with priority and preemption.
1239 """
1240 s=SimulationTrace()
1241 s.initialize()
1242 res=Resource(name="Server",capacity=1,monitored=True,
1243 qType=PriorityQ,preemptable=True,sim=s)
1244 usetime=5
1245 timeout=3
1246 j1=JobTO_P(server=res,name="Job_1",sim=s)
1247 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime,priority=1))
1248 j2=JobTO_P(server=res,name="Job_2",sim=s)
1249 j2_arrival=1
1250 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime,priority=5),
1251 at=j2_arrival)
1252 j3=JobTO_P(server=res,name="Job_2",sim=s)
1253 j3_arrival=2
1254 s.activate(j3,j3.execute(timeout=timeout,usetime=usetime,priority=10),
1255 at=j3_arrival)
1256 s.simulate(until=3*usetime)
1257 assert(s.now()== 3*usetime),"time not == 2* usetime, but %s"%now()
1258 assert(j1.gotResource),"Job_1 did not get resource"
1259 assert(j2.gotResource),"Job_2 did renege"
1260 assert(j2.gotResource),"Job_3 did renege"
1261 assert not (res.waitQ or res.activeQ),\
1262 "job waiting or using resource"
1263 assert res.waitMon==[[j2_arrival,1],[j3_arrival,2],[usetime+j3_arrival,1],[usetime+j2_arrival+usetime,0]],\
1264 "res.waitMon wrong: %s"%res.waitMon
1265
1267 """Test that timeout occurs when resource has no capacity free
1268 """
1269
1270 s=SimulationTrace()
1271 s.initialize()
1272 res=Resource(name="Server",capacity=0,sim=s)
1273 usetime=5
1274 timeout=3
1275 j1=JobTO(server=res,name="Job_1",sim=s)
1276 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1277 j2=JobTO(server=res,name="Job_2",sim=s)
1278 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1279 s.simulate(until=2*usetime)
1280 assert s.now()==timeout,"time %s not == timeout"%s.now()
1281 assert not j1.gotResource,"Job_1 got resource"
1282 assert not j2.gotResource,"Job_2 got resource"
1283 assert not (res.waitQ or res.activeQ),\
1284 "job waiting or using resource"
1285
1287 """Test that timeout occurs when resource has no capacity free.
1288 Resource monitored.
1289 """
1290
1291 s=SimulationTrace()
1292 s.initialize()
1293 res=Resource(name="Server",capacity=0,monitored=True,sim=s)
1294 usetime=5
1295 timeout=3
1296 j1=JobTO(server=res,name="Job_1",sim=s)
1297 s.activate(j1,j1.execute(timeout=timeout,usetime=usetime))
1298 j2=JobTO(server=res,name="Job_2",sim=s)
1299 s.activate(j2,j2.execute(timeout=timeout,usetime=usetime))
1300 s.simulate(until=2*usetime)
1301 assert s.now()==timeout,"time %s not == timeout"%s.now()
1302 assert not j1.gotResource,"Job_1 got resource"
1303 assert not j2.gotResource,"Job_2 got resource"
1304 assert not (res.waitQ or res.activeQ),\
1305 "job waiting or using resource"
1306 assert res.waitMon==[[0,1],[0,2],[timeout,1],[timeout,0]],\
1307 "res.waitMon is wrong: %s"%res.waitMon
1308
1322
1323
1324
1325
1326
1327
1328
1329
1331 """ Job class for testing event reneging
1332 """
1333 - def __init__(self,server=None,name="",sim=None):
1337
1339 yield (request,self,self.res),(waitevent,self,event)
1340 if self.acquired(self.res):
1341 self.gotResource=True
1342 yield hold,self,usetime
1343 yield release,self,self.res
1344 else:
1345 self.gotResource=False
1346
1348 """ Job class for testing event reneging with multi-event lists
1349 """
1350 - def __init__(self,server=None,name="",sim=None):
1354
1355 - def execute(self,eventlist,usetime):
1356 yield (request,self,self.res),(waitevent,self,eventlist)
1357 if self.acquired(self.res):
1358 self.gotResource=True
1359 yield hold,self,usetime
1360 yield release,self,self.res
1361 else:
1362 self.gotResource=False
1363
1365 """Fires reneging event
1366 """
1369 - def fire(self,fireDelay,event):
1370 yield hold,self,fireDelay
1371 event.signal()
1372
1374 """Tests of "yield (request,self,res),(waiteevent,self,event)"
1375 event reneging command
1376 """
1378 """Test that processes acquire resource normally if no event fires
1379 """
1380 s=SimulationTrace()
1381 s.initialize()
1382 event=SimEvent("Renege_trigger",sim=s)
1383 res=Resource(name="Server",capacity=1,sim=s)
1384 usetime=5
1385 j1=JobEvt(server=res,name="Job_1",sim=s)
1386 s.activate(j1,j1.execute(event=event,usetime=usetime))
1387 j2=JobEvt(server=res,name="Job_2",sim=s)
1388 s.activate(j2,j2.execute(event=event,usetime=usetime))
1389 s.simulate(until=2*usetime)
1390
1391 assert s.now()==2*usetime,"time not ==2*usetime"
1392 assert j1.gotResource and j2.gotResource,\
1393 "at least one job failed to get resource"
1394 assert not (res.waitQ or res.activeQ),\
1395 "job waiting or using resource"
1396
1398 """Test that processes acquire resource normally if no event fires.
1399 Resource monitored.
1400 """
1401 s=SimulationTrace()
1402 s.initialize()
1403 res=Resource(name="Server",capacity=1,monitored=True,sim=s)
1404 event=SimEvent("Renege_trigger",sim=s)
1405 usetime=5
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 s.simulate(until=2*usetime)
1411
1412 assert s.now()==2*usetime,"time not ==2*usetime"
1413 assert j1.gotResource and j2.gotResource,\
1414 "at least one job failed to get resource"
1415 assert not (res.waitQ or res.activeQ),\
1416 "job waiting or using resource"
1417 assert res.waitMon==[[0,1],[usetime,0]],"res.waitMoni is wrong: %s"%res.waitMon
1418
1420 """Test that signalled event leads to renege when resource busy
1421 """
1422
1423 s=SimulationTrace()
1424 s.initialize()
1425 res=Resource(name="Server",capacity=1,sim=s)
1426 event=SimEvent("Renege_trigger",sim=s)
1427 usetime=5
1428 eventtime=1
1429 j1=JobEvt(server=res,name="Job_1",sim=s)
1430 s.activate(j1,j1.execute(event=event,usetime=usetime))
1431 j2=JobEvt(server=res,name="Job_2",sim=s)
1432 s.activate(j2,j2.execute(event=event,usetime=usetime))
1433 f=FireEvent(name="FireEvent",sim=s)
1434 s.activate(f,f.fire(fireDelay=eventtime,event=event))
1435 s.simulate(until=2*usetime)
1436
1437 assert(s.now()==usetime),"time not ==usetime"
1438 assert(j1.gotResource),"Job_1 did not get resource"
1439 assert(not j2.gotResource),"Job_2 did not renege"
1440 assert not (res.waitQ or res.activeQ),\
1441 "job waiting or using resource"
1442
1444 """Test that signalled event leads to renege when resource busy.
1445 Resource monitored.
1446 """
1447
1448 s=SimulationTrace()
1449 s.initialize()
1450 res=Resource(name="Server",capacity=1,monitored=True,sim=s)
1451 event=SimEvent("Renege_trigger",sim=s)
1452 usetime=5
1453 eventtime=1
1454 j1=JobEvt(server=res,name="Job_1",sim=s)
1455 s.activate(j1,j1.execute(event=event,usetime=usetime))
1456 j2=JobEvt(server=res,name="Job_2",sim=s)
1457 s.activate(j2,j2.execute(event=event,usetime=usetime))
1458 f=FireEvent(name="FireEvent",sim=s)
1459 s.activate(f,f.fire(fireDelay=eventtime,event=event))
1460 s.simulate(until=2*usetime)
1461
1462 assert(s.now()==usetime),"time not == usetime"
1463 assert(j1.gotResource),"Job_1 did not get resource"
1464 assert(not j2.gotResource),"Job_2 did not renege"
1465 assert not (res.waitQ or res.activeQ),\
1466 "job waiting or using resource"
1467 assert res.waitMon==[[0,1],[eventtime,0]],"res.waitMon is wrong: %s"%res.waitMon
1468
1470 """Test that renege-triggering event can be one of an event list
1471 """
1472
1473 s=SimulationTrace()
1474 s.initialize()
1475 res=Resource(name="Server",capacity=1,sim=s)
1476 event1=SimEvent("Renege_trigger_1",sim=s)
1477 event2=SimEvent("Renege_trigger_2",sim=s)
1478 usetime=5
1479 eventtime=1
1480 j1=JobEvtMulti(server=res,name="Job_1",sim=s)
1481 s.activate(j1,j1.execute(eventlist=[event1,event2],usetime=usetime))
1482 j2=JobEvtMulti(server=res,name="Job_2",sim=s)
1483 s.activate(j2,j2.execute(eventlist=[event1,event2],usetime=usetime))
1484 f1=FireEvent(name="FireEvent_1",sim=s)
1485 s.activate(f1,f1.fire(fireDelay=eventtime,event=event1))
1486 f2=FireEvent(name="FireEvent_2",sim=s)
1487 s.activate(f2,f2.fire(fireDelay=eventtime,event=event2))
1488 s.simulate(until=2*usetime)
1489
1490 assert(s.now()==usetime),"time not ==usetime"
1491 assert(j1.gotResource),"Job_1 did not get resource"
1492 assert(not j2.gotResource),"Job_2 did not renege"
1493 assert not (res.waitQ or res.activeQ),\
1494 "job waiting or using resource"
1495
1497 """Test that renege-triggering event can be one of an event list.
1498 Resource monitored.
1499 """
1500
1501 s=SimulationTrace()
1502 s.initialize()
1503 res=Resource(name="Server",capacity=1,monitored=True,sim=s)
1504 event1=SimEvent("Renege_trigger_1",sim=s)
1505 event2=SimEvent("Renege_trigger_2",sim=s)
1506 usetime=5
1507 eventtime=1
1508 j1=JobEvtMulti(server=res,name="Job_1",sim=s)
1509 s.activate(j1,j1.execute(eventlist=[event1,event2],usetime=usetime))
1510 j2=JobEvtMulti(server=res,name="Job_2",sim=s)
1511 s.activate(j2,j2.execute(eventlist=[event1,event2],usetime=usetime))
1512 f1=FireEvent(name="FireEvent_1",sim=s)
1513 s.activate(f1,f1.fire(fireDelay=eventtime,event=event1))
1514 f2=FireEvent(name="FireEvent_2",sim=s)
1515 s.activate(f2,f2.fire(fireDelay=eventtime,event=event2))
1516 s.simulate(until=2*usetime)
1517
1518 assert(s.now()==usetime),"time not ==usetime"
1519 assert(j1.gotResource),"Job_1 did not get resource"
1520 assert(not j2.gotResource),"Job_2 did not renege"
1521 assert not (res.waitQ or res.activeQ),\
1522 "job waiting or using resource"
1523 assert res.waitMon==[[0,1],[eventtime,0]],"res.waitMon is wrong: %s"%res.waitMon
1524
1537
1538
1539
1540
1541
1542
1544 produced=0
1553 """PriorityQ for Producers"""
1554 Producer.produced+=4
1555 yield put,self,buffer,4,priority
1556 yield hold,self,1
1557 self.done=self.sim.now()
1558 doneList.append(self.name)
1560 for i in range(4):
1561 yield put,self,buffer,4
1562 yield hold,self,1
1564 consumed=0
1568 """FIFO"""
1569 yield get,self,buffer
1570 Consumer.consumed+=1
1571 assert self.got==1,"wrong self.got: %s"%self.got
1572 yield get,self,buffer,3
1573 Consumer.consumed+=3
1574 assert self.got==3,"wrong self.got: %s"%self.got
1575
1577 """producer PriorityQ, consumer FIFO"""
1578 while True:
1579 yield get,self,buffer,2
1580 yield hold,self,1
1582 """PriorityQ for Consumers"""
1583 yield get,self,buffer,4,priority
1584 doneList.append(self.name)
1585
1586
1590 - def produce(self,buffer,productionTime):
1591 while True:
1592 assert not(buffer.amount>0 and len(buffer.getQ)>0),\
1593 "Consumer(s) waiting while buffer not empty"
1594 yield hold,self,productionTime
1595 yield put,self,buffer,1
1596
1600 - def consume(self,buffer,consumptionTime):
1601 while True:
1602 assert not(buffer.amount==0 and len(buffer.putQ)>0),\
1603 "Producer(s) waiting while buffer empty"
1604 yield get,self,buffer,1
1605 yield hold,self,consumptionTime
1606
1607
1608
1611 """Tests initialization of Level instances
1612 """
1613 s=SimulationTrace()
1614 s.initialize()
1615 a=Level(sim=s)
1616 assert a.capacity==sys.maxint,"wrong capacity:%s"%a
1617 assert a.amount==0,"wrong buffer content: %s"%a
1618 assert a.name=="a_level","wrong name: %s"%a
1619 assert not a.monitored,"should not be monitored: %s"%a
1620 assert a.putQMon is None,"should not have putQMon: %s"%a
1621 assert a.getQMon is None,"should not have getQMon: %s"%a
1622 assert a.bufferMon is None,"should not have bufferMon: %s"%a
1623 assert a.putQType.__name__=="FIFO" and a.getQType.__name__=="FIFO",\
1624 "putQType and getQType should be FIFO: %s"%a
1625
1626 b=Level(name="b",initialBuffered=10.0,monitored=True,capacity=12,
1627 putQType=PriorityQ,sim=s)
1628 a=Level(sim=s)
1629 assert b.capacity==12,"wrong capacity:%s"%b
1630 assert b.amount==10,"wrong buffer content: %s"%b
1631 assert b.name=="b","wrong name: %s"%b
1632 assert b.monitored,"should be monitored: %s"%b
1633 assert not (b.putQMon is None),"should have putQMon: %s"%b
1634 assert not (b.getQMon is None),"should have getQMon: %s"%b
1635 assert not (b.bufferMon is None),"should have bufferMon: %s"%b
1636 assert b.putQType.__name__=="PriorityQ",\
1637 "putQType should be PriorityQ: %s"%b
1638 assert b.getQType.__name__=="FIFO",\
1639 "getQType should be PriorityQ: %s"%b
1640
1642 """Level: tests basic Producer/Consumer principles:
1643 - Consumers must not be waiting while Level buffer value > 0,
1644 - Producers must not be waiting while Level buffer value == 0
1645 """
1646 s=SimulationTrace()
1647 s.initialize()
1648 bufferSize=1
1649 productionTime=1
1650 consumptionTime=5
1651 endtime=50
1652 buffer=Level(capacity=bufferSize,sim=s)
1653 consumer=ConsumerPrincL(sim=s)
1654 s.activate(consumer,consumer.consume(buffer,consumptionTime))
1655 producer=ProducerPrincL(sim=s)
1656 s.activate(producer,producer.produce(buffer,productionTime))
1657 s.simulate(until=endtime)
1658
1672
1690
1692 """Level: tests put/get in multiple Producer/Consumer scenario,
1693 with Producers having different priorities.
1694 How: Producers forced to queue; all after first should be done in
1695 priority order
1696 """
1697 global doneList
1698 doneList=[]
1699 s=SimulationTrace()
1700 s.initialize()
1701 buffer=Level(capacity=7,putQType=PriorityQ,monitored=True,sim=s)
1702 for i in range(4):
1703 p=Producer(str(i) ,sim=s)
1704 pPriority=i
1705 s.activate(p,p.producePriority(buffer=buffer,priority=pPriority))
1706 c=Consumer(sim=s)
1707 s.activate(c,c.consume1(buffer=buffer))
1708 s.simulate(until=100)
1709 assert doneList==["0","3","2","1"],"puts were not done in priority order: %s"\
1710 %doneList
1711
1713 """Level: tests put/get in multiple Producer/Consumer scenario, with
1714 Consumers having different priorities.
1715 How: Consumers forced to queue; all after first should be done in
1716 priority order
1717 """
1718 global doneList
1719 doneList=[]
1720 s=SimulationTrace()
1721 s.initialize()
1722 buffer=Level(capacity=7,getQType=PriorityQ,monitored=True,sim=s)
1723 for i in range(4):
1724 c=Consumer(str(i), sim=s)
1725 cPriority=i
1726 s.activate(c,c.consumePriority(buffer=buffer,priority=cPriority))
1727 p=Producer(sim=s)
1728 s.activate(p,p.produce1(buffer=buffer))
1729 s.simulate(until=100)
1730 assert doneList==["3","2","1","0"],"gets were not done in priority order: %s"\
1731 %doneList
1732
1744
1745
1746
1747
1748
1749
1750
1775
1803
1807
1809 """Sorts Widget instances by weight attribute."""
1810 tmplist=[(x.weight,x) for x in par]
1811 tmplist.sort()
1812 return [x for (key,x) in tmplist]
1813
1814
1818 - def produce(self,buffer,productionTime):
1819 while True:
1820 assert not(buffer.nrBuffered>0 and len(buffer.getQ)>0),\
1821 "Consumer(s) waiting while buffer not empty"
1822 yield hold,self,productionTime
1823 product=WidgetPrinc()
1824 yield put,self,buffer,[product]
1825
1829 - def consume(self,buffer,consumptionTime):
1830 while True:
1831 assert not(buffer.nrBuffered==0 and buffer.putQ),\
1832 "Producer(s) waiting while buffer empty"
1833 yield get,self,buffer,1
1834 yield hold,self,consumptionTime
1835
1838
1840 """Used in testBufferFilter"""
1846
1848 """get all items with weight between a and b"""
1849 def between_a_and_b(buf):
1850 res=[]
1851 for item in buf:
1852 if a<item.weight<b:
1853 res.append(item)
1854
1855 all=store.buffered
1856 yield get,self,store,between_a_and_b
1857 "All retrieved items weight in range?"
1858 for it in self.got:
1859 assert a<it.weight<b,"weight %s not in range %s..%s"\
1860 %(it.weight,a,b)
1861 "Any item fitting filter pred left in buffer?"
1862 for it in store.buffer:
1863 assert not (a<it.weight<b),\
1864 "item left in buffer which fits filter (%s<%s<%s)"\
1865 %(a,it.weight,b)
1866 "All items either in store.buffer of self.got?"
1867 for it in all:
1868 assert (it in self.buffer) or (it in self.got),\
1869 "item w. weight %s neither in store nor in got"%it.weight
1870
1871
1872
1875 """Store: tests initialization of Store instances
1876 """
1877 s=SimulationTrace()
1878 s.initialize()
1879 a=Store(sim=s)
1880 assert a.capacity==sys.maxint,"wrong capacity:%s"%a
1881 assert a.nrBuffered==0,"wrong buffer content: %s"%a
1882 assert a.name=="a_store","wrong name: %s"%a
1883 assert not a.monitored,"should not be monitored: %s"%a
1884 assert a.putQMon is None,"should not have putQMon: %s"%a
1885 assert a.getQMon is None,"should not have getQMon: %s"%a
1886 assert a.bufferMon is None,"should not have bufferMon: %s"%a
1887 assert a.putQType.__name__=="FIFO" and a.getQType.__name__=="FIFO",\
1888 "putQType and getQType should be FIFO: %s"%a
1889
1890 stored=[Widget(weight=5)]*10
1891 b=Store(name="b",initialBuffered=stored,monitored=True,capacity=12,
1892 putQType=PriorityQ,sim=s)
1893 assert b.capacity==12,"wrong capacity:%s"%b
1894 assert b.nrBuffered==10,"wrong buffer content: %s"%b
1895 assert b.name=="b","wrong name: %s"%b
1896 assert b.monitored,"should be monitored: %s"%b
1897 assert not (b.putQMon is None),"should have putQMon: %s"%b
1898 assert not (b.getQMon is None),"should have getQMon: %s"%b
1899 assert not (b.bufferMon is None),"should have bufferMon: %s"%b
1900 assert b.putQType.__name__=="PriorityQ",\
1901 "putQType should be PriorityQ: %s"%b
1902 assert b.getQType.__name__=="FIFO",\
1903 "getQType should be PriorityQ: %s"%b
1904
1906 """Store: tests basic Producer/Consumer principles:
1907 - Consumers must not be waiting while items in Store buffer,
1908 - Producers must not be waiting while space available in Store buffer
1909 """
1910 bufferSize=1
1911 productionTime=1
1912 consumptionTime=5
1913 endtime=50
1914 s=SimulationTrace()
1915 s.initialize()
1916 buffer=Store(capacity=bufferSize,sim=s)
1917 consumer=ConsumerPrincS(sim=s)
1918 s.activate(consumer,consumer.consume(buffer,consumptionTime))
1919 producer=ProducerPrincS(sim=s)
1920 s.activate(producer,producer.produce(buffer,productionTime))
1921 s.simulate(until=endtime)
1922
1937
1955
1957 """Store: Tests put/get in multiple Producer/Consumer scenario,
1958 with Producers having different priorities.
1959 How; Producers forced to queue; all after first should be done in
1960 priority order
1961 """
1962 global doneList
1963 doneList=[]
1964 s=SimulationTrace()
1965 s.initialize()
1966 buffer=Store(capacity=7,putQType=PriorityQ,monitored=True,sim=s)
1967 for i in range(4):
1968 p=ProducerWidget(name=str(i), sim=s)
1969 pPriority=i
1970 s.activate(p,p.producePriority(buffer=buffer,priority=pPriority))
1971 c=ConsumerWidget(sim=s)
1972 s.activate(c,c.consume1(buffer=buffer))
1973 s.simulate(until=100)
1974 assert doneList==["0","3","2","1"],"puts were not done in priority order: %s"\
1975 %doneList
1976
1978 """Tests put/get in multiple Producer/Consumer scenario, with
1979 Consumers having different priorities.
1980 How; Consumers forced to queue; all after first should be done in
1981 priority order
1982 """
1983 global doneList
1984 doneList=[]
1985 s=SimulationTrace()
1986 s.initialize()
1987 buffer=Store(capacity=7,getQType=PriorityQ,monitored=True,sim=s)
1988 for i in range(4):
1989 c=ConsumerWidget(name=str(i),sim=s)
1990 cPriority=i
1991 s.activate(c,c.consumePriority(buffer=buffer,priority=cPriority))
1992 p=ProducerWidget(sim=s)
1993 s.activate(p,p.produce1(buffer=buffer))
1994 s.simulate(until=100)
1995 assert doneList==["3","2","1","0"],\
1996 "gets were not done in priority order: %s"%doneList
1997
1999 """Tests the optional sorting of theBuffer by applying a user-defined
2000 sort function."""
2001 s=SimulationTrace()
2002 s.initialize()
2003 gotten=[]
2004 sortedStore=Store(sim=s)
2005 sortedStore.addSort(mySortFunc)
2006 p=ProducerWidget(sim=s)
2007 s.activate(p,p.produceUnordered(sortedStore))
2008 for i in range(9):
2009 c=ConsumerWidget(sim=s)
2010 s.activate(c,c.consumeSorted(buffer=sortedStore,gotten=gotten),at=1)
2011 s.simulate(until=10)
2012 assert gotten==[1,2,3,4,5,6,7,8,9],"sort wrong: %s"%gotten
2013
2026
2041
2042
2043
2044
2045
2046
2047 -class TBT(Process):
2048 """Store: For testBasicTime"""
2051 - def tbt(self,store):
2052 yield get,self,store,1
2053 assert self.got,"Did not get Item"
2054 yield (get,self,store,1),(hold,self,5)
2055 if self.acquired(store):
2056 assert len(self.got)==1,"did not get 1 Item"
2057 else:
2058 assert not self.got and self.sim.now()==5 and not store.getQ,\
2059 "time renege not working"
2060
2061 -class TBE(Process):
2062 """Store: For testBasicEvent"""
2065 - def tbe(self,store,trigger):
2066 yield get,self,store,1
2067 assert self.got,"Did not get Item"
2068 yield (get,self,store,1),(waitevent,self,trigger)
2069 if self.acquired(store):
2070 assert False, "should have reneged"
2071 else:
2072 assert self.eventsFired[0]==trigger and self.sim.now()==5 \
2073 and not store.getQ,"event renege not working"
2074
2076 """Store: For testBasicEvent"""
2079 - def fire(self,trigger):
2082
2083
2085 """Store: for testBasicTimePut"""
2088 - def tbt(self,store):
2089 class Item:pass
2090 yield (put,self,store,[Item()]),(hold,self,4)
2091 if self.stored(store):
2092 assert store.nrBuffered==1 and not store.putQ,\
2093 "put did not execute"
2094 else:
2095 assert False,"should not have reneged"
2096 yield (put,self,store,[Item()]),(hold,self,5)
2097 if self.stored(store):
2098 assert False,"should have reneged"
2099 else:
2100 assert store.nrBuffered==1 and not store.putQ,\
2101 "renege not working correctly"
2102
2104 """Store: for testBasicEventPut"""
2107 - def tbe(self,store,trigger):
2108 class Item:pass
2109 yield (put,self,store,[Item()]),(waitevent,self,trigger)
2110 if self.stored(store):
2111 assert store.nrBuffered==1 and not store.putQ,\
2112 "put did not execute"
2113 else:
2114 assert False,"should have not have reneged"
2115 yield (put,self,store,[Item()]),(waitevent,self,trigger)
2116 if self.stored(store):
2117 assert False,"should have reneged"
2118 else:
2119 assert self.sim.now()==5 and self.eventsFired[0]==trigger\
2120 and not store.putQ,"renege not working correctly"
2121
2123 """Store: For testBasicEventPut"""
2126 - def fire(self,trigger):
2129
2131 """Store: Testcase for compound get statements"""
2132
2133
2134
2135
2136
2137
2148
2149
2150
2151
2152
2153
2163
2165 """Store (monitored):
2166 test monitors with 'yield (put,self,store),(hold,self,time)"""
2167 s=SimulationTrace()
2168 s.initialize()
2169 st=Store(capacity=1,monitored=True,sim=s)
2170 t=TBTput(sim=s)
2171 s.activate(t,t.tbt(store=st))
2172 s.simulate(until=10)
2173
2174 assert st.putQMon==[[0,0],[0,1],[5,0]],"putQMon wrong: %s"\
2175 %st.putQMon
2176
2177 assert st.bufferMon==[[0,0],[0,1]],"bufferMon wrong: %s"%st.bufferMon
2178
2179
2180
2181
2182
2183
2197
2198
2199
2200
2201
2202
2215
2217 """Store (monitored):
2218 test monitors with 'yield (put,self,store),(waitevent,self,event)"""
2219 si=SimulationTrace()
2220 si.initialize()
2221 s=SimEvent(sim=si)
2222 st=Store(capacity=1,monitored=True,sim=si)
2223 t=TBEtriggerPut(sim=si)
2224 si.activate(t,t.fire(trigger=s))
2225 tb=TBEput(sim=si)
2226 si.activate(tb,tb.tbe(store=st,trigger=s))
2227 si.simulate(until=10)
2228
2229 assert st.putQMon==[[0,0],[0,1],[5,0]],"putQMon wrong: %s"\
2230 %st.putQMon
2231
2232 assert st.bufferMon==[[0,0],[0,1]],"bufferMon wrong: %s"%st.bufferMon
2233
2249
2250
2251
2252
2253
2254
2256 """Level: For testBasicTime"""
2259 - def tbt(self,level):
2260 yield get,self,level,1
2261 assert self.got,"did not get 1 unit"
2262 yield (get,self,level,1),(hold,self,5)
2263 if self.acquired(level):
2264 assert self.got==1,"did not get 1 unit"
2265 else:
2266 assert not self.got and self.sim.now()==5,\
2267 "time renege not working"
2268
2270 """Level: For testBasicEvent"""
2273 - def tbe(self,level,trigger):
2274 yield get,self,level,1
2275 assert self.got,"did not get 1 unit"
2276 yield (get,self,level,1),(waitevent,self,trigger)
2277 if self.acquired(level):
2278 assert self.got==1,"did not get 1 Item"
2279 else:
2280 assert self.sim.now()==5.5 and self.eventsFired[0]==trigger,\
2281 "event renege not working"
2282
2284 """Level: For testBasicEvent"""
2287 - def fire(self,trigger):
2290
2292 """Level: For testBasicTimePut"""
2295 - def tbt(self,level):
2296 yield put,self,level,1
2297 assert level.amount,"did not put 1 unit"
2298 yield (put,self,level,1),(hold,self,5)
2299 if self.stored(level):
2300 assert False,"should have reneged"
2301 else:
2302 assert level.amount==1 and self.sim.now()==5,\
2303 "time renege not working"
2304
2306 """Level: For testBasicEventPut and testBasicEventPutM"""
2309 - def tbe(self,level,trigger):
2310 yield (put,self,level,1),(waitevent,self,trigger)
2311 if self.stored(level):
2312 assert level.amount==1,"did not put 1 unit"
2313 else:
2314 assert False,"should not have reneged"
2315 yield (put,self,level,1),(waitevent,self,trigger)
2316 if self.stored(level):
2317 assert False, "should have reneged"
2318 else:
2319 assert self.sim.now()==5.5 and self.eventsFired[0]==trigger ,\
2320 "renege not working"
2321
2323 """Level: For testBasicEventPut"""
2326 - def fire(self,trigger):
2329
2331 """Level: Testcase for compound get and put statements"""
2332
2333
2334
2335
2336
2337
2348
2349
2350
2351
2352
2353
2363
2364
2365
2366
2367
2368
2381
2383 """Level (monitored):
2384 test monitors with 'yield (get,self,level),(waitevent,self,event)"""
2385 s=SimulationTrace()
2386 s.initialize()
2387 l=Level(initialBuffered=1,monitored=True,sim=s)
2388 trig=SimEvent(sim=s)
2389 t=TBELev(sim=s)
2390 s.activate(t,t.tbe(level=l,trigger=trig))
2391 tr=TBEtriggerLev(sim=s)
2392 s.activate(tr,tr.fire(trigger=trig))
2393 s.simulate(until=10)
2394
2395 assert l.getQMon==[[0,0],[0,1],[5.5,0]],"getQMon not working: %s"\
2396 %l.getQMon
2397
2398 assert l.bufferMon==[[0,1],[0,0]],\
2399 "bufferMon not working: %s"%l.bufferMon
2400
2401
2402
2403
2404
2405
2418
2420 """Level (monitored):
2421 test monitors with 'yield (put,self,level),(waitevent,self,event)"""
2422 s=SimulationTrace()
2423 s.initialize()
2424 l=Level(capacity=1,monitored=True,sim=s)
2425 trig=SimEvent(sim=s)
2426 t=TBELevPut(sim=s)
2427 s.activate(t,t.tbe(level=l,trigger=trig))
2428 tr=TBEtriggerLevPut(sim=s)
2429 s.activate(tr,tr.fire(trigger=trig))
2430 s.simulate(until=10)
2431 "First put succeeds, second reneges at t=5.5?"
2432 assert l.putQMon==[[0,0],[0,1],[5.5,0]],"putQMon wrong: %s"\
2433 %l.putQMon
2434 "1 unit added at t=0, renege at t=5 before 2nd unit added?"
2435 assert l.bufferMon==[[0,0],[0,1]],"bufferMon wrong: %s"%l.bufferMon
2436
2451
2452 if __name__ == '__main__':
2453 alltests = unittest.TestSuite((
2454 makeSSuite(),
2455 makeRSuite(),
2456 makeISuite(),
2457 makePSuite(),
2458 makeESuite(),
2459 makeWSuite(),
2460 makeTOSuite(),
2461 makeEvtRenegeSuite(),
2462 makeLevelSuite(),
2463 makeStoreSuite(),
2464 makeStoreCompSuite(),
2465 makeLevelCompSuite(),
2466 makeMSuite()
2467 ))
2468
2469 runner = unittest.TextTestRunner()
2470 runner.run(alltests)
2471
2472