Port test_new.py to unittest.

Lib/test/output/test_new

-test_new
-new.module()
-new.classobj()
-new.instance()
-new.instancemethod()
-new.function()
-new.code()

Lib/test/test_new.py

-from test.test_support import verbose, verify, TestFailed
-import sys
-import new
-
-class Eggs:
-    def get_yolks(self):
-        return self.yolks
-
-print 'new.module()'
-m = new.module('Spam')
-if verbose:
-    print m
-m.Eggs = Eggs
-sys.modules['Spam'] = m
-import Spam
-
-def get_more_yolks(self):
-    return self.yolks + 3
-
-print 'new.classobj()'
-C = new.classobj('Spam', (Spam.Eggs,), {'get_more_yolks': get_more_yolks})
-if verbose:
-    print C
-print 'new.instance()'
-c = new.instance(C, {'yolks': 3})
-if verbose:
-    print c
-o = new.instance(C)
-verify(o.__dict__ == {},
-       "new __dict__ should be empty")
-del o
-o = new.instance(C, None)
-verify(o.__dict__ == {},
-       "new __dict__ should be empty")
-del o
-
-def break_yolks(self):
-    self.yolks = self.yolks - 2
-print 'new.instancemethod()'
-im = new.instancemethod(break_yolks, c, C)
-if verbose:
-    print im
-
-verify(c.get_yolks() == 3 and c.get_more_yolks() == 6,
-       'Broken call of hand-crafted class instance')
-im()
-verify(c.get_yolks() == 1 and c.get_more_yolks() == 4,
-       'Broken call of hand-crafted instance method')
-
-im = new.instancemethod(break_yolks, c)
-im()
-verify(c.get_yolks() == -1)
-try:
-    new.instancemethod(break_yolks, None)
-except TypeError:
-    pass
-else:
-    raise TestFailed, "dangerous instance method creation allowed"
-
-# Verify that instancemethod() doesn't allow keyword args
-try:
-    new.instancemethod(break_yolks, c, kw=1)
-except TypeError:
-    pass
-else:
-    raise TestFailed, "instancemethod shouldn't accept keyword args"
-
-# It's unclear what the semantics should be for a code object compiled at
-# module scope, but bound and run in a function.  In CPython, `c' is global
-# (by accident?) while in Jython, `c' is local.  The intent of the test
-# clearly is to make `c' global, so let's be explicit about it.
-codestr = '''
-global c
-a = 1
-b = 2
-c = a + b
-'''
-
-ccode = compile(codestr, '<string>', 'exec')
-# Jython doesn't have a __builtins__, so use a portable alternative
-import __builtin__
-g = {'c': 0, '__builtins__': __builtin__}
-# this test could be more robust
-print 'new.function()'
-func = new.function(ccode, g)
-if verbose:
-    print func
-func()
-verify(g['c'] == 3,
-       'Could not create a proper function object')
-
-# test the various extended flavors of function.new
-def f(x):
-    def g(y):
-        return x + y
-    return g
-g = f(4)
-new.function(f.func_code, {}, "blah")
-g2 = new.function(g.func_code, {}, "blah", (2,), g.func_closure)
-verify(g2() == 6)
-g3 = new.function(g.func_code, {}, "blah", None, g.func_closure)
-verify(g3(5) == 9)
-def test_closure(func, closure, exc):
-    try:
-        new.function(func.func_code, {}, "", None, closure)
-    except exc:
-        pass
-    else:
-        print "corrupt closure accepted"
-
-test_closure(g, None, TypeError) # invalid closure
-test_closure(g, (1,), TypeError) # non-cell in closure
-test_closure(g, (1, 1), ValueError) # closure is wrong size
-test_closure(f, g.func_closure, ValueError) # no closure needed
-
-print 'new.code()'
-# bogus test of new.code()
-# Note: Jython will never have new.code()
-if hasattr(new, 'code'):
-    def f(a): pass
-
-    c = f.func_code
-    argcount = c.co_argcount
-    nlocals = c.co_nlocals
-    stacksize = c.co_stacksize
-    flags = c.co_flags
-    codestring = c.co_code
-    constants = c.co_consts
-    names = c.co_names
-    varnames = c.co_varnames
-    filename = c.co_filename
-    name = c.co_name
-    firstlineno = c.co_firstlineno
-    lnotab = c.co_lnotab
-    freevars = c.co_freevars
-    cellvars = c.co_cellvars
-
-    d = new.code(argcount, nlocals, stacksize, flags, codestring,
-                 constants, names, varnames, filename, name,
-                 firstlineno, lnotab, freevars, cellvars)
-
-    # test backwards-compatibility version with no freevars or cellvars
-    d = new.code(argcount, nlocals, stacksize, flags, codestring,
-                 constants, names, varnames, filename, name,
-                 firstlineno, lnotab)
-
-    try: # this used to trigger a SystemError
-        d = new.code(-argcount, nlocals, stacksize, flags, codestring,
-                     constants, names, varnames, filename, name,
-                     firstlineno, lnotab)
-    except ValueError:
-        pass
-    else:
-        raise TestFailed, "negative co_argcount didn't trigger an exception"
-
-    try: # this used to trigger a SystemError
-        d = new.code(argcount, -nlocals, stacksize, flags, codestring,
-                     constants, names, varnames, filename, name,
-                     firstlineno, lnotab)
-    except ValueError:
-        pass
-    else:
-        raise TestFailed, "negative co_nlocals didn't trigger an exception"
-
-    try: # this used to trigger a Py_FatalError!
-        d = new.code(argcount, nlocals, stacksize, flags, codestring,
-                     constants, (5,), varnames, filename, name,
-                     firstlineno, lnotab)
-    except TypeError:
-        pass
-    else:
-        raise TestFailed, "non-string co_name didn't trigger an exception"
-
-    # new.code used to be a way to mutate a tuple...
-    class S(str): pass
-    t = (S("ab"),)
-    d = new.code(argcount, nlocals, stacksize, flags, codestring,
-                 constants, t, varnames, filename, name,
-                 firstlineno, lnotab)
-    verify(type(t[0]) is S, "eek, tuple changed under us!")
-
-    if verbose:
-        print d
+import unittest
+from test import test_support
+import sys, new
+
+class NewTest(unittest.TestCase):
+    def test_spam(self):
+        class Eggs:
+            def get_yolks(self):
+                return self.yolks
+
+        m = new.module('Spam')
+        m.Eggs = Eggs
+        sys.modules['Spam'] = m
+        import Spam
+
+        def get_more_yolks(self):
+            return self.yolks + 3
+
+        # new.classobj()
+        C = new.classobj('Spam', (Spam.Eggs,), {'get_more_yolks': get_more_yolks})
+
+        # new.instance()
+        c = new.instance(C, {'yolks': 3})
+
+        o = new.instance(C)
+        self.assertEqual(o.__dict__, {}, "new __dict__ should be empty")
+        del o
+        o = new.instance(C, None)
+        self.assertEqual(o.__dict__, {}, "new __dict__ should be empty")
+        del o
+
+        def break_yolks(self):
+            self.yolks = self.yolks - 2
+
+        # new.instancemethod()
+        im = new.instancemethod(break_yolks, c, C)
+
+        self.assertEqual(c.get_yolks(), 3,
+            'Broken call of hand-crafted class instance')
+        self.assertEqual(c.get_more_yolks(), 6,
+            'Broken call of hand-crafted class instance')
+
+        im()
+        self.assertEqual(c.get_yolks(), 1,
+            'Broken call of hand-crafted instance method')
+        self.assertEqual(c.get_more_yolks(), 4,
+            'Broken call of hand-crafted instance method')
+
+        im = new.instancemethod(break_yolks, c)
+        im()
+        self.assertEqual(c.get_yolks(), -1)
+
+        # Verify that dangerous instance method creation is forbidden
+        self.assertRaises(TypeError, new.instancemethod, break_yolks, None)
+
+        # Verify that instancemethod() doesn't allow keyword args
+        self.assertRaises(TypeError, new.instancemethod, break_yolks, c, kw=1)
+
+    def test_scope(self):
+        # It's unclear what the semantics should be for a code object compiled
+        # at module scope, but bound and run in a function.  In CPython, `c' is
+        # global (by accident?) while in Jython, `c' is local.  The intent of
+        # the test clearly is to make `c' global, so let's be explicit about it.
+        codestr = '''
+        global c
+        a = 1
+        b = 2
+        c = a + b
+        '''
+
+        codestr = "\n".join(l.strip() for l in codestr.splitlines())
+
+        ccode = compile(codestr, '<string>', 'exec')
+        # Jython doesn't have a __builtins__, so use a portable alternative
+        import __builtin__
+        g = {'c': 0, '__builtins__': __builtin__}
+
+        # this test could be more robust
+        func = new.function(ccode, g)
+        func()
+        self.assertEqual(g['c'], 3, 'Could not create a proper function object')
+
+    def test_function(self):
+        # test the various extended flavors of function.new
+        def f(x):
+            def g(y):
+                return x + y
+            return g
+        g = f(4)
+        new.function(f.func_code, {}, "blah")
+        g2 = new.function(g.func_code, {}, "blah", (2,), g.func_closure)
+        self.assertEqual(g2(), 6)
+        g3 = new.function(g.func_code, {}, "blah", None, g.func_closure)
+        self.assertEqual(g3(5), 9)
+        def test_closure(func, closure, exc):
+            self.assertRaises(exc, new.function, func.func_code, {}, "", None, closure)
+
+        test_closure(g, None, TypeError) # invalid closure
+        test_closure(g, (1,), TypeError) # non-cell in closure
+        test_closure(g, (1, 1), ValueError) # closure is wrong size
+        test_closure(f, g.func_closure, ValueError) # no closure needed
+
+    # Note: Jython will never have new.code()
+    if hasattr(new, 'code'):
+        def test_code(self):
+            # bogus test of new.code()
+            def f(a): pass
+
+            c = f.func_code
+            argcount = c.co_argcount
+            nlocals = c.co_nlocals
+            stacksize = c.co_stacksize
+            flags = c.co_flags
+            codestring = c.co_code
+            constants = c.co_consts
+            names = c.co_names
+            varnames = c.co_varnames
+            filename = c.co_filename
+            name = c.co_name
+            firstlineno = c.co_firstlineno
+            lnotab = c.co_lnotab
+            freevars = c.co_freevars
+            cellvars = c.co_cellvars
+
+            d = new.code(argcount, nlocals, stacksize, flags, codestring,
+                         constants, names, varnames, filename, name,
+                         firstlineno, lnotab, freevars, cellvars)
+
+            # test backwards-compatibility version with no freevars or cellvars
+            d = new.code(argcount, nlocals, stacksize, flags, codestring,
+                         constants, names, varnames, filename, name,
+                         firstlineno, lnotab)
+
+            # negative co_argcount used to trigger a SystemError
+            self.assertRaises(ValueError, new.code,
+                -argcount, nlocals, stacksize, flags, codestring,
+                constants, names, varnames, filename, name, firstlineno, lnotab)
+
+            # negative co_nlocals used to trigger a SystemError
+            self.assertRaises(ValueError, new.code,
+                argcount, -nlocals, stacksize, flags, codestring,
+                constants, names, varnames, filename, name, firstlineno, lnotab)
+
+            # non-string co_name used to trigger a Py_FatalError
+            self.assertRaises(TypeError, new.code,
+                argcount, nlocals, stacksize, flags, codestring,
+                constants, (5,), varnames, filename, name, firstlineno, lnotab)
+
+            # new.code used to be a way to mutate a tuple...
+            class S(str):
+                pass
+            t = (S("ab"),)
+            d = new.code(argcount, nlocals, stacksize, flags, codestring,
+                         constants, t, varnames, filename, name,
+                         firstlineno, lnotab)
+            self.assert_(type(t[0]) is S, "eek, tuple changed under us!")
+
+def test_main():
+    test_support.run_unittest(NewTest)
+
+if __name__ == "__main__":
+    test_main()