__findattr__ refactor

Lib/test/test_descr_jy.py

 """Test descriptors, binary ops, etc.
 
 Made for Jython.
 """
 import types
 import unittest
 from test import test_support
 
 class Old:
     pass
@@ skipping 54 matching lines @@
         except TypeError:
             pass
         else:
             self.assert_(False, "should have raised TypeError")
         try:
             foo = C(None)
         except TypeError:
             pass
         else:
             self.assert_(False, "should have raised TypeError")
+
+    def test_raising_custom_attribute_error(self):
+        class RaisesCustomMsg(object):
+            def __get__(self, instance, type):
+                raise AttributeError("Custom message")
+
+
+        class CustomAttributeError(AttributeError): pass
+
+        class RaisesCustomErr(object):
+            def __get__(self, instance, type):
+                raise CustomAttributeError
+
+        class Foo(object):
+            custom_msg = RaisesCustomMsg()
+            custom_err = RaisesCustomErr()
+
+        self.assertRaises(CustomAttributeError, lambda: Foo().custom_err)
+        try:
+            Foo().custom_msg
+            self.assert_(False) # Previous line should raise AttributteError
+        except AttributeError, e:
+            self.assertEquals("Custom message", str(e))
 
 class SubclassDescrTestCase(unittest.TestCase):
 
     def test_subclass_cmp_right_op(self):
         # Case 1: subclass of int
 
         class B(int):
             def __ge__(self, other):
                 return "B.__ge__"
             def __le__(self, other):
@@ skipping 52 matching lines @@
 
         class C(object):
             def __radd__(self, o):
                 return '%r + C()' % (o,)
 
             def __rmul__(self, o):
                 return '%r * C()' % (o,)
 
         # Test strs, unicode, lists and tuples
         mapping = []
-        
+
         # + binop
         mapping.append((lambda o: 'foo' + o,
                         TypeError, "cannot concatenate 'str' and 'B' objects",
                         "'foo' + C()"))
         # XXX: There's probably work to be done here besides just emulating this
         # message
         if test_support.is_jython:
             mapping.append((lambda o: u'foo' + o,
                             TypeError, "cannot concatenate 'unicode' and 'B' objects",
                             "u'foo' + C()"))
@@ skipping 128 matching lines @@
                 eval('%s(new)' % op)
             except TypeError:
                 pass
             else:
                 self._assert(False, 'Expected a TypeError, op: %s' % op)
 
     def _test(self, func):
         self.assertRaises(AttributeError, func, old)
         self.assertRaises(TypeError, func, new)
 
+class GetAttrTestCase(unittest.TestCase):
+    def test_raising_custom_attribute_error(self):
+        # Very similar to
+        # test_descr_jy.TestDescrTestCase.test_raising_custom_attribute_error
+        class BarAttributeError(AttributeError): pass
+
+        class Bar(object):
+            def __getattr__(self, name):
+                raise BarAttributeError
+
+        class Foo(object):
+            def __getattr__(self, name):
+                raise AttributeError("Custom message")
+        self.assertRaises(BarAttributeError, lambda: Bar().x)
+        try:
+            Foo().x
+            self.assert_(False) # Previous line should raise AttributteError
+        except AttributeError, e:
+            self.assertEquals("Custom message", str(e))
 
 def test_main():
     test_support.run_unittest(TestDescrTestCase,
                               SubclassDescrTestCase,
                               InPlaceTestCase,
-                              DescrExceptionsTestCase)
+                              DescrExceptionsTestCase,
+                              GetAttrTestCase)
 
 if __name__ == '__main__':
     test_main()