def test_case_diff():
tc1 = parse(src1)[0]
tc2 = parse(src1b)[0]
diff = _testcase_diff(tc1, tc2)
assert not diff.is_different
assert str(diff) == indent(src1.strip(), 4)
def test_invalid_command():
with pytest.raises(IoSpecSyntaxError):
parse('@invalid-command foo')
for cmd in ['command', 'build-error', 'timeout-error']:
with pytest.raises(IoSpecSyntaxError):
parse('@%s (garbage)\n a block of data' % cmd)
def test_case_diff_2():
tc1 = parse(src1)[0]
tc2 = parse(src2)[0]
diff = _testcase_diff(tc1, tc2)
assert diff.is_different
print(diff)
assert str(diff) == """ <foo>
def test_normalize_iospec(self):
src = '<bar>\n<baz>\nfoobar\n\nfoo <bar>\nfoobar'
ast = iospec.parse(src)
ast2 = iospec.parse(src)
ast.normalize()
case1, case2 = ast
assert list(case1) == [Out(''), In('bar'), Out(''), In('baz'),
Out('foobar')]
assert case2 == ast2[1]
def test_system_streams_feedback_comparison():
key = parse(RENDER_BACK_SOURCES['simple example'])
equiv = ('<bar>\n'
'foo: foobar')
equiv = parse(equiv)
key2 = key.copy()
key2.normalize(stream=True)
assert key2[:] == equiv[:]
del equiv[0][0]
equiv.pprint()
fb1 = get_feedback(equiv, key, stream=False)
fb2 = get_feedback(equiv, key, stream=True)
assert fb1.status != fb2.status
assert not fb1.is_correct
assert fb2.is_correct
def test_command_with_arguments_from_iospec_source():
out, in_ = parse('foo: $int(0, 10)')[0]
assert out == 'foo: '
assert isinstance(in_, Command)
assert isinstance(in_.generate(), int)
assert in_.generate() >= 0
assert in_.generate() <= 10
def spec2():
return parse('''Foo<bar>
barfoo
Ham<spam>
eggs
''')
def spec1():
return parse('''foo <bar>
barfoo
ham <spam>
eggs
''')
def test_computed_input():
tree = parse('foo$name(10)')
session = tree[0]
assert len(session) == 2
assert session[0].type == 'output'
assert session[1].type == 'command'
assert session[1].name == 'name'
assert session[1].args == '10'
def load_iospec_data(data):
"""
Load IoSpec content from a section
"""
data = unindent(data)
ast = iospec.parse(data + '\n')
return ast
def load_iospec_data(data):
"""
Load IoSpec content from a section
"""
data = unindent(data)
ast = iospec.parse(data + '\n')
return ast
def test_import_command():
tree = parse(
'@import math\n'
'@from random import choice\n'
'@command\n'
'def foo(arg):'
' return math.sqrt(choice([1]))')
assert tree.commands.foo.generate() == 1
def iospec_view():
from iospec import parse
iospec = parse(
'name: <John>\n'
'Hello John!\n'
)
return iospec_to_html(iospec)
def test_simple_ellipsis():
tree = parse('foo<bar>\nfoo...bar')
case = tree[0]
assert case[0] == Out('foo')
assert case[1] == In('bar')
assert case[2] == OutEllipsis('foo...bar')
assert isinstance(case[2], OutEllipsis)
assert case[2] == 'fooblazbar'
def test_multiline_with_pipes():
tree = parse(
'|foo\n'
'|\n'
'|bar'
)
assert len(tree) == 1
assert len(tree[0]) == 1
assert tree[0][0] == Out('foo\n\nbar')
def spec_with_error():
return parse('''foo <bar>
barfoo
@runtime-error
foo <42>
@error
invalid name: 42
''')
def command_grade(args):
"""
Implements "ejudge grade <source> <inputs>" command.
"""
source, lang = get_source_and_lang(args.file)
input_data = iospec.parse(args.inputs)
feedback = ejudge.grade(source, input_data, lang=lang)
print(feedback.render_text())
def test_simple_inputs():
ast = iospec.parse(simple_inputs)
ast.normalize()
result = functions.run(simple_source, ast, lang='python', sandbox=False)
result.normalize()
ast.pprint()
result.pprint()
assert ast.to_json() == result.to_json()
assert iospec.is_equal(ast, result)
def test_use_command():
tree = parse('''
@command
def foo(arg):
return 'computed value'
foo: $foo
''')
assert len(tree) == 1
assert 'foo' in tree.commands
assert tree[0, 1].data == '$foo'
def test_expand_from_code_keep_simple_cases():
src = "print(input('x:'))"
iospec = ('x: <foo>\n'
'foo\n'
'\n'
'@input $name\n'
'\n'
'x: <bar>\n'
'bar')
iospec = parse(iospec)
expanded = expand_from_code(src, iospec, lang='python')
expected = StandardTestCase([Out('x: '), In('foo'), Out('foo')])
assert expanded[0] == expected
def test_system_streams_normalization():
src = RENDER_BACK_SOURCES['simple example']
ast = parse(src)
ast.normalize(stream=True)
assert len(ast) == 1
testcase = ast[0]
assert testcase[0].is_input
assert testcase[1].is_output
assert len(testcase) == 2
x, y = testcase
assert x == 'bar'
assert y == 'foo: foobar'
def test_expand_from_code_keep_simple_cases():
src = "print(input('x:'))"
iospec = (
'x: <foo>\n'
'foo\n'
'\n'
'@input $name\n'
'\n'
'x: <bar>\n'
'bar'
)
iospec = parse(iospec)
expanded = expand_from_code(src, iospec, lang='python')
expected = StandardTestCase([Out('x: '), In('foo'), Out('foo')])
assert expanded[0] == expected
def test_normalization_is_idempotent(source):
ast1 = parse(source)
ast2 = ast1.copy()
ast2.normalize()
ast3 = ast2.copy()
ast3.normalize()
assert ast2 == ast3
assert ast2.to_json() == ast3.to_json()
# Now with stream=True normalization
ast2 = ast1.copy()
ast2.normalize(stream=True)
ast3 = ast2.copy()
ast3.normalize(stream=True)
print('-------')
ast2.pprint()
ast3.pprint()
assert ast2 == ast3
assert ast2.to_json() == ast3.to_json()
def command_run(args):
"""
Implements "ejudge run <source> <inputs>" command.
"""
source, lang = get_source_and_lang(args.file)
if args.iospec:
with open(args.iospec) as F:
input_data = iospec.parse(F)
elif args.inputs:
with open(args.inputs) as F:
input_data = F.read()
if input_data.endswith('\n'):
input_data = input_data[:-1]
input_data = input_data.splitlines()
else:
with open(args.file) as F:
source = F.read()
lang = ejudge.registry.language_from_filename(args.file)
ejudge.exec(source, lang=lang)
return
result = ejudge.run(source, input_data, lang=lang)
print(result.source())
def iospec_view():
from iospec import parse
iospec = parse('name: <John>\n' 'Hello John!\n')
return iospec_to_html(iospec)
def test_open_file():
src = 'foo<bar>'
assert parse(io.StringIO(src)) == parse(src)
def test_escaped_lt_sign():
testcase = parse(r'foo\<bar')[0]
assert testcase[0] == Out('foo<bar')
def test_hanging_dollar_sign():
testcase = parse(r'U$ 10.00')[0]
assert len(testcase) == 1
assert testcase[0] == Out('U$ 10.00')
def test_escaped_dollar_sign():
testcase = parse(r'foo\$bar')[0]
assert testcase[0] == Out('foo$bar')
def test_open_file():
src = "foo<bar>"
assert parse(io.StringIO(src)) == parse_string(src)
def example_pair(example_src):
src, json_src = example_src
ast = iospec.parse(src)
json_data = json.loads(json_src)
return ast, json_data
def test_open_file():
src = 'foo<bar>'
assert parse(io.StringIO(src)) == parse_string(src)
def test_simple_io():
tree = parse('foo<bar>\nfoobar')
case = tree[0]
assert case[0] == Out('foo')
assert case[1] == In('bar')
assert case[2] == Out('foobar')
def test_broken_io():
with pytest.raises(IoSpecSyntaxError):
parse('foo<bar\nfoobar')