Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / sam-t2 / devtools / v8plus / 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()