def test_many_arguments(self):
self.test_many_arguments_info = []
def something(arg1, arg2, arg3="def", arg4=2384):
self.test_many_arguments_info.append(
(simulator.now(), arg1, arg2, arg3, arg4))
simulator.ready()
simulator.schedule(0, something, 285, 92948)
simulator.schedule(15, something, "abc", "xyz", arg3=88)
simulator.schedule(200, something, 2894242, 462626, arg4=8282)
simulator.schedule(45, something, -289424, 928295, arg4=33, arg3=11)
# 3rd/4th positional argument used for known arguments
simulator.schedule(3, something, "xyz", 82835, 99, 88)
# 3rd positional argument used for known argument
simulator.schedule(5747, something, 0, "test", "here")
simulator.schedule(200, something, -1, "abc")
simulator.schedule_with_priority(0, -100, something, "abc", 28825)
simulator.schedule(577394743, something, 1902892859, 8252852985)
simulator.run()
simulator.reset()
self.assertEqual(self.test_many_arguments_info,
[(0, "abc", 28825, "def", 2384),
(0, 285, 92948, "def", 2384),
(3, "xyz", 82835, 99, 88),
(15, "abc", "xyz", 88, 2384),
(45, -289424, 928295, 11, 33),
(200, 2894242, 462626, "def", 8282),
(200, -1, "abc", "def", 2384),
(5747, 0, "test", "here", 2384),
(577394743, 1902892859, 8252852985, "def", 2384)])
def test_end_in_event(self):
self.test_end_in_event_counter = 22
def x(val):
self.test_end_in_event_counter += val
def y():
simulator.end(5)
simulator.ready()
simulator.schedule(60, x, 22)
simulator.schedule(70, y)
simulator.schedule(70, x, 3)
simulator.schedule(71, y)
simulator.schedule(74, x, 5)
simulator.schedule(75, x, 22)
simulator.schedule(76, x, 22)
simulator.schedule(888, x, 22)
simulator.schedule(999, x, 22)
simulator.schedule(8953, x, 22)
simulator.end(1000)
simulator.run()
self.assertEqual(self.test_end_in_event_counter, 22 + 22 + 3 + 5)
self.assertEqual(simulator.now(), 75)
self.assertTrue(simulator.is_finished())
self.assertEqual(simulator.event_heap_size(), 5)
simulator.reset()
def test_4x100m_relay(self):
def relay_finished():
print("Last athlete finished: 4x100m relay in %.3gs" %
(simulator.now() / 1e9))
class Athlete:
def __init__(self, idx, athletes, speed_m_per_s):
self.idx = idx
self.athletes = athletes
self.speed_m_per_s = speed_m_per_s
def receive_stick_and_run(self):
print("Athlete %d receives stick and starts run at t=%.3gs" %
(self.idx, simulator.now() / 1e9))
if self.idx != len(self.athletes) - 1:
simulator.schedule(
int(100.0 / self.speed_m_per_s * 1e9),
self.athletes[self.idx + 1].receive_stick_and_run)
else:
simulator.schedule(int(100.0 / self.speed_m_per_s * 1e9),
relay_finished)
athletes = []
athletes.append(Athlete(0, athletes, 10.2)) # Nesta Carter
athletes.append(Athlete(1, athletes, 10.1)) # Michael Frater
athletes.append(Athlete(2, athletes, 10.3)) # Yohan Blake
athletes.append(Athlete(3, athletes, 10.4)) # Usain Bolt
# All Athlete instances will now have a complete athletes list
# because Python objects are passed by reference
simulator.ready()
simulator.schedule(0, athletes[0].receive_stick_and_run)
print("Simulating a 4x100m relay")
simulator.run()
simulator.reset()
def test_run_empty_no_end_time(self):
simulator.ready()
self.assertEqual(simulator.now(), 0)
self.assertFalse(simulator.is_finished())
simulator.run()
self.assertEqual(simulator.now(), 0)
self.assertTrue(simulator.is_finished())
simulator.reset()
def test_schedule_event_without_callback_arguments(self):
def something():
print("t=" + str(simulator.now()) + ": something() was called")
simulator.ready()
simulator.schedule(100, something)
simulator.run()
simulator.reset()
def test_schedule_event_with_one_callback_argument(self):
def something(value):
print("t=" + str(simulator.now()) + ": something() with value: " +
str(value))
simulator.ready()
simulator.schedule(100, something, "ABC")
simulator.run()
simulator.reset()
def test_with_builtin_method(self):
self.test_with_builtin_method_info = []
simulator.ready()
simulator.schedule(100, self.test_with_builtin_method_info.append, 566)
simulator.run()
simulator.reset()
self.assertEqual(self.test_with_builtin_method_info, [566])
def test_readme(self):
def something(value):
print("t=" + str(simulator.now()) + ": something() with value " +
str(value))
simulator.ready()
simulator.schedule(44, something, "ABC")
simulator.schedule(967, something, "XYZ")
simulator.end(10000)
simulator.run()
simulator.reset()
def test_schedule_event_with_many_callback_arguments(self):
def something(val1, val2, abc3, xyz=28):
print("t=" + str(simulator.now()) + ": something() with: val1=" +
str(val1) + ", val2=" + str(val2) + ", abc3=" + str(abc3) +
", xyz=" + str(xyz))
simulator.ready()
simulator.schedule(0, something, "ABC", 1, 4, xyz=83)
simulator.schedule(77, something, 363, "here", 4)
simulator.run()
simulator.reset()
def test_schedule_another_event_in_callback(self):
def something(value):
print("t=" + str(simulator.now()) + ": something() with value: " +
str(value))
simulator.schedule(200, something,
"XYZ") # 100 time units in the future from now
simulator.ready()
simulator.schedule(200, something, "ABC")
simulator.end(1001)
simulator.run()
simulator.reset()
def test_schedule_multiple_events_in_same_time_ordered(self):
def something(value):
print("t=" + str(simulator.now()) + ": something() with value: " +
str(value))
simulator.ready()
simulator.schedule_with_priority(100, 77, something,
"XYZ") # Priority of 77
simulator.schedule_with_priority(100, 44, something,
"ABC") # Priority of 44
simulator.run()
simulator.reset()
def test_args_ref_object(self):
simulator.ready()
def x(v):
self.assertEqual(v[4], 789)
z = {4: 99}
val = (z, )
simulator.schedule(0, x, *val)
z[4] = 789 # This dictionary was passed as positional argument, so this *is* still referred to
simulator.run()
simulator.reset()
def test_kwargs_ref_object(self):
simulator.ready()
def x(v=(10, 33, 10, 3, 66)):
self.assertEqual(v[4], 123)
z = {4: 99}
val = {"v": z}
simulator.schedule(0, x, **val)
z[4] = 123 # This dictionary was passed as keyword argument, so this *is* still referred to
simulator.run()
simulator.reset()
def test_set_end_time(self):
def something(value):
print("t=" + str(simulator.now()) + ": something() with value: " +
str(value))
simulator.ready()
simulator.schedule(100, something, "ABC")
simulator.schedule(120, something, "DEF")
simulator.schedule(160, something, "GHI")
# End time is 160, meaning that only events scheduled
# for t in [0, 160) are executed (thus excluding t = 160)
simulator.end(160)
simulator.run()
simulator.reset()
def test_inspecting_the_event_heap(self):
print("")
def something():
print("t=" + str(simulator.now()) + ": something() was called")
print(simulator._Simulator__event_heap)
simulator.ready()
simulator.schedule(100, something)
simulator.schedule(106, something)
simulator.schedule(107, something)
print(simulator._Simulator__event_heap)
simulator.run()
simulator.reset()
def test_end_one(self):
self.test_end_one_counter = 0
def x(val):
self.test_end_one_counter += val
simulator.ready()
simulator.schedule(10, x, 57)
simulator.end(100)
simulator.run()
self.assertEqual(self.test_end_one_counter, 57)
self.assertEqual(simulator.now(), 100)
self.assertTrue(simulator.is_finished())
simulator.reset()
def test_schedule_event_with_callback_an_instance_method(self):
class Example:
def __init__(self, x):
self.x = x
def something(self, value):
print("t=" + str(simulator.now()) +
": instance of class Example (x=" + str(self.x) +
") something() with value: " + str(value))
abc = Example("Test")
simulator.ready()
simulator.schedule(55, abc.something, "ABCDEF")
simulator.run()
simulator.reset()
def test_with_lambda_function(self):
self.test_with_lambda_function_info = []
def something(val1, val2):
self.test_with_lambda_function_info.append(val1 + val2)
self.assertEqual(val1, 28425)
self.assertEqual(val2, 566)
return 400
simulator.ready()
simulator.schedule(100, lambda x: x + something(28425, x), 566)
simulator.run()
simulator.reset()
self.assertEqual(self.test_with_lambda_function_info, [(28425 + 566)])
def test_end_override(self):
self.test_end_two_override_counter = 22
def x(val):
self.test_end_two_override_counter += val
simulator.ready()
simulator.schedule(57, x, 67)
simulator.end(100)
simulator.end(57)
simulator.end(100)
simulator.run()
self.assertEqual(self.test_end_two_override_counter, 22)
self.assertEqual(simulator.now(), 57)
self.assertTrue(simulator.is_finished())
simulator.reset()
def test_function_in_function(self):
self.test_function_in_function_info = []
def something(value, xyz):
def x(v):
self.test_function_in_function_info.append(
(simulator.now(), xyz, v))
simulator.schedule(1000, x, value)
simulator.ready()
something("Here!", 36362)
simulator.run()
simulator.reset()
self.assertEqual(self.test_function_in_function_info,
[(1000, 36362, "Here!")])
def test_normal_just(self):
self.test_normal_counter = 0
def x(val):
self.test_normal_counter += val
simulator.ready()
simulator.schedule(100, x, 57)
simulator.schedule(100, x, 473)
simulator.schedule(199, x, 88)
simulator.end(200)
simulator.run()
self.assertEqual(self.test_normal_counter, 57 + 473 + 88)
self.assertEqual(simulator.now(), 200)
self.assertTrue(simulator.is_finished())
self.assertEqual(simulator.event_heap_size(), 0)
simulator.reset()
self.assertEqual(simulator.event_heap_size(), 0)
def test_normal_not(self):
self.test_normal_counter = 0
def x(val):
self.test_normal_counter -= val
simulator.ready()
simulator.schedule(100, x, 57)
simulator.schedule(153, x, 245)
simulator.schedule(199, x, 88)
simulator.end(156)
simulator.run()
self.assertEqual(self.test_normal_counter, - 57 - 245)
self.assertEqual(simulator.now(), 156)
self.assertTrue(simulator.is_finished())
self.assertEqual(simulator.event_heap_size(), 1)
simulator.reset()
self.assertEqual(simulator.event_heap_size(), 0)
def test_end_in_same_event(self):
self.test_end_in_same_event_counter = 0
def x():
self.test_end_in_same_event_counter += 100
def y():
self.test_end_in_same_event_counter += 3
def z():
self.test_end_in_same_event_counter += 5
self.assertFalse(simulator.is_init())
self.assertFalse(simulator.is_ready())
self.assertTrue(simulator.is_running())
self.assertFalse(simulator.is_finished())
simulator.end() # End after this event has been executed
self.assertFalse(simulator.is_init())
self.assertFalse(simulator.is_ready())
self.assertTrue(simulator.is_running())
self.assertFalse(simulator.is_finished())
simulator.ready()
simulator.schedule_with_priority(70, 5, x)
simulator.schedule_with_priority(70, 5, x)
simulator.schedule_with_priority(70, 20, y)
simulator.schedule_with_priority(70, 10, z)
simulator.run()
self.assertEqual(self.test_end_in_same_event_counter, 100 + 100 + 5)
self.assertEqual(simulator.now(), 70)
self.assertTrue(simulator.is_finished())
self.assertEqual(simulator.event_heap_size(), 1)
simulator.reset()
self.assertTrue(simulator.is_init())
self.assertFalse(simulator.is_ready())
self.assertFalse(simulator.is_running())
self.assertFalse(simulator.is_finished())
self.assertEqual(simulator.now(), 0)
self.assertEqual(simulator.event_heap_size(), 0)
def test_end_within_event_while_running(self):
def something(value):
print("t=" + str(simulator.now()) + ": something() with value: " +
str(value))
def we_are_done(value):
print("t=" + str(simulator.now()) +
": we_are_done() with value: " + str(value))
simulator.end()
simulator.ready()
simulator.schedule(100, something, "ABC")
simulator.schedule(120, something, "DEF")
simulator.schedule(140, we_are_done, "XYZ")
simulator.schedule(160, something, "TEST")
simulator.schedule(700, something, "GHI")
simulator.end(1000)
simulator.run()
print("End time: " + str(simulator.now()))
simulator.reset()
def test_zero_arguments(self):
self.test_zero_arguments_info = []
def something():
self.test_zero_arguments_info.append(simulator.now())
simulator.ready()
simulator.schedule(0, something)
simulator.schedule(15, something)
simulator.schedule(200, something)
simulator.schedule(45, something)
simulator.schedule(3, something)
simulator.schedule(5747, something)
simulator.schedule(200, something)
simulator.schedule(0, something)
simulator.schedule(577394743, something)
simulator.run()
simulator.reset()
self.assertEqual(self.test_zero_arguments_info,
[0, 0, 3, 15, 45, 200, 200, 5747, 577394743])
def main():
# Instantiate state (the nodes)
nodes = []
node0 = Node(0, {1: (1, 204), 2: (2, 222867)}, nodes)
node1 = Node(1, {0: (0, 204), 2: (0, 204)}, nodes)
node2 = Node(2, {0: (0, 222867), 1: (0, 222867)}, nodes)
nodes.append(node0)
nodes.append(node1)
nodes.append(node2)
# Setup and run simulator
simulator.ready()
message = {"dst_node_id": 2, "content": "Hello world!"}
simulator.schedule(100, nodes[1].receive, message)
simulator.run()
simulator.reset()
# Show results
print("Node 0 forward counter: %d" % node0.get_forward_counter())
print("Node 1 forward counter: %d" % node1.get_forward_counter())
print("Node 2 forward counter: %d" % node2.get_forward_counter())
def test_with_builtin_function(self):
class X:
def __init__(self, init_val):
self.__val = init_val
def __len__(self):
self.__val += 7834
return 1
def get_val(self):
return self.__val
obj = X(40000)
self.assertEqual(obj.get_val(), 40000)
simulator.ready()
simulator.schedule(0, len, obj)
simulator.schedule(100, len, obj)
simulator.schedule(1200, len, obj)
simulator.schedule(34895829589258925256226, len, obj)
simulator.run()
simulator.reset()
self.assertEqual(obj.get_val(), 40000 + 4 * 7834)
def random_schedule_test(test_instance, seed, max_time, num_events,
min_priority, max_priority):
result = []
def x(val):
result.append((simulator.now(), val))
random.seed(seed)
simulator.ready()
expectation = []
for i in range(num_events):
t = random.randint(0, max_time)
p = random.randint(min_priority, max_priority)
v = random.randint(-50000, 100000)
simulator.schedule_with_priority(t, p, x, v)
expectation.append((t, p, i, v))
expectation = sorted(expectation)
expectation = list(map(lambda a: (a[0], a[3]), expectation))
simulator.run()
test_instance.assertEqual(result, expectation)
simulator.reset()
def test_one_argument(self):
self.test_one_argument_info = []
def something(arg1):
self.test_one_argument_info.append((simulator.now(), arg1))
simulator.ready()
simulator.schedule(0, something, 285)
simulator.schedule(15, something, "abc")
simulator.schedule(200, something, 2894242)
simulator.schedule(45, something, -289424)
simulator.schedule(3, something, "xyz")
simulator.schedule(5747, something, 0)
simulator.schedule(200, something, -1)
simulator.schedule_with_priority(0, -100, something, 1)
simulator.schedule(577394743, something, 1902892859)
simulator.run()
simulator.reset()
self.assertEqual(self.test_one_argument_info,
[(0, 1), (0, 285), (3, "xyz"), (15, "abc"),
(45, -289424), (200, 2894242), (200, -1), (5747, 0),
(577394743, 1902892859)])
def test_invalid_schedule_errors(self):
# Schedule delay is not an integer
try:
def x():
pass
simulator.ready()
simulator.schedule("abc", x)
self.fail()
except ValueError as e:
self.assertEqual(str(e), "Delay must be an integer")
simulator.run()
simulator.reset()
# Schedule delay is a negative integer
try:
def x():
pass
simulator.ready()
simulator.schedule(-10, x)
self.fail()
except ValueError as e:
self.assertEqual(str(e), "Delay must be non-negative: -10")
simulator.run()
simulator.reset()
# Callback is not a method or function
try:
simulator.ready()
simulator.schedule(5, 25)
self.fail()
except ValueError as e:
self.assertEqual(str(e), "Callback must be a function or a method")
simulator.run()
simulator.reset()
# Priority is not an integer
try:
def x():
pass
simulator.ready()
simulator.schedule_with_priority(10, "abc", x)
self.fail()
except ValueError as e:
self.assertEqual(str(e), "Priority must be an integer")
simulator.run()
simulator.reset()
