def test_list_double_index(self): key = 'asdf' value = np.array([[0, 1], [2, 3]]) db = GodMap() db.set_data([key], value) for i in range(value.shape[0]): for j in range(value.shape[1]): self.assertEqual(db.get_data([key, i, j]), value[i, j])
def test_god_map_with_world(self): gm = GodMap() w = World() r = WorldObject(pr2_urdf()) w.add_robot(r, PoseStamped(), [], 0, KeyDefaultDict(lambda key: 0), False) gm.safe_set_data([u'world'], w) assert r == gm.safe_get_data([u'world', u'robot'])
def test_class3(self, class_names): db = GodMap() for i, name in enumerate(class_names): c = type(str(name), (object,), {})() db.set_data(class_names[:i + 1], c) for i, name in enumerate(class_names): c = db.get_data(class_names[:i + 1]) self.assertEqual(type(c).__name__, name)
def test_function4(self, key1, key2, key3, key4, key5): db = GodMap() class MUH(object): def __call__(self, next_member, next_next_member): return [key5] a = MUH() d = {key2: a} db.safe_set_data([key1], d) self.assertEqual(key5, db.safe_get_data([key1, key2, (key3, key4), 0]))
def test_function2(self, key, dict_key, return_value): db = GodMap() class MUH(object): def __call__(self, god_map): return return_value a = MUH() d = {dict_key: a} db.set_data([key], d) self.assertEqual(db.get_data([key, dict_key]), return_value)
def test_function_no_param(self, key1, key2, key3): db = GodMap() class MUH(object): def __call__(self): return [key3] a = MUH() d = {key2: a} db.set_data([key1], d) self.assertEqual(key3, db.get_data([key1, key2, tuple(), 0]))
def test_clear_cache(self): db = GodMap() d = {'b': 'c'} db.set_data(['a'], d) self.assertEqual('c', db.get_data(['a', 'b'])) db.clear_cache() class C(object): b = 'c' db.set_data(['a'], C()) self.assertEqual('c', db.get_data(['a', 'b']))
def test_function_2param_call(self, key1, key2, key3, key4): db = GodMap() class MUH(object): def __call__(self, next_member, next_next_member): return next_next_member a = MUH() d = {key2: a} db.set_data([key1], d) self.assertEqual(db.get_data([key1, key2, (key3, key4)]), key4)
def test_god_map_with_world(self): gm = GodMap() w = World() r = WorldObject(pr2_urdf()) w.add_robot(robot=r, base_pose=PoseStamped(), controlled_joints=[], ignored_pairs=set(), added_pairs=set()) gm.set_data([u'world'], w) gm_robot = gm.get_data(identifier.robot) assert 'pr2' == gm_robot.get_name()
def test_frame_input(self, translation_prefix, translation_suffix, rotation_prefix, rotation_suffix, x, y, z, qx, qy, qz, qw): gm = GodMap() input = FrameInput(gm.to_symbol, translation_prefix, translation_suffix, rotation_prefix, rotation_suffix, x, y, z, qx, qy, qz, qw) x_symbol = str(input.x) y_symbol = str(input.y) z_symbol = str(input.z) qx_symbol = str(input.qx) qy_symbol = str(input.qy) qz_symbol = str(input.qz) qw_symbol = str(input.qw) for e in chain(x, translation_prefix, translation_suffix): self.assertTrue(e in x_symbol) for e in chain(y, translation_prefix, translation_suffix): self.assertTrue(e in y_symbol) for e in chain(z, translation_prefix, translation_suffix): self.assertTrue(e in z_symbol) for e in chain(qx, rotation_prefix, rotation_suffix): self.assertTrue(e in qx_symbol) for e in chain(qy, rotation_prefix, rotation_suffix): self.assertTrue(e in qy_symbol) for e in chain(qz, rotation_prefix, rotation_suffix): self.assertTrue(e in qz_symbol) for e in chain(qw, rotation_prefix, rotation_suffix): self.assertTrue(e in qw_symbol)
def test_list_overwrite_entry(self, key, lists): first_values, second_values = lists db = GodMap() db.set_data([key], first_values) for i, v in enumerate(first_values): self.assertEqual(db.get_data([key, i]), v) db.set_data([key, i], second_values[i]) for i, v in enumerate(second_values): self.assertEqual(db.get_data([key, i]), v)
def test_get_symbol_map(self, keys_values): keys, values = keys_values gm = GodMap() for key, value in zip(keys, values): gm.set_data([key], value) gm.to_symbol([key]) self.assertEqual(len(gm.get_values(keys)), len(keys))
def test_god_map_with_world(self): gm = GodMap() w = World() r = WorldObject(pr2_urdf()) w.add_robot(robot=r, base_pose=PoseStamped(), controlled_joints=[], joint_vel_limit=KeyDefaultDict(lambda key: 0), joint_acc_limit=KeyDefaultDict(lambda key: 0), joint_weights=KeyDefaultDict(lambda key: 0), calc_self_collision_matrix=False, ignored_pairs=set(), added_pairs=set(), symengine_backend='llvm', symengine_opt_level=0) gm.safe_set_data([u'world'], w) gm_robot = gm.safe_get_data(identifier.robot) assert 'pr2' == gm_robot.get_name()
def test_dict2(self, key, key_values): d = {} db = GodMap() db.set_data([key], d) for k, v in zip(*key_values): db.set_data([key, k], v) for k, v in zip(*key_values): self.assertEqual(db.get_data([key, k]), v)
def __init__(self, initial_state=None): """Initializes the process manager. Arguments: initial_state -- An initial god map for this process manager """ self._plugins = OrderedDict() self._god_map = GodMap() if initial_state is None else copy( initial_state) self.original_universe = initial_state is None
def test_joint_states_input(self, joint_names, prefix, suffix): gm = GodMap() js_input = JointStatesInput(gm.to_symbol, joint_names, prefix, suffix) for i, (joint_name, joint_symbol) in enumerate(js_input.joint_map.items()): self.assertTrue(joint_name in joint_names) symbol_str = str(joint_symbol) for e in prefix: self.assertTrue(e in symbol_str) for e in suffix: self.assertTrue(e in symbol_str)
def test_vector3_input(self, x, y, z, prefix, suffix): gm = GodMap() input = Vector3Input(gm.to_symbol, prefix, suffix, x, y, z) x_symbol = str(input.x) y_symbol = str(input.y) z_symbol = str(input.z) for e in chain(x, prefix, suffix): self.assertTrue(e in x_symbol) for e in chain(y, prefix, suffix): self.assertTrue(e in y_symbol) for e in chain(z, prefix, suffix): self.assertTrue(e in z_symbol)
def test_class1(self, key, class_name, key_values): c = type(str(class_name), (object,), {})() for k, v in zip(*key_values): setattr(c, k, None) db = GodMap() db.set_data([key], c) for k, v in zip(*key_values): self.assertEqual(db.get_data([key, k]), None) for k, v in zip(*key_values): db.set_data([key, k], v) for k, v in zip(*key_values): self.assertEqual(db.get_data([key, k]), v)
def test_function3(self, key1, key2, key3, key4, key5): db = GodMap() class MUH(object): def __call__(self, next_member): return [key5] a = MUH() d = {key2: a} db.set_data([key1], d) try: db.get_data([key1, key2, (key3, key4), 0]) assert False except TypeError: assert True
def test_namedtuple1(self): Frame = namedtuple(u'Frame', [u'pos']) db = GodMap() db.set_data([u'f12'], Frame(pos=2)) with self.assertRaises(AttributeError): db.set_data([u'f12', u'pos'], 42)
def test_namedtuple(self, key, tuple_name, key_values): Frame = namedtuple(tuple_name, key_values[0]) db = GodMap() db.set_data([key], Frame(*key_values[1])) for k, v in zip(*key_values): self.assertEqual(db.get_data([key, k]), v)
def test_set_get_float(self, key, number): db = GodMap() db.set_data([key], number) db.set_data([key], number) self.assertEqual(db.get_data([key]), number)
def test_set_get_integer2(self, key, number): db = GodMap() db.set_data([key], number) self.assertEqual(db.get_data([key]), number, msg=u'key={}, number={}'.format(key, number)) self.assertEqual(db.get_data([key]), number, msg=u'key={}, number={}'.format(key, number))
def test_list_negative_index(self, key, l): db = GodMap() db.set_data([key], l) for i in range(len(l)): self.assertEqual(db.get_data([key, -i]), l[-i])
def test_dict3(self, key, tuple_key, value): tuple_key = tuple(tuple_key) d = {tuple_key: value} db = GodMap() db.set_data([key], d) self.assertEqual(db.get_data([key, tuple_key]), value)
def test_god_map_key_error(self, key, wrong_key, number, default_value): assume(key != wrong_key) db = GodMap(default_value) db.set_data([key], number) self.assertEqual(db.get_data([wrong_key]), default_value, msg=u'key={}, number={}'.format(key, number))
def test_tuple1(self, key, value): value = tuple(value) db = GodMap() db.set_data([key], value) for i, v in enumerate(value): self.assertEqual(db.get_data([key, i]), v)
def test_to_symbol(self, key, value): gm = GodMap() gm.set_data([key], value) self.assertTrue(w.is_symbol(gm.to_symbol([key]))) self.assertTrue(key in str(gm.to_symbol([key])))
def test_function_1param_lambda(self, key, key2): db = GodMap() f = lambda x: x db.set_data([key], f) self.assertEqual(db.get_data([key, (key2,)]), key2)
def test_list_index_error(self, key, l): db = GodMap() db.set_data([key], l) with self.assertRaises(IndexError): db.set_data([key, len(l) + 1], 0)