Andreas/evennia
1
0
Fork 0
mirror of https://github.com/evennia/evennia.git synced 2026-03-16 21:06:30 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Remove unused test stubs.

Browse source
This commit is contained in:
Jonathan Piacenti 2015-02-22 17:19:05 -06:00 • committed by Griatch
parent 584d94b32b
commit f075bcf297
46 changed files with 0 additions and 3536 deletions
Download patch file Download diff file Expand all files Collapse all files

14
evennia/tests/test_commands_cmdhandler.py
View file

@ -1,14 +0,0 @@
import unittest
class TestGetAndMergeCmdsets(unittest.TestCase):
def test_get_and_merge_cmdsets(self):
# self.assertEqual(expected, get_and_merge_cmdsets(caller, session, player, obj, callertype, sessid))
assert True # TODO: implement your test here
class TestCmdhandler(unittest.TestCase):
def test_cmdhandler(self):
# self.assertEqual(expected, cmdhandler(called_by, raw_string, _testing, callertype, sessid))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

24
evennia/tests/test_commands_cmdparser.py
View file

@ -1,24 +0,0 @@
import unittest
class TestCmdparser(unittest.TestCase):
def test_cmdparser(self):
# self.assertEqual(expected, cmdparser(raw_string, cmdset, caller, match_index))
assert True # TODO: implement your test here
class TestAtSearchResult(unittest.TestCase):
def test_at_search_result(self):
# self.assertEqual(expected, at_search_result(msg_obj, ostring, results, global_search, nofound_string, multimatch_string))
assert True # TODO: implement your test here
class TestAtMultimatchInput(unittest.TestCase):
def test_at_multimatch_input(self):
# self.assertEqual(expected, at_multimatch_input(ostring))
assert True # TODO: implement your test here
class TestAtMultimatchCmd(unittest.TestCase):
def test_at_multimatch_cmd(self):
# self.assertEqual(expected, at_multimatch_cmd(caller, matches))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

74
evennia/tests/test_commands_cmdset.py
View file

@ -1,74 +0,0 @@
import unittest
class test__CmdSetMeta(unittest.TestCase):
def test___init__(self):
# __cmd_set_meta = _CmdSetMeta(*args, **kwargs)
assert True # TODO: implement your test here
class TestCmdSet(unittest.TestCase):
def test___add__(self):
# cmd_set = CmdSet(cmdsetobj, key)
# self.assertEqual(expected, cmd_set.__add__(cmdset_b))
assert True # TODO: implement your test here
def test___contains__(self):
# cmd_set = CmdSet(cmdsetobj, key)
# self.assertEqual(expected, cmd_set.__contains__(othercmd))
assert True # TODO: implement your test here
def test___init__(self):
# cmd_set = CmdSet(cmdsetobj, key)
assert True # TODO: implement your test here
def test___iter__(self):
# cmd_set = CmdSet(cmdsetobj, key)
# self.assertEqual(expected, cmd_set.__iter__())
assert True # TODO: implement your test here
def test___str__(self):
# cmd_set = CmdSet(cmdsetobj, key)
# self.assertEqual(expected, cmd_set.__str__())
assert True # TODO: implement your test here
def test_add(self):
# cmd_set = CmdSet(cmdsetobj, key)
# self.assertEqual(expected, cmd_set.add(cmd))
assert True # TODO: implement your test here
def test_at_cmdset_creation(self):
# cmd_set = CmdSet(cmdsetobj, key)
# self.assertEqual(expected, cmd_set.at_cmdset_creation())
assert True # TODO: implement your test here
def test_count(self):
# cmd_set = CmdSet(cmdsetobj, key)
# self.assertEqual(expected, cmd_set.count())
assert True # TODO: implement your test here
def test_get(self):
# cmd_set = CmdSet(cmdsetobj, key)
# self.assertEqual(expected, cmd_set.get(cmd))
assert True # TODO: implement your test here
def test_get_all_cmd_keys_and_aliases(self):
# cmd_set = CmdSet(cmdsetobj, key)
# self.assertEqual(expected, cmd_set.get_all_cmd_keys_and_aliases(caller))
assert True # TODO: implement your test here
def test_get_system_cmds(self):
# cmd_set = CmdSet(cmdsetobj, key)
# self.assertEqual(expected, cmd_set.get_system_cmds())
assert True # TODO: implement your test here
def test_make_unique(self):
# cmd_set = CmdSet(cmdsetobj, key)
# self.assertEqual(expected, cmd_set.make_unique(caller))
assert True # TODO: implement your test here
def test_remove(self):
# cmd_set = CmdSet(cmdsetobj, key)
# self.assertEqual(expected, cmd_set.remove(cmd))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

64
evennia/tests/test_commands_cmdsethandler.py
View file

@ -1,64 +0,0 @@
import unittest
class TestImportCmdset(unittest.TestCase):
def test_import_cmdset(self):
# self.assertEqual(expected, import_cmdset(python_path, cmdsetobj, emit_to_obj, no_logging))
assert True # TODO: implement your test here
class TestCmdSetHandler(unittest.TestCase):
def test___init__(self):
# cmd_set_handler = CmdSetHandler(obj)
assert True # TODO: implement your test here
def test___str__(self):
# cmd_set_handler = CmdSetHandler(obj)
# self.assertEqual(expected, cmd_set_handler.__str__())
assert True # TODO: implement your test here
def test_add(self):
# cmd_set_handler = CmdSetHandler(obj)
# self.assertEqual(expected, cmd_set_handler.add(cmdset, emit_to_obj, permanent))
assert True # TODO: implement your test here
def test_add_default(self):
# cmd_set_handler = CmdSetHandler(obj)
# self.assertEqual(expected, cmd_set_handler.add_default(cmdset, emit_to_obj, permanent))
assert True # TODO: implement your test here
def test_all(self):
# cmd_set_handler = CmdSetHandler(obj)
# self.assertEqual(expected, cmd_set_handler.all())
assert True # TODO: implement your test here
def test_clear(self):
# cmd_set_handler = CmdSetHandler(obj)
# self.assertEqual(expected, cmd_set_handler.clear())
assert True # TODO: implement your test here
def test_delete(self):
# cmd_set_handler = CmdSetHandler(obj)
# self.assertEqual(expected, cmd_set_handler.delete(cmdset))
assert True # TODO: implement your test here
def test_delete_default(self):
# cmd_set_handler = CmdSetHandler(obj)
# self.assertEqual(expected, cmd_set_handler.delete_default())
assert True # TODO: implement your test here
def test_has_cmdset(self):
# cmd_set_handler = CmdSetHandler(obj)
# self.assertEqual(expected, cmd_set_handler.has_cmdset(cmdset_key, must_be_default))
assert True # TODO: implement your test here
def test_reset(self):
# cmd_set_handler = CmdSetHandler(obj)
# self.assertEqual(expected, cmd_set_handler.reset())
assert True # TODO: implement your test here
def test_update(self):
# cmd_set_handler = CmdSetHandler(obj)
# self.assertEqual(expected, cmd_set_handler.update(init_mode))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

69
evennia/tests/test_commands_command.py
View file

@ -1,69 +0,0 @@
import unittest
class TestCommandMeta(unittest.TestCase):
def test___init__(self):
# command_meta = CommandMeta(*args, **kwargs)
assert True # TODO: implement your test here
class TestCommand(unittest.TestCase):
def test___contains__(self):
# command = Command(**kwargs)
# self.assertEqual(expected, command.__contains__(query))
assert True # TODO: implement your test here
def test___eq__(self):
# command = Command(**kwargs)
# self.assertEqual(expected, command.__eq__(cmd))
assert True # TODO: implement your test here
def test___init__(self):
# command = Command(**kwargs)
assert True # TODO: implement your test here
def test___ne__(self):
# command = Command(**kwargs)
# self.assertEqual(expected, command.__ne__(cmd))
assert True # TODO: implement your test here
def test___str__(self):
# command = Command(**kwargs)
# self.assertEqual(expected, command.__str__())
assert True # TODO: implement your test here
def test_access(self):
# command = Command(**kwargs)
# self.assertEqual(expected, command.access(srcobj, access_type, default))
assert True # TODO: implement your test here
def test_at_post_cmd(self):
# command = Command(**kwargs)
# self.assertEqual(expected, command.at_post_cmd())
assert True # TODO: implement your test here
def test_at_pre_cmd(self):
# command = Command(**kwargs)
# self.assertEqual(expected, command.at_pre_cmd())
assert True # TODO: implement your test here
def test_func(self):
# command = Command(**kwargs)
# self.assertEqual(expected, command.func())
assert True # TODO: implement your test here
def test_match(self):
# command = Command(**kwargs)
# self.assertEqual(expected, command.match(cmdname))
assert True # TODO: implement your test here
def test_msg(self):
# command = Command(**kwargs)
# self.assertEqual(expected, command.msg(msg, to_obj, from_obj, sessid, all_sessions, **kwargs))
assert True # TODO: implement your test here
def test_parse(self):
# command = Command(**kwargs)
# self.assertEqual(expected, command.parse())
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

45
evennia/tests/test_comms_channelhandler.py
View file

@ -1,45 +0,0 @@
import unittest
class TestChannelCommand(unittest.TestCase):
def test_func(self):
# channel_command = ChannelCommand()
# self.assertEqual(expected, channel_command.func())
assert True # TODO: implement your test here
def test_parse(self):
# channel_command = ChannelCommand()
# self.assertEqual(expected, channel_command.parse())
assert True # TODO: implement your test here
class TestChannelHandler(unittest.TestCase):
def test___init__(self):
# channel_handler = ChannelHandler()
assert True # TODO: implement your test here
def test___str__(self):
# channel_handler = ChannelHandler()
# self.assertEqual(expected, channel_handler.__str__())
assert True # TODO: implement your test here
def test_add_channel(self):
# channel_handler = ChannelHandler()
# self.assertEqual(expected, channel_handler.add_channel(channel))
assert True # TODO: implement your test here
def test_clear(self):
# channel_handler = ChannelHandler()
# self.assertEqual(expected, channel_handler.clear())
assert True # TODO: implement your test here
def test_get_cmdset(self):
# channel_handler = ChannelHandler()
# self.assertEqual(expected, channel_handler.get_cmdset(source_object))
assert True # TODO: implement your test here
def test_update(self):
# channel_handler = ChannelHandler()
# self.assertEqual(expected, channel_handler.update())
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

90
evennia/tests/test_comms_comms.py
View file

@ -1,90 +0,0 @@
import unittest
class TestChannel(unittest.TestCase):
def test_at_channel_create(self):
# channel = Channel()
# self.assertEqual(expected, channel.at_channel_create())
assert True # TODO: implement your test here
def test_at_init(self):
# channel = Channel()
# self.assertEqual(expected, channel.at_init())
assert True # TODO: implement your test here
def test_channel_prefix(self):
# channel = Channel()
# self.assertEqual(expected, channel.channel_prefix(msg, emit))
assert True # TODO: implement your test here
def test_distribute_message(self):
# channel = Channel()
# self.assertEqual(expected, channel.distribute_message(msg, online))
assert True # TODO: implement your test here
def test_format_external(self):
# channel = Channel()
# self.assertEqual(expected, channel.format_external(msg, senders, emit))
assert True # TODO: implement your test here
def test_format_message(self):
# channel = Channel()
# self.assertEqual(expected, channel.format_message(msg, emit))
assert True # TODO: implement your test here
def test_format_senders(self):
# channel = Channel()
# self.assertEqual(expected, channel.format_senders(senders))
assert True # TODO: implement your test here
def test_message_transform(self):
# channel = Channel()
# self.assertEqual(expected, channel.message_transform(msg, emit, prefix, sender_strings, external))
assert True # TODO: implement your test here
def test_msg(self):
# channel = Channel()
# self.assertEqual(expected, channel.msg(msgobj, header, senders, sender_strings, persistent, online, emit, external))
assert True # TODO: implement your test here
def test_pose_transform(self):
# channel = Channel()
# self.assertEqual(expected, channel.pose_transform(msg, sender_string))
assert True # TODO: implement your test here
def test_post_join_channel(self):
# channel = Channel()
# self.assertEqual(expected, channel.post_join_channel(joiner))
assert True # TODO: implement your test here
def test_post_leave_channel(self):
# channel = Channel()
# self.assertEqual(expected, channel.post_leave_channel(leaver))
assert True # TODO: implement your test here
def test_post_send_message(self):
# channel = Channel()
# self.assertEqual(expected, channel.post_send_message(msg))
assert True # TODO: implement your test here
def test_pre_join_channel(self):
# channel = Channel()
# self.assertEqual(expected, channel.pre_join_channel(joiner))
assert True # TODO: implement your test here
def test_pre_leave_channel(self):
# channel = Channel()
# self.assertEqual(expected, channel.pre_leave_channel(leaver))
assert True # TODO: implement your test here
def test_pre_send_message(self):
# channel = Channel()
# self.assertEqual(expected, channel.pre_send_message(msg))
assert True # TODO: implement your test here
def test_tempmsg(self):
# channel = Channel()
# self.assertEqual(expected, channel.tempmsg(message, header, senders))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

84
evennia/tests/test_comms_models.py
View file

@ -1,84 +0,0 @@
import unittest
class TestMsg(unittest.TestCase):
def test___init__(self):
# msg = Msg(*args, **kwargs)
assert True # TODO: implement your test here
def test___str__(self):
# msg = Msg(*args, **kwargs)
# self.assertEqual(expected, msg.__str__())
assert True # TODO: implement your test here
def test_remove_receiver(self):
# msg = Msg(*args, **kwargs)
# self.assertEqual(expected, msg.remove_receiver(obj))
assert True # TODO: implement your test here
def test_remove_sender(self):
# msg = Msg(*args, **kwargs)
# self.assertEqual(expected, msg.remove_sender(value))
assert True # TODO: implement your test here
class TestTempMsg(unittest.TestCase):
def test___init__(self):
# temp_msg = TempMsg(senders, receivers, channels, message, header, type, lockstring, hide_from)
assert True # TODO: implement your test here
def test___str__(self):
# temp_msg = TempMsg(senders, receivers, channels, message, header, type, lockstring, hide_from)
# self.assertEqual(expected, temp_msg.__str__())
assert True # TODO: implement your test here
def test_access(self):
# temp_msg = TempMsg(senders, receivers, channels, message, header, type, lockstring, hide_from)
# self.assertEqual(expected, temp_msg.access(accessing_obj, access_type, default))
assert True # TODO: implement your test here
def test_remove_receiver(self):
# temp_msg = TempMsg(senders, receivers, channels, message, header, type, lockstring, hide_from)
# self.assertEqual(expected, temp_msg.remove_receiver(obj))
assert True # TODO: implement your test here
def test_remove_sender(self):
# temp_msg = TempMsg(senders, receivers, channels, message, header, type, lockstring, hide_from)
# self.assertEqual(expected, temp_msg.remove_sender(obj))
assert True # TODO: implement your test here
class TestChannelDB(unittest.TestCase):
def test___init__(self):
# channel_d_b = ChannelDB(*args, **kwargs)
assert True # TODO: implement your test here
def test___str__(self):
# channel_d_b = ChannelDB(*args, **kwargs)
# self.assertEqual(expected, channel_d_b.__str__())
assert True # TODO: implement your test here
def test_access(self):
# channel_d_b = ChannelDB(*args, **kwargs)
# self.assertEqual(expected, channel_d_b.access(accessing_obj, access_type, default))
assert True # TODO: implement your test here
def test_connect(self):
# channel_d_b = ChannelDB(*args, **kwargs)
# self.assertEqual(expected, channel_d_b.connect(player))
assert True # TODO: implement your test here
def test_delete(self):
# channel_d_b = ChannelDB(*args, **kwargs)
# self.assertEqual(expected, channel_d_b.delete())
assert True # TODO: implement your test here
def test_disconnect(self):
# channel_d_b = ChannelDB(*args, **kwargs)
# self.assertEqual(expected, channel_d_b.disconnect(player))
assert True # TODO: implement your test here
def test_has_connection(self):
# channel_d_b = ChannelDB(*args, **kwargs)
# self.assertEqual(expected, channel_d_b.has_connection(player))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

129
evennia/tests/test_locks_lockfuncs.py
View file

@ -1,129 +0,0 @@
import unittest
class TestTrue(unittest.TestCase):
def test_true(self):
# self.assertEqual(expected, true(*args, **kwargs))
assert True # TODO: implement your test here
class TestAll(unittest.TestCase):
def test_all(self):
# self.assertEqual(expected, all(*args, **kwargs))
assert True # TODO: implement your test here
class TestTrue(unittest.TestCase):
def test_false(self):
# self.assertEqual(expected, false(*args, **kwargs))
assert True # TODO: implement your test here
class TestNone(unittest.TestCase):
def test_none(self):
# self.assertEqual(expected, none(*args, **kwargs))
assert True # TODO: implement your test here
class TestSelf(unittest.TestCase):
def test_self(self):
# self.assertEqual(expected, self(accessing_obj, accessed_obj, *args, **kwargs))
assert True # TODO: implement your test here
class TestPerm(unittest.TestCase):
def test_perm(self):
# self.assertEqual(expected, perm(accessing_obj, accessed_obj, *args, **kwargs))
assert True # TODO: implement your test here
class TestPermAbove(unittest.TestCase):
def test_perm_above(self):
# self.assertEqual(expected, perm_above(accessing_obj, accessed_obj, *args, **kwargs))
assert True # TODO: implement your test here
class TestPperm(unittest.TestCase):
def test_pperm(self):
# self.assertEqual(expected, pperm(accessing_obj, accessed_obj, *args, **kwargs))
assert True # TODO: implement your test here
class TestPpermAbove(unittest.TestCase):
def test_pperm_above(self):
# self.assertEqual(expected, pperm_above(accessing_obj, accessed_obj, *args, **kwargs))
assert True # TODO: implement your test here
class TestDbref(unittest.TestCase):
def test_dbref(self):
# self.assertEqual(expected, dbref(accessing_obj, accessed_obj, *args, **kwargs))
assert True # TODO: implement your test here
class TestPdbref(unittest.TestCase):
def test_pdbref(self):
# self.assertEqual(expected, pdbref(accessing_obj, accessed_obj, *args, **kwargs))
assert True # TODO: implement your test here
class TestId(unittest.TestCase):
def test_id(self):
# self.assertEqual(expected, id(accessing_obj, accessed_obj, *args, **kwargs))
assert True # TODO: implement your test here
class TestPid(unittest.TestCase):
def test_pid(self):
# self.assertEqual(expected, pid(accessing_obj, accessed_obj, *args, **kwargs))
assert True # TODO: implement your test here
class TestAttr(unittest.TestCase):
def test_attr(self):
# self.assertEqual(expected, attr(accessing_obj, accessed_obj, *args, **kwargs))
assert True # TODO: implement your test here
class TestObjattr(unittest.TestCase):
def test_objattr(self):
# self.assertEqual(expected, objattr(accessing_obj, accessed_obj, *args, **kwargs))
assert True # TODO: implement your test here
class TestLocattr(unittest.TestCase):
def test_locattr(self):
# self.assertEqual(expected, locattr(accessing_obj, accessed_obj, *args, **kwargs))
assert True # TODO: implement your test here
class TestAttrEq(unittest.TestCase):
def test_attr_eq(self):
# self.assertEqual(expected, attr_eq(accessing_obj, accessed_obj, *args, **kwargs))
assert True # TODO: implement your test here
class TestAttrGt(unittest.TestCase):
def test_attr_gt(self):
# self.assertEqual(expected, attr_gt(accessing_obj, accessed_obj, *args, **kwargs))
assert True # TODO: implement your test here
class TestAttrGe(unittest.TestCase):
def test_attr_ge(self):
# self.assertEqual(expected, attr_ge(accessing_obj, accessed_obj, *args, **kwargs))
assert True # TODO: implement your test here
class TestAttrLt(unittest.TestCase):
def test_attr_lt(self):
# self.assertEqual(expected, attr_lt(accessing_obj, accessed_obj, *args, **kwargs))
assert True # TODO: implement your test here
class TestAttrLe(unittest.TestCase):
def test_attr_le(self):
# self.assertEqual(expected, attr_le(accessing_obj, accessed_obj, *args, **kwargs))
assert True # TODO: implement your test here
class TestAttrNe(unittest.TestCase):
def test_attr_ne(self):
# self.assertEqual(expected, attr_ne(accessing_obj, accessed_obj, *args, **kwargs))
assert True # TODO: implement your test here
class TestHolds(unittest.TestCase):
def test_holds(self):
# self.assertEqual(expected, holds(accessing_obj, accessed_obj, *args, **kwargs))
assert True # TODO: implement your test here
class TestSuperuser(unittest.TestCase):
def test_superuser(self):
# self.assertEqual(expected, superuser(*args, **kwargs))
assert True # TODO: implement your test here
class TestServersetting(unittest.TestCase):
def test_serversetting(self):
# self.assertEqual(expected, serversetting(accessing_obj, accessed_obj, *args, **kwargs))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

59
evennia/tests/test_locks_lockhandler.py
View file

@ -1,59 +0,0 @@
import unittest
class TestLockHandler(unittest.TestCase):
def test___init__(self):
# lock_handler = LockHandler(obj)
assert True # TODO: implement your test here
def test___str__(self):
# lock_handler = LockHandler(obj)
# self.assertEqual(expected, lock_handler.__str__())
assert True # TODO: implement your test here
def test_add(self):
# lock_handler = LockHandler(obj)
# self.assertEqual(expected, lock_handler.add(lockstring))
assert True # TODO: implement your test here
def test_cache_lock_bypass(self):
# lock_handler = LockHandler(obj)
# self.assertEqual(expected, lock_handler.cache_lock_bypass(obj))
assert True # TODO: implement your test here
def test_check(self):
# lock_handler = LockHandler(obj)
# self.assertEqual(expected, lock_handler.check(accessing_obj, access_type, default, no_superuser_bypass))
assert True # TODO: implement your test here
def test_check_lockstring(self):
# lock_handler = LockHandler(obj)
# self.assertEqual(expected, lock_handler.check_lockstring(accessing_obj, lockstring, no_superuser_bypass))
assert True # TODO: implement your test here
def test_clear(self):
# lock_handler = LockHandler(obj)
# self.assertEqual(expected, lock_handler.clear())
assert True # TODO: implement your test here
def test_delete(self):
# lock_handler = LockHandler(obj)
# self.assertEqual(expected, lock_handler.delete(access_type))
assert True # TODO: implement your test here
def test_get(self):
# lock_handler = LockHandler(obj)
# self.assertEqual(expected, lock_handler.get(access_type))
assert True # TODO: implement your test here
def test_replace(self):
# lock_handler = LockHandler(obj)
# self.assertEqual(expected, lock_handler.replace(lockstring))
assert True # TODO: implement your test here
def test_reset(self):
# lock_handler = LockHandler(obj)
# self.assertEqual(expected, lock_handler.reset())
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

64
evennia/tests/test_objects_models.py
View file

@ -1,64 +0,0 @@
import unittest
class TestObjectDB(unittest.TestCase):
def test___init__(self):
# object_d_b = ObjectDB(*args, **kwargs)
assert True # TODO: implement your test here
def test_clear_contents(self):
# object_d_b = ObjectDB(*args, **kwargs)
# self.assertEqual(expected, object_d_b.clear_contents())
assert True # TODO: implement your test here
def test_clear_exits(self):
# object_d_b = ObjectDB(*args, **kwargs)
# self.assertEqual(expected, object_d_b.clear_exits())
assert True # TODO: implement your test here
def test_contents_get(self):
# object_d_b = ObjectDB(*args, **kwargs)
# self.assertEqual(expected, object_d_b.contents_get(exclude))
assert True # TODO: implement your test here
def test_copy(self):
# object_d_b = ObjectDB(*args, **kwargs)
# self.assertEqual(expected, object_d_b.copy(new_key))
assert True # TODO: implement your test here
def test_delete(self):
# object_d_b = ObjectDB(*args, **kwargs)
# self.assertEqual(expected, object_d_b.delete())
assert True # TODO: implement your test here
def test_execute_cmd(self):
# object_d_b = ObjectDB(*args, **kwargs)
# self.assertEqual(expected, object_d_b.execute_cmd(raw_string, sessid))
assert True # TODO: implement your test here
def test_move_to(self):
# object_d_b = ObjectDB(*args, **kwargs)
# self.assertEqual(expected, object_d_b.move_to(destination, quiet, emit_to_obj, use_destination, to_none))
assert True # TODO: implement your test here
def test_msg(self):
# object_d_b = ObjectDB(*args, **kwargs)
# self.assertEqual(expected, object_d_b.msg(text, from_obj, sessid, **kwargs))
assert True # TODO: implement your test here
def test_msg_contents(self):
# object_d_b = ObjectDB(*args, **kwargs)
# self.assertEqual(expected, object_d_b.msg_contents(message, exclude, from_obj, **kwargs))
assert True # TODO: implement your test here
def test_search(self):
# object_d_b = ObjectDB(*args, **kwargs)
# self.assertEqual(expected, object_d_b.search(searchdata, global_search, use_nicks, typeclass, location, attribute_name, quiet, exact))
assert True # TODO: implement your test here
def test_search_player(self):
# object_d_b = ObjectDB(*args, **kwargs)
# self.assertEqual(expected, object_d_b.search_player(searchdata, quiet))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

302
evennia/tests/test_objects_objects.py
View file

@ -1,302 +0,0 @@
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()

106
evennia/tests/test_players_bots.py
View file

@ -1,106 +0,0 @@
import unittest
class TestBotStarter(unittest.TestCase):
def test_at_repeat(self):
# bot_starter = BotStarter()
# self.assertEqual(expected, bot_starter.at_repeat())
assert True # TODO: implement your test here
def test_at_script_creation(self):
# bot_starter = BotStarter()
# self.assertEqual(expected, bot_starter.at_script_creation())
assert True # TODO: implement your test here
def test_at_server_reload(self):
# bot_starter = BotStarter()
# self.assertEqual(expected, bot_starter.at_server_reload())
assert True # TODO: implement your test here
def test_at_server_shutdown(self):
# bot_starter = BotStarter()
# self.assertEqual(expected, bot_starter.at_server_shutdown())
assert True # TODO: implement your test here
def test_at_start(self):
# bot_starter = BotStarter()
# self.assertEqual(expected, bot_starter.at_start())
assert True # TODO: implement your test here
class TestCmdBotListen(unittest.TestCase):
def test_func(self):
# cmd_bot_listen = CmdBotListen()
# self.assertEqual(expected, cmd_bot_listen.func())
assert True # TODO: implement your test here
class TestBotCmdSet(unittest.TestCase):
def test_at_cmdset_creation(self):
# bot_cmd_set = BotCmdSet()
# self.assertEqual(expected, bot_cmd_set.at_cmdset_creation())
assert True # TODO: implement your test here
class TestBot(unittest.TestCase):
def test_basetype_setup(self):
# bot = Bot()
# self.assertEqual(expected, bot.basetype_setup())
assert True # TODO: implement your test here
def test_execute_cmd(self):
# bot = Bot()
# self.assertEqual(expected, bot.execute_cmd(raw_string, sessid))
assert True # TODO: implement your test here
def test_msg(self):
# bot = Bot()
# self.assertEqual(expected, bot.msg(text, from_obj, sessid, **kwargs))
assert True # TODO: implement your test here
def test_start(self):
# bot = Bot()
# self.assertEqual(expected, bot.start(**kwargs))
assert True # TODO: implement your test here
class TestIRCBot(unittest.TestCase):
def test_execute_cmd(self):
# i_rc_bot = IRCBot()
# self.assertEqual(expected, i_rc_bot.execute_cmd(text, sessid))
assert True # TODO: implement your test here
def test_msg(self):
# i_rc_bot = IRCBot()
# self.assertEqual(expected, i_rc_bot.msg(text, **kwargs))
assert True # TODO: implement your test here
def test_start(self):
# i_rc_bot = IRCBot()
# self.assertEqual(expected, i_rc_bot.start(ev_channel, irc_botname, irc_channel, irc_network, irc_port))
assert True # TODO: implement your test here
class TestRSSBot(unittest.TestCase):
def test_execute_cmd(self):
# r_ss_bot = RSSBot()
# self.assertEqual(expected, r_ss_bot.execute_cmd(text, sessid))
assert True # TODO: implement your test here
def test_start(self):
# r_ss_bot = RSSBot()
# self.assertEqual(expected, r_ss_bot.start(ev_channel, rss_url, rss_rate))
assert True # TODO: implement your test here
class TestIMC2Bot(unittest.TestCase):
def test_execute_cmd(self):
# i_m_c2_bot = IMC2Bot()
# self.assertEqual(expected, i_m_c2_bot.execute_cmd(text, sessid))
assert True # TODO: implement your test here
def test_msg(self):
# i_m_c2_bot = IMC2Bot()
# self.assertEqual(expected, i_m_c2_bot.msg(text, **kwargs))
assert True # TODO: implement your test here
def test_start(self):
# i_m_c2_bot = IMC2Bot()
# self.assertEqual(expected, i_m_c2_bot.start(ev_channel, imc2_network, imc2_mudname, imc2_port, imc2_client_pwd, imc2_server_pwd))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

94
evennia/tests/test_players_models.py
View file

@ -1,94 +0,0 @@
import unittest
class TestPlayerDB(unittest.TestCase):
def test___init__(self):
# player_d_b = PlayerDB(*args, **kwargs)
assert True # TODO: implement your test here
def test___str__(self):
# player_d_b = PlayerDB(*args, **kwargs)
# self.assertEqual(expected, player_d_b.__str__())
assert True # TODO: implement your test here
def test___unicode__(self):
# player_d_b = PlayerDB(*args, **kwargs)
# self.assertEqual(expected, player_d_b.__unicode__())
assert True # TODO: implement your test here
def test_cmdset_storage_del(self):
# player_d_b = PlayerDB(*args, **kwargs)
# self.assertEqual(expected, player_d_b.cmdset_storage_del())
assert True # TODO: implement your test here
def test_cmdset_storage_get(self):
# player_d_b = PlayerDB(*args, **kwargs)
# self.assertEqual(expected, player_d_b.cmdset_storage_get())
assert True # TODO: implement your test here
def test_cmdset_storage_set(self):
# player_d_b = PlayerDB(*args, **kwargs)
# self.assertEqual(expected, player_d_b.cmdset_storage_set(value))
assert True # TODO: implement your test here
def test_delete(self):
# player_d_b = PlayerDB(*args, **kwargs)
# self.assertEqual(expected, player_d_b.delete(*args, **kwargs))
assert True # TODO: implement your test here
def test_disconnect_session_from_player(self):
# player_d_b = PlayerDB(*args, **kwargs)
# self.assertEqual(expected, player_d_b.disconnect_session_from_player(sessid))
assert True # TODO: implement your test here
def test_execute_cmd(self):
# player_d_b = PlayerDB(*args, **kwargs)
# self.assertEqual(expected, player_d_b.execute_cmd(raw_string, sessid))
assert True # TODO: implement your test here
def test_get_all_puppets(self):
# player_d_b = PlayerDB(*args, **kwargs)
# self.assertEqual(expected, player_d_b.get_all_puppets(return_dbobj))
assert True # TODO: implement your test here
def test_get_all_sessions(self):
# player_d_b = PlayerDB(*args, **kwargs)
# self.assertEqual(expected, player_d_b.get_all_sessions())
assert True # TODO: implement your test here
def test_get_puppet(self):
# player_d_b = PlayerDB(*args, **kwargs)
# self.assertEqual(expected, player_d_b.get_puppet(sessid, return_dbobj))
assert True # TODO: implement your test here
def test_get_session(self):
# player_d_b = PlayerDB(*args, **kwargs)
# self.assertEqual(expected, player_d_b.get_session(sessid))
assert True # TODO: implement your test here
def test_msg(self):
# player_d_b = PlayerDB(*args, **kwargs)
# self.assertEqual(expected, player_d_b.msg(text, from_obj, sessid, **kwargs))
assert True # TODO: implement your test here
def test_puppet_object(self):
# player_d_b = PlayerDB(*args, **kwargs)
# self.assertEqual(expected, player_d_b.puppet_object(sessid, obj, normal_mode))
assert True # TODO: implement your test here
def test_search(self):
# player_d_b = PlayerDB(*args, **kwargs)
# self.assertEqual(expected, player_d_b.search(ostring, return_puppet, return_character, **kwargs))
assert True # TODO: implement your test here
def test_unpuppet_all(self):
# player_d_b = PlayerDB(*args, **kwargs)
# self.assertEqual(expected, player_d_b.unpuppet_all())
assert True # TODO: implement your test here
def test_unpuppet_object(self):
# player_d_b = PlayerDB(*args, **kwargs)
# self.assertEqual(expected, player_d_b.unpuppet_object(sessid))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

10
evennia/tests/test_scripts_models.py
View file

@ -31,12 +31,6 @@ class TestScriptDB(TestCase):
self.scr.delete()
self.scr.delete()
#@unittest.skip("not implemented")
#def test___init__fails(self): # Users should be told not to do this
# - No they should not; ScriptDB() is required internally. /Griatch
# with self.assertRaises(Exception):
# ScriptDB()
def test_deleted_script_fails_start(self):
"Would it ever be necessary to start a deleted script?"
self.scr.delete()
@ -49,7 +43,3 @@ class TestScriptDB(TestCase):
"Can deleted scripts be said to be valid?"
self.scr.delete()
self.assertFalse(self.scr.is_valid()) # assertRaises? See issue #509
if __name__ == '__main__':
unittest.main()

44
evennia/tests/test_scripts_scripthandler.py
View file

@ -1,44 +0,0 @@
import unittest
class TestScriptHandler(unittest.TestCase):
def test___init__(self):
# script_handler = ScriptHandler(obj)
assert True # TODO: implement your test here
def test___str__(self):
# script_handler = ScriptHandler(obj)
# self.assertEqual(expected, script_handler.__str__())
assert True # TODO: implement your test here
def test_add(self):
# script_handler = ScriptHandler(obj)
# self.assertEqual(expected, script_handler.add(scriptclass, key, autostart))
assert True # TODO: implement your test here
def test_all(self):
# script_handler = ScriptHandler(obj)
# self.assertEqual(expected, script_handler.all(scriptid))
assert True # TODO: implement your test here
def test_delete(self):
# script_handler = ScriptHandler(obj)
# self.assertEqual(expected, script_handler.delete(scriptid))
assert True # TODO: implement your test here
def test_start(self):
# script_handler = ScriptHandler(obj)
# self.assertEqual(expected, script_handler.start(scriptid))
assert True # TODO: implement your test here
def test_stop(self):
# script_handler = ScriptHandler(obj)
# self.assertEqual(expected, script_handler.stop(scriptid))
assert True # TODO: implement your test here
def test_validate(self):
# script_handler = ScriptHandler(obj)
# self.assertEqual(expected, script_handler.validate(init_mode))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

181
evennia/tests/test_scripts_scripts.py
View file

@ -1,181 +0,0 @@
import unittest
class TestExtendedLoopingCall(unittest.TestCase):
def test___call__(self):
# extended_looping_call = ExtendedLoopingCall()
# self.assertEqual(expected, extended_looping_call.__call__())
assert True # TODO: implement your test here
def test_force_repeat(self):
# extended_looping_call = ExtendedLoopingCall()
# self.assertEqual(expected, extended_looping_call.force_repeat())
assert True # TODO: implement your test here
def test_next_call_time(self):
# extended_looping_call = ExtendedLoopingCall()
# self.assertEqual(expected, extended_looping_call.next_call_time())
assert True # TODO: implement your test here
def test_start(self):
# extended_looping_call = ExtendedLoopingCall()
# self.assertEqual(expected, extended_looping_call.start(interval, now, start_delay, count_start))
assert True # TODO: implement your test here
class TestScriptBase(unittest.TestCase):
def test___eq__(self):
# script_base = ScriptBase()
# self.assertEqual(expected, script_base.__eq__(other))
assert True # TODO: implement your test here
def test_at_init(self):
# script_base = ScriptBase()
# self.assertEqual(expected, script_base.at_init())
assert True # TODO: implement your test here
def test_at_repeat(self):
# script_base = ScriptBase()
# self.assertEqual(expected, script_base.at_repeat())
assert True # TODO: implement your test here
def test_at_script_creation(self):
# script_base = ScriptBase()
# self.assertEqual(expected, script_base.at_script_creation())
assert True # TODO: implement your test here
def test_at_start(self):
# script_base = ScriptBase()
# self.assertEqual(expected, script_base.at_start())
assert True # TODO: implement your test here
def test_at_stop(self):
# script_base = ScriptBase()
# self.assertEqual(expected, script_base.at_stop())
assert True # TODO: implement your test here
def test_force_repeat(self):
# script_base = ScriptBase()
# self.assertEqual(expected, script_base.force_repeat())
assert True # TODO: implement your test here
def test_is_valid(self):
# script_base = ScriptBase()
# self.assertEqual(expected, script_base.is_valid())
assert True # TODO: implement your test here
def test_pause(self):
# script_base = ScriptBase()
# self.assertEqual(expected, script_base.pause())
assert True # TODO: implement your test here
def test_remaining_repeats(self):
# script_base = ScriptBase()
# self.assertEqual(expected, script_base.remaining_repeats())
assert True # TODO: implement your test here
def test_start(self):
# script_base = ScriptBase()
# self.assertEqual(expected, script_base.start(force_restart))
assert True # TODO: implement your test here
def test_stop(self):
# script_base = ScriptBase()
# self.assertEqual(expected, script_base.stop(kill))
assert True # TODO: implement your test here
def test_time_until_next_repeat(self):
# script_base = ScriptBase()
# self.assertEqual(expected, script_base.time_until_next_repeat())
assert True # TODO: implement your test here
def test_unpause(self):
# script_base = ScriptBase()
# self.assertEqual(expected, script_base.unpause())
assert True # TODO: implement your test here
class TestScript(unittest.TestCase):
def test___init__(self):
# script = Script(dbobj)
assert True # TODO: implement your test here
def test_at_repeat(self):
# script = Script(dbobj)
# self.assertEqual(expected, script.at_repeat())
assert True # TODO: implement your test here
def test_at_script_creation(self):
# script = Script(dbobj)
# self.assertEqual(expected, script.at_script_creation())
assert True # TODO: implement your test here
def test_at_server_reload(self):
# script = Script(dbobj)
# self.assertEqual(expected, script.at_server_reload())
assert True # TODO: implement your test here
def test_at_server_shutdown(self):
# script = Script(dbobj)
# self.assertEqual(expected, script.at_server_shutdown())
assert True # TODO: implement your test here
def test_at_start(self):
# script = Script(dbobj)
# self.assertEqual(expected, script.at_start())
assert True # TODO: implement your test here
def test_at_stop(self):
# script = Script(dbobj)
# self.assertEqual(expected, script.at_stop())
assert True # TODO: implement your test here
def test_is_valid(self):
# script = Script(dbobj)
# self.assertEqual(expected, script.is_valid())
assert True # TODO: implement your test here
class TestDoNothing(unittest.TestCase):
def test_at_script_creation(self):
# do_nothing = DoNothing()
# self.assertEqual(expected, do_nothing.at_script_creation())
assert True # TODO: implement your test here
class TestStore(unittest.TestCase):
def test_at_script_creation(self):
# store = Store()
# self.assertEqual(expected, store.at_script_creation())
assert True # TODO: implement your test here
class TestCheckSessions(unittest.TestCase):
def test_at_repeat(self):
# check_sessions = CheckSessions()
# self.assertEqual(expected, check_sessions.at_repeat())
assert True # TODO: implement your test here
def test_at_script_creation(self):
# check_sessions = CheckSessions()
# self.assertEqual(expected, check_sessions.at_script_creation())
assert True # TODO: implement your test here
class TestValidateScripts(unittest.TestCase):
def test_at_repeat(self):
# validate_scripts = ValidateScripts()
# self.assertEqual(expected, validate_scripts.at_repeat())
assert True # TODO: implement your test here
def test_at_script_creation(self):
# validate_scripts = ValidateScripts()
# self.assertEqual(expected, validate_scripts.at_script_creation())
assert True # TODO: implement your test here
class TestValidateChannelHandler(unittest.TestCase):
def test_at_repeat(self):
# validate_channel_handler = ValidateChannelHandler()
# self.assertEqual(expected, validate_channel_handler.at_repeat())
assert True # TODO: implement your test here
def test_at_script_creation(self):
# validate_channel_handler = ValidateChannelHandler()
# self.assertEqual(expected, validate_channel_handler.at_script_creation())
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

84
evennia/tests/test_scripts_tickerhandler.py
View file

@ -1,84 +0,0 @@
import unittest
class TestTicker(unittest.TestCase):
def test___init__(self):
# ticker = Ticker(interval)
assert True # TODO: implement your test here
def test_add(self):
# ticker = Ticker(interval)
# self.assertEqual(expected, ticker.add(store_key, obj, *args, **kwargs))
assert True # TODO: implement your test here
def test_remove(self):
# ticker = Ticker(interval)
# self.assertEqual(expected, ticker.remove(store_key))
assert True # TODO: implement your test here
def test_stop(self):
# ticker = Ticker(interval)
# self.assertEqual(expected, ticker.stop())
assert True # TODO: implement your test here
def test_validate(self):
# ticker = Ticker(interval)
# self.assertEqual(expected, ticker.validate(start_delay))
assert True # TODO: implement your test here
class TestTickerPool(unittest.TestCase):
def test___init__(self):
# ticker_pool = TickerPool()
assert True # TODO: implement your test here
def test_add(self):
# ticker_pool = TickerPool()
# self.assertEqual(expected, ticker_pool.add(store_key, obj, interval, *args, **kwargs))
assert True # TODO: implement your test here
def test_remove(self):
# ticker_pool = TickerPool()
# self.assertEqual(expected, ticker_pool.remove(store_key, interval))
assert True # TODO: implement your test here
def test_stop(self):
# ticker_pool = TickerPool()
# self.assertEqual(expected, ticker_pool.stop(interval))
assert True # TODO: implement your test here
class TestTickerHandler(unittest.TestCase):
def test___init__(self):
# ticker_handler = TickerHandler(save_name)
assert True # TODO: implement your test here
def test_add(self):
# ticker_handler = TickerHandler(save_name)
# self.assertEqual(expected, ticker_handler.add(obj, interval, *args, **kwargs))
assert True # TODO: implement your test here
def test_all(self):
# ticker_handler = TickerHandler(save_name)
# self.assertEqual(expected, ticker_handler.all(interval))
assert True # TODO: implement your test here
def test_clear(self):
# ticker_handler = TickerHandler(save_name)
# self.assertEqual(expected, ticker_handler.clear(interval))
assert True # TODO: implement your test here
def test_remove(self):
# ticker_handler = TickerHandler(save_name)
# self.assertEqual(expected, ticker_handler.remove(obj, interval))
assert True # TODO: implement your test here
def test_restore(self):
# ticker_handler = TickerHandler(save_name)
# self.assertEqual(expected, ticker_handler.restore())
assert True # TODO: implement your test here
def test_save(self):
# ticker_handler = TickerHandler(save_name)
# self.assertEqual(expected, ticker_handler.save())
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

125
evennia/tests/test_server_amp.py
View file

@ -1,125 +0,0 @@
import unittest
class TestGetRestartMode(unittest.TestCase):
def test_get_restart_mode(self):
# self.assertEqual(expected, get_restart_mode(restart_file))
assert True # TODO: implement your test here
class TestAmpServerFactory(unittest.TestCase):
def test___init__(self):
# amp_server_factory = AmpServerFactory(server)
assert True # TODO: implement your test here
def test_buildProtocol(self):
# amp_server_factory = AmpServerFactory(server)
# self.assertEqual(expected, amp_server_factory.buildProtocol(addr))
assert True # TODO: implement your test here
class TestAmpClientFactory(unittest.TestCase):
def test___init__(self):
# amp_client_factory = AmpClientFactory(portal)
assert True # TODO: implement your test here
def test_buildProtocol(self):
# amp_client_factory = AmpClientFactory(portal)
# self.assertEqual(expected, amp_client_factory.buildProtocol(addr))
assert True # TODO: implement your test here
def test_clientConnectionFailed(self):
# amp_client_factory = AmpClientFactory(portal)
# self.assertEqual(expected, amp_client_factory.clientConnectionFailed(connector, reason))
assert True # TODO: implement your test here
def test_clientConnectionLost(self):
# amp_client_factory = AmpClientFactory(portal)
# self.assertEqual(expected, amp_client_factory.clientConnectionLost(connector, reason))
assert True # TODO: implement your test here
def test_startedConnecting(self):
# amp_client_factory = AmpClientFactory(portal)
# self.assertEqual(expected, amp_client_factory.startedConnecting(connector))
assert True # TODO: implement your test here
class TestDumps(unittest.TestCase):
def test_dumps(self):
# self.assertEqual(expected, dumps(data))
assert True # TODO: implement your test here
class TestLoads(unittest.TestCase):
def test_loads(self):
# self.assertEqual(expected, loads(data))
assert True # TODO: implement your test here
class TestAMPProtocol(unittest.TestCase):
def test_amp_function_call(self):
# a_mp_protocol = AMPProtocol()
# self.assertEqual(expected, a_mp_protocol.amp_function_call(module, function, args, **kwargs))
assert True # TODO: implement your test here
def test_amp_msg_portal2server(self):
# a_mp_protocol = AMPProtocol()
# self.assertEqual(expected, a_mp_protocol.amp_msg_portal2server(sessid, ipart, nparts, msg, data))
assert True # TODO: implement your test here
def test_amp_msg_server2portal(self):
# a_mp_protocol = AMPProtocol()
# self.assertEqual(expected, a_mp_protocol.amp_msg_server2portal(sessid, ipart, nparts, msg, data))
assert True # TODO: implement your test here
def test_amp_portal_admin(self):
# a_mp_protocol = AMPProtocol()
# self.assertEqual(expected, a_mp_protocol.amp_portal_admin(sessid, ipart, nparts, operation, data))
assert True # TODO: implement your test here
def test_amp_server_admin(self):
# a_mp_protocol = AMPProtocol()
# self.assertEqual(expected, a_mp_protocol.amp_server_admin(sessid, ipart, nparts, operation, data))
assert True # TODO: implement your test here
def test_call_remote_FunctionCall(self):
# a_mp_protocol = AMPProtocol()
# self.assertEqual(expected, a_mp_protocol.call_remote_FunctionCall(modulepath, functionname, *args, **kwargs))
assert True # TODO: implement your test here
def test_call_remote_MsgPortal2Server(self):
# a_mp_protocol = AMPProtocol()
# self.assertEqual(expected, a_mp_protocol.call_remote_MsgPortal2Server(sessid, msg, data))
assert True # TODO: implement your test here
def test_call_remote_MsgServer2Portal(self):
# a_mp_protocol = AMPProtocol()
# self.assertEqual(expected, a_mp_protocol.call_remote_MsgServer2Portal(sessid, msg, data))
assert True # TODO: implement your test here
def test_call_remote_PortalAdmin(self):
# a_mp_protocol = AMPProtocol()
# self.assertEqual(expected, a_mp_protocol.call_remote_PortalAdmin(sessid, operation, data))
assert True # TODO: implement your test here
def test_call_remote_ServerAdmin(self):
# a_mp_protocol = AMPProtocol()
# self.assertEqual(expected, a_mp_protocol.call_remote_ServerAdmin(sessid, operation, data))
assert True # TODO: implement your test here
def test_connectionMade(self):
# a_mp_protocol = AMPProtocol()
# self.assertEqual(expected, a_mp_protocol.connectionMade())
assert True # TODO: implement your test here
def test_errback(self):
# a_mp_protocol = AMPProtocol()
# self.assertEqual(expected, a_mp_protocol.errback(e, info))
assert True # TODO: implement your test here
def test_safe_recv(self):
# a_mp_protocol = AMPProtocol()
# self.assertEqual(expected, a_mp_protocol.safe_recv(command, sessid, ipart, nparts, **kwargs))
assert True # TODO: implement your test here
def test_safe_send(self):
# a_mp_protocol = AMPProtocol()
# self.assertEqual(expected, a_mp_protocol.safe_send(command, sessid, **kwargs))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

54
evennia/tests/test_server_caches.py
View file

@ -1,54 +0,0 @@
import unittest
class TestHashid(unittest.TestCase):
def test_hashid(self):
# self.assertEqual(expected, hashid(obj, suffix))
assert True # TODO: implement your test here
class TestFieldPreSave(unittest.TestCase):
def test_field_pre_save(self):
# self.assertEqual(expected, field_pre_save(sender, instance, update_fields, raw, **kwargs))
assert True # TODO: implement your test here
class TestFieldPostSave(unittest.TestCase):
def test_field_post_save(self):
# self.assertEqual(expected, field_post_save(sender, instance, update_fields, raw, **kwargs))
assert True # TODO: implement your test here
class TestGetAttrCache(unittest.TestCase):
def test_get_attr_cache(self):
# self.assertEqual(expected, get_attr_cache(obj))
assert True # TODO: implement your test here
class TestSetAttrCache(unittest.TestCase):
def test_set_attr_cache(self):
# self.assertEqual(expected, set_attr_cache(obj, store))
assert True # TODO: implement your test here
class TestGetPropCache(unittest.TestCase):
def test_get_prop_cache(self):
# self.assertEqual(expected, get_prop_cache(obj, propname))
assert True # TODO: implement your test here
class TestSetPropCache(unittest.TestCase):
def test_set_prop_cache(self):
# self.assertEqual(expected, set_prop_cache(obj, propname, propvalue))
assert True # TODO: implement your test here
class TestDelPropCache(unittest.TestCase):
def test_del_prop_cache(self):
# self.assertEqual(expected, del_prop_cache(obj, propname))
assert True # TODO: implement your test here
class TestFlushPropCache(unittest.TestCase):
def test_flush_prop_cache(self):
# self.assertEqual(expected, flush_prop_cache())
assert True # TODO: implement your test here
class TestGetCacheSizes(unittest.TestCase):
def test_get_cache_sizes(self):
# self.assertEqual(expected, get_cache_sizes())
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

54
evennia/tests/test_server_initial_setup.py
View file

@ -1,54 +0,0 @@
import unittest
class TestCreateConfigValues(unittest.TestCase):
def test_create_config_values(self):
# self.assertEqual(expected, create_config_values())
assert True # TODO: implement your test here
class TestGetGodPlayer(unittest.TestCase):
def test_get_god_player(self):
# self.assertEqual(expected, get_god_player())
assert True # TODO: implement your test here
class TestCreateObjects(unittest.TestCase):
def test_create_objects(self):
# self.assertEqual(expected, create_objects())
assert True # TODO: implement your test here
class TestCreateChannels(unittest.TestCase):
def test_create_channels(self):
# self.assertEqual(expected, create_channels())
assert True # TODO: implement your test here
class TestCreateSystemScripts(unittest.TestCase):
def test_create_system_scripts(self):
# self.assertEqual(expected, create_system_scripts())
assert True # TODO: implement your test here
class TestStartGameTime(unittest.TestCase):
def test_start_game_time(self):
# self.assertEqual(expected, start_game_time())
assert True # TODO: implement your test here
class TestCreateAdminMediaLinks(unittest.TestCase):
def test_create_admin_media_links(self):
# self.assertEqual(expected, create_admin_media_links())
assert True # TODO: implement your test here
class TestAtInitialSetup(unittest.TestCase):
def test_at_initial_setup(self):
# self.assertEqual(expected, at_initial_setup())
assert True # TODO: implement your test here
class TestResetServer(unittest.TestCase):
def test_reset_server(self):
# self.assertEqual(expected, reset_server())
assert True # TODO: implement your test here
class TestHandleSetup(unittest.TestCase):
def test_handle_setup(self):
# self.assertEqual(expected, handle_setup(last_step))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

15
evennia/tests/test_server_manager.py
View file

@ -1,15 +0,0 @@
import unittest
class TestServerConfigManager(unittest.TestCase):
def test_conf(self):
# server_config_manager = ServerConfigManager()
# self.assertEqual(expected, server_config_manager.conf(key, value, delete, default))
assert True # TODO: implement your test here
def test_get_mysql_db_version(self):
# server_config_manager = ServerConfigManager()
# self.assertEqual(expected, server_config_manager.get_mysql_db_version())
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

15
evennia/tests/test_server_models.py
View file

@ -1,15 +0,0 @@
import unittest
class TestServerConfig(unittest.TestCase):
def test___unicode__(self):
# server_config = ServerConfig()
# self.assertEqual(expected, server_config.__unicode__())
assert True # TODO: implement your test here
def test_store(self):
# server_config = ServerConfig()
# self.assertEqual(expected, server_config.store(key, value))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

49
evennia/tests/test_server_oob_msdp.py
View file

@ -1,49 +0,0 @@
import unittest
class TestOOBFieldTracker(unittest.TestCase):
def test___init__(self):
# o_ob_field_tracker = OOBFieldTracker(oobhandler, fieldname, sessid, *args, **kwargs)
assert True # TODO: implement your test here
def test_update(self):
# o_ob_field_tracker = OOBFieldTracker(oobhandler, fieldname, sessid, *args, **kwargs)
# self.assertEqual(expected, o_ob_field_tracker.update(new_value, *args, **kwargs))
assert True # TODO: implement your test here
class TestOOBAttributeTracker(unittest.TestCase):
def test___init__(self):
# o_ob_attribute_tracker = OOBAttributeTracker(oobhandler, fieldname, sessid, attrname, *args, **kwargs)
assert True # TODO: implement your test here
def test_update(self):
# o_ob_attribute_tracker = OOBAttributeTracker(oobhandler, fieldname, sessid, attrname, *args, **kwargs)
# self.assertEqual(expected, o_ob_attribute_tracker.update(new_value, *args, **kwargs))
assert True # TODO: implement your test here
class TestOobError(unittest.TestCase):
def test_oob_error(self):
# self.assertEqual(expected, oob_error(oobhandler, session, errmsg, *args, **kwargs))
assert True # TODO: implement your test here
class TestList(unittest.TestCase):
def test_list(self):
# self.assertEqual(expected, list(oobhandler, session, mode, *args, **kwargs))
assert True # TODO: implement your test here
class TestSend(unittest.TestCase):
def test_send(self):
# self.assertEqual(expected, send(oobhandler, session, *args, **kwargs))
assert True # TODO: implement your test here
class TestReport(unittest.TestCase):
def test_report(self):
# self.assertEqual(expected, report(oobhandler, session, *args, **kwargs))
assert True # TODO: implement your test here
class TestUnreport(unittest.TestCase):
def test_unreport(self):
# self.assertEqual(expected, unreport(oobhandler, session, vartype, *args, **kwargs))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

114
evennia/tests/test_server_oobhandler.py
View file

@ -1,114 +0,0 @@
import unittest
class TestTrackerHandler(unittest.TestCase):
def test___init__(self):
# tracker_handler = TrackerHandler(obj)
assert True # TODO: implement your test here
def test_add(self):
# tracker_handler = TrackerHandler(obj)
# self.assertEqual(expected, tracker_handler.add(fieldname, tracker))
assert True # TODO: implement your test here
def test_remove(self):
# tracker_handler = TrackerHandler(obj)
# self.assertEqual(expected, tracker_handler.remove(fieldname, trackerclass, *args, **kwargs))
assert True # TODO: implement your test here
def test_update(self):
# tracker_handler = TrackerHandler(obj)
# self.assertEqual(expected, tracker_handler.update(fieldname, new_value))
assert True # TODO: implement your test here
class TestTrackerBase(unittest.TestCase):
def test___init__(self):
# tracker_base = TrackerBase(*args, **kwargs)
assert True # TODO: implement your test here
def test_at_remove(self):
# tracker_base = TrackerBase(*args, **kwargs)
# self.assertEqual(expected, tracker_base.at_remove(*args, **kwargs))
assert True # TODO: implement your test here
def test_update(self):
# tracker_base = TrackerBase(*args, **kwargs)
# self.assertEqual(expected, tracker_base.update(*args, **kwargs))
assert True # TODO: implement your test here
class TestOOBTicker(unittest.TestCase):
def test___init__(self):
# o_ob_ticker = OOBTicker(interval)
assert True # TODO: implement your test here
class TestOOBHandler(unittest.TestCase):
def test___init__(self):
# o_ob_handler = OOBHandler()
assert True # TODO: implement your test here
def test_execute_cmd(self):
# o_ob_handler = OOBHandler()
# self.assertEqual(expected, o_ob_handler.execute_cmd(session, func_key, *args, **kwargs))
assert True # TODO: implement your test here
def test_get_all_tracked(self):
# o_ob_handler = OOBHandler()
# self.assertEqual(expected, o_ob_handler.get_all_tracked(session))
assert True # TODO: implement your test here
def test_msg(self):
# o_ob_handler = OOBHandler()
# self.assertEqual(expected, o_ob_handler.msg(sessid, funcname, *args, **kwargs))
assert True # TODO: implement your test here
def test_repeat(self):
# o_ob_handler = OOBHandler()
# self.assertEqual(expected, o_ob_handler.repeat(obj, sessid, func_key, interval, *args, **kwargs))
assert True # TODO: implement your test here
def test_restore(self):
# o_ob_handler = OOBHandler()
# self.assertEqual(expected, o_ob_handler.restore())
assert True # TODO: implement your test here
def test_save(self):
# o_ob_handler = OOBHandler()
# self.assertEqual(expected, o_ob_handler.save())
assert True # TODO: implement your test here
def test_track(self):
# o_ob_handler = OOBHandler()
# self.assertEqual(expected, o_ob_handler.track(obj, sessid, fieldname, trackerclass, *args, **kwargs))
assert True # TODO: implement your test here
def test_track_attribute(self):
# o_ob_handler = OOBHandler()
# self.assertEqual(expected, o_ob_handler.track_attribute(obj, sessid, attr_name, trackerclass))
assert True # TODO: implement your test here
def test_track_field(self):
# o_ob_handler = OOBHandler()
# self.assertEqual(expected, o_ob_handler.track_field(obj, sessid, field_name, trackerclass))
assert True # TODO: implement your test here
def test_unrepeat(self):
# o_ob_handler = OOBHandler()
# self.assertEqual(expected, o_ob_handler.unrepeat(obj, sessid, func_key, interval))
assert True # TODO: implement your test here
def test_untrack(self):
# o_ob_handler = OOBHandler()
# self.assertEqual(expected, o_ob_handler.untrack(obj, sessid, fieldname, trackerclass, *args, **kwargs))
assert True # TODO: implement your test here
def test_untrack_attribute(self):
# o_ob_handler = OOBHandler()
# self.assertEqual(expected, o_ob_handler.untrack_attribute(obj, sessid, attr_name, trackerclass))
assert True # TODO: implement your test here
def test_untrack_field(self):
# o_ob_handler = OOBHandler()
# self.assertEqual(expected, o_ob_handler.untrack_field(obj, sessid, field_name))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

39
evennia/tests/test_server_server.py
View file

@ -1,39 +0,0 @@
import unittest
class TestEvennia(unittest.TestCase):
def test___init__(self):
# evennia = Evennia(application)
assert True # TODO: implement your test here
def test_run_init_hooks(self):
# evennia = Evennia(application)
# self.assertEqual(expected, evennia.run_init_hooks())
assert True # TODO: implement your test here
def test_run_initial_setup(self):
# evennia = Evennia(application)
# self.assertEqual(expected, evennia.run_initial_setup())
assert True # TODO: implement your test here
def test_set_restart_mode(self):
# evennia = Evennia(application)
# self.assertEqual(expected, evennia.set_restart_mode(mode))
assert True # TODO: implement your test here
def test_shutdown(self):
# evennia = Evennia(application)
# self.assertEqual(expected, evennia.shutdown(mode, _reactor_stopping))
assert True # TODO: implement your test here
def test_sqlite3_prep(self):
# evennia = Evennia(application)
# self.assertEqual(expected, evennia.sqlite3_prep())
assert True # TODO: implement your test here
def test_update_defaults(self):
# evennia = Evennia(application)
# self.assertEqual(expected, evennia.update_defaults())
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

104
evennia/tests/test_server_serversession.py
View file

@ -1,104 +0,0 @@
import unittest
class TestServerSession(unittest.TestCase):
def test___eq__(self):
# server_session = ServerSession()
# self.assertEqual(expected, server_session.__eq__(other))
assert True # TODO: implement your test here
def test___init__(self):
# server_session = ServerSession()
assert True # TODO: implement your test here
def test___str__(self):
# server_session = ServerSession()
# self.assertEqual(expected, server_session.__str__())
assert True # TODO: implement your test here
def test___unicode__(self):
# server_session = ServerSession()
# self.assertEqual(expected, server_session.__unicode__())
assert True # TODO: implement your test here
def test_access(self):
# server_session = ServerSession()
# self.assertEqual(expected, server_session.access(*args, **kwargs))
assert True # TODO: implement your test here
def test_at_cmdset_get(self):
# server_session = ServerSession()
# self.assertEqual(expected, server_session.at_cmdset_get(**kwargs))
assert True # TODO: implement your test here
def test_at_disconnect(self):
# server_session = ServerSession()
# self.assertEqual(expected, server_session.at_disconnect())
assert True # TODO: implement your test here
def test_at_login(self):
# server_session = ServerSession()
# self.assertEqual(expected, server_session.at_login(player))
assert True # TODO: implement your test here
def test_at_sync(self):
# server_session = ServerSession()
# self.assertEqual(expected, server_session.at_sync())
assert True # TODO: implement your test here
def test_data_in(self):
# server_session = ServerSession()
# self.assertEqual(expected, server_session.data_in(text, **kwargs))
assert True # TODO: implement your test here
def test_data_out(self):
# server_session = ServerSession()
# self.assertEqual(expected, server_session.data_out(text, **kwargs))
assert True # TODO: implement your test here
def test_get_player(self):
# server_session = ServerSession()
# self.assertEqual(expected, server_session.get_player())
assert True # TODO: implement your test here
def test_get_puppet(self):
# server_session = ServerSession()
# self.assertEqual(expected, server_session.get_puppet())
assert True # TODO: implement your test here
def test_get_puppet_or_player(self):
# server_session = ServerSession()
# self.assertEqual(expected, server_session.get_puppet_or_player())
assert True # TODO: implement your test here
def test_log(self):
# server_session = ServerSession()
# self.assertEqual(expected, server_session.log(message, channel))
assert True # TODO: implement your test here
def test_msg(self):
# server_session = ServerSession()
# self.assertEqual(expected, server_session.msg(text, **kwargs))
assert True # TODO: implement your test here
def test_ndb_del(self):
# server_session = ServerSession()
# self.assertEqual(expected, server_session.ndb_del())
assert True # TODO: implement your test here
def test_ndb_get(self):
# server_session = ServerSession()
# self.assertEqual(expected, server_session.ndb_get())
assert True # TODO: implement your test here
def test_ndb_set(self):
# server_session = ServerSession()
# self.assertEqual(expected, server_session.ndb_set(value))
assert True # TODO: implement your test here
def test_update_session_counters(self):
# server_session = ServerSession()
# self.assertEqual(expected, server_session.update_session_counters(idle))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

40
evennia/tests/test_server_session.py
View file

@ -1,40 +0,0 @@
import unittest
class TestSession(unittest.TestCase):
def test_at_sync(self):
# session = Session()
# self.assertEqual(expected, session.at_sync())
assert True # TODO: implement your test here
def test_data_in(self):
# session = Session()
# self.assertEqual(expected, session.data_in(text, **kwargs))
assert True # TODO: implement your test here
def test_data_out(self):
# session = Session()
# self.assertEqual(expected, session.data_out(text, **kwargs))
assert True # TODO: implement your test here
def test_disconnect(self):
# session = Session()
# self.assertEqual(expected, session.disconnect(reason))
assert True # TODO: implement your test here
def test_get_sync_data(self):
# session = Session()
# self.assertEqual(expected, session.get_sync_data())
assert True # TODO: implement your test here
def test_init_session(self):
# session = Session()
# self.assertEqual(expected, session.init_session(protocol_key, address, sessionhandler))
assert True # TODO: implement your test here
def test_load_sync_data(self):
# session = Session()
# self.assertEqual(expected, session.load_sync_data(sessdata))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

46
evennia/tests/test_server_webserver.py
View file

@ -1,46 +0,0 @@
import unittest
class TestHTTPChannelWithXForwardedFor(unittest.TestCase):
def test_allHeadersReceived(self):
# h_ttp_channel_with_x_forwarded_for = HTTPChannelWithXForwardedFor()
# self.assertEqual(expected, h_ttp_channel_with_x_forwarded_for.allHeadersReceived())
assert True # TODO: implement your test here
class TestEvenniaReverseProxyResource(unittest.TestCase):
def test_getChild(self):
# evennia_reverse_proxy_resource = EvenniaReverseProxyResource()
# self.assertEqual(expected, evennia_reverse_proxy_resource.getChild(path, request))
assert True # TODO: implement your test here
def test_render(self):
# evennia_reverse_proxy_resource = EvenniaReverseProxyResource()
# self.assertEqual(expected, evennia_reverse_proxy_resource.render(request))
assert True # TODO: implement your test here
class TestDjangoWebRoot(unittest.TestCase):
def test___init__(self):
# django_web_root = DjangoWebRoot(pool)
assert True # TODO: implement your test here
def test_getChild(self):
# django_web_root = DjangoWebRoot(pool)
# self.assertEqual(expected, django_web_root.getChild(path, request))
assert True # TODO: implement your test here
class TestWSGIWebServer(unittest.TestCase):
def test___init__(self):
# w_sgi_web_server = WSGIWebServer(pool, *args, **kwargs)
assert True # TODO: implement your test here
def test_startService(self):
# w_sgi_web_server = WSGIWebServer(pool, *args, **kwargs)
# self.assertEqual(expected, w_sgi_web_server.startService())
assert True # TODO: implement your test here
def test_stopService(self):
# w_sgi_web_server = WSGIWebServer(pool, *args, **kwargs)
# self.assertEqual(expected, w_sgi_web_server.stopService())
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

266
evennia/tests/test_typeclasses_models.py
View file

@ -1,266 +0,0 @@
import unittest
class TestAttribute(unittest.TestCase):
def test___init__(self):
# attribute = Attribute(*args, **kwargs)
assert True # TODO: implement your test here
def test___str__(self):
# attribute = Attribute(*args, **kwargs)
# self.assertEqual(expected, attribute.__str__())
assert True # TODO: implement your test here
def test___unicode__(self):
# attribute = Attribute(*args, **kwargs)
# self.assertEqual(expected, attribute.__unicode__())
assert True # TODO: implement your test here
def test_access(self):
# attribute = Attribute(*args, **kwargs)
# self.assertEqual(expected, attribute.access(accessing_obj, access_type, default, **kwargs))
assert True # TODO: implement your test here
def test_at_set(self):
# attribute = Attribute(*args, **kwargs)
# self.assertEqual(expected, attribute.at_set(new_value))
assert True # TODO: implement your test here
class TestAttributeHandler(unittest.TestCase):
def test___init__(self):
# attribute_handler = AttributeHandler(obj)
assert True # TODO: implement your test here
def test_add(self):
# attribute_handler = AttributeHandler(obj)
# self.assertEqual(expected, attribute_handler.add(key, value, category, lockstring, strattr, accessing_obj, default_access))
assert True # TODO: implement your test here
def test_all(self):
# attribute_handler = AttributeHandler(obj)
# self.assertEqual(expected, attribute_handler.all(accessing_obj, default_access))
assert True # TODO: implement your test here
def test_clear(self):
# attribute_handler = AttributeHandler(obj)
# self.assertEqual(expected, attribute_handler.clear(category, accessing_obj, default_access))
assert True # TODO: implement your test here
def test_get(self):
# attribute_handler = AttributeHandler(obj)
# self.assertEqual(expected, attribute_handler.get(key, category, default, return_obj, strattr, raise_exception, accessing_obj, default_access, not_found_none))
assert True # TODO: implement your test here
def test_has(self):
# attribute_handler = AttributeHandler(obj)
# self.assertEqual(expected, attribute_handler.has(key, category))
assert True # TODO: implement your test here
def test_remove(self):
# attribute_handler = AttributeHandler(obj)
# self.assertEqual(expected, attribute_handler.remove(key, raise_exception, category, accessing_obj, default_access))
assert True # TODO: implement your test here
class TestNickHandler(unittest.TestCase):
def test_add(self):
# nick_handler = NickHandler()
# self.assertEqual(expected, nick_handler.add(key, replacement, category, **kwargs))
assert True # TODO: implement your test here
def test_get(self):
# nick_handler = NickHandler()
# self.assertEqual(expected, nick_handler.get(key, category, **kwargs))
assert True # TODO: implement your test here
def test_has(self):
# nick_handler = NickHandler()
# self.assertEqual(expected, nick_handler.has(key, category))
assert True # TODO: implement your test here
def test_nickreplace(self):
# nick_handler = NickHandler()
# self.assertEqual(expected, nick_handler.nickreplace(raw_string, categories, include_player))
assert True # TODO: implement your test here
def test_remove(self):
# nick_handler = NickHandler()
# self.assertEqual(expected, nick_handler.remove(key, category, **kwargs))
assert True # TODO: implement your test here
class TestNAttributeHandler(unittest.TestCase):
def test___init__(self):
# n_attribute_handler = NAttributeHandler(obj)
assert True # TODO: implement your test here
def test_add(self):
# n_attribute_handler = NAttributeHandler(obj)
# self.assertEqual(expected, n_attribute_handler.add(key, value))
assert True # TODO: implement your test here
def test_all(self):
# n_attribute_handler = NAttributeHandler(obj)
# self.assertEqual(expected, n_attribute_handler.all())
assert True # TODO: implement your test here
def test_get(self):
# n_attribute_handler = NAttributeHandler(obj)
# self.assertEqual(expected, n_attribute_handler.get(key))
assert True # TODO: implement your test here
def test_has(self):
# n_attribute_handler = NAttributeHandler(obj)
# self.assertEqual(expected, n_attribute_handler.has(key))
assert True # TODO: implement your test here
def test_remove(self):
# n_attribute_handler = NAttributeHandler(obj)
# self.assertEqual(expected, n_attribute_handler.remove(key))
assert True # TODO: implement your test here
class TestTag(unittest.TestCase):
def test___str__(self):
# tag = Tag()
# self.assertEqual(expected, tag.__str__())
assert True # TODO: implement your test here
def test___unicode__(self):
# tag = Tag()
# self.assertEqual(expected, tag.__unicode__())
assert True # TODO: implement your test here
class TestTagHandler(unittest.TestCase):
def test___init__(self):
# tag_handler = TagHandler(obj)
assert True # TODO: implement your test here
def test___str__(self):
# tag_handler = TagHandler(obj)
# self.assertEqual(expected, tag_handler.__str__())
assert True # TODO: implement your test here
def test_add(self):
# tag_handler = TagHandler(obj)
# self.assertEqual(expected, tag_handler.add(tag, category, data))
assert True # TODO: implement your test here
def test_all(self):
# tag_handler = TagHandler(obj)
# self.assertEqual(expected, tag_handler.all(category, return_key_and_category))
assert True # TODO: implement your test here
def test_clear(self):
# tag_handler = TagHandler(obj)
# self.assertEqual(expected, tag_handler.clear())
assert True # TODO: implement your test here
def test_get(self):
# tag_handler = TagHandler(obj)
# self.assertEqual(expected, tag_handler.get(key, category, return_tagobj))
assert True # TODO: implement your test here
def test_remove(self):
# tag_handler = TagHandler(obj)
# self.assertEqual(expected, tag_handler.remove(key, category))
assert True # TODO: implement your test here
class TestTypedObject(unittest.TestCase):
def test___eq__(self):
# typed_object = TypedObject(*args, **kwargs)
# self.assertEqual(expected, typed_object.__eq__(other))
assert True # TODO: implement your test here
def test___getattribute__(self):
# typed_object = TypedObject(*args, **kwargs)
# self.assertEqual(expected, typed_object.__getattribute__(propname))
assert True # TODO: implement your test here
def test___init__(self):
# typed_object = TypedObject(*args, **kwargs)
assert True # TODO: implement your test here
def test___str__(self):
# typed_object = TypedObject(*args, **kwargs)
# self.assertEqual(expected, typed_object.__str__())
assert True # TODO: implement your test here
def test___unicode__(self):
# typed_object = TypedObject(*args, **kwargs)
# self.assertEqual(expected, typed_object.__unicode__())
assert True # TODO: implement your test here
def test_access(self):
# typed_object = TypedObject(*args, **kwargs)
# self.assertEqual(expected, typed_object.access(accessing_obj, access_type, default, **kwargs))
assert True # TODO: implement your test here
def test_attr(self):
# typed_object = TypedObject(*args, **kwargs)
# self.assertEqual(expected, typed_object.attr(attribute_name, value, delete))
assert True # TODO: implement your test here
def test_check_permstring(self):
# typed_object = TypedObject(*args, **kwargs)
# self.assertEqual(expected, typed_object.check_permstring(permstring))
assert True # TODO: implement your test here
def test_del_attribute(self):
# typed_object = TypedObject(*args, **kwargs)
# self.assertEqual(expected, typed_object.del_attribute(attribute_name, raise_exception))
assert True # TODO: implement your test here
def test_delete(self):
# typed_object = TypedObject(*args, **kwargs)
# self.assertEqual(expected, typed_object.delete(*args, **kwargs))
assert True # TODO: implement your test here
def test_flush_from_cache(self):
# typed_object = TypedObject(*args, **kwargs)
# self.assertEqual(expected, typed_object.flush_from_cache())
assert True # TODO: implement your test here
def test_get_all_attributes(self):
# typed_object = TypedObject(*args, **kwargs)
# self.assertEqual(expected, typed_object.get_all_attributes())
assert True # TODO: implement your test here
def test_get_attribute(self):
# typed_object = TypedObject(*args, **kwargs)
# self.assertEqual(expected, typed_object.get_attribute(attribute_name, default, raise_exception))
assert True # TODO: implement your test here
def test_get_attribute_obj(self):
# typed_object = TypedObject(*args, **kwargs)
# self.assertEqual(expected, typed_object.get_attribute_obj(attribute_name, default))
assert True # TODO: implement your test here
def test_has_attribute(self):
# typed_object = TypedObject(*args, **kwargs)
# self.assertEqual(expected, typed_object.has_attribute(attribute_name))
assert True # TODO: implement your test here
def test_is_typeclass(self):
# typed_object = TypedObject(*args, **kwargs)
# self.assertEqual(expected, typed_object.is_typeclass(typeclass, exact))
assert True # TODO: implement your test here
def test_nattr(self):
# typed_object = TypedObject(*args, **kwargs)
# self.assertEqual(expected, typed_object.nattr(attribute_name, value, delete))
assert True # TODO: implement your test here
def test_secure_attr(self):
# typed_object = TypedObject(*args, **kwargs)
# self.assertEqual(expected, typed_object.secure_attr(accessing_object, attribute_name, value, delete, default_access_read, default_access_edit, default_access_create))
assert True # TODO: implement your test here
def test_set_attribute(self):
# typed_object = TypedObject(*args, **kwargs)
# self.assertEqual(expected, typed_object.set_attribute(attribute_name, new_value, lockstring))
assert True # TODO: implement your test here
def test_swap_typeclass(self):
# typed_object = TypedObject(*args, **kwargs)
# self.assertEqual(expected, typed_object.swap_typeclass(new_typeclass, clean_attributes, no_default))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

49
evennia/tests/test_typeclasses_typeclass.py
View file

@ -1,49 +0,0 @@
import unittest
class TestMetaTypeClass(unittest.TestCase):
def test___init__(self):
# meta_type_class = MetaTypeClass(*args, **kwargs)
assert True # TODO: implement your test here
def test___str__(self):
# meta_type_class = MetaTypeClass(*args, **kwargs)
# self.assertEqual(expected, meta_type_class.__str__())
assert True # TODO: implement your test here
class TestTypeClass(unittest.TestCase):
def test___delattr__(self):
# type_class = TypeClass(dbobj)
# self.assertEqual(expected, type_class.__delattr__(propname))
assert True # TODO: implement your test here
def test___eq__(self):
# type_class = TypeClass(dbobj)
# self.assertEqual(expected, type_class.__eq__(other))
assert True # TODO: implement your test here
def test___getattribute__(self):
# type_class = TypeClass(dbobj)
# self.assertEqual(expected, type_class.__getattribute__(propname))
assert True # TODO: implement your test here
def test___init__(self):
# type_class = TypeClass(dbobj)
assert True # TODO: implement your test here
def test___setattr__(self):
# type_class = TypeClass(dbobj)
# self.assertEqual(expected, type_class.__setattr__(propname, value))
assert True # TODO: implement your test here
def test___str__(self):
# type_class = TypeClass(dbobj)
# self.assertEqual(expected, type_class.__str__())
assert True # TODO: implement your test here
def test___unicode__(self):
# type_class = TypeClass(dbobj)
# self.assertEqual(expected, type_class.__unicode__())
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

139
evennia/tests/test_utils_ansi.py
View file

@ -1,139 +0,0 @@
import unittest
class TestANSIParser(unittest.TestCase):
def test_parse_ansi(self):
# a_nsi_parser = ANSIParser()
# self.assertEqual(expected, a_nsi_parser.parse_ansi(string, strip_ansi, xterm256))
assert True # TODO: implement your test here
def test_strip_raw_codes(self):
# a_nsi_parser = ANSIParser()
# self.assertEqual(expected, a_nsi_parser.strip_raw_codes(string))
assert True # TODO: implement your test here
def test_sub_ansi(self):
# a_nsi_parser = ANSIParser()
# self.assertEqual(expected, a_nsi_parser.sub_ansi(ansimatch))
assert True # TODO: implement your test here
def test_sub_xterm256(self):
# a_nsi_parser = ANSIParser()
# self.assertEqual(expected, a_nsi_parser.sub_xterm256(rgbmatch))
assert True # TODO: implement your test here
def test_parse_rgb(self):
# a_nsi_parser = ANSIParser()
# self.assertEqual(expected, a_nsi_parser.parse_rgb(rgbmatch))
assert True # TODO: implement your test here
class TestParseAnsi(unittest.TestCase):
def test_parse_ansi(self):
# self.assertEqual(expected, parse_ansi(string, strip_ansi, parser, xterm256))
assert True # TODO: implement your test here
class TestRaw(unittest.TestCase):
def test_raw(self):
# self.assertEqual(expected, raw(string))
assert True # TODO: implement your test here
class TestGroup(unittest.TestCase):
def test_group(self):
# self.assertEqual(expected, group(lst, n))
assert True # TODO: implement your test here
class TestANSIMeta(unittest.TestCase):
def test___init__(self):
# a_nsi_meta = ANSIMeta(*args, **kwargs)
assert True # TODO: implement your test here
class TestANSIString(unittest.TestCase):
def test___add__(self):
# a_nsi_string = ANSIString(*args, **kwargs)
# self.assertEqual(expected, a_nsi_string.__add__(other))
assert True # TODO: implement your test here
def test___getitem__(self):
# a_nsi_string = ANSIString(*args, **kwargs)
# self.assertEqual(expected, a_nsi_string.__getitem__(item))
assert True # TODO: implement your test here
def test___getslice__(self):
# a_nsi_string = ANSIString(*args, **kwargs)
# self.assertEqual(expected, a_nsi_string.__getslice__(i, j))
assert True # TODO: implement your test here
def test___init__(self):
# a_nsi_string = ANSIString(*args, **kwargs)
assert True # TODO: implement your test here
def test___new__(self):
# a_nsi_string = ANSIString(*args, **kwargs)
assert True # TODO: implement your test here
def test___radd__(self):
# a_nsi_string = ANSIString(*args, **kwargs)
# self.assertEqual(expected, a_nsi_string.__radd__(other))
assert True # TODO: implement your test here
def test___repr__(self):
# a_nsi_string = ANSIString(*args, **kwargs)
# self.assertEqual(expected, a_nsi_string.__repr__())
assert True # TODO: implement your test here
def test___str__(self):
# a_nsi_string = ANSIString(*args, **kwargs)
# self.assertEqual(expected, a_nsi_string.__str__())
assert True # TODO: implement your test here
def test___unicode__(self):
# a_nsi_string = ANSIString(*args, **kwargs)
# self.assertEqual(expected, a_nsi_string.__unicode__())
assert True # TODO: implement your test here
def test_center(self):
# a_nsi_string = ANSIString(*args, **kwargs)
# self.assertEqual(expected, a_nsi_string.center(width, fillchar, difference))
assert True # TODO: implement your test here
def test_clean(self):
# a_nsi_string = ANSIString(*args, **kwargs)
# self.assertEqual(expected, a_nsi_string.clean())
assert True # TODO: implement your test here
def test_join(self):
# a_nsi_string = ANSIString(*args, **kwargs)
# self.assertEqual(expected, a_nsi_string.join(iterable))
assert True # TODO: implement your test here
def test_ljust(self):
# a_nsi_string = ANSIString(*args, **kwargs)
# self.assertEqual(expected, a_nsi_string.ljust(width, fillchar, difference))
assert True # TODO: implement your test here
def test_partition(self):
# a_nsi_string = ANSIString(*args, **kwargs)
# self.assertEqual(expected, a_nsi_string.partition(sep, reverse))
assert True # TODO: implement your test here
def test_raw(self):
# a_nsi_string = ANSIString(*args, **kwargs)
# self.assertEqual(expected, a_nsi_string.raw())
assert True # TODO: implement your test here
def test_rjust(self):
# a_nsi_string = ANSIString(*args, **kwargs)
# self.assertEqual(expected, a_nsi_string.rjust(width, fillchar, difference))
assert True # TODO: implement your test here
def test_rsplit(self):
# a_nsi_string = ANSIString(*args, **kwargs)
# self.assertEqual(expected, a_nsi_string.rsplit(by, maxsplit))
assert True # TODO: implement your test here
def test_split(self):
# a_nsi_string = ANSIString(*args, **kwargs)
# self.assertEqual(expected, a_nsi_string.split(by, maxsplit))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

9
evennia/tests/test_utils_ansi_new.py
View file

@ -1,9 +0,0 @@
import unittest
class TestSubMeth(unittest.TestCase):
def test_sub_meth(self):
# self.assertEqual(expected, sub_meth(obj, function))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

36
evennia/tests/test_utils_batchprocessors.py
View file

@ -1,36 +0,0 @@
import unittest
class TestReadBatchfile(unittest.TestCase):
def test_read_batchfile(self):
# self.assertEqual(expected, read_batchfile(pythonpath, file_ending))
assert True # TODO: implement your test here
class TestBatchCommandProcessor(unittest.TestCase):
def test_parse_file(self):
# batch_command_processor = BatchCommandProcessor()
# self.assertEqual(expected, batch_command_processor.parse_file(pythonpath))
assert True # TODO: implement your test here
class TestTbFilename(unittest.TestCase):
def test_tb_filename(self):
# self.assertEqual(expected, tb_filename(tb))
assert True # TODO: implement your test here
class TestTbIter(unittest.TestCase):
def test_tb_iter(self):
# self.assertEqual(expected, tb_iter(tb))
assert True # TODO: implement your test here
class TestBatchCodeProcessor(unittest.TestCase):
def test_code_exec(self):
# batch_code_processor = BatchCodeProcessor()
# self.assertEqual(expected, batch_code_processor.code_exec(codedict, extra_environ, debug))
assert True # TODO: implement your test here
def test_parse_file(self):
# batch_code_processor = BatchCodeProcessor()
# self.assertEqual(expected, batch_code_processor.parse_file(pythonpath))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

44
evennia/tests/test_utils_create.py
View file

@ -1,44 +0,0 @@
import unittest
class TestHandleDbref(unittest.TestCase):
def test_handle_dbref(self):
# self.assertEqual(expected, handle_dbref(inp, objclass, raise_errors))
assert True # TODO: implement your test here
class TestCreateObject(unittest.TestCase):
def test_create_object(self):
# self.assertEqual(expected, create_object(typeclass, key, location, home, permissions, locks, aliases, destination, report_to, nohome))
assert True # TODO: implement your test here
class TestCreateScript(unittest.TestCase):
def test_create_script(self):
# self.assertEqual(expected, create_script(typeclass, key, obj, player, locks, interval, start_delay, repeats, persistent, autostart, report_to))
assert True # TODO: implement your test here
class TestCreateHelpEntry(unittest.TestCase):
def test_create_help_entry(self):
# self.assertEqual(expected, create_help_entry(key, entrytext, category, locks))
assert True # TODO: implement your test here
class TestCreateMessage(unittest.TestCase):
def test_create_message(self):
# self.assertEqual(expected, create_message(senderobj, message, channels, receivers, locks, header))
assert True # TODO: implement your test here
class TestCreateChannel(unittest.TestCase):
def test_create_channel(self):
# self.assertEqual(expected, create_channel(key, aliases, desc, locks, keep_log, typeclass))
assert True # TODO: implement your test here
class TestCreateTag(unittest.TestCase):
def test_create_tag(self):
# self.assertEqual(expected, create_tag(self, key, category, data))
assert True # TODO: implement your test here
class TestCreatePlayer(unittest.TestCase):
def test_create_player(self):
# self.assertEqual(expected, create_player(key, email, password, typeclass, is_superuser, locks, permissions, report_to))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

124
evennia/tests/test_utils_dbserialize.py
View file

@ -1,124 +0,0 @@
import unittest
class test__SaverMutable(unittest.TestCase):
def test___delitem__(self):
# __saver_mutable = _SaverMutable(*args, **kwargs)
# self.assertEqual(expected, __saver_mutable.__delitem__(key))
assert True # TODO: implement your test here
def test___getitem__(self):
# __saver_mutable = _SaverMutable(*args, **kwargs)
# self.assertEqual(expected, __saver_mutable.__getitem__(key))
assert True # TODO: implement your test here
def test___init__(self):
# __saver_mutable = _SaverMutable(*args, **kwargs)
assert True # TODO: implement your test here
def test___iter__(self):
# __saver_mutable = _SaverMutable(*args, **kwargs)
# self.assertEqual(expected, __saver_mutable.__iter__())
assert True # TODO: implement your test here
def test___len__(self):
# __saver_mutable = _SaverMutable(*args, **kwargs)
# self.assertEqual(expected, __saver_mutable.__len__())
assert True # TODO: implement your test here
def test___repr__(self):
# __saver_mutable = _SaverMutable(*args, **kwargs)
# self.assertEqual(expected, __saver_mutable.__repr__())
assert True # TODO: implement your test here
def test___setitem__(self):
# __saver_mutable = _SaverMutable(*args, **kwargs)
# self.assertEqual(expected, __saver_mutable.__setitem__(key, value))
assert True # TODO: implement your test here
class test__SaverList(unittest.TestCase):
def test___add__(self):
# __saver_list = _SaverList(*args, **kwargs)
# self.assertEqual(expected, __saver_list.__add__(otherlist))
assert True # TODO: implement your test here
def test___init__(self):
# __saver_list = _SaverList(*args, **kwargs)
assert True # TODO: implement your test here
def test_insert(self):
# __saver_list = _SaverList(*args, **kwargs)
# self.assertEqual(expected, __saver_list.insert(index, value))
assert True # TODO: implement your test here
class test__SaverDict(unittest.TestCase):
def test___init__(self):
# __saver_dict = _SaverDict(*args, **kwargs)
assert True # TODO: implement your test here
def test_has_key(self):
# __saver_dict = _SaverDict(*args, **kwargs)
# self.assertEqual(expected, __saver_dict.has_key(key))
assert True # TODO: implement your test here
class test__SaverSet(unittest.TestCase):
def test___contains__(self):
# __saver_set = _SaverSet(*args, **kwargs)
# self.assertEqual(expected, __saver_set.__contains__(value))
assert True # TODO: implement your test here
def test___init__(self):
# __saver_set = _SaverSet(*args, **kwargs)
assert True # TODO: implement your test here
def test_add(self):
# __saver_set = _SaverSet(*args, **kwargs)
# self.assertEqual(expected, __saver_set.add(value))
assert True # TODO: implement your test here
def test_discard(self):
# __saver_set = _SaverSet(*args, **kwargs)
# self.assertEqual(expected, __saver_set.discard(value))
assert True # TODO: implement your test here
class TestPackDbobj(unittest.TestCase):
def test_pack_dbobj(self):
# self.assertEqual(expected, pack_dbobj(item))
assert True # TODO: implement your test here
class TestUnpackDbobj(unittest.TestCase):
def test_unpack_dbobj(self):
# self.assertEqual(expected, unpack_dbobj(item))
assert True # TODO: implement your test here
class TestToPickle(unittest.TestCase):
def test_to_pickle(self):
# self.assertEqual(expected, to_pickle(data))
assert True # TODO: implement your test here
class TestFromPickle(unittest.TestCase):
def test_from_pickle(self):
# self.assertEqual(expected, from_pickle(data, db_obj))
assert True # TODO: implement your test here
class TestDoPickle(unittest.TestCase):
def test_do_pickle(self):
# self.assertEqual(expected, do_pickle(data))
assert True # TODO: implement your test here
class TestDoUnpickle(unittest.TestCase):
def test_do_unpickle(self):
# self.assertEqual(expected, do_unpickle(data))
assert True # TODO: implement your test here
class TestDbserialize(unittest.TestCase):
def test_dbserialize(self):
# self.assertEqual(expected, dbserialize(data))
assert True # TODO: implement your test here
class TestDbunserialize(unittest.TestCase):
def test_dbunserialize(self):
# self.assertEqual(expected, dbunserialize(data, db_obj))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

29
evennia/tests/test_utils_evform.py
View file

@ -1,29 +0,0 @@
import unittest
class TestEvForm(unittest.TestCase):
def test___init__(self):
# ev_form = EvForm(filename, cells, tables, form, **kwargs)
assert True # TODO: implement your test here
def test___str__(self):
# ev_form = EvForm(filename, cells, tables, form, **kwargs)
# self.assertEqual(expected, ev_form.__str__())
assert True # TODO: implement your test here
def test___unicode__(self):
# ev_form = EvForm(filename, cells, tables, form, **kwargs)
# self.assertEqual(expected, ev_form.__unicode__())
assert True # TODO: implement your test here
def test_map(self):
# ev_form = EvForm(filename, cells, tables, form, **kwargs)
# self.assertEqual(expected, ev_form.map(cells, tables, **kwargs))
assert True # TODO: implement your test here
def test_reload(self):
# ev_form = EvForm(filename, cells, tables, form, **kwargs)
# self.assertEqual(expected, ev_form.reload(filename, form, **kwargs))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

109
evennia/tests/test_utils_evtable.py
View file

@ -1,109 +0,0 @@
import unittest
class TestMakeIter(unittest.TestCase):
def test_make_iter(self):
# self.assertEqual(expected, make_iter(obj))
assert True # TODO: implement your test here
class TestWrap(unittest.TestCase):
def test_wrap(self):
# self.assertEqual(expected, wrap(text, width, **kwargs))
assert True # TODO: implement your test here
class TestFill(unittest.TestCase):
def test_fill(self):
# self.assertEqual(expected, fill(text, width, **kwargs))
assert True # TODO: implement your test here
class TestCell(unittest.TestCase):
def test___init__(self):
# cell = Cell(data, **kwargs)
assert True # TODO: implement your test here
def test___str__(self):
# cell = Cell(data, **kwargs)
# self.assertEqual(expected, cell.__str__())
assert True # TODO: implement your test here
def test___unicode__(self):
# cell = Cell(data, **kwargs)
# self.assertEqual(expected, cell.__unicode__())
assert True # TODO: implement your test here
def test_get(self):
# cell = Cell(data, **kwargs)
# self.assertEqual(expected, cell.get())
assert True # TODO: implement your test here
def test_get_height(self):
# cell = Cell(data, **kwargs)
# self.assertEqual(expected, cell.get_height())
assert True # TODO: implement your test here
def test_get_min_height(self):
# cell = Cell(data, **kwargs)
# self.assertEqual(expected, cell.get_min_height())
assert True # TODO: implement your test here
def test_get_min_width(self):
# cell = Cell(data, **kwargs)
# self.assertEqual(expected, cell.get_min_width())
assert True # TODO: implement your test here
def test_get_width(self):
# cell = Cell(data, **kwargs)
# self.assertEqual(expected, cell.get_width())
assert True # TODO: implement your test here
def test_reformat(self):
# cell = Cell(data, **kwargs)
# self.assertEqual(expected, cell.reformat(**kwargs))
assert True # TODO: implement your test here
def test_replace_data(self):
# cell = Cell(data, **kwargs)
# self.assertEqual(expected, cell.replace_data(data, **kwargs))
assert True # TODO: implement your test here
class TestEvTable(unittest.TestCase):
def test___init__(self):
# ev_table = EvTable(*args, **kwargs)
assert True # TODO: implement your test here
def test___str__(self):
# ev_table = EvTable(*args, **kwargs)
# self.assertEqual(expected, ev_table.__str__())
assert True # TODO: implement your test here
def test___unicode__(self):
# ev_table = EvTable(*args, **kwargs)
# self.assertEqual(expected, ev_table.__unicode__())
assert True # TODO: implement your test here
def test_add_column(self):
# ev_table = EvTable(*args, **kwargs)
# self.assertEqual(expected, ev_table.add_column(*args, **kwargs))
assert True # TODO: implement your test here
def test_add_header(self):
# ev_table = EvTable(*args, **kwargs)
# self.assertEqual(expected, ev_table.add_header(*args, **kwargs))
assert True # TODO: implement your test here
def test_add_row(self):
# ev_table = EvTable(*args, **kwargs)
# self.assertEqual(expected, ev_table.add_row(*args, **kwargs))
assert True # TODO: implement your test here
def test_get(self):
# ev_table = EvTable(*args, **kwargs)
# self.assertEqual(expected, ev_table.get())
assert True # TODO: implement your test here
def test_reformat(self):
# ev_table = EvTable(*args, **kwargs)
# self.assertEqual(expected, ev_table.reformat(**kwargs))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

55
evennia/tests/test_utils_gametime.py
View file

@ -1,55 +0,0 @@
import unittest
class TestGameTime(unittest.TestCase):
def test_at_repeat(self):
# game_time = GameTime()
# self.assertEqual(expected, game_time.at_repeat())
assert True # TODO: implement your test here
def test_at_script_creation(self):
# game_time = GameTime()
# self.assertEqual(expected, game_time.at_script_creation())
assert True # TODO: implement your test here
def test_at_start(self):
# game_time = GameTime()
# self.assertEqual(expected, game_time.at_start())
assert True # TODO: implement your test here
class TestSave(unittest.TestCase):
def test_save(self):
# self.assertEqual(expected, save())
assert True # TODO: implement your test here
class TestRuntime(unittest.TestCase):
def test_runtime(self):
# self.assertEqual(expected, runtime(format))
assert True # TODO: implement your test here
class TestUptime(unittest.TestCase):
def test_uptime(self):
# self.assertEqual(expected, uptime(format))
assert True # TODO: implement your test here
class TestGametime(unittest.TestCase):
def test_gametime(self):
# self.assertEqual(expected, gametime(format))
assert True # TODO: implement your test here
class TestGametimeToRealtime(unittest.TestCase):
def test_gametime_to_realtime(self):
# self.assertEqual(expected, gametime_to_realtime(secs, mins, hrs, days, weeks, months, yrs, format))
assert True # TODO: implement your test here
class TestRealtimeToGametime(unittest.TestCase):
def test_realtime_to_gametime(self):
# self.assertEqual(expected, realtime_to_gametime(secs, mins, hrs, days, weeks, months, yrs, format))
assert True # TODO: implement your test here
class TestInitGametime(unittest.TestCase):
def test_init_gametime(self):
# self.assertEqual(expected, init_gametime())
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

29
evennia/tests/test_utils_logger.py
View file

@ -1,29 +0,0 @@
import unittest
class TestLogTrace(unittest.TestCase):
def test_log_trace(self):
# self.assertEqual(expected, log_trace(errmsg))
assert True # TODO: implement your test here
class TestLogErrmsg(unittest.TestCase):
def test_log_errmsg(self):
# self.assertEqual(expected, log_errmsg(errmsg))
assert True # TODO: implement your test here
class TestLogWarnmsg(unittest.TestCase):
def test_log_warnmsg(self):
# self.assertEqual(expected, log_warnmsg(warnmsg))
assert True # TODO: implement your test here
class TestLogInfomsg(unittest.TestCase):
def test_log_infomsg(self):
# self.assertEqual(expected, log_infomsg(infomsg))
assert True # TODO: implement your test here
class TestLogDepmsg(unittest.TestCase):
def test_log_depmsg(self):
# self.assertEqual(expected, log_depmsg(depmsg))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

64
evennia/tests/test_utils_picklefield.py
View file

@ -1,64 +0,0 @@
import unittest
class test__ObjectWrapper(unittest.TestCase):
def test___init__(self):
# __object_wrapper = _ObjectWrapper(obj)
assert True # TODO: implement your test here
class TestWrapConflictualObject(unittest.TestCase):
def test_wrap_conflictual_object(self):
# self.assertEqual(expected, wrap_conflictual_object(obj))
assert True # TODO: implement your test here
class TestDbsafeEncode(unittest.TestCase):
def test_dbsafe_encode(self):
# self.assertEqual(expected, dbsafe_encode(value, compress_object, pickle_protocol))
assert True # TODO: implement your test here
class TestDbsafeDecode(unittest.TestCase):
def test_dbsafe_decode(self):
# self.assertEqual(expected, dbsafe_decode(value, compress_object))
assert True # TODO: implement your test here
class TestPickledObjectField(unittest.TestCase):
def test___init__(self):
# pickled_object_field = PickledObjectField(*args, **kwargs)
assert True # TODO: implement your test here
def test_get_db_prep_lookup(self):
# pickled_object_field = PickledObjectField(*args, **kwargs)
# self.assertEqual(expected, pickled_object_field.get_db_prep_lookup(lookup_type, value, connection, prepared))
assert True # TODO: implement your test here
def test_get_db_prep_value(self):
# pickled_object_field = PickledObjectField(*args, **kwargs)
# self.assertEqual(expected, pickled_object_field.get_db_prep_value(value, connection, prepared))
assert True # TODO: implement your test here
def test_get_default(self):
# pickled_object_field = PickledObjectField(*args, **kwargs)
# self.assertEqual(expected, pickled_object_field.get_default())
assert True # TODO: implement your test here
def test_get_internal_type(self):
# pickled_object_field = PickledObjectField(*args, **kwargs)
# self.assertEqual(expected, pickled_object_field.get_internal_type())
assert True # TODO: implement your test here
def test_pre_save(self):
# pickled_object_field = PickledObjectField(*args, **kwargs)
# self.assertEqual(expected, pickled_object_field.pre_save(model_instance, add))
assert True # TODO: implement your test here
def test_to_python(self):
# pickled_object_field = PickledObjectField(*args, **kwargs)
# self.assertEqual(expected, pickled_object_field.to_python(value))
assert True # TODO: implement your test here
def test_value_to_string(self):
# pickled_object_field = PickledObjectField(*args, **kwargs)
# self.assertEqual(expected, pickled_object_field.value_to_string(obj))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

134
evennia/tests/test_utils_prettytable.py
View file

@ -1,134 +0,0 @@
import unittest
class TestPrettyTable(unittest.TestCase):
def test___getattr__(self):
# pretty_table = PrettyTable(field_names, **kwargs)
# self.assertEqual(expected, pretty_table.__getattr__(name))
assert True # TODO: implement your test here
def test___getitem__(self):
# pretty_table = PrettyTable(field_names, **kwargs)
# self.assertEqual(expected, pretty_table.__getitem__(index))
assert True # TODO: implement your test here
def test___init__(self):
# pretty_table = PrettyTable(field_names, **kwargs)
assert True # TODO: implement your test here
def test___str__(self):
# pretty_table = PrettyTable(field_names, **kwargs)
# self.assertEqual(expected, pretty_table.__str__())
assert True # TODO: implement your test here
def test___str___case_2(self):
# pretty_table = PrettyTable(field_names, **kwargs)
# self.assertEqual(expected, pretty_table.__str__())
assert True # TODO: implement your test here
def test___unicode__(self):
# pretty_table = PrettyTable(field_names, **kwargs)
# self.assertEqual(expected, pretty_table.__unicode__())
assert True # TODO: implement your test here
def test_add_column(self):
# pretty_table = PrettyTable(field_names, **kwargs)
# self.assertEqual(expected, pretty_table.add_column(fieldname, column, align, valign))
assert True # TODO: implement your test here
def test_add_row(self):
# pretty_table = PrettyTable(field_names, **kwargs)
# self.assertEqual(expected, pretty_table.add_row(row))
assert True # TODO: implement your test here
def test_clear(self):
# pretty_table = PrettyTable(field_names, **kwargs)
# self.assertEqual(expected, pretty_table.clear())
assert True # TODO: implement your test here
def test_clear_rows(self):
# pretty_table = PrettyTable(field_names, **kwargs)
# self.assertEqual(expected, pretty_table.clear_rows())
assert True # TODO: implement your test here
def test_copy(self):
# pretty_table = PrettyTable(field_names, **kwargs)
# self.assertEqual(expected, pretty_table.copy())
assert True # TODO: implement your test here
def test_del_row(self):
# pretty_table = PrettyTable(field_names, **kwargs)
# self.assertEqual(expected, pretty_table.del_row(row_index))
assert True # TODO: implement your test here
def test_get_html_string(self):
# pretty_table = PrettyTable(field_names, **kwargs)
# self.assertEqual(expected, pretty_table.get_html_string(**kwargs))
assert True # TODO: implement your test here
def test_get_string(self):
# pretty_table = PrettyTable(field_names, **kwargs)
# self.assertEqual(expected, pretty_table.get_string(**kwargs))
assert True # TODO: implement your test here
def test_set_style(self):
# pretty_table = PrettyTable(field_names, **kwargs)
# self.assertEqual(expected, pretty_table.set_style(style))
assert True # TODO: implement your test here
class TestFromCsv(unittest.TestCase):
def test_from_csv(self):
# self.assertEqual(expected, from_csv(fp, field_names, **kwargs))
assert True # TODO: implement your test here
class TestFromDbCursor(unittest.TestCase):
def test_from_db_cursor(self):
# self.assertEqual(expected, from_db_cursor(cursor, **kwargs))
assert True # TODO: implement your test here
class TestTableHandler(unittest.TestCase):
def test___init__(self):
# table_handler = TableHandler(**kwargs)
assert True # TODO: implement your test here
def test_generate_table(self):
# table_handler = TableHandler(**kwargs)
# self.assertEqual(expected, table_handler.generate_table(rows))
assert True # TODO: implement your test here
def test_handle_data(self):
# table_handler = TableHandler(**kwargs)
# self.assertEqual(expected, table_handler.handle_data(data))
assert True # TODO: implement your test here
def test_handle_endtag(self):
# table_handler = TableHandler(**kwargs)
# self.assertEqual(expected, table_handler.handle_endtag(tag))
assert True # TODO: implement your test here
def test_handle_starttag(self):
# table_handler = TableHandler(**kwargs)
# self.assertEqual(expected, table_handler.handle_starttag(tag, attrs))
assert True # TODO: implement your test here
def test_make_fields_unique(self):
# table_handler = TableHandler(**kwargs)
# self.assertEqual(expected, table_handler.make_fields_unique(fields))
assert True # TODO: implement your test here
class TestFromHtml(unittest.TestCase):
def test_from_html(self):
# self.assertEqual(expected, from_html(html_code, **kwargs))
assert True # TODO: implement your test here
class TestFromHtmlOne(unittest.TestCase):
def test_from_html_one(self):
# self.assertEqual(expected, from_html_one(html_code, **kwargs))
assert True # TODO: implement your test here
class TestMain(unittest.TestCase):
def test_main(self):
# self.assertEqual(expected, main())
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

24
evennia/tests/test_utils_search.py
View file

@ -1,24 +0,0 @@
import unittest
class TestSearchObjectTag(unittest.TestCase):
def test_search_object_tag(self):
# self.assertEqual(expected, search_object_tag(key, category))
assert True # TODO: implement your test here
class TestSearchPlayerTag(unittest.TestCase):
def test_search_player_tag(self):
# self.assertEqual(expected, search_player_tag(key, category))
assert True # TODO: implement your test here
class TestSearchScriptTag(unittest.TestCase):
def test_search_script_tag(self):
# self.assertEqual(expected, search_script_tag(key, category))
assert True # TODO: implement your test here
class TestSearchChannelTag(unittest.TestCase):
def test_search_channel_tag(self):
# self.assertEqual(expected, search_channel_tag(key, category))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

40
evennia/tests/test_utils_tests.py
View file

@ -1,40 +0,0 @@
import unittest
class TestANSIStringTestCase(unittest.TestCase):
def test_checker(self):
# a_nsi_string_test_case = ANSIStringTestCase()
# self.assertEqual(expected, a_nsi_string_test_case.checker(ansi, raw, clean))
assert True # TODO: implement your test here
def test_table_check(self):
# a_nsi_string_test_case = ANSIStringTestCase()
# self.assertEqual(expected, a_nsi_string_test_case.table_check(ansi, char, code))
assert True # TODO: implement your test here
def test_test_instance(self):
# a_nsi_string_test_case = ANSIStringTestCase()
# self.assertEqual(expected, a_nsi_string_test_case.test_instance())
assert True # TODO: implement your test here
def test_test_join(self):
# a_nsi_string_test_case = ANSIStringTestCase()
# self.assertEqual(expected, a_nsi_string_test_case.test_join())
assert True # TODO: implement your test here
def test_test_len(self):
# a_nsi_string_test_case = ANSIStringTestCase()
# self.assertEqual(expected, a_nsi_string_test_case.test_len())
assert True # TODO: implement your test here
def test_test_slice(self):
# a_nsi_string_test_case = ANSIStringTestCase()
# self.assertEqual(expected, a_nsi_string_test_case.test_slice())
assert True # TODO: implement your test here
def test_test_split(self):
# a_nsi_string_test_case = ANSIStringTestCase()
# self.assertEqual(expected, a_nsi_string_test_case.test_split())
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

55
evennia/tests/test_utils_text2html.py
View file

@ -1,55 +0,0 @@
import unittest
class TestTextToHTMLparser(unittest.TestCase):
def test_convert_linebreaks(self):
# text_to_htm_lparser = TextToHTMLparser()
# self.assertEqual(expected, text_to_htm_lparser.convert_linebreaks(text))
assert True # TODO: implement your test here
def test_convert_urls(self):
# text_to_htm_lparser = TextToHTMLparser()
# self.assertEqual(expected, text_to_htm_lparser.convert_urls(text))
assert True # TODO: implement your test here
def test_do_sub(self):
# text_to_htm_lparser = TextToHTMLparser()
# self.assertEqual(expected, text_to_htm_lparser.do_sub(m))
assert True # TODO: implement your test here
def test_parse(self):
# text_to_htm_lparser = TextToHTMLparser()
# self.assertEqual(expected, text_to_htm_lparser.parse(text, strip_ansi))
assert True # TODO: implement your test here
def test_re_bold(self):
# text_to_htm_lparser = TextToHTMLparser()
# self.assertEqual(expected, text_to_htm_lparser.re_bold(text))
assert True # TODO: implement your test here
def test_re_color(self):
# text_to_htm_lparser = TextToHTMLparser()
# self.assertEqual(expected, text_to_htm_lparser.re_color(text))
assert True # TODO: implement your test here
def test_re_underline(self):
# text_to_htm_lparser = TextToHTMLparser()
# self.assertEqual(expected, text_to_htm_lparser.re_underline(text))
assert True # TODO: implement your test here
def test_remove_backspaces(self):
# text_to_htm_lparser = TextToHTMLparser()
# self.assertEqual(expected, text_to_htm_lparser.remove_backspaces(text))
assert True # TODO: implement your test here
def test_remove_bells(self):
# text_to_htm_lparser = TextToHTMLparser()
# self.assertEqual(expected, text_to_htm_lparser.remove_bells(text))
assert True # TODO: implement your test here
class TestParseHtml(unittest.TestCase):
def test_parse_html(self):
# self.assertEqual(expected, parse_html(string, strip_ansi, parser))
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()

138
evennia/tests/test_utils_utils.py
View file

@ -56,141 +56,3 @@ class TestListToString(unittest.TestCase):
self.assertEqual('1, 2 and 3', utils.list_to_string([1,2,3]))
self.assertEqual('"1", "2" and "3"', utils.list_to_string([1,2,3], endsep="and", addquote=True))
class TestWildcardToRegexp(unittest.TestCase):
def test_wildcard_to_regexp(self):
# self.assertEqual(expected, wildcard_to_regexp(instring))
assert True # TODO: implement your test here
class TestTimeFormat(unittest.TestCase):
def test_time_format(self):
# self.assertEqual(expected, time_format(seconds, style))
assert True # TODO: implement your test here
class TestDatetimeFormat(unittest.TestCase):
def test_datetime_format(self):
# self.assertEqual(expected, datetime_format(dtobj))
assert True # TODO: implement your test here
class TestHostOsIs(unittest.TestCase):
def test_host_os_is(self):
# self.assertEqual(expected, host_os_is(osname))
assert True # TODO: implement your test here
class TestGetEvenniaVersion(unittest.TestCase):
def test_get_evennia_version(self):
# self.assertEqual(expected, get_evennia_version())
assert True # TODO: implement your test here
class TestPypathToRealpath(unittest.TestCase):
def test_pypath_to_realpath(self):
# self.assertEqual(expected, pypath_to_realpath(python_path, file_ending))
assert True # TODO: implement your test here
class TestToUnicode(unittest.TestCase):
def test_to_unicode(self):
# self.assertEqual(expected, to_unicode(obj, encoding, force_string))
assert True # TODO: implement your test here
class TestToStr(unittest.TestCase):
def test_to_str(self):
# self.assertEqual(expected, to_str(obj, encoding, force_string))
assert True # TODO: implement your test here
class TestValidateEmailAddress(unittest.TestCase):
def test_validate_email_address(self):
# self.assertEqual(expected, validate_email_address(emailaddress))
assert True # TODO: implement your test here
class TestInheritsFrom(unittest.TestCase):
def test_inherits_from(self):
# self.assertEqual(expected, inherits_from(obj, parent))
assert True # TODO: implement your test here
class TestServerServices(unittest.TestCase):
def test_server_services(self):
# self.assertEqual(expected, server_services())
assert True # TODO: implement your test here
class TestUsesDatabase(unittest.TestCase):
def test_uses_database(self):
# self.assertEqual(expected, uses_database(name))
assert True # TODO: implement your test here
class TestDelay(unittest.TestCase):
def test_delay(self):
# self.assertEqual(expected, delay(delay, callback, retval))
assert True # TODO: implement your test here
class TestCleanObjectCaches(unittest.TestCase):
def test_clean_object_caches(self):
# self.assertEqual(expected, clean_object_caches(obj))
assert True # TODO: implement your test here
class TestRunAsync(unittest.TestCase):
def test_run_async(self):
# self.assertEqual(expected, run_async(to_execute, *args, **kwargs))
assert True # TODO: implement your test here
class TestCheckEvenniaDependencies(unittest.TestCase):
def test_check_evennia_dependencies(self):
# self.assertEqual(expected, check_evennia_dependencies())
assert True # TODO: implement your test here
class TestHasParent(unittest.TestCase):
def test_has_parent(self):
# self.assertEqual(expected, has_parent(basepath, obj))
assert True # TODO: implement your test here
class TestModImport(unittest.TestCase):
def test_mod_import(self):
# self.assertEqual(expected, mod_import(module))
assert True # TODO: implement your test here
class TestAllFromModule(unittest.TestCase):
def test_all_from_module(self):
# self.assertEqual(expected, all_from_module(module))
assert True # TODO: implement your test here
class TestVariableFromModule(unittest.TestCase):
def test_variable_from_module(self):
# self.assertEqual(expected, variable_from_module(module, variable, default))
assert True # TODO: implement your test here
class TestStringFromModule(unittest.TestCase):
def test_string_from_module(self):
# self.assertEqual(expected, string_from_module(module, variable, default))
assert True # TODO: implement your test here
class TestInitNewPlayer(unittest.TestCase):
def test_init_new_player(self):
# self.assertEqual(expected, init_new_player(player))
assert True # TODO: implement your test here
class TestStringSimilarity(unittest.TestCase):
def test_string_similarity(self):
# self.assertEqual(expected, string_similarity(string1, string2))
assert True # TODO: implement your test here
class TestStringSuggestions(unittest.TestCase):
def test_string_suggestions(self):
# self.assertEqual(expected, string_suggestions(string, vocabulary, cutoff, maxnum))
assert True # TODO: implement your test here
class TestStringPartialMatching(unittest.TestCase):
def test_string_partial_matching(self):
# self.assertEqual(expected, string_partial_matching(alternatives, inp, ret_index))
assert True # TODO: implement your test here
class TestFormatTable(unittest.TestCase):
def test_format_table(self):
# self.assertEqual(expected, format_table(table, extra_space))
assert True # TODO: implement your test here
class TestGetEvenniaPids(unittest.TestCase):
def test_get_evennia_pids(self):
# self.assertEqual(expected, get_evennia_pids())
assert True # TODO: implement your test here
if __name__ == '__main__':
unittest.main()