def _judger_memory_args_check(self):
with self.assertRaisesRegexp(ValueError, "max_memory must > 16M or unlimited"):
judger.run(path="/bin/true", in_file="/dev/null",
out_file="/dev/null", max_cpu_time=1000, max_memory=100,
env=["aaa=123"], use_sandbox=True, use_nobody=True)
try:
judger.run(path="/bin/true", in_file="/dev/null",
out_file="/dev/null", max_cpu_time=1000, max_memory=judger.MEMORY_UNLIMITED,
env=["aaa=123"], use_sandbox=True, use_nobody=True)
except Exception as e:
self.fail(e.message)
def _judger_cpu_time_args_check(self):
with self.assertRaisesRegexp(ValueError, "max_cpu_time must > 1 ms or unlimited"):
judger.run(path="/bin/true", in_file="/dev/null",
out_file="/dev/null", max_cpu_time=0, max_memory=200000000,
env=["aaa=123"], use_sandbox=False, use_nobody=False)
try:
judger.run(path="/bin/true", in_file="/dev/null",
out_file="/dev/null", max_cpu_time=judger.CPU_TIME_UNLIMITED, max_memory=200000000,
env=["aaa=123"], use_sandbox=False, use_nobody=False)
except Exception as e:
self.fail(e.message)
def _judge_one(self, test_case_id):
execute_command = self._language["execute_command"].format(exe_path=self._exe_path).split(" ")
run_result = judger.run(path=execute_command[0],
max_cpu_time=self._max_cpu_time,
max_memory=self._max_memory,
in_file=os.path.join(self._test_case_dir, str(test_case_id) + ".in"),
out_file=os.path.join(self._judge_base_path, str(test_case_id) + ".out"),
args=execute_command[1:],
env=["PATH=" + os.environ["PATH"]],
use_sandbox=self._language["use_sandbox"])
if run_result["flag"] == 0:
output_md5, r = self._compare_output(test_case_id)
if r:
run_result["result"] = result["accepted"]
else:
run_result["result"] = result["wrong_answer"]
run_result["output_md5"] = output_md5
elif run_result["flag"] in [1, 2]:
run_result["result"] = result["time_limit_exceeded"]
elif run_result["flag"] == 3:
run_result["result"] = result["memory_limit_exceeded"]
elif run_result["flag"] == 4:
run_result["result"] = result["runtime_error"]
elif run_result["flag"] == 5:
run_result["result"] = result["system_error"]
return run_result
def test_run(self):
shutil.rmtree(self.tmp_path, ignore_errors=True)
os.mkdir(self.tmp_path)
for i in os.listdir("."):
try:
int(i)
except Exception:
continue
print "\n\nRunning test: ", i
test_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), str(i))
exe_path = os.path.join(self.tmp_path, str(i))
config = json.loads(open(os.path.join(test_dir, "config")).read())
self.assertEqual(self.compile_src(os.path.join(test_dir, "Main.c"), config.pop("language"), exe_path), 0)
run_result = judger.run(path=exe_path,
in_file=os.path.join(test_dir, "in"),
out_file=os.path.join(self.tmp_path, str(i) + ".out"),
**config)
result = json.loads(open(os.path.join(test_dir, "result")).read())
print run_result
self.assertEqual(result["flag"], run_result["flag"])
self.assertEqual(result["signal"], run_result["signal"])
self.assertEqual(open(os.path.join(test_dir, "out")).read(),
open(os.path.join(self.tmp_path, str(i) + ".out")).read())
self._judger_cpu_time_args_check()
self._judger_memory_args_check()
self._judger_exec_file_args_check()
self._judger_in_file_args_check()
self._judger_args_args_check()
self._judger_env_args_check()
self._judger_child_process_cpu_time_check()
self._judger_user_args_check()
def _judge_one(self, test_case_id):
run_result = judger.run(path=self.execute_command[0],
max_cpu_time=self._max_cpu_time,
max_memory=self._max_memory,
in_file=os.path.join(self._test_case_dir, str(test_case_id) + ".in"),
out_file=os.path.join(self._judge_base_path, str(test_case_id) + ".out"),
args=self.execute_command[1:],
env=["PATH=" + os.environ["PATH"]],
use_sandbox=self._language["use_sandbox"],
use_nobody=True)
run_result["test_case"] = test_case_id
# 对Java的特殊处理, 详见__init__函数中注释
if self._language["name"] == "java" and run_result["memory"] > self._real_max_memory * 1.5:
run_result["flag"] = 3
# 将judger返回的结果标志转换为本系统中使用的
if run_result["flag"] == 0:
output_md5, r = self._compare_output(test_case_id)
if r:
run_result["result"] = result["accepted"]
else:
run_result["result"] = result["wrong_answer"]
run_result["output_md5"] = output_md5
elif run_result["flag"] in [1, 2]:
run_result["result"] = result["time_limit_exceeded"]
elif run_result["flag"] == 3:
run_result["result"] = result["memory_limit_exceeded"]
elif run_result["flag"] == 4:
run_result["result"] = result["runtime_error"]
elif run_result["flag"] == 5:
run_result["result"] = result["system_error"]
return run_result
def compile_(language_item, src_path, exe_path, judge_base_path, compile_spj=False):
command_item = "spj_compile_command" if compile_spj else "compile_command"
compile_command = language_item[command_item].format(src_path=src_path, exe_path=exe_path).split(" ")
compiler = compile_command[0]
compile_args = compile_command[1:]
compiler_output_file = os.path.join(judge_base_path, "compiler.out")
compile_result = judger.run(path=compiler,
in_file="/dev/null",
out_file=compiler_output_file,
max_cpu_time=2000,
max_memory=2000000000,
args=compile_args,
env=["PATH=" + os.environ["PATH"]],
use_sandbox=False,
use_nobody=True)
compile_output_handler = open(compiler_output_file)
compile_output = compile_output_handler.read().strip()
compile_output_handler.close()
if compile_result["flag"] != 0:
logger.error("Compiler error")
logger.error(compile_output)
logger.error(str(compile_result))
if compile_output:
raise CompileError(compile_output)
else:
raise CompileError("Compile error, info: " + str(compile_result))
else:
if "error" in compile_output:
raise CompileError(compile_output)
return exe_path
def _compile():
return judger.run(path="/usr/bin/gcc",
in_file=os.path.join(base_path, "in"),
out_file=os.path.join(base_path, "gcc_out"),
max_cpu_time=2000,
max_memory=200000000,
args=[os.path.join(base_path, "demo.c"), "-o", os.path.join(base_path, "demo")],
env=["PATH=" + os.environ["PATH"]],
use_sandbox=False)
def _compile():
return judger.run(path="/usr/bin/gcc",
in_file=os.path.join(base_path, "in"),
out_file=os.path.join(base_path, "gcc_out"),
max_cpu_time=judger.CPU_TIME_UNLIMITED,
max_memory=judger.MEMORY_UNLIMITED,
args=[os.path.join(base_path, "demo.c"), "-o", os.path.join(base_path, "demo")],
env=["PATH=" + os.environ["PATH"]],
use_sandbox=False,
use_nobody=False)
def run(use_sandbox):
path = os.path.join(base_path, "demo")
return judger.run(path=path,
in_file=os.path.join(base_path, "1.in"),
out_file=os.path.join(base_path, "seccomp.out"),
# ms
max_cpu_time=2000000,
# Byte
max_memory=200000000,
# default is True
use_sandbox=use_sandbox)
def spj(path, max_cpu_time, max_memory, in_path, user_out_path):
if file_exists(in_path) and file_exists(user_out_path):
result = judger.run(path=path, in_file=in_path, out_file="/tmp/spj.out",
max_cpu_time=max_cpu_time, max_memory=max_memory,
args=[in_path, user_out_path], env=["PATH=" + os.environ.get("PATH", "")],
use_sandbox=True, use_nobody=True)
if result["signal"] == 0 and result["exit_status"] in [AC, WA, SPJ_ERROR]:
result["spj_result"] = result["exit_status"]
else:
result["spj_result"] = SPJ_ERROR
return result
else:
raise ValueError("in_path or user_out_path does not exist")
def _judger_child_process_cpu_time_check(self):
try:
max_cpu_time = 2000
result = judger.run(path=os.path.join(self.tmp_path, "17"), in_file="/dev/null",
out_file="/dev/null", max_cpu_time=max_cpu_time, max_memory=200000000,
env=["aaa=123"], use_sandbox=False, use_nobody=True)
expected_cpu_time = (max_cpu_time + 1000) / 1000 * 1000
if result["cpu_time"] > expected_cpu_time * 1.1:
self.fail("cpu time exceeded")
if result["real_time"] >= max_cpu_time * 3:
self.fail("real time exceeded")
except Exception as e:
self.fail(e.message)
def run(use_sandbox):
_compile()
path = os.path.join(base_path, "demo")
return judger.run(path=path,
in_file=os.path.join(base_path, "in"),
out_file=os.path.join(base_path, "out"),
# ms
max_cpu_time=2000,
# Byte
max_memory=200000000,
# args and env are optional
args=["1", "2", "####"],
env=["aaa=123"],
# default is True
use_sandbox=use_sandbox)
def run(use_sandbox, use_nobody):
print "compile result: ", _compile()
path = os.path.join(base_path, "demo")
return judger.run(path=path,
in_file=os.path.join(base_path, "in"),
out_file=os.path.join(base_path, "out"),
# ms
max_cpu_time=2000,
# Byte
max_memory=200000000,
# args env and log_path are optional
args=["1", "2", "####"],
env=["aaa=123"],
log_path="run.log",
# default is True
use_sandbox=use_sandbox,
use_nobody=use_nobody)
def _judger_args_args_check(self):
with self.assertRaisesRegexp(ValueError, "args must be a list"):
judger.run(path="/bin/ls", in_file="/dev/null",
out_file="/dev/null", max_cpu_time=1000, max_memory=200000000,
args=123, use_sandbox=True, use_nobody=True)
with self.assertRaisesRegexp(ValueError, "arg in args must be a string"):
judger.run(path="/bin/ls", in_file="/dev/null",
out_file="/dev/null", max_cpu_time=1000, max_memory=200000000,
args=["123", {"a": "b"}], use_sandbox=True, use_nobody=True)
with self.assertRaisesRegexp(ValueError, "Number of args must < 95"):
judger.run(path="/bin/ls", in_file="/dev/null",
out_file="/dev/null", max_cpu_time=1000, max_memory=200000000,
args=["123"] * 200, use_sandbox=True, use_nobody=True)
def test_args_must_be_list(self):
with self.assertRaisesRegex(ValueError, "args must be a list!"):
config = self.base_config
config["args"] = "test"
judger.run(**config)
with self.assertRaisesRegex(ValueError, "args must be a list!"):
config = self.base_config
config["args"] = ("test", 1)
judger.run(**config)
with self.assertRaisesRegex(ValueError, "args must be a list!"):
config = self.base_config
config["args"] = {"a": "v"}
judger.run(**config)
def test_run(self):
shutil.rmtree(self.tmp_path, ignore_errors=True)
os.mkdir(self.tmp_path)
for i in os.listdir("."):
try:
int(i)
except Exception:
continue
test_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), str(i))
exe_path = os.path.join("/tmp/judger_test", str(i))
config = json.loads(open(os.path.join(test_dir, "config")).read())
self.assertEqual(self.compile_src(os.path.join(test_dir, "Main.c"), config.pop("language"), exe_path), 0)
run_result = judger.run(path=exe_path,
in_file=os.path.join(test_dir, "in"),
out_file=os.path.join(self.tmp_path, str(i) + ".out"),
**config)
result = json.loads(open(os.path.join(test_dir, "result")).read())
self.assertEqual(result["flag"], run_result["flag"])
self.assertEqual(result["signal"], run_result["signal"])
self.assertEqual(open(os.path.join(test_dir, "out")).read(), open(os.path.join(self.tmp_path, str(i) + ".out")).read())
def test_args_item_must_be_string(self):
with self.assertRaisesRegex(ValueError, "args item must be a string!"):
config = self.base_config
config["args"] = ["test", 1]
judger.run(**config)
with self.assertRaisesRegex(ValueError, "args item must be a string!"):
config = self.base_config
config["args"] = [None, "1"]
judger.run(**config)
args = ["测试".encode("utf-8")]
with self.assertRaisesRegex(ValueError, "args item must be a string!"):
config = self.base_config
config["args"] = args
judger.run(**config)
def test_env_item_must_be_string(self):
with self.assertRaisesRegex(ValueError, "env item must be a string!"):
config = self.base_config
config["env"] = ["test", 1]
judger.run(**config)
with self.assertRaisesRegex(ValueError, "env item must be a string!"):
config = self.base_config
config["env"] = [None, "1"]
judger.run(**config)
env = ["测试".encode("utf-8")]
with self.assertRaisesRegex(ValueError, "env item must be a string!"):
config = self.base_config
config["env"] = env
judger.run(**config)
def compile_(language_item,
src_path,
exe_path,
judge_base_path,
compile_spj=False):
command_item = "spj_compile_command" if compile_spj else "compile_command"
compile_command = language_item[command_item].format(
src_path=src_path, exe_path=exe_path).split(" ")
compiler = compile_command[0]
compile_args = compile_command[1:]
compiler_output_file = os.path.join(judge_base_path, "compiler.out")
compile_result = judger.run(
path=compiler,
in_file="/dev/null",
out_file=compiler_output_file,
max_cpu_time=language_item["compile_max_cpu_time"],
max_memory=language_item["compile_max_memory"],
args=compile_args,
env=["PATH=" + os.environ["PATH"]],
use_sandbox=False,
use_nobody=True)
compile_output_handler = open(compiler_output_file)
compile_output = compile_output_handler.read().strip()
compile_output_handler.close()
if compile_result["flag"] != 0:
logger.error("Compiler error")
logger.error(compile_output)
logger.error(str(compile_result))
if compile_output:
raise CompileError(compile_output)
else:
raise CompileError("Compile error, info: " + str(compile_result))
else:
if "error" in compile_output:
raise CompileError(compile_output)
return exe_path
def test_run(self):
shutil.rmtree(self.tmp_path, ignore_errors=True)
os.mkdir(self.tmp_path)
for i in os.listdir("."):
try:
int(i)
except Exception:
continue
print "\n\nRunning test: ", i
test_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)),
str(i))
exe_path = os.path.join(self.tmp_path, str(i))
config = json.loads(open(os.path.join(test_dir, "config")).read())
self.assertEqual(
self.compile_src(os.path.join(test_dir, "Main.c"),
config.pop("language"), exe_path), 0)
run_result = judger.run(path=exe_path,
in_file=os.path.join(test_dir, "in"),
out_file=os.path.join(
self.tmp_path,
str(i) + ".out"),
**config)
result = json.loads(open(os.path.join(test_dir, "result")).read())
print run_result
self.assertEqual(result["flag"], run_result["flag"])
self.assertEqual(result["signal"], run_result["signal"])
self.assertEqual(
open(os.path.join(test_dir, "out")).read(),
open(os.path.join(self.tmp_path,
str(i) + ".out")).read())
self._judger_cpu_time_args_check()
self._judger_memory_args_check()
self._judger_exec_file_args_check()
self._judger_in_file_args_check()
self._judger_args_args_check()
self._judger_env_args_check()
self._judger_child_process_cpu_time_check()
self._judger_user_args_check()
def test_child_real_time(self):
config = self.base_config
config["exe_path"] = self._compile_c("test_child_real_time.c")
result = judger.run(**config)
self.assertEqual(result["result"],
judger.RESULT_REAL_TIME_LIMIT_EXCEEDED)
def _judger_in_file_args_check(self):
with self.assertRaisesRegexp(ValueError, "in_file does not exist"):
judger.run(path="/bin/true", in_file="/dev/xxx",
out_file="/dev/null", max_cpu_time=1000, max_memory=200000000,
env=["aaa=123"], use_sandbox=True, use_nobody=True)
# coding=utf-8
import os
import judger
base_path = os.path.dirname(os.path.abspath(__file__))
print judger.run(path=os.path.join(base_path, "test"),
in_file=os.path.join(base_path, "in"),
out_file=os.path.join(base_path, "out"),
max_cpu_time=2000,
max_memory=200000000,
args=["1", "2", "####"],
env=["LD_PRELOAD=" + os.path.join(base_path, "sandbox.so")])
def test_sysinfo(self):
config = self.base_config
config["exe_path"] = self._compile_c("test_sysinfo.c")
result = judger.run(**config)
self.assertEqual(result["result"], judger.RESULT_SUCCESS)
def _judger_user_args_check(self):
os.setuid(pwd.getpwnam("nobody").pw_uid)
with self.assertRaisesRegexp(ValueError, "Root user is required when use_nobody=True"):
judger.run(path="/bin/ls", in_file="/dev/null",
out_file="/dev/null", max_cpu_time=2000, max_memory=200000000,
env=["aaa=123"], use_sandbox=True, use_nobody=True)
