def test_snapshot_length(self): """Test __len__ function result""" for backend_name in backends_to_test: frm = build_frame(True, total_snapshot=10, backend_name=backend_name) self.assertEqual(0, len(frm.snapshots))
def test_snapshot_node_length(self): """Test if node number in snapshot correct""" for backend_name in backends_to_test: frm = build_frame(True, backend_name=backend_name) self.assertEqual(STATIC_NODE_NUM, len(frm.snapshots["static"])) self.assertEqual(DYNAMIC_NODE_NUM, len(frm.snapshots["dynamic"]))
def test_take_snapshot(self): """Test if take_stapshot work""" frame = build_frame(True) # 1st static node static_node = frame.static_nodes[0] static_node.a1[:] = [1, 23] frame.take_snapshot(0) a1_at_tick_0 = frame.snapshots["static"][:0:"a1"] # the value should be same with current self.assertListEqual( list(a1_at_tick_0.astype("i")), [1, 23], msg="1st static node's a1 should be [1, 23] at tick 0") # test if the value in snapshot will be changed after change frame static_node.a1[1] = 123 a1_at_tick_0 = frame.snapshots["static"][:0:"a1"] self.assertListEqual( list(a1_at_tick_0.astype("i")), [1, 23], msg= "1st static node's a1 should be [1, 23] at tick 0 even static node value changed" )
def test_get_attribute_with_undefined_attribute(self): frm = build_frame(True) frm.take_snapshot(0) # not exist attribute name with self.assertRaises(ValueError) as ctx: states = frm.snapshots["static"][::"a8"] # not exist node name self.assertIsNone(frm.snapshots["hehe"])
def test_get_attribute_with_undefined_attribute(self): for backend_name in backends_to_test: frm = build_frame(True, backend_name=backend_name) frm.take_snapshot(0) # not exist attribute name with self.assertRaises(Exception) as ctx: states = frm.snapshots["static"][::"a8"] # not exist node name self.assertIsNone(frm.snapshots["hehe"])
def test_take_snapshot(self): for backend_name in backends_to_test: """Test if take_stapshot work""" frame = build_frame(True, backend_name=backend_name) # 1st static node static_node = frame.static_nodes[0] static_node.a1[:] = [1, 23] frame.take_snapshot(0) frame_index_list = frame.snapshots.get_frame_index_list() # check if frame list correct # NOTE: since our resolution is 1 here, so tick==frame_index self.assertListEqual(frame_index_list, [0]) a1_at_tick_0 = frame.snapshots["static"][:0:"a1"] # NOTE: we use flatten here, as raw backend's snapshotlist will have 4 dim result # the value should be same with current self.assertListEqual(list(a1_at_tick_0.flatten().astype("i")), [ 1, 23], msg="1st static node's a1 should be [1, 23] at tick 0") # test if the value in snapshot will be changed after change frame static_node.a1[1] = 123 a1_at_tick_0 = frame.snapshots["static"][:0:"a1"] self.assertListEqual(list(a1_at_tick_0.flatten().astype("i")), [ 1, 23], msg="1st static node's a1 should be [1, 23] at tick 0 even static node value changed") frame.take_snapshot(1) frame_index_list = frame.snapshots.get_frame_index_list() self.assertListEqual(frame_index_list, [0, 1])
def test_quering_with_not_exist_indices(self): # NOTE: when quering with not exist indices, snapshot will try to fill the result of that index with 0 for backend_name in backends_to_test: frm = build_frame(True, backend_name=backend_name) for node in frm.static_nodes: node.a2 = node.index frm.take_snapshot(0) # with 1 invalid index, all should be 0 states = frm.snapshots["static"][1::"a2"] # NOTE: raw backend will padding with nan while numpy padding with 0 if backend_name == "dynamic": # all should be nan self.assertTrue(np.isnan(states).all()) else: self.assertListEqual(list(states.astype("I")), [ 0]*STATIC_NODE_NUM) # with 1 invalid index, one valid index states = frm.snapshots["static"][(0, 1)::"a2"] # NOTE: this reshape for raw backend will get 2 dim array, each for one tick states = states.reshape(-1, STATIC_NODE_NUM) # index 0 should be same with current value self.assertListEqual(list(states[0].astype("i")), [ i for i in range(STATIC_NODE_NUM)]) if backend_name == "dynamic": self.assertTrue(np.isnan(states[1]).all()) else: self.assertListEqual(list(states[1].astype("i")), [ 0]*STATIC_NODE_NUM)
def test_quering_with_not_exist_indices(self): # NOTE: when quering with not exist indices, snapshot will try to fill the result of that index with 0 frm = build_frame(True) for node in frm.static_nodes: node.a2 = node.index frm.take_snapshot(0) # with 1 invalid index, all should be 0 states = frm.snapshots["static"][1::"a2"] self.assertListEqual(list(states.astype("I")), [0] * STATIC_NODE_NUM) # with 1 invalid index, one valid index states = frm.snapshots["static"][(0, 1)::"a2"] states = states.reshape(-1, STATIC_NODE_NUM) # index 0 should be same with out current value self.assertListEqual(list(states[0].astype("i")), [i for i in range(STATIC_NODE_NUM)]) self.assertListEqual(list(states[1].astype("i")), [0] * STATIC_NODE_NUM)
def test_slice_quering(self): for backend_name in backends_to_test: """Test if states quering result correct""" frame = build_frame(True, total_snapshot=2, backend_name=backend_name) # one node changes static_node = frame.static_nodes[0] static_node.a2 = 1 # before takeing snapshot, states should be 0 static_node_a2_states = frame.snapshots["static"][0:0:"a2"] self.assertEqual(1, len(static_node_a2_states), msg="slicing with 1 tick, 1 node and 1 attr, should return array with 1 result") if backend_name == "dynamic": self.assertTrue(np.isnan(static_node_a2_states).all()) else: self.assertEqual(0, static_node_a2_states.astype( "i")[0], msg="states before taking snapshot should be 0") frame.take_snapshot(0) # set a2 and a3 for all static nodes for i, node in enumerate(frame.static_nodes): node.a3 = 100 * i node.a2 = 100 * i + 1 # take snapshot frame.take_snapshot(1) # query with 2 attributes states = frame.snapshots["static"][1::["a3", "a2"]] # with this quering, the result should be like # so we can reshape it as states = states.reshape(len(frame.static_nodes), 2) # then 1st should a3 value for all static node # 2nd should be a2 value for all static node self.assertListEqual(list(states[:, 0].astype("i")), [ 100 * i for i in range(len(frame.static_nodes))], msg="1st row of states should be a3 value") self.assertListEqual(list(states[:, 1].astype("i")), [100 * i + 1 for i in range( len(frame.static_nodes))], msg="2nd row of states should be a2 value") # quering without tick, means return all ticks in snapshot states = frame.snapshots["static"][:0:"a2"] # reshape it as 2-dim, so row is tick states = states.reshape(2, -1).astype("i") # then each row is a2 value for 1st static node at that tick self.assertEqual( 1, len(states[0]), msg="1st static should contains 1 a2 value at tick 0") self.assertEqual( 1, states[0], msg="1st static node a2 value should be 1 at tick 0") self.assertEqual( 1, states[1], msg="1st staic node a2 value should be 1 at tick 1") # quering without node index, means return attributes of all the nodes states = frame.snapshots["static"][1::"a2"] # NOTE: dynamic backend have shape if backend_name == "dynamic": self.assertTrue(len(states), len(frame.static_nodes)) else: self.assertEqual(len(frame.static_nodes), len(states), msg="1 tick 1 attribute and not specified ticks, should return array length same as node number") self.assertListEqual(list(states.flatten().astype("i")), [100 * i + 1 for i in range( len(frame.static_nodes))], msg="a2 at 1st row should be values at tick 1") # when reach the max size of snapshot, oldest one will be overwrite static_node.a2 = 1000 frame.take_snapshot(2) # check if current snapshot max size correct self.assertEqual(2, len(frame.snapshots), msg="snapshot list max size should be 2") # and result without ticks should return 2 row: 2*len(static_nodes) states = frame.snapshots["static"][::"a2"] states = states.reshape(-1, len(frame.static_nodes)) self.assertEqual( 2, len(states), msg="states should contains 2 row") # 1st row should be values at tick 1 self.assertListEqual(list(states[0].astype("i")), [100 * i + 1 for i in range( len(frame.static_nodes))], msg="a2 at tick 1 for all nodes should be correct") # 2nd row should be lastest one self.assertEqual( 1000, states[1][0], msg="a2 for 1st static node for 2nd row should be 1000") # quering with ticks that being over-wrote, should return 0 for that tick states = frame.snapshots["static"][(0, 1, 2)::"a2"] states = states.reshape(-1, len(frame.static_nodes)) self.assertEqual( 3, len(states), msg="states should contains 3 row") if backend_name == "dynamic": self.assertTrue(np.isnan(states[0]).all()) else: self.assertListEqual([0]*len(frame.static_nodes), list(states[0].astype("i")), msg="over-wrote tick should return 0") self.assertListEqual(list(states[1].astype("i")), [100 * i + 1 for i in range( len(frame.static_nodes))], msg="a2 at tick 1 for all nodes should be correct") self.assertEqual( 1000, states[2][0], msg="a2 for 1st static node for 2nd row should be 1000") frame_index_list = frame.snapshots.get_frame_index_list() self.assertListEqual(frame_index_list, [1, 2])
def test_snapshot_length(self): """Test __len__ function result""" frm = build_frame(True, total_snapshot=10) self.assertEqual(10, len(frm.snapshots))