def _store_python_exe(self, python_exe): """Postprocess --python_exe.""" if python_exe is None and utils.can_compile_bytecode_natively( self.output_options.python_version): # The user has not requested a custom exe and pytype does not need an exe # for bytecode compilation. Abort early to avoid extracting a large unused # exe into /tmp. self.output_options.python_exe = (None, None) return if python_exe is None: python_exe, flags = utils.get_python_exe( self.output_options.python_version) user_provided_exe = False else: if isinstance(python_exe, tuple): python_exe, flags = python_exe else: flags = [] user_provided_exe = True python_exe_version = utils.get_python_exe_version(python_exe) if python_exe_version != self.output_options.python_version: if not user_provided_exe: err = ("Need a valid python%d.%d executable in $PATH" % self.output_options.python_version) elif python_exe_version: err = ("--python_exe version %d.%d does not match " "--python_version %d.%d" % ( python_exe_version + self.output_options.python_version)) else: err = "Bad flag --python_exe: could not run %s" % python_exe self.error(err) self.output_options.python_exe = (python_exe, flags)
def _store_python_version(self, python_version): """Configure the python version.""" if python_version: if isinstance(python_version, str): self.output_options.python_version = utils.version_from_string( python_version) elif isinstance(python_version, int): self.output_options.python_version = utils.full_version_from_major( python_version) else: self.output_options.python_version = python_version else: self.output_options.python_version = sys.version_info[:2] if len(self.output_options.python_version) != 2: self.error( "--python_version must be <major>.<minor>: %r" % python_version) # Check that we have a version supported by pytype. utils.validate_version(self.output_options.python_version) if utils.can_compile_bytecode_natively(self.output_options.python_version): # pytype does not need an exe for bytecode compilation. Abort early to # avoid extracting a large unused exe into /tmp. self.output_options.python_exe = (None, None) return python_exe, flags = utils.get_python_exe(self.output_options.python_version) python_exe_version = utils.get_python_exe_version(python_exe) if python_exe_version != self.output_options.python_version: self.error("Need a valid python%d.%d executable in $PATH" % self.output_options.python_version) self.output_options.python_exe = (python_exe, flags)
def _store_python_exe(self, python_exe): """Postprocess --python_exe.""" if python_exe is None: python_exe, flags = utils.get_python_exe( self.output_options.python_version) user_provided_exe = False else: if isinstance(python_exe, tuple): python_exe, flags = python_exe else: flags = [] user_provided_exe = True python_exe_version = utils.get_python_exe_version(python_exe) if python_exe_version != self.output_options.python_version: if not user_provided_exe: err = ("Need a valid python%d.%d executable in $PATH" % self.output_options.python_version) elif python_exe_version: err = ( "--python_exe version %d.%d does not match " "--python_version %d.%d" % (python_exe_version + self.output_options.python_version)) else: err = "Bad flag --python_exe: could not run %s" % python_exe self.error(err) self.output_options.python_exe = (python_exe, flags)
def ConfigureOptions(self, **kwargs): assert "python_version" not in kwargs, ( "Individual tests cannot set the python_version of the config options.") self.options.tweak(**kwargs) if self.options.python_version is None: self.options.python_version = self.python_version self.options.tweak( python_exe=utils.get_python_exe(self.options.python_version))
def Replacement(self, *args, **kwargs): self.python_version = python_version # The "options" attribute should have been set by the setUp method of # the test class. assert hasattr(self, "options") self.options.tweak(python_version=self.python_version, python_exe=utils.get_python_exe( self.python_version)) return actual_method(self, *args, **kwargs)
def _GenerateBuiltinsTwice(self, python_version): os.environ["PYTHONHASHSEED"] = "0" f1 = self._TmpPath("builtins1.pickle") f2 = self._TmpPath("builtins2.pickle") for f in (f1, f2): self.pytype_args["--generate-builtins"] = f self.pytype_args["--python_exe"] = utils.get_python_exe( python_version) self._RunPytype(self.pytype_args) return f1, f2
def _store_python_exe(self, python_exe): """Postprocess --python_exe.""" if python_exe is None: python_exe = utils.get_python_exe(self.python_version) err = "Need a valid python%d.%d executable in $PATH" % self.python_version else: err = "Bad flag --python_exe: could not run %s" % python_exe if not utils.is_valid_python_exe(python_exe): raise optparse.OptParseError(err) self.python_exe = python_exe
def test_each_instruction_once_loops(self): code_nested_loop = pyc.compile_src(src=self.src_nested_loop, python_version=self.python_version, python_exe=utils.get_python_exe( self.python_version), filename="<>") self.assertEqual(code_nested_loop.co_code, self.code_nested_loop) self.trace_vm.run_program(self.src_nested_loop, "", maximum_depth=10) # We expect all instructions, except 26, in the above to execute. six.assertCountEqual(self, self.trace_vm.instructions_executed, set(range(32)) - {26})
def __setattr__(self, name, value): if name == "python_version": if isinstance(value, str): value = utils.split_version(value) if self._adjust_python_exe: super(Options, self).__setattr__("python_exe", utils.get_python_exe(value)) else: # Python exe adjustment should be unblocked for next time. self._adjust_python_exe = True super(Options, self).__setattr__(name, value)
def _store_python_exe(self, python_exe): """Postprocess --python_exe.""" if python_exe is None: python_exe = utils.get_python_exe( self.output_options.python_version) err = ("Need a valid python%d.%d executable in $PATH" % self.output_options.python_version) else: err = "Bad flag --python_exe: could not run %s" % python_exe if not utils.is_valid_python_exe(python_exe): self.error(err) self.output_options.python_exe = python_exe
def test_each_instruction_once_dead_code(self): code_deadcode = pyc.compile_src(src=self.src_deadcode, python_version=self.python_version, python_exe=utils.get_python_exe( self.python_version), filename="<>") self.assertEqual(code_deadcode.co_code, self.code_deadcode) try: self.trace_vm.run_program(self.src_deadcode, "", maximum_depth=10) except vm.VirtualMachineError: pass # The code we test throws an exception. Ignore it. six.assertCountEqual(self, self.trace_vm.instructions_executed, [0, 1, 5, 6])
def setUp(self): # The test class (type of |self|) constructor is required to initialize the # 'python_version' attribute. assert hasattr(self, "python_version") if self.python_version: self.options = config.Options.create( python_version=self.python_version, python_exe=utils.get_python_exe(self.python_version)) else: # If the target Python version is None, it means that the test runner # will set it before running the test. Hence, we create an empty Options # object which can be configured by the test runner. self.options = config.Options.create()
def _CreateLoader(self): if self.options.python_version: custom_version = True self.options.tweak( python_exe=utils.get_python_exe(self.options.python_version)) # pylint: disable=invalid-name self.PYTHON_VERSION = self.options.python_version self.PYTHON_EXE = self.options.python_exe # pylint: enable=invalid-name else: custom_version = False self.options.tweak(python_version=self.PYTHON_VERSION) if self.options.module_name or self.options.pythonpath or custom_version: self.loader = load_pytd.create_loader(self.options)
class PytypeTest(unittest.TestCase): """Integration test for pytype.""" PYTHON_VERSION = (2, 7) PYTHON_EXE = utils.get_python_exe(PYTHON_VERSION) DEFAULT_PYI = builtins.DEFAULT_SRC INCLUDE = object() @classmethod def setUpClass(cls): cls.pytype_dir = os.path.dirname(os.path.dirname(parser.__file__)) def setUp(self): self._ResetPytypeArgs() self.tmp_dir = tempfile.mkdtemp() self.errors_csv = os.path.join(self.tmp_dir, "errors.csv") def tearDown(self): shutil.rmtree(self.tmp_dir) def _ResetPytypeArgs(self): self.pytype_args = {"--python_exe": self.PYTHON_EXE, "--verbosity": 1} def _DataPath(self, filename): if os.path.dirname(filename) == self.tmp_dir: return filename return os.path.join(self.pytype_dir, "test_data/", filename) def _TmpPath(self, filename): return os.path.join(self.tmp_dir, filename) def _MakePyFile(self, contents): if utils.USE_ANNOTATIONS_BACKPORT: contents = test_base.WithAnnotationsImport(contents) return self._MakeFile(contents, extension=".py") def _MakeFile(self, contents, extension): contents = textwrap.dedent(contents) path = self._TmpPath( hashlib.md5(contents.encode("utf-8")).hexdigest() + extension) with open(path, "w") as f: print(contents, file=f) return path def _RunPytype(self, pytype_args_dict): """A single command-line call to the pytype binary. Typically you'll want to use _CheckTypesAndErrors or _InferTypesAndCheckErrors, which will set up the command-line arguments properly and check that the errors file is in the right state after the call. (The errors check is bundled in to avoid the user forgetting to call assertHasErrors() with no arguments when expecting no errors.) Args: pytype_args_dict: A dictionary of the arguments to pass to pytype, minus the binary name. For example, to run pytype simple.py --output=- the arguments should be {"simple.py": self.INCLUDE, "--output": "-"} """ pytype_exe = os.path.join(self.pytype_dir, "pytype") pytype_args = [pytype_exe] for arg, value in pytype_args_dict.items(): if value is not self.INCLUDE: arg += "=" + str(value) pytype_args.append(arg) p = subprocess.Popen(pytype_args, stdout=subprocess.PIPE, stderr=subprocess.PIPE) self.stdout, self.stderr = (s.decode("utf-8") for s in p.communicate()) self.returncode = p.returncode def _ParseString(self, string): """A wrapper for parser.parse_string that inserts the python version.""" return parser.parse_string(string, python_version=self.PYTHON_VERSION) def assertOutputStateMatches(self, **has_output): """Check that the output state matches expectations. If, for example, you expect the program to print something to stdout and nothing to stderr before exiting with an error code, you would write assertOutputStateMatches(stdout=True, stderr=False, returncode=True). Args: **has_output: Whether each output type should have output. """ output_types = {"stdout", "stderr", "returncode"} assert len(output_types) == len(has_output) for output_type in output_types: output_value = getattr(self, output_type) if has_output[output_type]: self.assertTrue(output_value, output_type + " unexpectedly empty") else: value = str(output_value) if len(value) > 50: value = value[:47] + "..." self.assertFalse( output_value, "Unexpected output to %s: %r" % (output_type, value)) def assertHasErrors(self, *expected_errors): with open(self.errors_csv, "r") as f: errors = list(csv.reader(f, delimiter=",")) num, expected_num = len(errors), len(expected_errors) try: self.assertEqual( num, expected_num, "Expected %d errors, got %d" % (expected_num, num)) for error, expected_error in zip(errors, expected_errors): self.assertEqual( expected_error, error[2], "Expected %r, got %r" % (expected_error, error[2])) except: print("\n".join(" | ".join(error) for error in errors), file=sys.stderr) raise def _SetUpChecking(self, filename): self.pytype_args[self._DataPath(filename)] = self.INCLUDE self.pytype_args["--check"] = self.INCLUDE def _CheckTypesAndErrors(self, filename, expected_errors): self._SetUpChecking(filename) self.pytype_args["--output-errors-csv"] = self.errors_csv self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=False, returncode=False) self.assertHasErrors(*expected_errors) def _InferTypesAndCheckErrors(self, filename, expected_errors): self.pytype_args[self._DataPath(filename)] = self.INCLUDE self.pytype_args["--output"] = "-" self.pytype_args["--output-errors-csv"] = self.errors_csv self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=True, stderr=False, returncode=False) self.assertHasErrors(*expected_errors) def assertInferredPyiEquals(self, expected_pyi=None, filename=None): assert bool(expected_pyi) != bool(filename) if filename: with open(self._DataPath(filename), "r") as f: expected_pyi = f.read() message = ("\n==Expected pyi==\n" + expected_pyi + "\n==Actual pyi==\n" + self.stdout) self.assertTrue( self._ParseString(self.stdout).ASTeq( self._ParseString(expected_pyi)), message) def GeneratePickledSimpleFile(self, pickle_name, verify_pickle=True): pickled_location = os.path.join(self.tmp_dir, pickle_name) self.pytype_args["--pythonpath"] = self.tmp_dir self.pytype_args["--pickle-output"] = self.INCLUDE self.pytype_args["--module-name"] = "simple" if verify_pickle: self.pytype_args["--verify-pickle"] = self.INCLUDE self.pytype_args["--output"] = pickled_location self.pytype_args[self._DataPath("simple.py")] = self.INCLUDE self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=False, returncode=0) self.assertTrue(os.path.exists(pickled_location)) return pickled_location def testPickledFileStableness(self): # Tests that the pickled format is stable under a constant PYTHONHASHSEED. l_1 = self.GeneratePickledSimpleFile("simple1.pickled") l_2 = self.GeneratePickledSimpleFile("simple2.pickled") with open(l_1, "rb") as f_1: with open(l_2, "rb") as f_2: self.assertEqual(f_1.read(), f_2.read()) def testGeneratePickledAst(self): self.GeneratePickledSimpleFile("simple.pickled", verify_pickle=True) def testGenerateUnverifiedPickledAst(self): self.GeneratePickledSimpleFile("simple.pickled", verify_pickle=False) def testPickleNoOutput(self): self.pytype_args["--pickle-output"] = self.INCLUDE self.pytype_args[self._DataPath("simple.py")] = self.INCLUDE self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=True, returncode=True) def testPickleBadOutput(self): self.pytype_args["--pickle-output"] = self.INCLUDE self.pytype_args["--output"] = os.path.join(self.tmp_dir, "simple.pyi") self.pytype_args[self._DataPath("simple.py")] = self.INCLUDE self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=True, returncode=True) def testBadVerifyPickle(self): self.pytype_args["--verify-pickle"] = self.INCLUDE self.pytype_args[self._DataPath("simple.py")] = self.INCLUDE self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=True, returncode=True) def testNonexistentOption(self): self.pytype_args["--rumpelstiltskin"] = self.INCLUDE self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=True, returncode=True) def testCfgTypegraphConflict(self): self._SetUpChecking("simple.py") output_path = self._TmpPath("simple.svg") self.pytype_args["--output-cfg"] = output_path self.pytype_args["--output-typegraph"] = output_path self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=True, returncode=True) def testCheckInferConflict(self): self.pytype_args["--check"] = self.INCLUDE self.pytype_args["--output"] = "-" self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=True, returncode=True) def testCheckInferConflict2(self): self.pytype_args["--check"] = self.INCLUDE self.pytype_args["input.py:output.pyi"] = self.INCLUDE self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=True, returncode=True) def testInputOutputPair(self): self.pytype_args[self._DataPath("simple.py") + ":-"] = self.INCLUDE self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=True, stderr=False, returncode=False) self.assertInferredPyiEquals(filename="simple.pyi") def testMultipleOutput(self): self.pytype_args["input.py:output1.pyi"] = self.INCLUDE self.pytype_args["--output"] = "output2.pyi" self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=True, returncode=True) def testGenerateBuiltinsInputConflict(self): self.pytype_args["--generate-builtins"] = "builtins.py" self.pytype_args["input.py"] = self.INCLUDE self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=True, returncode=True) def testGenerateBuiltinsPythonpathConflict(self): self.pytype_args["--generate-builtins"] = "builtins.py" self.pytype_args["--pythonpath"] = "foo:bar" self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=True, returncode=True) def testGenerateBuiltinsPy2(self): self.pytype_args["--generate-builtins"] = self._TmpPath("builtins.py") self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=False, returncode=False) def testGenerateBuiltinsPy3(self): self.pytype_args["--generate-builtins"] = self._TmpPath("builtins.py") self.pytype_args["--python_version"] = "3.6" self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=False, returncode=False) def testMissingInput(self): self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=True, returncode=True) def testMultipleInput(self): self.pytype_args["input1.py"] = self.INCLUDE self.pytype_args["input2.py"] = self.INCLUDE self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=True, returncode=True) def testBadInputFormat(self): self.pytype_args["input.py:output.pyi:rumpelstiltskin"] = self.INCLUDE self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=True, returncode=True) def testPytypeErrors(self): self._SetUpChecking("bad.py") self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=True, returncode=True) self.assertIn("[wrong-arg-types]", self.stderr) self.assertIn("[name-error]", self.stderr) def testPytypeErrorsCsv(self): self._SetUpChecking("bad.py") self.pytype_args["--output-errors-csv"] = self.errors_csv self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=False, returncode=False) self.assertHasErrors("wrong-arg-types", "name-error") def testPytypeErrorsNoReport(self): self._SetUpChecking("bad.py") self.pytype_args["--no-report-errors"] = self.INCLUDE self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=False, returncode=False) def testPytypeReturnSuccess(self): self._SetUpChecking("bad.py") self.pytype_args["--return-success"] = self.INCLUDE self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=True, returncode=False) self.assertIn("[wrong-arg-types]", self.stderr) self.assertIn("[name-error]", self.stderr) def testCompilerError(self): self._CheckTypesAndErrors("syntax.py", ["python-compiler-error"]) def testMultiLineStringTokenError(self): self._CheckTypesAndErrors("tokenerror1.py", ["python-compiler-error"]) def testMultiLineStatementTokenError(self): self._CheckTypesAndErrors("tokenerror2.py", ["python-compiler-error"]) def testComplex(self): self._CheckTypesAndErrors("complex.py", []) def testCheck(self): self._CheckTypesAndErrors("simple.py", []) def testReturnType(self): self._CheckTypesAndErrors( self._MakePyFile("""\ def f() -> int: return "foo" """), ["bad-return-type"]) def testUsageError(self): self._SetUpChecking( self._MakePyFile("""\ def f(): pass """)) # Set up a python version mismatch self.pytype_args["--python_version"] = "3.4" self.pytype_args["--output-errors-csv"] = self.errors_csv self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=True, returncode=True) def testSkipFile(self): filename = self._MakePyFile("""\ # pytype: skip-file """) self.pytype_args[self._DataPath(filename)] = self.INCLUDE self.pytype_args["--output"] = "-" self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=True, stderr=False, returncode=False) self.assertInferredPyiEquals(expected_pyi=self.DEFAULT_PYI) def testInfer(self): self._InferTypesAndCheckErrors("simple.py", []) self.assertInferredPyiEquals(filename="simple.pyi") def testInferPytypeErrors(self): self._InferTypesAndCheckErrors("bad.py", ["wrong-arg-types", "name-error"]) self.assertInferredPyiEquals(filename="bad.pyi") def testInferCompilerError(self): self._InferTypesAndCheckErrors("syntax.py", ["python-compiler-error"]) self.assertInferredPyiEquals(expected_pyi=self.DEFAULT_PYI) def testInferComplex(self): self._InferTypesAndCheckErrors("complex.py", []) self.assertInferredPyiEquals(filename="complex.pyi") def testCheckMain(self): self._SetUpChecking( self._MakePyFile("""\ def f(): name_error def g(): "".foobar g() """)) self.pytype_args["--main"] = self.INCLUDE self.pytype_args["--output-errors-csv"] = self.errors_csv self._RunPytype(self.pytype_args) self.assertHasErrors("attribute-error") def testInferToFile(self): self.pytype_args[self._DataPath("simple.py")] = self.INCLUDE pyi_file = self._TmpPath("simple.pyi") self.pytype_args["--output"] = pyi_file self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=False, returncode=False) with open(pyi_file, "r") as f: pyi = f.read() with open(self._DataPath("simple.pyi"), "r") as f: expected_pyi = f.read() self.assertTrue( self._ParseString(pyi).ASTeq(self._ParseString(expected_pyi))) def testParsePyi(self): self.pytype_args[self._DataPath("complex.pyi")] = self.INCLUDE self.pytype_args["--parse-pyi"] = self.INCLUDE self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=False, returncode=False) def testPytree(self): """Test pytype on a real-world program.""" self.pytype_args["--quick"] = self.INCLUDE self._InferTypesAndCheckErrors("pytree.py", [ "import-error", "import-error", "attribute-error", "attribute-error", "attribute-error", "name-error" ]) ast = self._ParseString(self.stdout) self.assertListEqual(["convert", "generate_matches", "type_repr"], [f.name for f in ast.functions]) self.assertListEqual([ "Base", "BasePattern", "Leaf", "LeafPattern", "NegatedPattern", "Node", "NodePattern", "WildcardPattern" ], [c.name for c in ast.classes]) def testNoAnalyzeAnnotated(self): filename = self._MakePyFile("""\ def f() -> str: return 42 """) self._InferTypesAndCheckErrors(self._DataPath(filename), []) def testAnalyzeAnnotated(self): filename = self._MakePyFile("""\ def f() -> str: return 42 """) self.pytype_args["--analyze-annotated"] = self.INCLUDE self._InferTypesAndCheckErrors(self._DataPath(filename), ["bad-return-type"]) def testRunPytype(self): """Basic unit test (smoke test) for _run_pytype.""" # TODO(kramm): This is a unit test, whereas all other tests in this file # are integration tests. Move this somewhere else? infile = self._TmpPath("input") outfile = self._TmpPath("output") with open(infile, "w") as f: f.write("def f(x): pass") argv = ["-o", outfile, infile] options = config.Options(argv) main_module._run_pytype(options) self.assertTrue(os.path.isfile(outfile)) def testGenerateAndUseBuiltins(self): """Test for --generate-builtins.""" filename = self._TmpPath("builtins.pickle") # Generate builtins pickle self.pytype_args["--generate-builtins"] = filename self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=False, returncode=False) self.assertTrue(os.path.isfile(filename)) src = self._MakePyFile("""\ import __future__ import sys import collections import typing """) # Use builtins pickle self._ResetPytypeArgs() self._SetUpChecking(src) self.pytype_args["--precompiled-builtins"] = filename self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=False, returncode=False) def testUseBuiltinsAndImportMap(self): """Test for --generate-builtins.""" filename = self._TmpPath("builtins.pickle") # Generate builtins pickle self.pytype_args["--generate-builtins"] = filename self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=False, returncode=False) self.assertTrue(os.path.isfile(filename)) # input files canary = "import pytypecanary" if typeshed.Typeshed.MISSING_FILE else "" src = self._MakePyFile("""\ import __future__ import sys import collections import typing import foo import csv import ctypes import xml.etree.ElementTree as ElementTree import md5 %s x = foo.x y = csv.writer z = md5.new """ % canary) pyi = self._MakeFile("""\ import datetime x = ... # type: datetime.tzinfo """, extension=".pyi") # Use builtins pickle with an imports map self._ResetPytypeArgs() self._SetUpChecking(src) self.pytype_args["--precompiled-builtins"] = filename self.pytype_args["--imports_info"] = self._MakeFile("""\ typing /dev/null foo %s """ % pyi, extension="") self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=False, returncode=False) @unittest.skip("Where do the pickles differ?") def testBuiltinsDeterminism(self): f1 = self._TmpPath("builtins1.pickle") f2 = self._TmpPath("builtins2.pickle") self.pytype_args["--generate-builtins"] = f1 self._RunPytype(self.pytype_args) self.pytype_args["--generate-builtins"] = f2 self._RunPytype(self.pytype_args) with open(f1, "rb") as pickle1: with open(f2, "rb") as pickle2: self.assertEqual(pickle1.read(), pickle2.read()) def testTimeout(self): # Note: At the time of this writing, pickling builtins takes well over one # second (~10s). If it ever was to get faster, this test would become flaky. self.pytype_args["--timeout"] = 1 self.pytype_args["--generate-builtins"] = self._TmpPath( "builtins.pickle") self._RunPytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=False, returncode=True)
def setUpClass(cls): cls.PYTHON_EXE = utils.get_python_exe(cls.PYTHON_VERSION) # This is the default loader. It might get shadowed. cls.loader = load_pytd.Loader(None, cls.PYTHON_VERSION)