a.append('{}:'.format(fix_path(remove_prefix(
t.path, test_temp_dir))))
v = OutputVisitor()
t.accept(v)
s = v.output()
if s != '':
a += s.split('\n')
first = False
except CompileError as e:
a = e.messages
assert_string_arrays_equal(
expected, a, 'Invalid source code output ({}, line {})'.format(
testcase.file, testcase.line))
def remove_prefix(path, prefix):
regexp = '^' + prefix.replace('\\', '\\\\')
np = re.sub(regexp, '', path)
if np.startswith(os.sep):
np = np[1:]
return np
def fix_path(path):
return path.replace('\\', '/')
if __name__ == '__main__':
run_test(OutputSuite(), sys.argv[1:])
def builtins_wrapper(func, path):
"""Decorate a function that implements a data-driven test case to copy an
alternative builtins module implementation in place before performing the
test case. Clean up after executing the test case.
"""
return lambda testcase: perform_test(func, path, testcase)
def perform_test(func, path, testcase):
for path, _ in testcase.files:
if os.path.basename(path) == "builtins.py":
default_builtins = False
break
else:
# Use default builtins.
builtins = os.path.join(test_temp_dir, "builtins.py")
shutil.copyfile(path, builtins)
default_builtins = True
# Actually peform the test case.
func(testcase)
if default_builtins:
# Clean up.
os.remove(builtins)
if __name__ == "__main__":
run_test(DyncheckTransformSuite(), sys.argv[1:])
# Run the program.
outfile = './_program'
outb = subprocess.check_output([outfile], stderr=subprocess.STDOUT)
# Split output into lines.
out = [s.rstrip('\n\r') for s in str(outb, 'utf8').splitlines()]
# Remove temp file.
os.remove(outfile)
except errors.CompileError as e:
out = e.messages
# Include line-end comments in the expected output.
# Note: # characters in string literals can confuse this.
for s in testcase.input:
m = re.search(' #(.*)', s)
if m:
testcase.output.append(m.group(1).strip())
# Verify output.
assert_string_arrays_equal(testcase.output, out,
'Invalid output ({}, line {})'.format(
testcase.file, testcase.line))
class CGenSuite(Suite):
def __init__(self):
self.test_compile = CGenCompileSuite()
self.test_run = CGenRunSuite()
super().__init__()
if __name__ == '__main__':
run_test(CGenSuite(), sys.argv[1:])
for fn in func_names:
a.append('def {}:'.format(fn))
try:
funccode = result.icode[fn]
except KeyError:
raise RuntimeError('no icode for %s (%s)' % (
fn, list(result.icode.keys())))
code = icode.render(funccode)
a.extend(code)
except CompileError as e:
a = e.messages
assert_string_arrays_equal_wildcards(
expected, a,
'Invalid source code output ({}, line {})'.format(testcase.file,
testcase.line))
def get_func_names(expected):
res = []
for s in expected:
m = re.match(r'def ([_a-zA-Z0-9.*$]+):', s)
if m:
res.append(m.group(1))
if not res:
raise RuntimeError('No function name in test case output')
return res
if __name__ == '__main__':
run_test(IcodeGenerationSuite(), sys.argv[1:])
first = True
# Transform each file separately.
for t in trees:
# Skip the builtins module and files with '_skip.' in the path.
if not t.path.endswith('/builtins.py') and '_skip.' not in t.path:
if not first:
# Display path for files other than the first.
a.append('{}:'.format(
remove_prefix(t.path, test_temp_dir)))
# Transform parse tree and produce the code for operations.
# Note that currently we generate this for each file
# separately; this needs to be fixed eventually.
v = DyncheckTransformVisitor(types, symtable, True)
t.accept(v)
s = generate_runtime_support(t)
if s != '':
a += s.split('\n')
first = False
except CompileError as e:
a = e.messages
assert_string_arrays_equal_wildcards(
expected, a,
'Invalid source code output ({}, line {})'.format(testcase.file,
testcase.line))
if __name__ == '__main__':
import sys
run_test(DyncheckOpGenSuite(), sys.argv[1:])
def expand_caller_kinds(kinds_or_names):
kinds = []
names = []
for k in kinds_or_names:
if isinstance(k, str):
kinds.append(ARG_NAMED)
names.append(k)
else:
kinds.append(k)
names.append(None)
return kinds, names
def expand_callee_kinds(kinds_and_names):
kinds = []
names = []
for v in kinds_and_names:
if isinstance(v, tuple):
kinds.append(v[0])
names.append(v[1])
else:
kinds.append(v)
names.append(None)
return kinds, names
if __name__ == '__main__':
run_test(MapActualsToFormalsSuite(), sys.argv[1:])
'check-interfaces.test',
'check-super.test',
'check-modules.test',
'check-generic-subtyping.test',
'check-unsupported.test']
class TypeCheckSuite(Suite):
def cases(self):
c = []
for f in files:
c += parse_test_cases(os.path.join(test_data_prefix, f),
self.run_test, test_temp_dir, True)
return c
def run_test(self, testcase):
a = []
try:
src = '\n'.join(testcase.input)
build(src, 'main', True, test_temp_dir, True)
except CompileError as e:
a = normalize_error_messages(e.messages)
assert_string_arrays_equal(
testcase.output, a,
'Invalid type checker output ({}, line {})'.format(
testcase.file, testcase.line))
if __name__ == '__main__':
run_test(TypeCheckSuite(), sys.argv[1:])
import testsemanal
import testcheck
import testoutput
import testpythongen
class AllSuite(Suite):
def __init__(self):
self.test_types = testtypes.TypesSuite()
self.test_typeops = testtypes.TypeOpsSuite()
self.test_join = testtypes.JoinSuite()
self.test_meet = testtypes.MeetSuite()
self.test_subtypes = testsubtypes.SubtypingSuite()
self.test_solve = testsolve.SolveSuite()
self.test_infer = testinfer.MapActualsToFormalsSuite()
self.test_lex = testlex.LexerSuite()
self.test_parse = testparse.ParserSuite()
self.test_parse_errors = testparse.ParseErrorSuite()
self.test_semanal = testsemanal.SemAnalSuite()
self.test_semanal_errors = testsemanal.SemAnalErrorSuite()
self.test_semanal_symtable = testsemanal.SemAnalSymtableSuite()
self.test_semanal_typeinfos = testsemanal.SemAnalTypeInfoSuite()
self.test_check = testcheck.TypeCheckSuite()
self.test_output = testoutput.OutputSuite()
self.test_pythongen = testpythongen.PythonGenerationSuite()
super().__init__()
if __name__ == '__main__':
run_test(AllSuite(), sys.argv[1:])
for f in python_eval_files:
c += parse_test_cases(os.path.join(test_data_prefix, f),
test_python_evaluation, test_temp_dir, True)
return c
def test_python_evaluation(testcase):
# Write the program to a file.
program = '_program.py'
outfile = '_program.out'
f = open(program, 'w')
for s in testcase.input:
f.write('{}\n'.format(s))
f.close()
# Run the program.
outb = subprocess.check_output([python_path,
os.path.expanduser(mypy_path),
'mypy.py',
program])
# Split output into lines.
out = [s.rstrip('\n\r') for s in str(outb, 'utf8').splitlines()]
# Remove temp file.
os.remove(program)
assert_string_arrays_equal(testcase.output, out,
'Invalid output ({}, line {})'.format(
testcase.file, testcase.line))
if __name__ == '__main__':
run_test(PythonEvaluationSuite(), sys.argv[1:])
mask = '(' + line[2:].strip() + ')$'
src = '\n'.join(testcase.input)
map = build(src, 'main', True, testconfig.test_temp_dir, True)[3]
kk = map.keys()
keys = []
for k in kk:
if k.line is not None and k.line != -1 and map[k]:
if (re.match(mask, short_type(k))
or (isinstance(k, NameExpr)
and re.match(mask, k.name))):
keys.append(k)
for key in sorted(keys,
key=lambda n: (n.line, short_type(n),
str(n) + str(map[n]))):
ts = str(map[key]).replace('*', '') # Remove erased tags
ts = ts.replace('__main__.', '')
a.append('{}({}) : {}'.format(short_type(key), key.line, ts))
except CompileError as e:
a = e.messages
assert_string_arrays_equal(
testcase.output, a,
'Invalid type checker output ({}, line {})'.format(testcase.file,
testcase.line))
import sys
if __name__ == '__main__':
run_test(TypeExportSuite(), sys.argv[1:])
# Produce an output containing the pretty-printed forms (with original
# formatting) of all the relevant source files.
for t in trees:
# Omit the builtins module and files marked for omission.
if not t.path.endswith(os.sep +
'builtins.py') and '-skip.' not in t.path:
# Add file name + colon for files other than the first.
if not first:
a.append('{}:'.format(
fix_path(remove_prefix(t.path, test_temp_dir))))
ver = 3
# Generate Python 2 instead of 3?
if '-2' in testcase.name:
ver = 2
v = PythonGenerator(ver)
t.accept(v)
s = v.output()
if s != '':
a += s.split('\n')
first = False
except CompileError as e:
a = e.messages
assert_string_arrays_equal(
expected, a, 'Invalid source code output ({}, line {})'.format(
testcase.file, testcase.line))
if __name__ == '__main__':
run_test(PythonGenerationSuite(), sys.argv[1:])
def cases(self):
# Test case descriptions are in an external file.
return parse_test_cases(os.path.join(testconfig.test_data_prefix,
'parse-errors.test'),
test_parse_error)
def test_parse_error(testcase):
try:
# Compile temporary file.
parse('\n'.join(testcase.input), INPUT_FILE_NAME)
raise AssertionFailure('No errors reported')
except CompileError as e:
# Verify that there was a compile error and that the error messages
# are equivalent.
assert_string_arrays_equal(
testcase.output, e.messages,
'Invalid compiler output ({}, line {})'.format(testcase.file,
testcase.line))
class CombinedParserSuite(Suite):
def __init__(self):
self.test_parse = ParserSuite()
self.test_parse_errors = ParseErrorSuite()
super().__init__()
if __name__ == '__main__':
run_test(CombinedParserSuite(), sys.argv[1:])
return c
def run_test(self, testcase):
"""Perform a test case."""
try:
# Build test case input.
src = '\n'.join(testcase.input)
trees, symtable, infos, types = build(src, 'main', True,
test_temp_dir)
# The output is the symbol table converted into a string.
a = str(infos).split('\n')
except CompileError as e:
a = e.messages
assert_string_arrays_equal(
testcase.output, a,
'Invalid semantic analyzer output ({}, line {})'.format(
testcase.file, testcase.line))
class CombinedSemAnalSuite(Suite):
def __init__(self):
self.test_semanal = SemAnalSuite()
self.test_semanal_errors = SemAnalErrorSuite()
self.test_semanal_symtable = SemAnalSymtableSuite()
self.test_semanal_typeinfos = SemAnalTypeInfoSuite()
super().__init__()
if __name__ == '__main__':
run_test(CombinedSemAnalSuite(), sys.argv[1:])
a = []
first = True
# Transform each file separately.
for t in trees:
# Skip the builtins module and files with '_skip.' in the path.
if not t.path.endswith('/builtins.py') and '_skip.' not in t.path:
if not first:
# Display path for files other than the first.
a.append('{}:'.format(remove_prefix(t.path,
test_temp_dir)))
# Transform parse tree and produce the code for operations.
# Note that currently we generate this for each file
# separately; this needs to be fixed eventually.
v = DyncheckTransformVisitor(types, symtable, True)
t.accept(v)
s = generate_runtime_support(t)
if s != '':
a += s.split('\n')
first = False
except CompileError as e:
a = e.messages
assert_string_arrays_equal_wildcards(
expected, a, 'Invalid source code output ({}, line {})'.format(
testcase.file, testcase.line))
if __name__ == '__main__':
import sys
run_test(DyncheckOpGenSuite(), sys.argv[1:])
