import unittest | |
from test import test_support | |
import sys | |
new = test_support.import_module('new', deprecated=True) | |
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.assertTrue(type(t[0]) is S, "eek, tuple changed under us!") | |
def test_main(): | |
test_support.run_unittest(NewTest) | |
if __name__ == "__main__": | |
test_main() |