def testRemove(self):
'''Test the remove Method'''
a = OrderedSet()
event1 = CounterEvent(2)
event2 = CounterEvent(1)
event3 = CounterEvent(0.5)
event4 = CounterEvent(4.5)
#Start Inserting
#---------------------------------------------------------------------------------
a.insert(event1)
a.insert(event2)
a.insert(event3)
a.insert(event4)
#Testing Remove
#---------------------------------------------------------------------------------
self.assertEqual(
'[<Event: 0.5>*, <Event: 1.0>, <Event: 2.0>, <Event: 4.5>]',
str(a))
a.remove(event3)
self.assertEqual('[<Event: 1.0>*, <Event: 2.0>, <Event: 4.5>]', str(a))
a.remove(event1)
self.assertEqual('[<Event: 1.0>*, <Event: 4.5>]', str(a))
a.remove(event2)
a.remove(event4)
self.assertEqual('[]', str(a))
def testInsert_CounterEvent_reposition(self):
'''Test Case for insertion------When thing to be inserted already in the set'''
a=OrderedSet()
event1 = CounterEvent(2)
event2 = CounterEvent(1)
event3 = CounterEvent(0.5)
event4 = CounterEvent(4.5)
#Insert Events in first
#Check the result
#Change Event 3
#Check again(Event Time Is changed/ Event Order is not chagned (wrong order))
#Insert Event 3
#Check again (Now ORder Should be Corrected)
#---------------------------------------------------------------------------------
a.insert(event1)
a.insert(event2)
a.insert(event3)
a.insert(event4)
self.assertEqual('[<Event: 0.5>*, <Event: 1.0>, <Event: 2.0>, <Event: 4.5>]',str(a))
event3.item = 4.75
self.assertEqual('[<Event: 4.75>*, <Event: 1.0>, <Event: 2.0>, <Event: 4.5>]',str(a))
print (a)
a.insert(event3)
self.assertEqual('[<Event: 1.0>*, <Event: 2.0>, <Event: 4.5>, <Event: 4.75>]',str(a))
def testConstructor(self):
e = CounterEvent(4)
self.assertEqual(str(e), '<Event: 4.0>')
e = CounterEvent(2)
self.assertEqual(str(e), '<Event: 2.0>')
e = CounterEvent(2.5)
self.assertEqual(str(e), '<Event: 2.5>')
def test_in_overloading(self):
''' Test the "in" operator overloading'''
a = OrderedSet()
event1 = CounterEvent(4)
event2 = CounterEvent(5)
event3 = CounterEvent(5.5)
event4 = CounterEvent(4)
a.insert(event1)
a.insert(event2)
a.insert(event3)
self.assertEqual(True, event1 in a)
self.assertEqual(False, event4 in a)
def testInsert_CounterEvent(self):
temp = []
event1 = CounterEvent(2)
event2 = CounterEvent(1)
event3 = CounterEvent(0.5)
event4 = CounterEvent(1)
#case1
#Distinctive event time
#CHeck both use str() method and getset method
#The advantage of getset method is that we can automatically sort the obeject and check it with the set
# So that donot have to manually check the string version
#---------------------------------------------------------------------------------
a = OrderedSet()
a.insert(event1)
temp.append(event1)
a.insert(event2)
temp.append(event2)
a.insert(event3)
temp.append(event3)
self.assertEqual(a.getset(), sorted(temp))
self.assertEqual('[<Event: 0.5>*, <Event: 1.0>, <Event: 2.0>]', str(a))
#Case2
#Reapted Event Time (different Objects)
#---------------------------------------------------------------------------------
temp = []
a = OrderedSet()
a.insert(event1)
temp.append(event1)
a.insert(event2)
temp.append(event2)
a.insert(event3)
temp.append(event3)
a.insert(event4)
temp.append(event4)
self.assertEqual(a.getset(), sorted(temp))
self.assertEqual(
'[<Event: 0.5>*, <Event: 1.0>, <Event: 1.0>, <Event: 2.0>]',
str(a))
#Additional Check
#Check the event 4 is after event 2(For events with same time, the event inserted later is after)
b = a.getset()
self.assertTrue(True, b[2] is event4)
def testExecuteInsert(self):
s = Simulator()
e = CounterEvent(0)
e.execute(s)
self.assertEqual(str(s), "<0.0: [<Event: 2.0>]>")
e = CounterEvent(5)
e.execute(s)
self.assertEqual(str(s), "<0.0: [<Event: 2.0>, <Event: 7.0>]>")
def testBadConstructor(self):
try:
val = 'cat'
CounterEvent(val)
self.assertTrue(False, 'no exception non number CounterEvent')
except TypeError:
self.assertTrue(True)
def testSimulateTwo(self):
sim = CounterSim()
sim.setup(5)
extra = CounterEvent(3)
sim.insert(extra)
sim.doAllEvents()
self.assertTrue(True)
def testExecuteReturn(self):
s = Simulator()
e = CounterEvent(0)
retval = e.execute(s).lower()
self.assertEqual(retval, "the event time is 0.0")
s = Simulator()
e = CounterEvent(5.25)
retval = e.execute(s).lower()
self.assertEqual(retval, "the event time is 5.25")
s = Simulator()
e = CounterEvent(2)
retval = e.execute(s).lower()
self.assertEqual(retval, "the event time is 2.0")
def testRemovefirst(self):
''' Test for RemoveFirst method'''
a = OrderedSet()
event1 = CounterEvent(2)
event2 = CounterEvent(1)
event3 = CounterEvent(0.5)
event4 = CounterEvent(4.5)
#Insert the events in first
#---------------------------------------------------------------------------------
a.insert(event1)
a.insert(event2)
a.insert(event3)
a.insert(event4)
#Aplly RemoveFirst
#Check both the thing returned
#and also the object left in the set
#---------------------------------------------------------------------------------
self.assertEqual(
'[<Event: 0.5>*, <Event: 1.0>, <Event: 2.0>, <Event: 4.5>]',
str(a))
temp = a.removeFirst()
self.assertEqual(True, temp is event3)
self.assertEqual('[<Event: 1.0>*, <Event: 2.0>, <Event: 4.5>]', str(a))
temp = a.removeFirst()
self.assertEqual(True, temp is event2)
self.assertEqual('[<Event: 2.0>*, <Event: 4.5>]', str(a))
temp = a.removeFirst()
self.assertEqual(True, temp is event1)
self.assertEqual('[<Event: 4.5>*]', str(a))
temp = a.removeFirst()
self.assertEqual(True, temp is event4)
self.assertEqual('[]', str(a))
temp = a.removeFirst()
self.assertEqual(None, temp)
def testLessThanOrEquals(self):
e = CounterEvent(5)
r = CounterEvent(9)
self.assertTrue(e <= r)
e = CounterEvent(4)
r = CounterEvent(4)
self.assertTrue(e <= r)
e = CounterEvent(2)
r = CounterEvent(2.0)
self.assertTrue(e <= r)
e = CounterEvent(1.0)
r = CounterEvent(13.2)
self.assertTrue(e <= r)
def testNotEqual(self):
e = CounterEvent(5)
r = CounterEvent(9)
self.assertTrue(e != r)
e = CounterEvent(4)
r = CounterEvent(4)
self.assertFalse(e != r)
e = CounterEvent(2)
r = CounterEvent(2.0)
self.assertFalse(e != r)
e = CounterEvent(1.0)
r = CounterEvent(13.2)
self.assertTrue(e != r)
def test_camparison_Operators_overloading(self):
'''Test Camparison Operators == /< /!= /<= overloading'''
a = OrderedSet()
event1 = CounterEvent(4)
event2 = CounterEvent(5)
event3 = CounterEvent(5.5)
event4 = CounterEvent(4)
#---------------------------------------------------------------------------------
self.assertEqual(True, event1 < event2)
self.assertEqual(False, event1 > event2)
#---------------------------------------------------------------------------------
self.assertEqual(True, event1 == event4)
self.assertEqual(False, event1 != event4)
#---------------------------------------------------------------------------------
self.assertEqual(True, event1 <= event4)
self.assertEqual(True, event1 >= event4)
#---------------------------------------------------------------------------------
self.assertEqual(True, event1 <= event3)
self.assertEqual(False, event2 <= event4)
def testInsert_CounterEvent_reposition(self):
'''Test Case for insertion------When thing to be inserted already in the set'''
a = OrderedSet()
event1 = CounterEvent(2)
event2 = CounterEvent(1)
event3 = CounterEvent(0.5)
event4 = CounterEvent(4.5)
#Insert Events in first
#Check the result
#Change Event 3
#Check again(Event Time Is changed/ Event Order is not chagned (wrong order))
#Insert Event 3
#Check again (Now ORder Should be Corrected)
#---------------------------------------------------------------------------------
a.insert(event1)
a.insert(event2)
a.insert(event3)
a.insert(event4)
self.assertEqual(
'[<Event: 0.5>*, <Event: 1.0>, <Event: 2.0>, <Event: 4.5>]',
str(a))
event3.item = 4.75
self.assertEqual(
'[<Event: 4.75>*, <Event: 1.0>, <Event: 2.0>, <Event: 4.5>]',
str(a))
print(a)
a.insert(event3)
self.assertEqual(
'[<Event: 1.0>*, <Event: 2.0>, <Event: 4.5>, <Event: 4.75>]',
str(a))
def testExecuteInsert(self):
s = Simulator()
e = CounterEvent(0)
e.execute(s)
self.assertEqual(str(s), "<0.0: [<Event: 2.0>]>")
e = CounterEvent(5)
e.execute(s)
self.assertEqual(str(s), "<0.0: [<Event: 2.0>, <Event: 7.0>]>")
def testLessThan(self):
e = CounterEvent(5)
r = CounterEvent(9)
self.assertTrue(e < r)
e = CounterEvent(4)
r = CounterEvent(4)
self.assertFalse(e < r)
e = CounterEvent(2.5)
r = CounterEvent(6.0)
self.assertTrue(e < r)
def testEquals(self):
e = CounterEvent(5)
r = CounterEvent(9)
self.assertFalse(e == r)
e = CounterEvent(4)
r = CounterEvent(4)
self.assertTrue(e == r)
self.assertTrue(r == e)
e = CounterEvent(2)
r = CounterEvent(2.0)
self.assertTrue(e == r)
def testExecuteReturn(self):
s = Simulator()
e = CounterEvent(0)
retval = e.execute(s).lower()
self.assertEqual(retval, "the event time is 0.0")
s = Simulator()
e = CounterEvent(5.25)
retval = e.execute(s).lower()
self.assertEqual(retval, "the event time is 5.25")
s = Simulator()
e = CounterEvent(2)
retval = e.execute(s).lower()
self.assertEqual(retval, "the event time is 2.0")
def testTime(self):
e = CounterEvent(4)
self.assertEqual(e.time(), 4.0)
e = CounterEvent(9.4)
self.assertEqual(e.time(), 9.4)
def testExecuteInsert10(self):
s = Simulator()
e = CounterEvent(10)
e.execute(s)
self.assertEqual(str(s), "<0.0: []>")
def testTime(self):
e = CounterEvent(4)
self.assertEqual(e.time(), 4.0)
e = CounterEvent(9.4)
self.assertEqual(e.time(), 9.4)
def testExecuteInsert10(self):
s = Simulator()
e = CounterEvent(10)
e.execute(s)
self.assertEqual(str(s), "<0.0: []>")
