class TestWorkerRunner(unittest.TestCase):
def setUp(self):
self.runner = WorkerRunner('test', pipeline=[KleeRunProcessor])
self.runner.__enter__()
def tearDown(self):
self.runner.__exit__(None, None, None)
def run_klee_test(self,
fixture_name,
run_configuration=None,
expect_failure=False):
if not run_configuration:
run_configuration = {}
test_fixtures = os.path.join(FIXTURE_DIR, fixture_name)
with codecs.open(os.path.join(test_fixtures, 'input.c'),
encoding='utf-8') as f:
code = f.read()
with codecs.open(os.path.join(test_fixtures, 'expected.stdout'),
'U',
encoding='utf-8') as f:
expected_out = f.read()
flags = re.M | re.DOTALL | re.UNICODE
expected_regex = re.compile(u"{}$".format(expected_out), flags)
if expect_failure:
self.assertRaisesRegexp(KleeRunFailure, expected_regex,
self.runner.execute_pipeline, code,
run_configuration)
else:
result = self.runner.execute_pipeline(code, run_configuration)
stdout = result['klee_run']['output']
self.assertRegexpMatches(stdout, expected_regex)
def test_simple_run(self):
self.run_klee_test('simple')
def test_simple_unicode_run(self):
self.run_klee_test('simple_unicode')
def test_symargs(self):
self.run_klee_test('symargs',
{'sym_args': {
'range': [1, 1],
'size': 1
}})
def test_symfiles(self):
self.run_klee_test('symfiles', {
'stdin_enabled': True,
'num_files': 0,
'size_files': 1
})
def test_fail_on_invalid_syntax(self):
self.run_klee_test('invalid_syntax', expect_failure=True)
class TestWorkerRunner(unittest.TestCase):
def setUp(self):
self.runner = WorkerRunner('test', pipeline=[KleeRunProcessor])
self.runner.__enter__()
def tearDown(self):
self.runner.__exit__(None, None, None)
def run_klee_test(self, fixture_name, run_configuration=None,
expect_failure=False):
if not run_configuration:
run_configuration = {}
test_fixtures = os.path.join(FIXTURE_DIR, fixture_name)
with codecs.open(os.path.join(test_fixtures, 'input.c'),
encoding='utf-8') as f:
code = f.read()
with codecs.open(os.path.join(test_fixtures, 'expected.stdout'), 'U',
encoding='utf-8') as f:
expected_out = f.read()
flags = re.M | re.DOTALL | re.UNICODE
expected_regex = re.compile(u"{}$".format(expected_out), flags)
if expect_failure:
self.assertRaisesRegexp(KleeRunFailure, expected_regex,
self.runner.execute_pipeline, code,
run_configuration)
else:
result = self.runner.execute_pipeline(code, run_configuration)
stdout = result['klee_run']['output']
self.assertRegexpMatches(stdout, expected_regex)
def test_simple_run(self):
self.run_klee_test('simple')
def test_simple_unicode_run(self):
self.run_klee_test('simple_unicode')
def test_symargs(self):
self.run_klee_test('symargs', {
'sym_args': {
'range': [1, 1],
'size': 1
}
})
def test_symfiles(self):
self.run_klee_test('symfiles', {
'stdin_enabled': True,
'num_files': 0,
'size_files': 1
})
def test_fail_on_invalid_syntax(self):
self.run_klee_test('invalid_syntax', expect_failure=True)
def submit_code(self, code, email, klee_args, endpoint):
# name will hold the name of the current worker
name = self.request.hostname
with WorkerRunner(self.request.id, endpoint, worker_name=name) as runner:
try:
runner.run(code, email, klee_args)
except SoftTimeLimitExceeded:
result = {
'klee_run': {
'output':
'Job exceeded time limit of '
'{} seconds'.format(worker_config.timeout)
}
}
runner.send_notification('job_failed', result)
def setUp(self):
self.runner = WorkerRunner('test', pipeline=[KleeRunProcessor])
self.runner.__enter__()
def setUp(self):
self.runner = WorkerRunner('test', pipeline=[KleeRunProcessor])
self.runner.__enter__()
class TestWorkerRunner(unittest.TestCase):
def setUp(self):
self.runner = WorkerRunner('test', pipeline=[KleeRunProcessor])
self.runner.__enter__()
def tearDown(self):
self.runner.__exit__(None, None, None)
def run_klee_test(self,
fixture_name,
run_configuration=None,
expect_failure=False):
if not run_configuration:
run_configuration = {}
test_fixtures = os.path.join(FIXTURE_DIR, fixture_name)
with codecs.open(os.path.join(test_fixtures, 'input.c'),
encoding='utf-8') as f:
code = f.read()
with codecs.open(os.path.join(test_fixtures, 'expected.stdout'),
encoding='utf-8') as f:
expected_out = f.read()
flags = re.M | re.DOTALL | re.UNICODE
expected_regex = re.compile(u"{}$".format(expected_out), flags)
if expect_failure:
self.assertRaisesRegex(KleeRunFailure, expected_regex,
self.runner.execute_pipeline, code,
run_configuration)
else:
result = self.runner.execute_pipeline(code, run_configuration)
stdout = result['klee_run']['output']
self.assertRegex(stdout, expected_regex)
def test_simple_run(self):
self.run_klee_test('simple')
def test_simple_unicode_run(self):
self.run_klee_test('simple_unicode')
def test_symargs(self):
self.run_klee_test('symargs',
{'sym_args': {
'range': [1, 1],
'size': 1
}})
def test_symin(self):
self.run_klee_test('symin', {'sym_in': {'size': 1}})
def test_fail_on_invalid_syntax(self):
self.run_klee_test('invalid_syntax', expect_failure=True)
def test_timeout_container(self):
try:
self.runner.run_with_docker(['/bin/sleep', '10'], timeout=1)
except KleeRunFailure as ex:
self.assertIn('Timeout error after 1', str(ex))
return
self.assertTrue(False)
import os
from worker.runner import WorkerRunner
BASE_DIR = os.path.dirname(os.path.realpath(__file__))
with WorkerRunner('test') as runner:
test_dir = os.getcwd()
input_dir = os.path.join(BASE_DIR, "input")
output_dir = os.path.join(BASE_DIR, "output")
for input_file_path in os.listdir(input_dir):
file_base_name = os.path.splitext(os.path.basename(input_file_path))[0]
output_file_path = os.path.join(test_dir, "output",
file_base_name + ".txt")
input_file = os.path.join(test_dir, "input", input_file_path)
with open(input_file, 'r') as code:
with open(output_file_path, 'w') as result:
result.write(runner.run_klee(code.read(), "").strip())