Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / sam-t2 / devtools / v9 / lib / python2.4 / test / test_funcattrs.py

from test.test_support import verbose, TestFailed, verify
import types

class F:
   def a(self):
       pass

def b():
   'my docstring'
   pass

# __module__ is a special attribute
verify(b.__module__ == __name__)
verify(verify.__module__ == "test.test_support")

# setting attributes on functions
try:
   b.publish
except AttributeError: pass
else: raise TestFailed, 'expected AttributeError'

if b.__dict__ <> {}:
   raise TestFailed, 'expected unassigned func.__dict__ to be {}'

b.publish = 1
if b.publish <> 1:
   raise TestFailed, 'function attribute not set to expected value'

docstring = 'its docstring'
b.__doc__ = docstring
if b.__doc__ <> docstring:
   raise TestFailed, 'problem with setting __doc__ attribute'

if 'publish' not in dir(b):
   raise TestFailed, 'attribute not in dir()'

try:
   del b.__dict__
except TypeError: pass
else: raise TestFailed, 'del func.__dict__ expected TypeError'

b.publish = 1
try:
   b.__dict__ = None
except TypeError: pass
else: raise TestFailed, 'func.__dict__ = None expected TypeError'

d = {'hello': 'world'}
b.__dict__ = d
if b.func_dict is not d:
   raise TestFailed, 'func.__dict__ assignment to dictionary failed'
if b.hello <> 'world':
   raise TestFailed, 'attribute after func.__dict__ assignment failed'

f1 = F()
f2 = F()

try:
   F.a.publish
except AttributeError: pass
else: raise TestFailed, 'expected AttributeError'

try:
   f1.a.publish
except AttributeError: pass
else: raise TestFailed, 'expected AttributeError'

# In Python 2.1 beta 1, we disallowed setting attributes on unbound methods
# (it was already disallowed on bound methods).  See the PEP for details.
try:
   F.a.publish = 1
except (AttributeError, TypeError): pass
else: raise TestFailed, 'expected AttributeError or TypeError'

# But setting it explicitly on the underlying function object is okay.
F.a.im_func.publish = 1

if F.a.publish <> 1:
   raise TestFailed, 'unbound method attribute not set to expected value'

if f1.a.publish <> 1:
   raise TestFailed, 'bound method attribute access did not work'

if f2.a.publish <> 1:
   raise TestFailed, 'bound method attribute access did not work'

if 'publish' not in dir(F.a):
   raise TestFailed, 'attribute not in dir()'

try:
   f1.a.publish = 0
except (AttributeError, TypeError): pass
else: raise TestFailed, 'expected AttributeError or TypeError'

# See the comment above about the change in semantics for Python 2.1b1
try:
   F.a.myclass = F
except (AttributeError, TypeError): pass
else: raise TestFailed, 'expected AttributeError or TypeError'

F.a.im_func.myclass = F

f1.a.myclass
f2.a.myclass
f1.a.myclass
F.a.myclass

if f1.a.myclass is not f2.a.myclass or \
      f1.a.myclass is not F.a.myclass:
   raise TestFailed, 'attributes were not the same'

# try setting __dict__
try:
   F.a.__dict__ = (1, 2, 3)
except (AttributeError, TypeError): pass
else: raise TestFailed, 'expected TypeError or AttributeError'

F.a.im_func.__dict__ = {'one': 11, 'two': 22, 'three': 33}

if f1.a.two <> 22:
   raise TestFailed, 'setting __dict__'

from UserDict import UserDict
d = UserDict({'four': 44, 'five': 55})

try:
   F.a.__dict__ = d
except (AttributeError, TypeError): pass
else: raise TestFailed

if f2.a.one <> f1.a.one <> F.a.one <> 11:
   raise TestFailed

# im_func may not be a Python method!
import new
F.id = new.instancemethod(id, None, F)

eff = F()
if eff.id() <> id(eff):
   raise TestFailed

try:
   F.id.foo
except AttributeError: pass
else: raise TestFailed

try:
   F.id.foo = 12
except (AttributeError, TypeError): pass
else: raise TestFailed

try:
   F.id.foo
except AttributeError: pass
else: raise TestFailed

try:
   eff.id.foo
except AttributeError: pass
else: raise TestFailed

try:
   eff.id.foo = 12
except (AttributeError, TypeError): pass
else: raise TestFailed

try:
   eff.id.foo
except AttributeError: pass
else: raise TestFailed

# Regression test for a crash in pre-2.1a1
def another():
   pass

try:
   del another.__dict__
except TypeError: pass
else: raise TestFailed

try:
   del another.func_dict
except TypeError: pass
else: raise TestFailed

try:
   another.func_dict = None
except TypeError: pass
else: raise TestFailed

try:
   del another.bar
except AttributeError: pass
else: raise TestFailed

# This isn't specifically related to function attributes, but it does test a
# core dump regression in funcobject.c
del another.func_defaults

def foo():
   pass

def bar():
   pass

def temp():
   print 1

if foo==bar:
   raise TestFailed

d={}
d[foo] = 1

foo.func_code = temp.func_code

d[foo]

# Test all predefined function attributes systematically

def cantset(obj, name, value, exception=(AttributeError, TypeError)):
   verify(hasattr(obj, name)) # Otherwise it's probably a typo
   try:
       setattr(obj, name, value)
   except exception:
       pass
   else:
       raise TestFailed, "shouldn't be able to set %s to %r" % (name, value)
   try:
       delattr(obj, name)
   except (AttributeError, TypeError):
       pass
   else:
       raise TestFailed, "shouldn't be able to del %s" % name

def test_func_closure():
   a = 12
   def f(): print a
   c = f.func_closure
   verify(isinstance(c, tuple))
   verify(len(c) == 1)
   verify(c[0].__class__.__name__ == "cell") # don't have a type object handy
   cantset(f, "func_closure", c)

def test_func_doc():
   def f(): pass
   verify(f.__doc__ is None)
   verify(f.func_doc is None)
   f.__doc__ = "hello"
   verify(f.__doc__ == "hello")
   verify(f.func_doc == "hello")
   del f.__doc__
   verify(f.__doc__ is None)
   verify(f.func_doc is None)
   f.func_doc = "world"
   verify(f.__doc__ == "world")
   verify(f.func_doc == "world")
   del f.func_doc
   verify(f.func_doc is None)
   verify(f.__doc__ is None)

def test_func_globals():
   def f(): pass
   verify(f.func_globals is globals())
   cantset(f, "func_globals", globals())

def test_func_name():
   def f(): pass
   verify(f.__name__ == "f")
   verify(f.func_name == "f")
   f.__name__ = "g"
   verify(f.__name__ == "g")
   verify(f.func_name == "g")
   f.func_name = "h"
   verify(f.__name__ == "h")
   verify(f.func_name == "h")
   cantset(f, "func_globals", 1)
   cantset(f, "__name__", 1)
   # test that you can access func.__name__ in restricted mode
   s = """def f(): pass\nf.__name__"""
   exec s in {'__builtins__':{}}


def test_func_code():
   a = b = 24
   def f(): pass
   def g(): print 12
   def f1(): print a
   def g1(): print b
   def f2(): print a, b
   verify(type(f.func_code) is types.CodeType)
   f.func_code = g.func_code
   cantset(f, "func_code", None)
   # can't change the number of free vars
   cantset(f,  "func_code", f1.func_code, exception=ValueError)
   cantset(f1, "func_code",  f.func_code, exception=ValueError)
   cantset(f1, "func_code", f2.func_code, exception=ValueError)
   f1.func_code = g1.func_code

def test_func_defaults():
   def f(a, b): return (a, b)
   verify(f.func_defaults is None)
   f.func_defaults = (1, 2)
   verify(f.func_defaults == (1, 2))
   verify(f(10) == (10, 2))
   def g(a=1, b=2): return (a, b)
   verify(g.func_defaults == (1, 2))
   del g.func_defaults
   verify(g.func_defaults is None)
   try:
       g()
   except TypeError:
       pass
   else:
       raise TestFailed, "shouldn't be allowed to call g() w/o defaults"

def test_func_dict():
   def f(): pass
   a = f.__dict__
   b = f.func_dict
   verify(a == {})
   verify(a is b)
   f.hello = 'world'
   verify(a == {'hello': 'world'})
   verify(f.func_dict is a is f.__dict__)
   f.func_dict = {}
   verify(not hasattr(f, "hello"))
   f.__dict__ = {'world': 'hello'}
   verify(f.world == "hello")
   verify(f.__dict__ is f.func_dict == {'world': 'hello'})
   cantset(f, "func_dict", None)
   cantset(f, "__dict__", None)

def test_im_class():
   class C:
       def foo(self): pass
   verify(C.foo.im_class is C)
   verify(C().foo.im_class is C)
   cantset(C.foo, "im_class", C)
   cantset(C().foo, "im_class", C)

def test_im_func():
   def foo(self): pass
   class C:
       pass
   C.foo = foo
   verify(C.foo.im_func is foo)
   verify(C().foo.im_func is foo)
   cantset(C.foo, "im_func", foo)
   cantset(C().foo, "im_func", foo)

def test_im_self():
   class C:
       def foo(self): pass
   verify(C.foo.im_self is None)
   c = C()
   verify(c.foo.im_self is c)
   cantset(C.foo, "im_self", None)
   cantset(c.foo, "im_self", c)

def test_im_dict():
   class C:
       def foo(self): pass
       foo.bar = 42
   verify(C.foo.__dict__ == {'bar': 42})
   verify(C().foo.__dict__ == {'bar': 42})
   cantset(C.foo, "__dict__", C.foo.__dict__)
   cantset(C().foo, "__dict__", C.foo.__dict__)

def test_im_doc():
   class C:
       def foo(self): "hello"
   verify(C.foo.__doc__ == "hello")
   verify(C().foo.__doc__ == "hello")
   cantset(C.foo, "__doc__", "hello")
   cantset(C().foo, "__doc__", "hello")

def test_im_name():
   class C:
       def foo(self): pass
   verify(C.foo.__name__ == "foo")
   verify(C().foo.__name__ == "foo")
   cantset(C.foo, "__name__", "foo")
   cantset(C().foo, "__name__", "foo")

def testmore():
   test_func_closure()
   test_func_doc()
   test_func_globals()
   test_func_name()
   test_func_code()
   test_func_defaults()
   test_func_dict()
   # Tests for instance method attributes
   test_im_class()
   test_im_func()
   test_im_self()
   test_im_dict()
   test_im_doc()
   test_im_name()

testmore()