traverseda
/
cpython
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Recorded merge of revisions 74650 via svnmerge from 

svn+ssh://pythondev@svn.python.org/python/trunk

........
  r74650 | georg.brandl | 2009-09-04 13:19:34 +0200 (Fr, 04 Sep 2009) | 1 line

  #5101: add back tests to test_funcattrs that were lost during unittest conversion, and make some PEP8 cleanups.
........
This commit is contained in:
Georg Brandl 2009-09-04 11:20:54 +00:00
parent 9cf32a12a1
commit 4cb97d03a8
1 changed files with 87 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

123
Lib/test/test_funcattrs.py
View File

@ -56,8 +56,29 @@ class FunctionPropertiesTest(FuncAttrsTest):
self.assertEqual(test(), 3) # self.b always returns 3, arbitrarily self.assertEqual(test(), 3) # self.b always returns 3, arbitrarily
def test___globals__(self): def test___globals__(self):
self.assertEqual(self.b.__globals__, globals()) self.assertIs(self.b.__globals__, globals())
self.cannot_set_attr(self.b, '__globals__', 2, (AttributeError, TypeError)) self.cannot_set_attr(self.b, '__globals__', 2,
(AttributeError, TypeError))
def test___closure__(self):
a = 12
def f(): print(a)
c = f.__closure__
self.assertTrue(isinstance(c, tuple))
self.assertEqual(len(c), 1)
# don't have a type object handy
self.assertEqual(c[0].__class__.__name__, "cell")
self.cannot_set_attr(f, "__closure__", c, AttributeError)
def test_empty_cell(self):
def f(): print(a)
try:
f.__closure__[0].cell_contents
except ValueError:
pass
else:
self.fail("shouldn't be able to read an empty cell")
a = 12
def test___name__(self): def test___name__(self):
self.assertEqual(self.b.__name__, 'b') self.assertEqual(self.b.__name__, 'b')
@ -90,16 +111,20 @@ class FunctionPropertiesTest(FuncAttrsTest):
self.assertEqual(c.__code__, d.__code__) self.assertEqual(c.__code__, d.__code__)
self.assertEqual(c(), 7) self.assertEqual(c(), 7)
# self.assertEqual(d(), 7) # self.assertEqual(d(), 7)
try: b.__code__ = c.__code__ try:
except ValueError: pass b.__code__ = c.__code__
else: self.fail( except ValueError:
"__code__ with different numbers of free vars should not be " pass
"possible") else:
try: e.__code__ = d.__code__ self.fail("__code__ with different numbers of free vars should "
except ValueError: pass "not be possible")
else: self.fail( try:
"__code__ with different numbers of free vars should not be " e.__code__ = d.__code__
"possible") except ValueError:
pass
else:
self.fail("__code__ with different numbers of free vars should "
"not be possible")
def test_blank_func_defaults(self): def test_blank_func_defaults(self):
self.assertEqual(self.b.__defaults__, None) self.assertEqual(self.b.__defaults__, None)
@ -120,13 +145,16 @@ class FunctionPropertiesTest(FuncAttrsTest):
self.assertEqual(first_func(3, 5), 8) self.assertEqual(first_func(3, 5), 8)
del second_func.__defaults__ del second_func.__defaults__
self.assertEqual(second_func.__defaults__, None) self.assertEqual(second_func.__defaults__, None)
try: second_func() try:
except TypeError: pass second_func()
else: self.fail( except TypeError:
"func_defaults does not update; deleting it does not remove " pass
"requirement") else:
self.fail("__defaults__ does not update; deleting it does not "
"remove requirement")
class ImplicitReferencesTest(FuncAttrsTest):
class InstancemethodAttrTest(FuncAttrsTest):
def test___class__(self): def test___class__(self):
self.assertEqual(self.fi.a.__self__.__class__, self.F) self.assertEqual(self.fi.a.__self__.__class__, self.F)
@ -146,32 +174,46 @@ class ImplicitReferencesTest(FuncAttrsTest):
self.fi.id = types.MethodType(id, self.fi) self.fi.id = types.MethodType(id, self.fi)
self.assertEqual(self.fi.id(), id(self.fi)) self.assertEqual(self.fi.id(), id(self.fi))
# Test usage # Test usage
try: self.fi.id.unknown_attr try:
except AttributeError: pass self.fi.id.unknown_attr
else: self.fail("using unknown attributes should raise AttributeError") except AttributeError:
pass
else:
self.fail("using unknown attributes should raise AttributeError")
# Test assignment and deletion # Test assignment and deletion
self.cannot_set_attr(self.fi.id, 'unknown_attr', 2, AttributeError) self.cannot_set_attr(self.fi.id, 'unknown_attr', 2, AttributeError)
class ArbitraryFunctionAttrTest(FuncAttrsTest): class ArbitraryFunctionAttrTest(FuncAttrsTest):
def test_set_attr(self): def test_set_attr(self):
self.b.known_attr = 7 self.b.known_attr = 7
self.assertEqual(self.b.known_attr, 7) self.assertEqual(self.b.known_attr, 7)
try: self.fi.a.known_attr = 7 try:
except AttributeError: pass self.fi.a.known_attr = 7
else: self.fail("setting attributes on methods should raise error") except AttributeError:
pass
else:
self.fail("setting attributes on methods should raise error")
def test_delete_unknown_attr(self): def test_delete_unknown_attr(self):
try: del self.b.unknown_attr try:
except AttributeError: pass del self.b.unknown_attr
else: self.fail("deleting unknown attribute should raise TypeError") except AttributeError:
pass
else:
self.fail("deleting unknown attribute should raise TypeError")
def test_unset_attr(self): def test_unset_attr(self):
for func in [self.b, self.fi.a]: for func in [self.b, self.fi.a]:
try: func.non_existent_attr try:
except AttributeError: pass func.non_existent_attr
else: self.fail("using unknown attributes should raise " except AttributeError:
pass
else:
self.fail("using unknown attributes should raise "
"AttributeError") "AttributeError")
class FunctionDictsTest(FuncAttrsTest): class FunctionDictsTest(FuncAttrsTest):
def test_setting_dict_to_invalid(self): def test_setting_dict_to_invalid(self):
self.cannot_set_attr(self.b, '__dict__', None, TypeError) self.cannot_set_attr(self.b, '__dict__', None, TypeError)
@ -183,11 +225,11 @@ class FunctionDictsTest(FuncAttrsTest):
d = {'known_attr': 7} d = {'known_attr': 7}
self.b.__dict__ = d self.b.__dict__ = d
# Test assignment # Test assignment
self.assertEqual(d, self.b.__dict__) self.assertIs(d, self.b.__dict__)
# ... and on all the different ways of referencing the method's func # ... and on all the different ways of referencing the method's func
self.F.a.__dict__ = d self.F.a.__dict__ = d
self.assertEqual(d, self.fi.a.__func__.__dict__) self.assertIs(d, self.fi.a.__func__.__dict__)
self.assertEqual(d, self.fi.a.__dict__) self.assertIs(d, self.fi.a.__dict__)
# Test value # Test value
self.assertEqual(self.b.known_attr, 7) self.assertEqual(self.b.known_attr, 7)
self.assertEqual(self.b.__dict__['known_attr'], 7) self.assertEqual(self.b.__dict__['known_attr'], 7)
@ -196,9 +238,12 @@ class FunctionDictsTest(FuncAttrsTest):
self.assertEqual(self.fi.a.known_attr, 7) self.assertEqual(self.fi.a.known_attr, 7)
def test_delete___dict__(self): def test_delete___dict__(self):
try: del self.b.__dict__ try:
except TypeError: pass del self.b.__dict__
else: self.fail("deleting function dictionary should raise TypeError") except TypeError:
pass
else:
self.fail("deleting function dictionary should raise TypeError")
def test_unassigned_dict(self): def test_unassigned_dict(self):
self.assertEqual(self.b.__dict__, {}) self.assertEqual(self.b.__dict__, {})
@ -209,6 +254,7 @@ class FunctionDictsTest(FuncAttrsTest):
d[self.b] = value d[self.b] = value
self.assertEqual(d[self.b], value) self.assertEqual(d[self.b], value)
class FunctionDocstringTest(FuncAttrsTest): class FunctionDocstringTest(FuncAttrsTest):
def test_set_docstring_attr(self): def test_set_docstring_attr(self):
self.assertEqual(self.b.__doc__, None) self.assertEqual(self.b.__doc__, None)
@ -224,6 +270,7 @@ class FunctionDocstringTest(FuncAttrsTest):
del self.b.__doc__ del self.b.__doc__
self.assertEqual(self.b.__doc__, None) self.assertEqual(self.b.__doc__, None)
def cell(value): def cell(value):
"""Create a cell containing the given value.""" """Create a cell containing the given value."""
def f(): def f():
@ -242,6 +289,7 @@ def empty_cell(empty=True):
a = 1729 a = 1729
return f.__closure__[0] return f.__closure__[0]
class CellTest(unittest.TestCase): class CellTest(unittest.TestCase):
def test_comparison(self): def test_comparison(self):
# These tests are here simply to exercise the comparison code; # These tests are here simply to exercise the comparison code;
@ -254,6 +302,7 @@ class CellTest(unittest.TestCase):
self.assertTrue(cell(-36) == cell(-36.0)) self.assertTrue(cell(-36) == cell(-36.0))
self.assertTrue(cell(True) > empty_cell()) self.assertTrue(cell(True) > empty_cell())
class StaticMethodAttrsTest(unittest.TestCase): class StaticMethodAttrsTest(unittest.TestCase):
def test_func_attribute(self): def test_func_attribute(self):
def f(): def f():
@ -267,7 +316,7 @@ class StaticMethodAttrsTest(unittest.TestCase):
def test_main(): def test_main():
support.run_unittest(FunctionPropertiesTest, ImplicitReferencesTest, support.run_unittest(FunctionPropertiesTest, InstancemethodAttrTest,
ArbitraryFunctionAttrTest, FunctionDictsTest, ArbitraryFunctionAttrTest, FunctionDictsTest,
FunctionDocstringTest, CellTest, FunctionDocstringTest, CellTest,
StaticMethodAttrsTest) StaticMethodAttrsTest)