def test_add_without_name(self):
registry = class_registry.ClassRegistry(HogeBase)
registry.Add(HogeBase)
self.assertIs(registry.classes['HogeBase'], HogeBase)
self.assertIs(registry.HogeBase, HogeBase)
self.assertIs(registry.Get('HogeBase'), HogeBase)
def test_override(self):
registry = class_registry.ClassRegistry(HogeBase)
registry.Add(HogeBase, 'Hoge')
registry.Override('Hoge', HogeImpl)
self.assertIs(registry.classes['Hoge'], HogeImpl)
self.assertIs(registry.Hoge, HogeImpl)
self.assertIs(registry.Get('Hoge'), HogeImpl)
class TestlibJudgeRunner(JudgeRunner):
PREFIX = 'testlib'
def Run(self, judge, infile, difffile, outfile, cwd, judgefile):
return judge.Run(args=(infile, outfile, difffile),
cwd=cwd,
input=os.devnull,
output=judgefile,
timeout=None,
precise=False,
redirect_error=True) # !redirect_error
judge_runner_registry = class_registry.ClassRegistry(JudgeRunner)
judge_runner_registry.Add(RimeJudgeRunner)
judge_runner_registry.Add(TestlibJudgeRunner)
class ReactiveRunner(object):
def Run(self, reactive, solution, args, cwd, input, output, timeout,
precise):
raise NotImplementedError()
class KUPCReactiveRunner(ReactiveRunner):
PREFIX = 'kupc'
def Run(self, reactive, args, cwd, input, output, timeout, precise):
return reactive.Run(args=("'%s'" % ' '.join(args), ),
def Run(self,
args,
cwd,
input,
output,
timeout,
precise,
redirect_error=False):
raise NotImplementedError()
def Clean(self):
raise NotImplementedError()
registry = class_registry.ClassRegistry(Code)
def CreateDictionary(name_fmt, codeset, src_dir, out_dir, wrapper=None):
"""Creates a dictionary used for configs."""
exports = {}
if wrapper is None:
def wrapper(c):
return c
for code_class in registry.classes.values():
def Closure(code_class):
def Registerer(src, *args, **kwargs):
codeset.append(
raise NotImplementedError()
class UploaderBase(object):
@taskgraph.task_method
def Upload(self, ui, problem, dryrun):
raise NotImplementedError()
class SubmitterBase(object):
@taskgraph.task_method
def Submit(self, ui, solution):
raise NotImplementedError()
packer_registry = class_registry.ClassRegistry(PackerBase)
uploader_registry = class_registry.ClassRegistry(UploaderBase)
submitter_registry = class_registry.ClassRegistry(SubmitterBase)
def EditFile(filename, initial):
EDITOR = os.environ.get('EDITOR', 'vi')
files.WriteFile(initial, filename)
call([EDITOR, filename])
class Project(targets.registry.Project):
@taskgraph.task_method
def Pack(self, ui):
results = yield taskgraph.TaskBranch(
[problem.Pack(ui) for problem in self.problems])
def testBaseClassNoOverride(self):
r = class_registry.ClassRegistry(HogeBase)
self.assertRaises(AssertionError, r.Override, 'Hoge', HogeImpl)
def testBaseClassNotSubclass(self):
r = class_registry.ClassRegistry(HogeBase)
r.Add(HogeBase, 'Hoge')
self.assertRaises(AssertionError, r.Override, 'Hoge', Piyo)
def testBaseClassSuccess(self):
r = class_registry.ClassRegistry(HogeBase)
r.Add(HogeBase, 'Hoge')
r.Override('Hoge', HogeImpl)
self.assertTrue(r.classes['Hoge'] is HogeImpl)
self.assertTrue(r.Hoge is HogeImpl)
else:
left_col_head = ' %s ' % longopt
rows.append((left_col_head, option.description.splitlines()))
if not rows:
ui.console.Print(' No options.')
else:
offset = max([len(left_col) for left_col, _ in rows])
for left_col_head, right_col_lines in rows:
for i, right_col_line in enumerate(right_col_lines):
left_col_line = (i == 0 and left_col_head or '').ljust(
offset)
ui.console.Print(left_col_line + right_col_line)
ui.console.Print()
registry = class_registry.ClassRegistry(Command)
def GetCommands():
commands = {}
default = registry.Default(None)
commands[None] = default
for name, clazz in registry.classes.items():
if name == 'Default':
continue
cmd = clazz(default)
commands[cmd.name] = cmd
return commands
def GetCommand(cmdname):
class GCJMerger(TestMerger):
PREFIX = 'gcj'
def __init__(self, output_replace=None):
super(GCJMerger, self).__init__(output_replace)
def _ConcatenateIn(self, srcs, dst):
with open(dst, 'w') as f:
f.write(str(len(srcs)) + '\n')
for i, src in enumerate(srcs):
f.write(files.ReadFile(src))
test_merger_registry = class_registry.ClassRegistry(TestMerger)
test_merger_registry.Add(ICPCMerger)
test_merger_registry.Add(GCJMerger)
class MergedTestCase(test.TestCase):
def __init__(self, testset, name, input_pattern):
super(MergedTestCase, self).__init__(
testset,
os.path.join(testset.out_dir, '{0}{1}'.format(name,
consts.IN_EXT)))
self.input_pattern = input_pattern
@property
def timeout(self):
return None
import unittest
from rime.util import class_registry
from rime.util import module_loader
from . import test_package
class TestModuleLoader(unittest.TestCase):
def test_load_module(self):
res = module_loader.LoadModule(
'tests.util_tests.test_package.test_module1')
self.assertTrue(res)
self.assertIs(registry.test_module1, test_package.test_module1.Test1)
def test_load_package(self):
module_loader.LoadPackage('tests.util_tests.test_package')
self.assertIs(registry.test_module1, test_package.test_module1.Test1)
self.assertIs(registry.test_module2,
test_package.test_subpackage.test_module2.Test2)
registry = class_registry.ClassRegistry()
class ReloadConfiguration(Exception):
pass
class Project(TargetBase):
"""Project target.
Project is the only target defined in rime.core. Here, only special methods
which need to be cared in the core library are defined, e.g. use_plugin().
"""
CONFIG_FILENAME = 'PROJECT'
def PreLoad(self, ui):
# Do not use super() here because targets.Project will be overridden.
TargetBase.PreLoad(self, ui)
def use_plugin(name):
module_name = 'rime.plugins.%s' % name
if module_name not in sys.modules:
if not module_loader.LoadModule(module_name):
raise ConfigurationError(
'Failed to load a plugin: %s' % name)
raise ReloadConfiguration('use_plugin(%s)' % repr(name))
self.exports['use_plugin'] = use_plugin
registry = class_registry.ClassRegistry(TargetBase)
registry.Add(Project)
def test_attribute_error(self):
registry = class_registry.ClassRegistry(HogeBase)
with self.assertRaises(AttributeError):
registry.Hoge
def test_base_class_no_override(self):
registry = class_registry.ClassRegistry(HogeBase)
with self.assertRaises(AssertionError):
registry.Override('Hoge', HogeImpl)
def test_base_class_not_subclass(self):
registry = class_registry.ClassRegistry(HogeBase)
registry.Add(HogeBase, 'Hoge')
with self.assertRaises(AssertionError):
registry.Override('Hoge', Piyo)
def test_add_duplication(self):
registry = class_registry.ClassRegistry(HogeBase)
registry.Add(HogeBase, 'Hoge')
with self.assertRaises(AssertionError):
registry.Add(HogeImpl, 'Hoge')
