diff -r 000000000000 -r ae805ac0140d python-2.5.2/win32/Lib/test/test_new.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/python-2.5.2/win32/Lib/test/test_new.py	Fri Apr 03 17:19:34 2009 +0100
@@ -0,0 +1,183 @@
+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