import unittest

class TestObject(unittest.TestCase):
    def test___eq__(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.__eq__(other))
        assert True # TODO: implement your test here

    def test___init__(self):
        # object = Object(dbobj)
        assert True # TODO: implement your test here

    def test_access(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.access(accessing_obj, access_type, default, **kwargs))
        assert True # TODO: implement your test here

    def test_announce_move_from(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.announce_move_from(destination))
        assert True # TODO: implement your test here

    def test_announce_move_to(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.announce_move_to(source_location))
        assert True # TODO: implement your test here

    def test_at_access(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.at_access(result, accessing_obj, access_type, **kwargs))
        assert True # TODO: implement your test here

    def test_at_access_failure(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.at_access_failure(accessing_obj, access_type))
        assert True # TODO: implement your test here

    def test_at_access_success(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.at_access_success(accessing_obj, access_type))
        assert True # TODO: implement your test here

    def test_at_after_move(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.at_after_move(source_location))
        assert True # TODO: implement your test here

    def test_at_after_traverse(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.at_after_traverse(traversing_object, source_location))
        assert True # TODO: implement your test here

    def test_at_before_move(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.at_before_move(destination))
        assert True # TODO: implement your test here

    def test_at_before_traverse(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.at_before_traverse(traversing_object))
        assert True # TODO: implement your test here

    def test_at_cmdset_get(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.at_cmdset_get(**kwargs))
        assert True # TODO: implement your test here

    def test_at_desc(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.at_desc(looker))
        assert True # TODO: implement your test here

    def test_at_drop(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.at_drop(dropper))
        assert True # TODO: implement your test here

    def test_at_failed_traverse(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.at_failed_traverse(traversing_object))
        assert True # TODO: implement your test here

    def test_at_get(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.at_get(getter))
        assert True # TODO: implement your test here

    def test_at_init(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.at_init())
        assert True # TODO: implement your test here

    def test_at_msg_receive(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.at_msg_receive(text, **kwargs))
        assert True # TODO: implement your test here

    def test_at_msg_send(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.at_msg_send(text, to_obj, **kwargs))
        assert True # TODO: implement your test here

    def test_at_object_creation(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.at_object_creation())
        assert True # TODO: implement your test here

    def test_at_object_delete(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.at_object_delete())
        assert True # TODO: implement your test here

    def test_at_object_leave(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.at_object_leave(moved_obj, target_location))
        assert True # TODO: implement your test here

    def test_at_object_receive(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.at_object_receive(moved_obj, source_location))
        assert True # TODO: implement your test here

    def test_at_post_puppet(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.at_post_puppet())
        assert True # TODO: implement your test here

    def test_at_post_unpuppet(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.at_post_unpuppet(player, sessid))
        assert True # TODO: implement your test here

    def test_at_pre_puppet(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.at_pre_puppet(player, sessid))
        assert True # TODO: implement your test here

    def test_at_pre_unpuppet(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.at_pre_unpuppet())
        assert True # TODO: implement your test here

    def test_at_say(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.at_say(speaker, message))
        assert True # TODO: implement your test here

    def test_at_server_reload(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.at_server_reload())
        assert True # TODO: implement your test here

    def test_at_server_shutdown(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.at_server_shutdown())
        assert True # TODO: implement your test here

    def test_at_traverse(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.at_traverse(traversing_object, target_location))
        assert True # TODO: implement your test here

    def test_basetype_posthook_setup(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.basetype_posthook_setup())
        assert True # TODO: implement your test here

    def test_basetype_setup(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.basetype_setup())
        assert True # TODO: implement your test here

    def test_check_permstring(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.check_permstring(permstring))
        assert True # TODO: implement your test here

    def test_copy(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.copy(new_key))
        assert True # TODO: implement your test here

    def test_delete(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.delete())
        assert True # TODO: implement your test here

    def test_execute_cmd(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.execute_cmd(raw_string, sessid))
        assert True # TODO: implement your test here

    def test_is_typeclass(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.is_typeclass(typeclass, exact))
        assert True # TODO: implement your test here

    def test_move_to(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.move_to(destination, quiet, emit_to_obj, use_destination, to_none))
        assert True # TODO: implement your test here

    def test_msg(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.msg(text, from_obj, sessid, **kwargs))
        assert True # TODO: implement your test here

    def test_msg_contents(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.msg_contents(text, exclude, from_obj, **kwargs))
        assert True # TODO: implement your test here

    def test_return_appearance(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.return_appearance(pobject))
        assert True # TODO: implement your test here

    def test_search(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.search(ostring, global_search, use_nicks, typeclass, location, attribute_name, quiet, exact))
        assert True # TODO: implement your test here

    def test_swap_typeclass(self):
        # object = Object(dbobj)
        # self.assertEqual(expected, object.swap_typeclass(new_typeclass, clean_attributes, no_default))
        assert True # TODO: implement your test here

class TestCharacter(unittest.TestCase):
    def test_at_after_move(self):
        # character = Character()
        # self.assertEqual(expected, character.at_after_move(source_location))
        assert True # TODO: implement your test here

    def test_at_object_creation(self):
        # character = Character()
        # self.assertEqual(expected, character.at_object_creation())
        assert True # TODO: implement your test here

    def test_at_post_puppet(self):
        # character = Character()
        # self.assertEqual(expected, character.at_post_puppet())
        assert True # TODO: implement your test here

    def test_at_post_unpuppet(self):
        # character = Character()
        # self.assertEqual(expected, character.at_post_unpuppet(player, sessid))
        assert True # TODO: implement your test here

    def test_at_pre_puppet(self):
        # character = Character()
        # self.assertEqual(expected, character.at_pre_puppet(player, sessid))
        assert True # TODO: implement your test here

    def test_basetype_setup(self):
        # character = Character()
        # self.assertEqual(expected, character.basetype_setup())
        assert True # TODO: implement your test here

class TestRoom(unittest.TestCase):
    def test_basetype_setup(self):
        # room = Room()
        # self.assertEqual(expected, room.basetype_setup())
        assert True # TODO: implement your test here

class TestExit(unittest.TestCase):
    def test_at_after_traverse(self):
        # exit = Exit()
        # self.assertEqual(expected, exit.at_after_traverse(traversing_object, source_location))
        assert True # TODO: implement your test here

    def test_at_cmdset_get(self):
        # exit = Exit()
        # self.assertEqual(expected, exit.at_cmdset_get(**kwargs))
        assert True # TODO: implement your test here

    def test_at_failed_traverse(self):
        # exit = Exit()
        # self.assertEqual(expected, exit.at_failed_traverse(traversing_object))
        assert True # TODO: implement your test here

    def test_at_object_creation(self):
        # exit = Exit()
        # self.assertEqual(expected, exit.at_object_creation())
        assert True # TODO: implement your test here

    def test_at_traverse(self):
        # exit = Exit()
        # self.assertEqual(expected, exit.at_traverse(traversing_object, target_location))
        assert True # TODO: implement your test here

    def test_basetype_setup(self):
        # exit = Exit()
        # self.assertEqual(expected, exit.basetype_setup())
        assert True # TODO: implement your test here

    def test_create_exit_cmdset(self):
        # exit = Exit()
        # self.assertEqual(expected, exit.create_exit_cmdset(exidbobj))
        assert True # TODO: implement your test here

if __name__ == '__main__':
    unittest.main()