def test_basic_proxy(self):
        o = C()
        self.check_proxy(o, weakref.proxy(o))

        L = UserList.UserList()
        p = weakref.proxy(L)
        self.failIf(p, "proxy for empty UserList should be false")
        p.append(12)
        self.assertEqual(len(L), 1)
        self.failUnless(p, "proxy for non-empty UserList should be true")
        with test_support._check_py3k_warnings():
            p[:] = [2, 3]
        self.assertEqual(len(L), 2)
        self.assertEqual(len(p), 2)
        self.failUnless(3 in p, "proxy didn't support __contains__() properly")
        p[1] = 5
        self.assertEqual(L[1], 5)
        self.assertEqual(p[1], 5)
        L2 = UserList.UserList(L)
        p2 = weakref.proxy(L2)
        self.assertEqual(p, p2)
        ## self.assertEqual(repr(L2), repr(p2))
        L3 = UserList.UserList(range(10))
        p3 = weakref.proxy(L3)
        with test_support._check_py3k_warnings():
            self.assertEqual(L3[:], p3[:])
            self.assertEqual(L3[5:], p3[5:])
            self.assertEqual(L3[:5], p3[:5])
            self.assertEqual(L3[2:5], p3[2:5])

 def test_socketserver(self):
     """Using a SocketServer to create and manage SSL connections."""
     server = SocketServerHTTPSServer(CERTFILE)
     flag = threading.Event()
     server.start(flag)
     # wait for it to start
     flag.wait()
     # try to connect
     try:
         if test_support.verbose:
             sys.stdout.write("\n")
         with open(CERTFILE, "rb") as f:
             d1 = f.read()
         d2 = ""
         # now fetch the same data from the HTTPS server
         url = "https://127.0.0.1:%d/%s" % (server.port, os.path.split(CERTFILE)[1])
         with test_support._check_py3k_warnings():
             f = urllib.urlopen(url)
         dlen = f.info().getheader("content-length")
         if dlen and (int(dlen) > 0):
             d2 = f.read(int(dlen))
             if test_support.verbose:
                 sys.stdout.write(" client: read %d bytes from remote server '%s'\n" % (len(d2), server))
         f.close()
         self.assertEqual(d1, d2)
     finally:
         server.stop()
         server.join()

    def testComplexDefinitions(self):

        def makeReturner(*lst):
            def returner():
                return lst
            return returner

        self.assertEqual(makeReturner(1,2,3)(), (1,2,3))

        def makeReturner2(**kwargs):
            def returner():
                return kwargs
            return returner

        self.assertEqual(makeReturner2(a=11)()['a'], 11)

        with _check_py3k_warnings(("tuple parameter unpacking has been removed",
                                  SyntaxWarning)):
            exec """\
def makeAddPair((a, b)):
    def addPair((c, d)):
        return (a + c, b + d)
    return addPair
""" in locals()
        self.assertEqual(makeAddPair((1, 2))((100, 200)), (101,202))

def test_main():
    with _check_py3k_warnings(("buffer.. not supported", DeprecationWarning),
                              ("classic (int|long) division", DeprecationWarning),):
        import ctypes.test
        skipped, testcases = ctypes.test.get_tests(ctypes.test, "test_*.py", verbosity=0)
        suites = [unittest.makeSuite(t) for t in testcases]
        run_unittest(unittest.TestSuite(suites))

    def testMethods(self):
        methods = ['fileno', 'flush', 'isatty', 'next', 'read', 'readinto',
                   'readline', 'readlines', 'seek', 'tell', 'truncate',
                   'write', 'xreadlines', '__iter__']
        if sys.platform.startswith('atheos'):
            methods.remove('truncate')

        # __exit__ should close the file
        self.f.__exit__(None, None, None)
        self.assert_(self.f.closed)

        for methodname in methods:
            method = getattr(self.f, methodname)
            # should raise on closed file
            with test_support._check_py3k_warnings(quiet=True):
                self.assertRaises(ValueError, method)
        self.assertRaises(ValueError, self.f.writelines, [])

        # file is closed, __exit__ shouldn't do anything
        self.assertEquals(self.f.__exit__(None, None, None), None)
        # it must also return None if an exception was given
        try:
            1 // 0
        except:
            self.assertEquals(self.f.__exit__(*sys.exc_info()), None)

def test_main():
    with _check_py3k_warnings(("exceptions must derive from BaseException",
                              DeprecationWarning),
                             ("catching classes that don't inherit "
                              "from BaseException is not allowed",
                              DeprecationWarning)):
        run_unittest(OpcodeTest)

    def test_builtin_map(self):
        self.assertEqual(map(lambda x: x + 1, SequenceClass(5)), range(1, 6))

        d = {"one": 1, "two": 2, "three": 3}
        self.assertEqual(map(lambda k, d=d: (k, d[k]), d), d.items())
        dkeys = d.keys()
        expected = [(i < len(d) and dkeys[i] or None, i, i < len(d) and dkeys[i] or None) for i in range(5)]

        # Deprecated map(None, ...)
        with _check_py3k_warnings():
            self.assertEqual(map(None, SequenceClass(5)), range(5))
            self.assertEqual(map(None, d), d.keys())
            self.assertEqual(map(None, d, SequenceClass(5), iter(d.iterkeys())), expected)

        f = open(TESTFN, "w")
        try:
            for i in range(10):
                f.write("xy" * i + "\n")  # line i has len 2*i+1
        finally:
            f.close()
        f = open(TESTFN, "r")
        try:
            self.assertEqual(map(len, f), range(1, 21, 2))
        finally:
            f.close()
            try:
                unlink(TESTFN)
            except OSError:
                pass

def test_main():
    test_support.requires('network')
    with test_support._check_py3k_warnings(
            ("urllib.urlopen.. has been removed", DeprecationWarning)):
        test_support.run_unittest(URLTimeoutTest,
                                  urlopenNetworkTests,
                                  urlretrieveNetworkTests)

 def test_execfile(self):
     namespace = {}
     with test_support._check_py3k_warnings():
         execfile(test_support.TESTFN, namespace)
     func = namespace['line3']
     self.assertEqual(func.func_code.co_firstlineno, 3)
     self.assertEqual(namespace['line4'], FATX)

def test_main():
    with _check_py3k_warnings(
            ("backquote not supported", SyntaxWarning),
            ("tuple parameter unpacking has been removed", SyntaxWarning),
            ("parenthesized argument names are invalid", SyntaxWarning),
            ("classic int division", DeprecationWarning),
            (".+ not supported in 3.x", DeprecationWarning)):
        run_unittest(TokenTests, GrammarTests)

 def test_varargs2_ext(self):
     try:
         with test_support._check_py3k_warnings():
             {}.has_key(*(1, 2))
     except TypeError:
         pass
     else:
         raise RuntimeError

def test_main():
    with test_support._check_py3k_warnings(
        ('dict(.has_key..| inequality comparisons) not supported in 3.x',
         DeprecationWarning)):
        test_support.run_unittest(
            DictTest,
            GeneralMappingTests,
            SubclassMappingTests,
        )

    def test_getargspec_sublistofone(self):
        with _check_py3k_warnings(
                ("tuple parameter unpacking has been removed", SyntaxWarning),
                ("parenthesized argument names are invalid", SyntaxWarning)):
            exec 'def sublistOfOne((foo,)): return 1'
            self.assertArgSpecEquals(sublistOfOne, [['foo']])

            exec 'def fakeSublistOfOne((foo)): return 1'
            self.assertArgSpecEquals(fakeSublistOfOne, ['foo'])

    def test_setslice_without_getslice(self):
        tmp = []
        class X(object):
            def __setslice__(self, i, j, k):
                tmp.append((i, j, k))

        x = X()
        with test_support._check_py3k_warnings():
            x[1:2] = 42
        self.assertEquals(tmp, [(1, 2, 42)])

    def test_unpack_with_buffer(self):
        with _check_py3k_warnings(("buffer.. not supported in 3.x",
                                  DeprecationWarning)):
            # SF bug 1563759: struct.unpack doesn't support buffer protocol objects
            data1 = array.array('B', '\x12\x34\x56\x78')
            data2 = buffer('......\x12\x34\x56\x78......', 6, 4)
            for data in [data1, data2]:
                value, = struct.unpack('>I', data)
                self.assertEqual(value, 0x12345678)

            self.test_unpack_from(cls=buffer)

 def test_buffer(self):
     for s in ["", "Andrè Previn", "abc", " "*10000]:
         with test_support._check_py3k_warnings(("buffer.. not supported",
                                                  DeprecationWarning)):
             b = buffer(s)
         new = marshal.loads(marshal.dumps(b))
         self.assertEqual(s, new)
         marshal.dump(b, file(test_support.TESTFN, "wb"))
         new = marshal.load(file(test_support.TESTFN, "rb"))
         self.assertEqual(s, new)
     os.unlink(test_support.TESTFN)

 def clientRun(self, test_func):
     self.server_ready.wait()
     self.client_ready.set()
     self.clientSetUp()
     with test_support._check_py3k_warnings():
         if not callable(test_func):
             raise TypeError("test_func must be a callable function.")
     try:
         test_func()
     except Exception, strerror:
         self.queue.put(strerror)

 def test_weird_formcontentdict(self):
     # Test the weird FormContentDict classes
     env = {'QUERY_STRING': "x=1&y=2.0&z=2-3.%2b0&1=1abc"}
     expect = {'x': 1, 'y': 2.0, 'z': '2-3.+0', '1': '1abc'}
     d = cgi.InterpFormContentDict(env)
     for k, v in expect.items():
         self.assertEqual(d[k], v)
     for k, v in d.items():
         self.assertEqual(expect[k], v)
     with _check_py3k_warnings():
         self.assertEqual(sorted(expect.values()), sorted(d.values()))

 def test_iterable_args(self):
     for f in (self.module.nlargest, self.module.nsmallest):
         for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):
             for g in (G, I, Ig, L, R):
                 with test_support._check_py3k_warnings(
                         ("comparing unequal types not supported",
                          DeprecationWarning), quiet=True):
                     self.assertEqual(f(2, g(s)), f(2,s))
             self.assertEqual(f(2, S(s)), [])
             self.assertRaises(TypeError, f, 2, X(s))
             self.assertRaises(TypeError, f, 2, N(s))
             self.assertRaises(ZeroDivisionError, f, 2, E(s))

 def test_repeat(self, size):
     try:
         with test_support._check_py3k_warnings():
             b = buffer("AAAA")*size
     except MemoryError:
         pass # acceptable on 32-bit
     else:
         count = 0
         for c in b:
             self.assertEquals(c, 'A')
             count += 1
         self.assertEquals(count, size*4)