cpython: f89ef18f9824 (original) (raw)

--- a/Lib/test/test_descr.py +++ b/Lib/test/test_descr.py @@ -3,6 +3,7 @@ import gc import sys import types import unittest +import warnings import weakref from copy import deepcopy @@ -1550,6 +1551,86 @@ order (MRO) for bases """ self.assertEqual(b.foo, 3) self.assertEqual(b.class, D)

@unittest.expectedFailure
def test_bad_new(self):

   self.assertRaises(TypeError, object.__new__)[](#l1.17)

   self.assertRaises(TypeError, object.__new__, '')[](#l1.18)

   self.assertRaises(TypeError, list.__new__, object)[](#l1.19)

   self.assertRaises(TypeError, object.__new__, list)[](#l1.20)

```
   class C(object):[](#l1.21)
```
```
       __new__ = list.__new__[](#l1.22)
```

   self.assertRaises(TypeError, C)[](#l1.23)

```
   class C(list):[](#l1.24)
```

       __new__ = object.__new__[](#l1.25)

   self.assertRaises(TypeError, C)[](#l1.26)

def test_object_new(self):
```
   class A(object):[](#l1.29)
```
```
       pass[](#l1.30)
```
```
   object.__new__(A)[](#l1.31)
```

   self.assertRaises(TypeError, object.__new__, A, 5)[](#l1.32)

```
   object.__init__(A())[](#l1.33)
```

   self.assertRaises(TypeError, object.__init__, A(), 5)[](#l1.34)

```
   class A(object):[](#l1.36)
```

       def __init__(self, foo):[](#l1.37)

```
           self.foo = foo[](#l1.38)
```
```
   object.__new__(A)[](#l1.39)
```
```
   object.__new__(A, 5)[](#l1.40)
```
```
   object.__init__(A(3))[](#l1.41)
```

   self.assertRaises(TypeError, object.__init__, A(3), 5)[](#l1.42)

```
   class A(object):[](#l1.44)
```
```
       def __new__(cls, foo):[](#l1.45)
```

           return object.__new__(cls)[](#l1.46)

```
   object.__new__(A)[](#l1.47)
```

   self.assertRaises(TypeError, object.__new__, A, 5)[](#l1.48)

```
   object.__init__(A(3))[](#l1.49)
```
```
   object.__init__(A(3), 5)[](#l1.50)
```

```
   class A(object):[](#l1.52)
```
```
       def __new__(cls, foo):[](#l1.53)
```

           return object.__new__(cls)[](#l1.54)

       def __init__(self, foo):[](#l1.55)

```
           self.foo = foo[](#l1.56)
```
```
   object.__new__(A)[](#l1.57)
```

   with warnings.catch_warnings(record=True) as w:[](#l1.58)

       warnings.simplefilter('always', DeprecationWarning)[](#l1.59)

       a = object.__new__(A, 5)[](#l1.60)

   self.assertEqual(type(a), A)[](#l1.61)

   self.assertEqual(len(w), 1)[](#l1.62)

```
   object.__init__(A(3))[](#l1.63)
```
```
   a = A(3)[](#l1.64)
```

   with warnings.catch_warnings(record=True) as w:[](#l1.65)

       warnings.simplefilter('always', DeprecationWarning)[](#l1.66)

```
       object.__init__(a, 5)[](#l1.67)
```
```
   self.assertEqual(a.foo, 3)[](#l1.68)
```

   self.assertEqual(len(w), 1)[](#l1.69)

@unittest.expectedFailure
def test_restored_object_new(self):
```
   class A(object):[](#l1.73)
```

       def __new__(cls, *args, **kwargs):[](#l1.74)

           raise AssertionError[](#l1.75)

   self.assertRaises(AssertionError, A)[](#l1.76)

```
   class B(A):[](#l1.77)
```

       __new__ = object.__new__[](#l1.78)

       def __init__(self, foo):[](#l1.79)

```
           self.foo = foo[](#l1.80)
```

   with warnings.catch_warnings():[](#l1.81)

       warnings.simplefilter('error', DeprecationWarning)[](#l1.82)

```
       b = B(3)[](#l1.83)
```
```
   self.assertEqual(b.foo, 3)[](#l1.84)
```

   self.assertEqual(b.__class__, B)[](#l1.85)

```
   del B.__new__[](#l1.86)
```

   self.assertRaises(AssertionError, B)[](#l1.87)

```
   del A.__new__[](#l1.88)
```

   with warnings.catch_warnings():[](#l1.89)

       warnings.simplefilter('error', DeprecationWarning)[](#l1.90)

```
       b = B(3)[](#l1.91)
```
```
   self.assertEqual(b.foo, 3)[](#l1.92)
```

   self.assertEqual(b.__class__, B)[](#l1.93)

+ def test_altmro(self): # Testing mro() and overriding it... class A(object): @@ -3756,6 +3837,24 @@ order (MRO) for bases """ self.assertEqual(isinstance(d, D), True) self.assertEqual(d.foo, 1)

```
   class C(object):[](#l1.102)
```
```
       @staticmethod[](#l1.103)
```
```
       def __new__(*args):[](#l1.104)
```
```
           return args[](#l1.105)
```

   self.assertEqual(C(1, 2), (C, 1, 2))[](#l1.106)

```
   class D(C):[](#l1.107)
```
```
       pass[](#l1.108)
```

   self.assertEqual(D(1, 2), (D, 1, 2))[](#l1.109)

```
   class C(object):[](#l1.111)
```
```
       @classmethod[](#l1.112)
```
```
       def __new__(*args):[](#l1.113)
```
```
           return args[](#l1.114)
```

   self.assertEqual(C(1, 2), (C, C, 1, 2))[](#l1.115)

```
   class D(C):[](#l1.116)
```
```
       pass[](#l1.117)
```

   self.assertEqual(D(1, 2), (D, D, 1, 2))[](#l1.118)

+ def test_imul_bug(self): # Testing for imul problems... # SF bug 544647