class StringlikeHashRandomizationTests(HashRandomizationTests): if check_impl_detail(pypy=True): EMPTY_STRING_HASH = -1 else: EMPTY_STRING_HASH = 0 def test_null_hash(self): # PYTHONHASHSEED=0 disables the randomized hash if IS_64BIT: known_hash_of_obj = 1453079729188098211 else: known_hash_of_obj = -1600925533 # Randomization is disabled by default: self.assertEqual(self.get_hash(self.repr_), known_hash_of_obj) # It can also be disabled by setting the seed to 0: self.assertEqual(self.get_hash(self.repr_, seed=0), known_hash_of_obj) def test_fixed_hash(self): # test a fixed seed for the randomized hash # Note that all types share the same values: if IS_64BIT: if sys.byteorder == 'little': h = -4410911502303878509 else: h = -3570150969479994130 else: if sys.byteorder == 'little': h = -206076799 else: h = -1024014457 self.assertEqual(self.get_hash(self.repr_, seed=42), h)
def test_getbuffer(self): memio = self.ioclass(b"1234567890") buf = memio.getbuffer() self.assertEqual(bytes(buf), b"1234567890") memio.seek(5) buf = memio.getbuffer() self.assertEqual(bytes(buf), b"1234567890") # Trying to change the size of the BytesIO while a buffer is exported # raises a BufferError. if support.check_impl_detail(pypy=False): # PyPy export buffers differently, and allows reallocation # of the underlying object. self.assertRaises(BufferError, memio.write, b'x' * 100) self.assertRaises(BufferError, memio.truncate) self.assertRaises(BufferError, memio.close) self.assertFalse(memio.closed) # Mutating the buffer updates the BytesIO buf[3:6] = b"abc" self.assertEqual(bytes(buf), b"123abc7890") self.assertEqual(memio.getvalue(), b"123abc7890") # After the buffer gets released, we can resize and close the BytesIO # again del buf support.gc_collect() memio.truncate() memio.close() self.assertRaises(ValueError, memio.getbuffer)
def check_resurrecting_chain(self, classes): if support.check_impl_detail(pypy=True): self.skipTest("in CPython, in a cycle of objects with __del__(), " "all the __del__() are called even if some of them " "resurrect. In PyPy the recurrection will stop " "the other objects from being considered as dead.") N = len(classes) with SimpleBase.test(): nodes = self.build_chain(classes) N = len(nodes) ids = [id(s) for s in nodes] survivor_ids = [ id(s) for s in nodes if isinstance(s, SimpleResurrector) ] wrs = [weakref.ref(s) for s in nodes] del nodes gc.collect() self.assert_del_calls(ids) self.assert_survivors(survivor_ids) # XXX desirable? self.assertEqual([wr() for wr in wrs], [None] * N) self.clear_survivors() gc.collect() self.assert_del_calls(ids) self.assert_survivors([])
def test_basic_script(self): with temp_dir() as script_dir: script_name = _make_test_script(script_dir, 'script') package = '' if support.check_impl_detail(pypy=True) else None self._check_script(script_name, script_name, script_name, script_dir, package, importlib.machinery.SourceFileLoader)
def interactive_python(self, separate_stderr=False): if separate_stderr: p = spawn_python('-i', bufsize=1, stderr=subprocess.PIPE) stderr = p.stderr else: p = spawn_python('-i', bufsize=1, stderr=subprocess.STDOUT) stderr = p.stdout try: # Drain stderr until prompt if support.check_impl_detail(pypy=True): ps1 = b">>>> " # PyPy: the prompt is still printed to stdout, like it # is in CPython 2.7. This messes up the logic below # if stdout and stderr are different. Skip for now. if separate_stderr: self.skipTest("the prompt is still written to " "stdout in pypy") else: ps1 = b">>> " # logic fixed to support the case of lines that are shorter # than len(ps1) characters got = b"" while not got.endswith(ps1): got += stderr.read(1) yield p finally: kill_python(p) stderr.close()
def test_excluding_predicates(self): self.istest(inspect.isbuiltin, 'sys.exit') if check_impl_detail(): self.istest(inspect.isbuiltin, '[].append') self.istest(inspect.iscode, 'mod.spam.func_code') self.istest(inspect.isframe, 'tb.tb_frame') self.istest(inspect.isfunction, 'mod.spam') self.istest(inspect.ismethod, 'mod.StupidGit.abuse') self.istest(inspect.ismethod, 'git.argue') self.istest(inspect.ismodule, 'mod') self.istest(inspect.istraceback, 'tb') self.istest(inspect.isdatadescriptor, '__builtin__.file.closed') self.istest(inspect.isdatadescriptor, '__builtin__.file.softspace') self.istest(inspect.isgenerator, '(x for x in xrange(2))') self.istest(inspect.isgeneratorfunction, 'generator_function_example') if hasattr(types, 'GetSetDescriptorType'): self.istest(inspect.isgetsetdescriptor, 'type(tb.tb_frame).f_locals') else: self.assertFalse( inspect.isgetsetdescriptor(type(tb.tb_frame).f_locals)) if hasattr(types, 'MemberDescriptorType'): # App-level slots are member descriptors on both PyPy and # CPython, but the various built-in attributes are all # getsetdescriptors on PyPy. So check ismemberdescriptor() # with an app-level slot. self.istest(inspect.ismemberdescriptor, 'ExampleClassWithSlot.myslot') else: self.assertFalse( inspect.ismemberdescriptor(datetime.timedelta.days))
def test_getsitepackages(self): site.PREFIXES = ['xoxo'] dirs = site.getsitepackages() if check_impl_detail(pypy=True): self.assertEqual(len(dirs), 1) wanted = os.path.join('xoxo', 'site-packages') self.assertEqual(dirs[0], wanted) elif (sys.platform == "darwin" and sysconfig.get_config_var("PYTHONFRAMEWORK")): # OS X framework builds site.PREFIXES = ['Python.framework'] dirs = site.getsitepackages() self.assertEqual(len(dirs), 2) wanted = os.path.join('/Library', sysconfig.get_config_var("PYTHONFRAMEWORK"), '%d.%d' % sys.version_info[:2], 'site-packages') self.assertEqual(dirs[1], wanted) elif os.sep == '/': # OS X non-framework builds, Linux, FreeBSD, etc self.assertEqual(len(dirs), 1) wanted = os.path.join('xoxo', 'lib', 'python%d.%d' % sys.version_info[:2], 'site-packages') self.assertEqual(dirs[0], wanted) else: # other platforms self.assertEqual(len(dirs), 2) self.assertEqual(dirs[0], 'xoxo') wanted = os.path.join('xoxo', 'lib', 'site-packages') self.assertEqual(dirs[1], wanted)
def test_no_len_for_infinite_repeat(self): # The repeat() object can also be infinite if support.check_impl_detail(pypy=True): # 3.4 (PEP 424) behavior self.assertEqual(len(repeat(None)), NotImplemented) else: self.assertRaises(TypeError, len, repeat(None))
def test_main(verbose=None): from test import test_code run_doctest(test_code, verbose) tests = [CodeTest, CodeConstsTest, CodeWeakRefTest] if check_impl_detail(cpython=True) and ctypes is not None: tests.append(CoExtra) run_unittest(*tests)
def test_popitem(self): # dict.popitem() for copymode in -1, +1: # -1: b has same structure as a # +1: b is a.copy() for log2size in range(12): size = 2**log2size a = {} b = {} for i in range(size): a[repr(i)] = i if copymode < 0: b[repr(i)] = i if copymode > 0: b = a.copy() for i in range(size): ka, va = ta = a.popitem() self.assertEqual(va, int(ka)) kb, vb = tb = b.popitem() self.assertEqual(vb, int(kb)) if support.check_impl_detail(): self.assertFalse(copymode < 0 and ta != tb) self.assertFalse(a) self.assertFalse(b) d = {} self.assertRaises(KeyError, d.popitem)
def test_excluding_predicates(self): self.istest(inspect.isbuiltin, 'sys.exit') if check_impl_detail(): self.istest(inspect.isbuiltin, '[].append') self.istest(inspect.iscode, 'mod.spam.__code__') self.istest(inspect.isframe, 'tb.tb_frame') self.istest(inspect.isfunction, 'mod.spam') self.istest(inspect.isfunction, 'mod.StupidGit.abuse') self.istest(inspect.ismethod, 'git.argue') self.istest(inspect.ismodule, 'mod') self.istest(inspect.istraceback, 'tb') self.istest(inspect.isdatadescriptor, 'collections.defaultdict.default_factory') self.istest(inspect.isgenerator, '(x for x in range(2))') self.istest(inspect.isgeneratorfunction, 'generator_function_example') if hasattr(types, 'GetSetDescriptorType'): self.istest(inspect.isgetsetdescriptor, 'type(tb.tb_frame).f_locals') else: self.assertFalse( inspect.isgetsetdescriptor(type(tb.tb_frame).f_locals)) if hasattr(types, 'MemberDescriptorType'): self.istest(inspect.ismemberdescriptor, 'type(lambda: None).__globals__') else: self.assertFalse( inspect.ismemberdescriptor(datetime.timedelta.days))
def test_invalid_identitifer(self): m = ast.Module([ast.Expr(ast.Name(42, ast.Load()))]) ast.fix_missing_locations(m) with self.assertRaises(TypeError) as cm: compile(m, "<test>", "exec") if support.check_impl_detail(): self.assertIn("identifier must be of type str", str(cm.exception))
def test_invalid_string(self): m = ast.Module([ast.Expr(ast.Str(42))]) ast.fix_missing_locations(m) with self.assertRaises(TypeError) as cm: compile(m, "<test>", "exec") if support.check_impl_detail(): self.assertIn("string must be of type str or uni", str(cm.exception))
def test_basic_script(self): with support.temp_dir() as script_dir: script_name = _make_test_script(script_dir, 'script') package = '' if support.check_impl_detail(pypy=True) else None self._check_script(script_name, script_name, script_name, script_dir, package, importlib.machinery.SourceFileLoader)
def test_unhandled(self): # Check for sensible reporting of unhandled exceptions for exc_type in (ValueError, BrokenStrException): with self.subTest(exc_type): try: exc = exc_type("test message") # The following line is included in the traceback report: raise exc except exc_type: with captured_stderr() as stderr: sys.__excepthook__(*sys.exc_info()) report = stderr.getvalue() self.assertIn("test_exceptions.py", report) self.assertIn("raise exc", report) self.assertIn(exc_type.__name__, report) if exc_type is BrokenStrException: if check_impl_detail(pypy=False): self.assertIn("<exception str() failed>", report) else: # pypy: this is what lib-python's traceback.py gives self.assertIn( "<unprintable BrokenStrException object>", report) else: self.assertIn("test message", report) self.assertTrue(report.endswith("\n"))
def test_former_statements_refer_to_builtins(self): keywords = "print", "exec" # Cases where we want the custom error cases = [ "{} foo", "{} {{1:foo}}", "if 1: {} foo", "if 1: {} {{1:foo}}", "if 1:\n {} foo", "if 1:\n {} {{1:foo}}", ] for keyword in keywords: custom_msg = "call to '{}'".format(keyword) for case in cases: source = case.format(keyword) with self.subTest(source=source): with self.assertRaisesRegex(SyntaxError, custom_msg): exec(source) source = source.replace("foo", "(foo.)") # PyPy's parser also detects the same "Missing parentheses" # if there are some parentheses later in the line # (above, the cases that contain '{1:'). # CPython gives up in this case. if check_impl_detail(pypy=True) and '{1:' in source: expected = custom_msg else: expected = "invalid syntax" with self.subTest(source=source): with self.assertRaisesRegex(SyntaxError, expected): exec(source)
def test_invalid_sum(self): pos = dict(lineno=2, col_offset=3) m = ast.Module([ast.Expr(ast.expr(**pos), **pos)]) with self.assertRaises(TypeError) as cm: compile(m, "<test>", "exec") if support.check_impl_detail(): self.assertIn("but got <_ast.expr", str(cm.exception))
def testModule(self): with open(__file__, "rb") as f: code = f.read() if __file__.endswith(".py"): code = compile(code, __file__, "exec") self.helper(code) self.helper3(code, check_sharing=support.check_impl_detail())
def test_one(n): global mutate, dict1, dict2, dict1keys, dict2keys # Fill the dicts without mutating them. mutate = 0 dict1keys = fill_dict(dict1, range(n), n) dict2keys = fill_dict(dict2, range(n), n) # Enable mutation, then compare the dicts so long as they have the # same size. mutate = 1 if verbose: print("trying w/ lengths", len(dict1), len(dict2), end=' ') while dict1 and len(dict1) == len(dict2): if verbose: print(".", end=' ') try: c = dict1 == dict2 except RuntimeError: # CPython never raises RuntimeError here, but other implementations # might, and it's fine. if check_impl_detail(cpython=True): raise if verbose: print()
def test_builtin_function(self): eq = self.assertEqual # Functions eq(repr(hash), "<built-in function hash>") # Methods if check_impl_detail(pypy=False): self.assertTrue(repr("".split).startswith("<built-in method split of str object at 0x"))
def test_c_buffer_raw(self): buf = c_buffer(32) buf.raw = memoryview(b"Hello, World") self.assertEqual(buf.value, b"Hello, World") if support.check_impl_detail(): self.assertRaises(TypeError, setattr, buf, "value", memoryview(b"abc")) self.assertRaises(ValueError, setattr, buf, "raw", memoryview(b"x" * 100))
def test_builtin_function(self): eq = self.assertEqual # Functions eq(repr(hash), '<built-in function hash>') # Methods if check_impl_detail(pypy=False): self.assertTrue(repr(''.split).startswith( '<built-in method split of str object at 0x'))
def test_select_mutated(self): a = [] class F: def fileno(self): del a[-1] return sys.__stdout__.fileno() a[:] = [F()] * 10 result = select.select([], a, []) # CPython: 'a' ends up with 5 items, because each fileno() # removes an item and at the middle the iteration stops. # PyPy: 'a' ends up empty, because the iteration is done on # a copy of the original list: fileno() is called 10 times. if support.check_impl_detail(cpython=True): self.assertEqual(len(result[1]), 5) self.assertEqual(len(a), 5) if support.check_impl_detail(pypy=True): self.assertEqual(len(result[1]), 10) self.assertEqual(len(a), 0)
def test_bad_indentation(self): err = self.get_exception_format(self.syntax_error_bad_indentation, IndentationError) self.assertEqual(len(err), 4) self.assertEqual(err[1].strip(), "print(2)") if check_impl_detail(): # on CPython, there is a "^" at the end of the line on PyPy, # there is a "^" too, but at the start, more logically self.assertIn("^", err[2]) self.assertEqual(err[1].find(")"), err[2].find("^"))
def testOpenDel(self): # "Test opening and deleting a file many times" self.createTempFile() for i in range(10000): if support.check_impl_detail(pypy=True): with BZ2File(self.filename) as o: pass else: o = BZ2File(self.filename) del o
def test_script_compiled(self): with support.temp_dir() as script_dir: script_name = _make_test_script(script_dir, 'script') py_compile.compile(script_name, doraise=True) os.remove(script_name) pyc_file = support.make_legacy_pyc(script_name) package = '' if support.check_impl_detail(pypy=True) else None self._check_script(pyc_file, pyc_file, pyc_file, script_dir, package, importlib.machinery.SourcelessFileLoader)
def test_script_compiled(self): with temp_dir() as script_dir: script_name = _make_test_script(script_dir, 'script') py_compile.compile(script_name, doraise=True) os.remove(script_name) pyc_file = support.make_legacy_pyc(script_name) package = '' if support.check_impl_detail(pypy=True) else None self._check_script(pyc_file, pyc_file, pyc_file, script_dir, package, importlib.machinery.SourcelessFileLoader)
def test_bad_integer(self): # issue13436: Bad error message with invalid numeric values body = [ast.ImportFrom(module='time', names=[ast.alias(name='sleep')], level=None, lineno=None, col_offset=None)] mod = ast.Module(body) with self.assertRaises((TypeError, ValueError)) as cm: compile(mod, 'test', 'exec') if support.check_impl_detail(): self.assertIn("invalid integer value: None", str(cm.exception))
def test_issue9319(self): path = os.path.dirname(__file__) try: imp.find_module("badsyntax_pep3120", [path]) except SyntaxError: pass else: # PyPy's find_module won't raise a SyntaxError when checking # the file's magic encoding comment, the point of the test # is to ensure no seg fault anyway self.assertTrue(support.check_impl_detail(cpython=False))
def test_bad_single_statement(self): self.assertInvalidSingle('1\n2') if check_impl_detail(): # it's a single statment in PyPy self.assertInvalidSingle('def f(): pass') self.assertInvalidSingle('a = 13\nb = 187') self.assertInvalidSingle('del x\ndel y') self.assertInvalidSingle('f()\ng()') self.assertInvalidSingle('f()\n# blah\nblah()') self.assertInvalidSingle('f()\nxy # blah\nblah()') self.assertInvalidSingle('x = 5 # comment\nx = 6\n')
def test_abs_paths(self): # Make sure all imported modules have their __file__ and __cached__ # attributes as absolute paths. Arranging to put the Lib directory on # PYTHONPATH would cause the os module to have a relative path for # __file__ if abs_paths() does not get run. sys and builtins (the # only other modules imported before site.py runs) do not have # __file__ or __cached__ because they are built-in. try: parent = os.path.relpath(os.path.dirname(os.__file__)) cwd = os.getcwd() except ValueError: # Failure to get relpath probably means we need to chdir # to the same drive. cwd, parent = os.path.split(os.path.dirname(os.__file__)) with change_cwd(cwd): env = os.environ.copy() env['PYTHONPATH'] = parent code = ( 'import os, sys', # use ASCII to avoid locale issues with non-ASCII directories 'os_file = os.__file__.encode("ascii", "backslashreplace")', r'sys.stdout.buffer.write(os_file + b"\n")', 'os_cached = os.__cached__.encode("ascii", "backslashreplace")', r'sys.stdout.buffer.write(os_cached + b"\n")') command = '\n'.join(code) # First, prove that with -S (no 'import site'), the paths are # relative. proc = subprocess.Popen([sys.executable, '-S', '-c', command], env=env, stdout=subprocess.PIPE) stdout, stderr = proc.communicate() self.assertEqual(proc.returncode, 0) os__file__, os__cached__ = stdout.splitlines()[:2] if check_impl_detail(cpython=True): # XXX: should probably match cpython self.assertFalse(os.path.isabs(os__file__)) self.assertFalse(os.path.isabs(os__cached__)) # Now, with 'import site', it works. proc = subprocess.Popen([sys.executable, '-c', command], env=env, stdout=subprocess.PIPE) stdout, stderr = proc.communicate() self.assertEqual(proc.returncode, 0) os__file__, os__cached__ = stdout.splitlines()[:2] self.assertTrue( os.path.isabs(os__file__), "expected absolute path, got {}".format( os__file__.decode('ascii'))) self.assertTrue( os.path.isabs(os__cached__), "expected absolute path, got {}".format( os__cached__.decode('ascii')))
def testSetattrWrapperNameIntern(self): # Issue #25794: __setattr__ should intern the attribute name class A: pass def add(self, other): return 'summa' name = str(b'__add__', 'ascii') # shouldn't be optimized if support.check_impl_detail(): self.assertIsNot(name, '__add__') # not interned type.__setattr__(A, name, add) self.assertEqual(A() + 1, 'summa') name2 = str(b'__add__', 'ascii') if support.check_impl_detail(): self.assertIsNot(name2, '__add__') self.assertIsNot(name2, name) type.__delattr__(A, name2) with self.assertRaises(TypeError): A() + 1
def test_setitem_writable(self): if not self.rw_type: self.skipTest("no writable type to test") tp = self.rw_type b = self.rw_type(self._source) oldrefcount = getrefcount(b) m = self._view(b) m[0] = ord(b'1') self._check_contents(tp, b, b"1bcdef") m[0:1] = tp(b"0") self._check_contents(tp, b, b"0bcdef") m[1:3] = tp(b"12") self._check_contents(tp, b, b"012def") m[1:1] = tp(b"") self._check_contents(tp, b, b"012def") m[:] = tp(b"abcdef") self._check_contents(tp, b, b"abcdef") # Overlapping copies of a view into itself m[0:3] = m[2:5] self._check_contents(tp, b, b"cdedef") m[:] = tp(b"abcdef") m[2:5] = m[0:3] self._check_contents(tp, b, b"ababcf") def setitem(key, value): m[key] = tp(value) # Bounds checking self.assertRaises(IndexError, setitem, 6, b"a") self.assertRaises(IndexError, setitem, -7, b"a") self.assertRaises(IndexError, setitem, sys.maxsize, b"a") self.assertRaises(IndexError, setitem, -sys.maxsize, b"a") # Wrong index/slice types self.assertRaises(TypeError, setitem, 0.0, b"a") if check_impl_detail(): self.assertRaises(TypeError, setitem, (0, ), b"a") self.assertRaises(TypeError, setitem, (slice(0, 1, 1), 0), b"a") self.assertRaises(TypeError, setitem, (0, slice(0, 1, 1)), b"a") self.assertRaises(TypeError, setitem, (0, ), b"a") self.assertRaises(TypeError, setitem, "a", b"a") # Not implemented: multidimensional slices slices = (slice(0, 1, 1), slice(0, 1, 2)) self.assertRaises(NotImplementedError, setitem, slices, b"a") # Trying to resize the memory object exc = ValueError if m.format == 'c' else TypeError self.assertRaises(exc, setitem, 0, b"") self.assertRaises(exc, setitem, 0, b"ab") self.assertRaises(ValueError, setitem, slice(1, 1), b"a") self.assertRaises(ValueError, setitem, slice(0, 2), b"a") m = None self.assertEqual(getrefcount(b), oldrefcount)
def test_method_lookup(self): f = self.do_create() wr = weakref.ref(f) write = f.write write2 = f.write del f write(b'foo') del write write2(b'bar') del write2 if support.check_impl_detail(cpython=True): self.assertIsNone(wr())
def test_setitem_writable(self): if not self.rw_type: self.skipTest("no writable type to test") tp = self.rw_type b = self.rw_type(self._source) oldrefcount = getrefcount(b) m = self._view(b) m[0] = ord(b'1') self._check_contents(tp, b, b"1bcdef") m[0:1] = tp(b"0") self._check_contents(tp, b, b"0bcdef") m[1:3] = tp(b"12") self._check_contents(tp, b, b"012def") m[1:1] = tp(b"") self._check_contents(tp, b, b"012def") m[:] = tp(b"abcdef") self._check_contents(tp, b, b"abcdef") # Overlapping copies of a view into itself m[0:3] = m[2:5] self._check_contents(tp, b, b"cdedef") m[:] = tp(b"abcdef") m[2:5] = m[0:3] self._check_contents(tp, b, b"ababcf") def setitem(key, value): m[key] = tp(value) # Bounds checking self.assertRaises(IndexError, setitem, 6, b"a") self.assertRaises(IndexError, setitem, -7, b"a") self.assertRaises(IndexError, setitem, sys.maxsize, b"a") self.assertRaises(IndexError, setitem, -sys.maxsize, b"a") # Wrong index/slice types self.assertRaises(TypeError, setitem, 0.0, b"a") if check_impl_detail(): self.assertRaises(TypeError, setitem, (0,), b"a") self.assertRaises(TypeError, setitem, (slice(0,1,1), 0), b"a") self.assertRaises(TypeError, setitem, (0, slice(0,1,1)), b"a") self.assertRaises(TypeError, setitem, (0,), b"a") self.assertRaises(TypeError, setitem, "a", b"a") # Not implemented: multidimensional slices slices = (slice(0,1,1), slice(0,1,2)) self.assertRaises(NotImplementedError, setitem, slices, b"a") # Trying to resize the memory object exc = ValueError if m.format == 'c' else TypeError self.assertRaises(exc, setitem, 0, b"") self.assertRaises(exc, setitem, 0, b"ab") self.assertRaises(ValueError, setitem, slice(1,1), b"a") self.assertRaises(ValueError, setitem, slice(0,2), b"a") m = None self.assertEqual(getrefcount(b), oldrefcount)
def testSyntaxErrorOffset(self): def check(src, lineno, offset): with self.assertRaises(SyntaxError) as cm: compile(src, '<fragment>', 'exec') self.assertEqual(cm.exception.lineno, lineno) self.assertEqual(cm.exception.offset, offset) is_pypy = check_impl_detail(pypy=True) check('def fact(x):\n\treturn x!\n', 2, 10) check('1 +\n', 1, 4 - is_pypy) check('def spam():\n print(1)\n print(2)', 3, 0 if is_pypy else 10) check('Python = "Python" +', 1, 20 - is_pypy) check('Python = "\u1e54\xfd\u0163\u0125\xf2\xf1" +', 1, 20 - is_pypy)
def test_AST_objects(self): if not support.check_impl_detail(): # PyPy also provides a __dict__ to the ast.AST base class. return x = ast.AST() self.assertEqual(x._fields, ()) with self.assertRaises(AttributeError): x.vararg with self.assertRaises(TypeError): # "_ast.AST constructor takes 0 positional arguments" ast.AST(2)
def test_uninitialized(self): # An uninitialized module has no __dict__ or __name__, # and __doc__ is None foo = ModuleType.__new__(ModuleType) self.assertFalse(foo.__dict__) if check_impl_detail(): self.assertTrue(foo.__dict__ is None) self.assertRaises(SystemError, dir, foo) try: s = foo.__name__ self.fail("__name__ = %s" % repr(s)) except AttributeError: pass self.assertEqual(foo.__doc__, ModuleType.__doc__)
def blowstack(fxn, arg, compare_to): # Make sure that calling isinstance with a deeply nested tuple for its # argument will raise RuntimeError eventually. tuple_arg = (compare_to,) if support.check_impl_detail(cpython=True): RECURSION_LIMIT = sys.getrecursionlimit() else: # on non-CPython implementations, the maximum actual recursion # limit might be higher, but probably not higher than 99999 RECURSION_LIMIT = 99999 for cnt in range(RECURSION_LIMIT + 5): tuple_arg = (tuple_arg,) fxn(arg, tuple_arg)
def test_method_lookup(self): # Issue #18879: Looking up a temporary file method should keep it # alive long enough. f = self.do_create() wr = weakref.ref(f) write = f.write write2 = f.write del f write(b"foo") del write write2(b"bar") del write2 if support.check_impl_detail(cpython=True): # No reference cycle was created. self.assertIsNone(wr())
def test_keep_buffer(self): # See bug 14212 b = bytearray(b'x') it = re.finditer(b'a', b) if check_impl_detail(pypy=False): # PyPy export buffers differently, and allows reallocation # of the underlying object. with self.assertRaises(BufferError): b.extend(b'x'*400) else: b.extend(b'x'*400) list(it) del it gc_collect() b.extend(b'x'*400)
def test_int_subclass_with_index(self): # __index__ should be used when computing indices, even for int # subclasses. See issue #17576. class MyInt(int): def __index__(self): return int(self) + 1 my_int = MyInt(7) direct_index = my_int.__index__() operator_index = operator.index(my_int) self.assertEqual(direct_index, 8) if support.check_impl_detail(): self.assertEqual(operator_index, 7) else: self.assertEqual(operator_index, 8) # Both results should be of exact type int. self.assertIs(type(direct_index), int)
def test_binary_subscr_on_unicode(self): if check_impl_detail(pypy=False): # valid code get optimized asm = dis_single('"foo"[0]') self.assertIn("('f')", asm) self.assertNotIn('BINARY_SUBSCR', asm) asm = dis_single('"\u0061\uffff"[1]') self.assertIn("('\\uffff')", asm) self.assertNotIn('BINARY_SUBSCR', asm) # invalid code doesn't get optimized # out of range asm = dis_single('"fuu"[10]') self.assertIn('BINARY_SUBSCR', asm) # non-BMP char (see #5057) asm = dis_single('"\U00012345"[0]') self.assertIn('BINARY_SUBSCR', asm)
def test_descriptors(self): eq = self.assertEqual # method descriptors if check_impl_detail(pypy=False): eq(repr(dict.items), "<method 'items' of 'dict' objects>") # XXX member descriptors # XXX attribute descriptors # XXX slot descriptors # static and class methods class C: def foo(cls): pass x = staticmethod(C.foo) self.assertTrue(repr(x).startswith("<staticmethod object at 0x")) x = classmethod(C.foo) self.assertTrue(repr(x).startswith("<classmethod object at 0x"))
def test_hash_randomization(self): # Verify that -R enables hash randomization: self.verify_valid_flag('-R') hashes = [] for i in range(2): code = 'print(hash("spam"))' rc, out, err = assert_python_ok('-R', '-c', code) self.assertEqual(rc, 0) hashes.append(out) if check_impl_detail(pypy=False): # PyPy does not really implement it! self.assertNotEqual(hashes[0], hashes[1]) # Verify that sys.flags contains hash_randomization code = 'import sys; print("random is", sys.flags.hash_randomization)' rc, out, err = assert_python_ok('-R', '-c', code) self.assertEqual(rc, 0) self.assertIn(b'random is 1', out)
def test_tofromstring(self): nb_warnings = 4 with warnings.catch_warnings(record=True) as r: warnings.filterwarnings("always", message=r"(to|from)string\(\) is deprecated", category=DeprecationWarning) a = array.array(self.typecode, 2 * self.example) b = array.array(self.typecode) self.assertRaises(TypeError, a.tostring, 42) self.assertRaises(TypeError, b.fromstring) self.assertRaises(TypeError, b.fromstring, 42) b.fromstring(a.tostring()) self.assertEqual(a, b) if a.itemsize > 1: self.assertRaises(ValueError, b.fromstring, "x") nb_warnings += 1 if support.check_impl_detail(): # PyPy's multimethod dispatch is different from CPython's # on CPython the warning is emitted before checking the arguments self.assertEqual(len(r), nb_warnings)
def test_send_error(self): # Use a subprocess to have only one thread. if os.name == 'nt': action = 'send' else: action = 'write' code = """if 1: import errno import signal import socket import sys import time import _testcapi from test.support import captured_stderr signum = signal.SIGINT def handler(signum, frame): pass signal.signal(signum, handler) read, write = socket.socketpair() read.setblocking(False) write.setblocking(False) signal.set_wakeup_fd(write.fileno()) # Close sockets: send() will fail read.close() write.close() with captured_stderr() as err: _testcapi.raise_signal(signum) err = err.getvalue() if ('Exception ignored when trying to {action} to the signal wakeup fd' not in err) and {cpython_only}: raise AssertionError(err) """.format(action=action, cpython_only=support.check_impl_detail()) # note that PyPy produces the same error message, but sent to # the real stderr instead of to sys.stderr. assert_python_ok('-c', code)