def main(toplevels, is_main_module=True): """The main method for tests subclassing one of the above classes. This function should be called unconditionally, and typically as follows: main(globals(), __name__ == "__main__") This enables one to run the tests using the 'python -m unittest ...' command, which does run the main test module as the main interpreter module. Call to unittest.main is made only if |is_main_module| is true. Arguments: toplevels: The toplevels defined in the main test module. is_main_module: True if the main test module is the main module in the interpreter. """ # In Python 3.5, some tests shouldn't run. tests_to_delete_35 = [] # We set a python_version attribute on every test class. python_versions = {} # For tests that we want to run under multiple target Python versions, we # create a subclass for each additional version. new_tests = {} for name, tp in toplevels.items(): if not isinstance(tp, type) or not issubclass(tp, BaseTest): continue if sys.version_info.minor < 6 and issubclass(tp, TargetPython3FeatureTest): # Many of our Python 3 feature tests are Python 3.6+, since they use # PEP 526-style variable annotations. tests_to_delete_35.append(name) continue if hasattr(tp, "PY_MAJOR_VERSIONS"): versions = sorted(tp.PY_MAJOR_VERSIONS, reverse=True) else: versions = [3] assert versions, "Must specify at least one Python major version" assert not hasattr(tp, "python_version"), ( "Do not set python_version directly; use PY_MAJOR_VERSIONS") # We can't set python_version yet, since that would cause the assertion that # python_version is not defined to fail on subclasses of tp. python_versions[tp] = utils.full_version_from_major(versions[0]) for version in versions[1:]: name = "%sPy%d" % (name, version) subtest = type(name, (tp,), {"python_version": utils.full_version_from_major(version)}) new_tests[name] = subtest for name in tests_to_delete_35: del toplevels[name] for tp, version in python_versions.items(): setattr(tp, "python_version", version) toplevels.update(new_tests) if is_main_module: unittest.main()
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)
class Python3Test(unittest.TestCase): """Tests for load_pytd.py on (target) Python 3.""" python_version = utils.full_version_from_major(3) def setUp(self): super(Python3Test, self).setUp() self.options = config.Options.create( python_version=self.python_version) def test_python3_builtins(self): # Test that we read python3 builtins from builtin.pytd if we pass a python3 # version to the loader. with file_utils.Tempdir() as d: d.create_file( "a.pyi", """ from typing import AsyncContextManager class A(AsyncContextManager[str]): ...""") loader = load_pytd.Loader("base", python_version=self.python_version, pythonpath=[d.path]) a = loader.import_name("a") cls = a.Lookup("a.A") self.assertEqual("AsyncContextManager[str]", pytd_utils.Print(cls.parents[0]))
def test_generate_builtins_py3(self): self.pytype_args["--generate-builtins"] = self._tmp_path("builtins.py") self.pytype_args["--python_version"] = utils.format_version( utils.full_version_from_major(3)) self._run_pytype(self.pytype_args) self.assertOutputStateMatches(stdout=False, stderr=False, returncode=False)
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)
def test_full_version_from_major3(self): major, _ = utils.full_version_from_major(3) self.assertEqual(major, 3)
def test_full_version_from_major2(self): self.assertEqual(utils.full_version_from_major(2), (2, 7))
class UnitTest(unittest.TestCase): """Base class for tests that specify a target Python version.""" python_version = utils.full_version_from_major(3)
def test_builtins_determinism3(self): f1, f2 = self._generate_builtins_twice( utils.format_version(utils.full_version_from_major(3))) self.assertBuiltinsPickleEqual(f1, f2)