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_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 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_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_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 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_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_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_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_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 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 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_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 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_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_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_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)