def Check(self,
code,
pythonpath=(),
skip_repeat_calls=True,
report_errors=True,
filename=None,
quick=False,
imports_map=None,
**kwargs):
"""Run an inference smoke test for the given code."""
self.ConfigureOptions(skip_repeat_calls=skip_repeat_calls,
quick=quick,
**self._GetPythonpathArgs(
pythonpath, imports_map))
try:
src = _Format(code)
errorlog = test_utils.TestErrorLog(code)
if errorlog.expected:
self.fail(
"Cannot assert errors with Check(); use CheckWithErrors()")
analyze.check_types(src,
filename,
loader=self.loader,
errorlog=errorlog,
options=self.options,
**kwargs)
except directors.SkipFileError:
pass
if report_errors and errorlog:
errorlog.print_to_stderr()
self.fail("Checker found {} errors:\n{}".format(
len(errorlog), errorlog))
def _SetUpErrorHandling(self, code, pythonpath, analyze_annotated, quick):
code = _Format(code)
errorlog = test_utils.TestErrorLog(code)
self.ConfigureOptions(
pythonpath=pythonpath, analyze_annotated=analyze_annotated, quick=quick)
return {"src": code, "errorlog": errorlog, "options": self.options,
"loader": self.loader}
def _InferAndVerify(self,
src,
pythonpath,
module_name,
report_errors,
analyze_annotated,
imports_map=None,
quick=False,
**kwargs):
"""Infer types for the source code treating it as a module.
Used by Infer().
Args:
src: The source code of a module. Treat it as "__main__".
pythonpath: --pythonpath as list/tuple of string
module_name: Name of the module we're analyzing. E.g. "foo.bar.mymodule".
report_errors: Whether to fail if the type inferencer reports any errors
in the program.
analyze_annotated: Whether to analyze functions with return annotations.
imports_map: --imports_info data
quick: Try to run faster, by avoiding costly computations.
**kwargs: Keyword parameters to pass through to the type inferencer.
Raises:
AssertionError: If report_errors is True and we found errors.
Returns:
A pytd.TypeDeclUnit
"""
self.ConfigureOptions(module_name=module_name,
quick=quick,
use_pickled_files=True,
pythonpath=[""] if
(not pythonpath and imports_map) else pythonpath,
imports_map=imports_map,
analyze_annotated=analyze_annotated)
errorlog = test_utils.TestErrorLog(src)
if errorlog.expected:
self.fail(
"Cannot assert errors with Infer(); use InferWithErrors()")
unit, builtins_pytd = analyze.infer_types(src,
errorlog,
self.options,
loader=self.loader,
**kwargs)
unit.Visit(visitors.VerifyVisitor())
if report_errors and errorlog:
errorlog.print_to_stderr()
self.fail("Inferencer found {} errors:\n{}".format(
len(errorlog), errorlog))
return unit, builtins_pytd
def InferFromFile(self, filename, pythonpath):
with open(filename, "r") as fi:
code = fi.read()
errorlog = test_utils.TestErrorLog(code)
if errorlog.expected:
self.fail(
"Cannot assert errors with InferFromFile(); use InferWithErrors()")
self.ConfigureOptions(
module_name=load_pytd.get_module_name(filename, pythonpath),
pythonpath=pythonpath)
unit, _ = analyze.infer_types(code, errorlog, self.options,
loader=self.loader, filename=filename)
unit.Visit(visitors.VerifyVisitor())
return pytd_utils.CanonicalOrdering(unit)
def test_populate_marks(self):
# Test that assert_error_regexes populates self.marks if not already done.
errorlog = test_utils.TestErrorLog("x = 0")
self.assertIsNone(errorlog.marks)
self.assertErrorRegexes(errorlog, {})
self.assertIsNotNone(errorlog.marks)
