def test_tcall(self):
# need special env for this one
env = Env("Test env",
members=[create_newton()],
exec_key=self.exec_key)
acts = run(self.test_user, test_run=True)
self.assertEqual(acts, DEF_STEPS)
def test_runN(self):
"""
Test running for N turns.
"""
new_env = Env("Test1 env", action=env_action, members=[self.newton])
num_periods = 10
acts = new_env.runN(num_periods)
self.assertEqual(acts, num_periods)
def test_restore_env(self):
"""
This test depends upon a particular, stored json
format: must be re-written.
"""
tests_env = env_json_basic.ret()
ret_env = Env("env", serial_obj=tests_env)
self.assertEqual(str(type(ret_env)), "<class 'indra.env.Env'>")
def setUp(self):
self.exec_key = get_exec_key()
self.env = Env("test_env", exec_key=self.exec_key)
(self.space, self.newton) = create_space(self.exec_key)
self.test_agent = Agent("test agent", exec_key=self.exec_key)
self.test_agent2 = Agent("test agent 2", exec_key=self.exec_key)
self.test_agent3 = Agent("test agent 3", exec_key=self.exec_key)
self.test_agent4 = Agent("test agent 4", exec_key=self.exec_key)
def __json_to_object(self, serial_obj, exec_key):
"""
Takes a serial JSON object back into a live Python object.
"""
restored_obj = dict()
restored_groups = []
model_deserialized = False
for obj_name in serial_obj:
should_restore_object = isinstance(serial_obj[obj_name],
dict) and "type" in serial_obj[
obj_name]
if should_restore_object:
if serial_obj[obj_name]["type"] == "TestUser":
restored_obj[obj_name] = TermUser(name=obj_name,
serial_obj=serial_obj[
obj_name],
exec_key=exec_key)
if serial_obj[obj_name]["type"] == "APIUser":
restored_obj[obj_name] = APIUser(name=obj_name,
serial_obj=serial_obj[
obj_name],
exec_key=exec_key)
if serial_obj[obj_name]["type"] == "Agent":
restored_obj[obj_name] = Agent(name=obj_name,
serial_obj=serial_obj[
obj_name],
exec_key=exec_key)
elif serial_obj[obj_name]["type"] == "Model":
from lib.model import Model
print(f'restoring model for key {exec_key}')
restored_obj[obj_name] = Model(exec_key=exec_key,
serial_obj=serial_obj[
obj_name])
model_deserialized = True
elif serial_obj[obj_name]["type"] == "Group":
from lib.group import Group
restored_obj[obj_name] = Group(exec_key=exec_key,
serial_obj=serial_obj[
obj_name],
name=serial_obj[obj_name][
'name'])
restored_groups.append(restored_obj[obj_name])
elif serial_obj[obj_name]["type"] == "Env":
restored_obj[obj_name] = Env(exec_key=exec_key,
serial_obj=serial_obj[
obj_name],
name=serial_obj[obj_name][
'name'])
else:
restored_obj[obj_name] = serial_obj[obj_name]
self.registries[exec_key][obj_name] = restored_obj[obj_name]
if model_deserialized:
restored_obj['model'].groups = restored_groups
restored_obj['model'].env = restored_obj['env']
self.registries[exec_key]['model'] = restored_obj['model']
return restored_obj
def test_backlog(self):
from lib.env import Env
from lib.paramenters import Parameters
import lib.other_agent as other_agent
pa = Parameters()
pa.num_nw = 5
pa.simu_len = 50
pa.num_ex = 10
pa.new_job_rate = 1
pa.compute_dependent_parameters()
env = Env(pa, render=False, repre='image')
env.step(5)
env.step(5)
env.step(5)
env.step(5)
env.step(5)
env.step(5)
# self.assertIsNotNone(env.job_backlog.backlog[0])
# self.assertIsNone(env.job_backlog.backlog[1])
print("New job is backlogged.")
env.step(5)
env.step(5)
env.step(5)
env.step(5)
job = env.job_backlog.backlog[0]
env.step(0)
self.assertEqual(env.job_slot.slot[0], job)
# assert env.job_slot.slot[0] == job
job = env.job_backlog.backlog[0]
env.step(0)
self.assertEqual(env.job_slot.slot[0], job)
# assert env.job_slot.slot[0] == job
job = env.job_backlog.backlog[0]
env.step(1)
self.assertEqual(env.job_slot.slot[1], job)
job = env.job_backlog.backlog[0]
env.step(1)
self.assertEqual(env.job_slot.slot[1], job)
env.step(5)
job = env.job_backlog.backlog[0]
env.step(3)
# self.assertEqual(env.job_slot.slot[3],job )
print("- Backlog test passed -")
def create_env(self, env_action=None, random_placing=True):
"""
Override this method to create a unique env...
but this one will already set the model name and add
the groups.
"""
# NOTE: WE DEFAULT TO RANDOM PLACING ALL THE TIME
# EVEN FOR MODELS LIKE FOREST FIRE
self.env = Env(self.module,
members=self.groups,
exec_key=self.exec_key,
width=self.width,
height=self.height,
action=env_action,
random_placing=random_placing)
self.env.user = self.user
self.env.user_type = self.user_type
self.create_pop_hist()
return self.env
def test_image_speed(self):
from lib.env import Env
from lib.paramenters import Parameters
import lib.other_agent as other_agent
pa = Parameters()
pa.simu_len = 50
pa.num_ex = 10
pa.new_job_rate = 0.3
pa.compute_dependent_parameters()
env = Env(pa, render=False, repre='image')
import time
start_time = time.time()
for i in range(100000):
a = other_agent.get_sjf_action(env.machine, env.job_slot)
env.step(a)
end_time = time.time()
print("- Elapsed time: ", end_time - start_time, "sec -")
def test_plot_data(self):
"""
Test the construction of scatter plot data.
"""
global travis
travis = os.getenv("TRAVIS")
if not travis:
our_grp = Group(GRP1,
members=[self.newton],
exec_key=self.exec_key)
self.env = Env("Test env",
members=[our_grp],
exec_key=self.exec_key)
ret = self.env.plot_data()
(x, y) = self.newton.pos
self.assertEqual(
ret, {GRP1: {
X: [x],
Y: [y],
'color': None,
'marker': None
}})
def from_json(self, jrep):
"""
This method restores a model from its JSON rep.
"""
self.module = jrep["module"]
self.exec_key = jrep["exec_key"]
self.period = jrep["period"]
self.switches = jrep["switches"]
# We should restore user from json:
# self.user = jrep["user"]
# But for the moment we will hard code this:
self.user = APIUser(model=self,
name="API",
exec_key=self.exec_key,
serial_obj=jrep["user"])
self.user_type = jrep["user_type"]
self.props = jrep["props"]
self.env = Env(self.module,
serial_obj=jrep["env"],
exec_key=self.exec_key)
# since self.groups is a list and self.env.members is an OrderedDict
self.groups = [
self.env.members[group_nm] for group_nm in self.env.members
]
def setUp(self):
self.exec_key = get_exec_key()
self.env = Env("Test env", exec_key=self.exec_key)
self.user = TermUser("User", exec_key=self.exec_key)
self.test_user = TestUser("TestUser", exec_key=self.exec_key)
