def testSilenceConsistency(self):
"""
:return:
"""
slzr = serializer.StandardSerializer()
ic = channels.InputChannel(slzr)
oc = channels.OutputChannel(slzr)
test_string = slzr.SILENCE_TOKEN * 10
something_read = [0]
def all_good(input_message):
"""
:param input_message:
:return:
"""
something_read[0] = len(input_message)
self.assertEqual(test_string[:len(input_message)], input_message)
oc.set_message(test_string)
ic.message_updated.register(all_good)
while not oc.is_empty():
b = oc.consume_bit()
ic.consume_bit(b)
# TODO fix len(test_string)
self.assertEqual(something_read[0], len(test_string))
def testOverwrittingConsistency(self):
# TODO REDESIGN into DEMENTED PYTHON
""" array because Python's scoping rules are demented: http://stackoverflow.com/questions/4851463/python
-closure-write-to-variable-in-parent-scope
:return:
"""
slzr = serializer.StandardSerializer()
ic = channels.InputChannel(slzr)
oc = channels.OutputChannel(slzr)
test_string = 'my message'
something_read = [0]
def all_good(input_message):
"""
:param input_message:
:return:
"""
something_read[0] = len(input_message)
self.assertEqual(test_string[:len(input_message)], input_message)
oc.set_message("this shouldn't matter")
oc.set_message(test_string)
ic.message_updated.register(all_good)
while not oc.is_empty():
b = oc.consume_bit()
ic.consume_bit(b)
self.assertEqual(something_read[0], len(test_string))
def testOutputSerialization(self):
"""
:return:
"""
slzr = serializer.StandardSerializer()
oc = channels.OutputChannel(slzr)
test_string = 'my message'
serialized_test_string = slzr.to_binary(test_string)
oc.set_message(test_string)
for b in serialized_test_string:
self.assertEqual(b, oc.consume_bit())
def task_messenger(task_funct, world_funct=None, serializer=serializer.StandardSerializer()):
""" Returns an EnvironmentMessenger to interact with the created task.
:param task_funct: takes an environment (optionally a world) and returns a task object.
:param world_funct: takes an environment and returns a world object.
:param serializer:
:return:
"""
if world_funct:
world = world_funct()
task = task_funct(world)
else:
task = task_funct()
scheduler = SingleTaskScheduler(task)
env = environment.Environment(serializer, scheduler)
m = EnvironmentMessenger(env, serializer)
yield m
def testConsistency(self):
"""
:return:
"""
slzr = serializer.StandardSerializer()
ic = channels.InputChannel(slzr)
oc = channels.OutputChannel(slzr)
test_string = 'my message'
def all_good(input_message):
self.assertEqual(test_string[:len(input_message)], input_message)
oc.set_message(test_string)
ic.message_updated.register(all_good)
while not oc.is_empty():
b = oc.consume_bit()
ic.consume_bit(b)
def testIsSient(self):
"""
:return:
"""
slzr = serializer.StandardSerializer()
oc = channels.OutputChannel(slzr)
self.assertTrue(oc.is_silent())
oc.set_message(slzr.SILENCE_TOKEN)
self.assertTrue(oc.is_silent())
while not oc.is_empty():
oc.consume_bit()
self.assertTrue(oc.is_silent())
oc.set_message('hello')
while not oc.is_empty():
oc.consume_bit()
if not oc.is_empty():
self.assertFalse(oc.is_silent())
self.assertTrue(oc.is_silent())
def testLimitReward(self):
"""
:return:
"""
env = environment.Environment(serializer.StandardSerializer(), SingleTaskScheduler(NullTask()))
learner = LearnerMock()
s = session.Session(env, learner)
def on_time_updated(t):
"""
:param t:
:return:
"""
if t >= 20:
s.stop()
s.total_time_updated.register(on_time_updated)
s.run()
self.assertLessEqual(s._total_reward, 10)
def testInputSerialization(self):
"""
:return:
"""
slzr = serializer.StandardSerializer()
ic = channels.InputChannel(slzr)
test_string = 'my message'
serialized_test_string = slzr.to_binary(test_string)
def all_good(input_message):
"""
:param input_message:
:return:
"""
self.assertEqual(test_string[:len(input_message)], input_message)
ic.message_updated.register(all_good)
for b in serialized_test_string:
ic.consume_bit(b)
