diff -r de5582c569ff Lib/test/test_float.py --- a/Lib/test/test_float.py Sun Nov 22 14:56:22 2015 +0200 +++ b/Lib/test/test_float.py Mon Nov 23 01:10:34 2015 +0200 @@ -27,6 +27,12 @@ requires_IEEE_754 = unittest.skipUnless( test_dir = os.path.dirname(__file__) or os.curdir format_testfile = os.path.join(test_dir, 'formatfloat_testcases.txt') +class FloatSubclass(float): + pass + +class OtherFloatSubclass(float): + pass + class GeneralFloatCases(unittest.TestCase): def test_float(self): @@ -200,6 +206,15 @@ class GeneralFloatCases(unittest.TestCas return "" self.assertRaises(TypeError, time.sleep, Foo5()) + # Issue #24731 + class F: + def __float__(self): + return OtherFloatSubclass(42.) + self.assertAlmostEqual(float(F()), 42.) + self.assertIs(type(float(F())), OtherFloatSubclass) + self.assertAlmostEqual(FloatSubclass(F()), 42.) + self.assertIs(type(FloatSubclass(F())), FloatSubclass) + def test_is_integer(self): self.assertFalse((1.1).is_integer()) self.assertTrue((1.).is_integer()) diff -r de5582c569ff Lib/test/test_int.py --- a/Lib/test/test_int.py Sun Nov 22 14:56:22 2015 +0200 +++ b/Lib/test/test_int.py Mon Nov 23 01:10:34 2015 +0200 @@ -45,6 +45,9 @@ if have_unicode: (unichr(0x200), ValueError), ] +class IntSubclass(int): + pass + class IntLongCommonTests(object): """Mixin of test cases to share between both test_int and test_long.""" @@ -477,6 +480,18 @@ class IntTestCases(IntLongCommonTests, u self.fail("Failed to raise TypeError with %s" % ((base, trunc_result_base),)) + class TruncReturnsIntSubclass(base): + def __trunc__(self): + return True + good_int = TruncReturnsIntSubclass() + n = int(good_int) + self.assertEqual(n, 1) + self.assertIs(type(n), bool) + n = IntSubclass(good_int) + self.assertEqual(n, 1) + self.assertIs(type(n), IntSubclass) + + def test_main(): run_unittest(IntTestCases) diff -r de5582c569ff Lib/test/test_long.py --- a/Lib/test/test_long.py Sun Nov 22 14:56:22 2015 +0200 +++ b/Lib/test/test_long.py Mon Nov 23 01:10:34 2015 +0200 @@ -79,6 +79,12 @@ if test_support.have_unicode: (unichr(0x200), ValueError), ] +class LongSubclass(long): + pass + +class OtherLongSubclass(long): + pass + class LongTest(test_int.IntLongCommonTests, unittest.TestCase): ntype = long @@ -539,6 +545,17 @@ class LongTest(test_int.IntLongCommonTes self.fail("Failed to raise TypeError with %s" % ((base, trunc_result_base),)) + class TruncReturnsLongSubclass(base): + def __long__(self): + return OtherLongSubclass(42L) + good_int = TruncReturnsLongSubclass() + n = long(good_int) + self.assertEqual(n, 42L) + self.assertIs(type(n), OtherLongSubclass) + n = LongSubclass(good_int) + self.assertEqual(n, 42L) + self.assertIs(type(n), LongSubclass) + def test_misc(self): # check the extremes in int<->long conversion diff -r de5582c569ff Lib/test/test_str.py --- a/Lib/test/test_str.py Sun Nov 22 14:56:22 2015 +0200 +++ b/Lib/test/test_str.py Mon Nov 23 01:10:34 2015 +0200 @@ -4,6 +4,9 @@ import sys from test import test_support, string_tests +class StrSubclass(str): + pass + class StrTest( string_tests.CommonTest, string_tests.MixinStrUnicodeUserStringTest, @@ -107,6 +110,9 @@ class StrTest( self.assertEqual(str(Foo6("bar")), "foos") self.assertEqual(str(Foo7("bar")), "foos") self.assertEqual(str(Foo8("foo")), "foofoo") + self.assertIs(type(str(Foo8("foo"))), Foo8) + self.assertEqual(StrSubclass(Foo8("foo")), "foofoo") + self.assertIs(type(StrSubclass(Foo8("foo"))), StrSubclass) self.assertEqual(str(Foo9("foo")), "string") self.assertEqual(unicode(Foo9("foo")), u"not unicode") diff -r de5582c569ff Lib/test/test_unicode.py --- a/Lib/test/test_unicode.py Sun Nov 22 14:56:22 2015 +0200 +++ b/Lib/test/test_unicode.py Mon Nov 23 01:10:34 2015 +0200 @@ -33,6 +33,9 @@ def search_function(encoding): return None codecs.register(search_function) +class UnicodeSubclass(unicode): + pass + class UnicodeTest( string_tests.CommonTest, string_tests.MixinStrUnicodeUserStringTest, @@ -685,9 +688,6 @@ class UnicodeTest( u'unicode remains unicode' ) - class UnicodeSubclass(unicode): - pass - self.assertEqual( unicode(UnicodeSubclass('unicode subclass becomes unicode')), u'unicode subclass becomes unicode' @@ -1269,6 +1269,9 @@ class UnicodeTest( self.assertEqual(unicode(Foo6("bar")), u"foou") self.assertEqual(unicode(Foo7("bar")), u"foou") self.assertEqual(unicode(Foo8("foo")), u"foofoo") + self.assertIs(type(unicode(Foo8("foo"))), Foo8) + self.assertEqual(UnicodeSubclass(Foo8("foo")), u"foofoo") + self.assertIs(type(UnicodeSubclass(Foo8("foo"))), UnicodeSubclass) self.assertEqual(str(Foo9("foo")), "string") self.assertEqual(unicode(Foo9("foo")), u"not unicode") diff -r de5582c569ff Objects/floatobject.c --- a/Objects/floatobject.c Sun Nov 22 14:56:22 2015 +0200 +++ b/Objects/floatobject.c Mon Nov 23 01:10:34 2015 +0200 @@ -1839,7 +1839,7 @@ float_subtype_new(PyTypeObject *type, Py tmp = float_new(&PyFloat_Type, args, kwds); if (tmp == NULL) return NULL; - assert(PyFloat_CheckExact(tmp)); + assert(PyFloat_Check(tmp)); newobj = type->tp_alloc(type, 0); if (newobj == NULL) { Py_DECREF(tmp); diff -r de5582c569ff Objects/longobject.c --- a/Objects/longobject.c Sun Nov 22 14:56:22 2015 +0200 +++ b/Objects/longobject.c Mon Nov 23 01:10:34 2015 +0200 @@ -4068,7 +4068,7 @@ long_subtype_new(PyTypeObject *type, PyO tmp = (PyLongObject *)long_new(&PyLong_Type, args, kwds); if (tmp == NULL) return NULL; - assert(PyLong_CheckExact(tmp)); + assert(PyLong_Check(tmp)); n = Py_SIZE(tmp); if (n < 0) n = -n; diff -r de5582c569ff Objects/stringobject.c --- a/Objects/stringobject.c Sun Nov 22 14:56:22 2015 +0200 +++ b/Objects/stringobject.c Mon Nov 23 01:10:34 2015 +0200 @@ -3719,7 +3719,7 @@ str_subtype_new(PyTypeObject *type, PyOb tmp = string_new(&PyString_Type, args, kwds); if (tmp == NULL) return NULL; - assert(PyString_CheckExact(tmp)); + assert(PyString_Check(tmp)); n = PyString_GET_SIZE(tmp); pnew = type->tp_alloc(type, n); if (pnew != NULL) {