def test_invalid_scenario(self): """Test specified invalid scenario""" # not exist scenario with self.assertRaises(ModuleNotFoundError) as ctx: env = Env("None", "5p_ssddd", 100) # not exist topology with self.assertRaises(FileNotFoundError) as ctx: env = Env("ecr", "None", 100)
def test_early_stop(self): """Test if we can stop at specified tick with early stop at post_step function""" max_tick = 10 env = Env(business_engine_cls=DummyEngine, start_tick=0, durations=max_tick, options={"post_step_early_stop": 6}) # early stop at tick 6, NOTE: simulator still run_to_end(env) # the end tick of env should be 6 as specified self.assertEqual(6, env.tick, msg=f"env should stop at tick 6, but {env.tick}") # avaiable snapshot should be 7 (0-6) states = env.snapshot_list["dummies"][::"val"].reshape(-1, 10) self.assertEqual( 7, len(states), msg=f"available snapshot number should be 7, but {len(states)}") # and last one should be 6 self.assertListEqual(list(states[-1]), [6] * 10, msg="last states should be 6")
def test_snapshot_resolution_with_max_snapshots(self): """Test env with both snapshot_resolution and max_snapshots parameters, and it should work as expected""" max_tick = 10 env = Env(business_engine_cls=DummyEngine, start_tick=0, durations=max_tick, snapshot_resolution=2, max_snapshots=2) run_to_end(env) # we should have snapshot same as max_snapshots self.assertEqual(2, len(env.snapshot_list), msg="We should have 2 snapshots in memory") # and only 7 and 9 in snapshot states = env.snapshot_list["dummies"][::"val"].reshape(-1, 10) # 1st should states at tick 7 self.assertListEqual(list(states[0]), [7] * 10, msg="1st snapshot should be at tick 7") # 2nd should states at tick 9 self.assertListEqual(list(states[1]), [9] * 10, msg="2nd snapshot should be at tick 9")
def test_max_snapshots(self): """Test env with max_snapshots, it should take snapshot every tick, but should last N kept""" max_tick = 10 env = Env(business_engine_cls=DummyEngine, start_tick=0, durations=max_tick, max_snapshots=2) run_to_end(env) # we should have 2 snapshots totally with max_snapshots speified self.assertEqual(2, len(env.snapshot_list), msg="We should have 2 snapshots in memory") # and only 87 and 9 in snapshot states = env.snapshot_list["dummies"][::"val"].reshape(-1, 10) # 1st should states at tick 7 self.assertListEqual(list(states[0]), [8] * 10, msg="1st snapshot should be at tick 8") # 2nd should states at tick 9 self.assertListEqual(list(states[1]), [9] * 10, msg="2nd snapshot should be at tick 9")
def test_snapshot_resolution(self): """Test env with snapshot_resolution, it should take snapshot every snapshot_resolution ticks""" for backend_name in backends_to_test: os.environ["DEFAULT_BACKEND_NAME"] = backend_name max_tick = 10 env = Env(business_engine_cls=DummyEngine, start_tick=0, durations=max_tick, snapshot_resolution=3) run_to_end(env) # we should have 4 snapshots totally without max_snapshots speified self.assertEqual(4, len(env.snapshot_list), msg="We should have 4 snapshots in memory") # snapshot at 2, 5, 8, 9 ticks states = env.snapshot_list["dummies"][::"val"].reshape(-1, 10) # NOTE: frame_index is the index of frame in snapshot list, it is 0 based, so snapshot resolution will make tick not equals to frame_index # for frame_index, tick in enumerate((2, 5, 8, 9)): self.assertListEqual(list(states[frame_index]), [ tick] * 10, msg=f"states should be {tick}")
def test_builtin_scenario_with_customized_topology(self): """Test using built-in scenario with customized topology""" max_tick = 10 env = Env(scenario="cim", topology="tests/data/cim/customized_config", start_tick=0, durations=max_tick) run_to_end(env) # check if the config same as ours self.assertEqual([2], env.configs["container_volumes"], msg="customized container_volumes should be 2")
def test_builtin_scenario_with_default_parameters(self): """Test if the env with built-in scenario initializing correct""" max_tick = 10 env = Env(scenario="cim", topology="toy.5p_ssddd_l0.0", durations=max_tick) run_to_end(env) # check port number ports_number = len(env.snapshot_list["ports"]) self.assertEqual(ports_number, 5, msg=f"5pssddd topology should contains 5 ports, got {ports_number}")
def run_to_end(env: Env): """Run the end of env""" is_done = False while not is_done: _, _, is_done = env.step(None)
def test_env_interfaces_with_specified_business_engine_cls(self): """Test if env interfaces works as expect""" max_tick = 5 env = Env(business_engine_cls=DummyEngine, start_tick=0, durations=max_tick) run_to_end(env) # check if the snapshot number equals with max_tick # NOTE: the snapshot_resolution default is 1, so the number of snapshots is same with max_tick num_of_snapshots = len(env.snapshot_list) self.assertEqual( max_tick, len(env.snapshot_list), msg=f"number of snapshots ({num_of_snapshots}) should be same " f"with max tick ({max_tick}) without specified snapshot_resolution and max_snapshots" ) # check if we can reach to the end [start_tick, max_tick) self.assertEqual(max_tick - 1, env.tick) # check if frame_index # NOTE: since we have not specified snapshot_resolution, frame_index should same with tick self.assertEqual(env.tick, env.frame_index) # check if config is same as we defined self.assertDictEqual(env.configs, {"name": "dummy"}, msg="configs should same as defined") # check node information node_info = env.summary["node_detail"] # check node exist self.assertTrue("dummies" in node_info, msg="dummy engine should contains dummy node") # check node number dummy_number = node_info["dummies"]["number"] self.assertEqual( 10, dummy_number, msg=f"dummy should contains 10 nodes, got {dummy_number}") attributes = node_info["dummies"]["attributes"] # it will contains one attribute self.assertEqual( 1, len(attributes), msg= f"dummy node should only contains 1 attribute, got {len(attributes)}" ) # and the attribute name is val self.assertTrue("val" in attributes) # attribute type should be i val_dtype = attributes['val']["type"] self.assertEqual( "i", val_dtype, msg=f"dummy's val attribute should be int type, got {val_dtype}") # val should have only one slot (default) val_slots = attributes['val']["slots"] self.assertEqual( 1, val_slots, msg=f"dummy's val attribute should be int type, got {val_slots}") # agent list should be [0, dummy_number) self.assertListEqual( list(range(0, dummy_number)), env.agent_idx_list, msg=f"dummy engine should have {dummy_number} agents") # check if snapshot list available self.assertIsNotNone(env.snapshot_list, msg="snapshot list should be None") # reset should work dummies_ss = env.snapshot_list["dummies"] vals_before_reset = dummies_ss[env.frame_index::"val"] # before reset, snapshot should have value self.assertListEqual( list(vals_before_reset), [env.tick] * dummy_number, msg= f"we should have val value same as last tick, got {vals_before_reset}" ) env.reset() # after reset, it should 0 vals_after_reset = dummies_ss[env.frame_index::"val"] self.assertListEqual( list(vals_after_reset), [0] * dummy_number, msg= f"we should have val value same as last tick, got {vals_after_reset}" )