173 lines
7.3 KiB
Python
173 lines
7.3 KiB
Python
from .suite import Tester
|
|
|
|
from .suite import Run, Runned, Verdict
|
|
from testsuites import *
|
|
|
|
class __TIFF(Testsuite):
|
|
__SUITE_NAME = "tiff"
|
|
__TIMEOUT = 1
|
|
__CATEGORIES_TO_ENVNAMES = { "rgb": "RGB", "gray": "GRAY", "neg": "NEG" }
|
|
__TESTDATA = os.path.join("testdata", __SUITE_NAME)
|
|
|
|
def __init__(self):
|
|
super().__init__(self.__SUITE_NAME, PREFIX_ENVIRONMENT_NAME, self.__CATEGORIES_TO_ENVNAMES)
|
|
|
|
def get_tester(self) -> Tester:
|
|
tester = Tester(self.name())
|
|
|
|
class __Expected(Expected):
|
|
__OFFSET_TO_SHOW = 16
|
|
|
|
def __init__(self, output_filename: str, reference_filename: str):
|
|
super().__init__()
|
|
|
|
self.__output_filename = output_filename
|
|
self.__reference_filename = reference_filename
|
|
|
|
def test(self, run: Run, runned: Runned) -> Verdict:
|
|
if runned.get_stdout() != "":
|
|
return Verdict(VerdictErrno.ERROR_STDOUT_IS_NOT_EMPTY, f"below is what was in the stdout", runned.get_stdout())
|
|
|
|
if not os.path.exists(self.__output_filename):
|
|
return Verdict(VerdictErrno.ERROR_FILE_NOT_FOUND, f"'{self.__output_filename}' is not created by user's program")
|
|
|
|
output = open(self.__output_filename, "rb").read()
|
|
reference = open(self.__reference_filename, "rb").read()
|
|
|
|
n_output = len(output)
|
|
n_reference = len(reference)
|
|
n = min(n_reference, n_output)
|
|
|
|
verdict_errno = VerdictErrno.ERROR_SUCCESS
|
|
what: Optional[str] = None
|
|
what_extended: List[str] = []
|
|
fail = False
|
|
|
|
for i in range(n):
|
|
if output[i] == reference[i]:
|
|
continue
|
|
|
|
verdict_errno = VerdictErrno.ERROR_ASSERTION
|
|
|
|
what = "wrong converting result"
|
|
|
|
what_extended.append(f"Comparing '{self.__output_filename}' and '{self.__reference_filename}'...")
|
|
if i != 0:
|
|
what_extended.append(f". . . <truncated {i} same bytes> . . .")
|
|
|
|
k = min(i + self.__OFFSET_TO_SHOW, n)
|
|
for j in range(i, k):
|
|
what_extended.append("%08X: %02X %02X" % (j, output[j], reference[j]))
|
|
|
|
if (k - i) == self.__OFFSET_TO_SHOW:
|
|
what_extended.append(f". . . <truncated output> . . .")
|
|
|
|
fail = True
|
|
|
|
break
|
|
|
|
is_reference_bigger = n_reference > n_output
|
|
if n_output != n_reference:
|
|
if not fail:
|
|
verdict_errno = VerdictErrno.ERROR_ASSERTION
|
|
what = "wrong file size"
|
|
if is_reference_bigger:
|
|
what_extended.append(f"Reference file '{self.__reference_filename}' is bigger, than actual file '{self.__output_filename}'.")
|
|
else:
|
|
what_extended.append(f"Actual file '{self.__output_filename}' is bigger, than reference file '{self.__reference_filename}'.")
|
|
|
|
return Verdict(verdict_errno, what, what_extended)
|
|
|
|
def __make_path_to(filename: str) -> str:
|
|
return os.path.abspath(os.path.join(self.__TESTDATA, filename))
|
|
|
|
def __single_test(input_basename: str, reference_basename: Optional[str], returncode: int = ERROR_SUCCESS, output_filename_override: Optional[str] = None, skip_when_dynamic_wrapper: Optional[DynamicWrapper] = None) -> SingleTest:
|
|
input_filename = __make_path_to(input_basename)
|
|
output_filename = __make_path_to(f"output.user") if output_filename_override is None else output_filename_override
|
|
reference_filename = "" if reference_basename is None else __make_path_to(reference_basename)
|
|
neg = returncode != ERROR_SUCCESS
|
|
returncode_policy = ReturnCodePolicy.ShouldBeZero if not neg else ReturnCodePolicy.MatchIfPresented
|
|
stderr_empty = not neg
|
|
run = Run(c_timeout = self.__TIMEOUT, c_stdin = None, c_args = [input_filename, output_filename], t_returncode_policy = returncode_policy, t_returncode = returncode, t_stderr_empty = stderr_empty, t_skip_when_dynamic_wrapper = skip_when_dynamic_wrapper)
|
|
expected = None
|
|
if not neg:
|
|
expected = __Expected(output_filename, reference_filename)
|
|
return run, expected
|
|
|
|
def __args_single_test(args: List[str]) -> SingleTest:
|
|
run = Run(c_timeout = self.__TIMEOUT, c_stdin = None, c_args = args, t_returncode_policy = ReturnCodePolicy.MatchIfPresented, t_returncode = ERROR_ARGUMENTS_INVALID, t_stderr_empty = False, t_skip_when_dynamic_wrapper = DynamicWrapper.GDB_DEBUGGER)
|
|
return run, None
|
|
|
|
def __neg_single_test(input_basename: str, returncode: int, output_filename_override: Optional[str]) -> SingleTest:
|
|
return __single_test(input_basename, None, returncode, output_filename_override, DynamicWrapper.GDB_DEBUGGER)
|
|
|
|
def __sequence(input_basename: str, reference_basename: str) -> List[SingleTest]:
|
|
return [__single_test(input_basename, reference_basename)]
|
|
|
|
def __neg_sequence(input_basename: str, returncode: int, output_filename_override: Optional[str]) -> List[SingleTest]:
|
|
return [__neg_single_test(input_basename, returncode, output_filename_override)]
|
|
|
|
def __arg_sequence(args: List[str]) -> List[SingleTest]:
|
|
return [__args_single_test(args)]
|
|
|
|
def __test(name: str, category: str, input_basename: str, reference_basename: str) -> Test:
|
|
return Test(name, [category], __sequence(input_basename, reference_basename))
|
|
|
|
def __neg_test(name: str, input_basename: str, returncode: int, output_filename_override: Optional[str]) -> Test:
|
|
category = "neg"
|
|
return Test(name, [category], __neg_sequence(input_basename, returncode, output_filename_override))
|
|
|
|
def __arg_test(name: str, args: List[str]) -> Test:
|
|
category = "neg"
|
|
return Test(name, [category], __arg_sequence(args))
|
|
|
|
category_counter: Dict[str, int] = dict((k, 0) for k in self.__CATEGORIES_TO_ENVNAMES.keys())
|
|
|
|
def __testname(category: str, prefix: str, input_basename: str):
|
|
category_counter[category] += 1
|
|
|
|
test_basename = input_basename.removesuffix(".tiff")
|
|
test_basename = test_basename.removesuffix(".pnm")
|
|
test_basename = test_basename.removeprefix(prefix)
|
|
test_basename = test_basename.removeprefix("_")
|
|
|
|
name_prefix = f"Picture [format = {category}] #{category_counter[category]}"
|
|
name_suffix = f"" if test_basename == "" else f": {" ".join(test_basename.split("_")).capitalize()}"
|
|
|
|
return f"{name_prefix}{name_suffix}"
|
|
|
|
def t1(category: str, prefix: str, input_basename: str, reference_basename: str):
|
|
tester.add(__test(__testname(category, prefix, input_basename), category, input_basename, reference_basename))
|
|
|
|
def t(category: str, prefix: str, exception_basename: Set[str] = set(), exception_prefixes: Set[str] = set()):
|
|
reference_basename = f"{prefix}.{"pnm" if category == "rgb" else "pgm"}"
|
|
|
|
for input_basename in os.listdir(self.__TESTDATA):
|
|
if not input_basename.startswith(prefix) or any(input_basename.startswith(p) for p in exception_prefixes):
|
|
continue
|
|
|
|
if input_basename == reference_basename or input_basename in exception_basename:
|
|
continue
|
|
|
|
t1(category, prefix, input_basename, reference_basename)
|
|
|
|
def n(name: str, input_basename: str, returncode: int, output_filename_override: Optional[str] = None):
|
|
tester.add(__neg_test(name, input_basename, returncode, output_filename_override))
|
|
|
|
def na(name: str, args: List[str]):
|
|
tester.add(__arg_test(name, args))
|
|
|
|
t("rgb", "const", exception_prefixes = {"constg"})
|
|
t("gray", "constg")
|
|
|
|
n("No input file found", "this_file_does_not_exists.tiff", ERROR_CANNOT_OPEN_FILE)
|
|
n("Can't create output file", "const_tiff.pnm", ERROR_CANNOT_OPEN_FILE, os.path.abspath(os.path.join(self.__TESTDATA, "this_directory_does_not_exists", "output.pnm")))
|
|
|
|
na("No args", [])
|
|
na("1 arg provided", ["argument 1"])
|
|
na("Too much arguments provided", ["argument 1", "argument 2", "argument 3"])
|
|
|
|
return tester
|
|
|
|
instance = __TIFF()
|