diff --git a/Lib/test/support/number_helper.py b/Lib/test/support/number_helper.py
new file mode 100644
index 00000000000000..a39da4482f9c28
--- /dev/null
+++ b/Lib/test/support/number_helper.py
@@ -0,0 +1,71 @@
+# Common test classes for numeric types.
+
+class WithIndex:
+    def __init__(self, value):
+        self.value = value
+
+    def __index__(self):
+        return self.value
+
+
+class IntSubclass(int):
+    pass
+
+class WithInt:
+    def __init__(self, value):
+        self.value = value
+
+    def __int__(self):
+        return self.value
+
+class WithIntAndIndex:
+    def __init__(self, value):
+        self.value = value
+
+    def __index__(self):
+        return self.value
+
+    def __int__(self):
+        return self.value + 12
+
+
+class FloatSubclass(float):
+    pass
+
+class OtherFloatSubclass(float):
+    pass
+
+class WithFloat:
+    def __init__(self, value):
+        self.value = value
+
+    def __float__(self):
+        return self.value
+
+class FloatLikeSubclass(float):
+    def __init__(self, value):
+        self.value = value
+
+    def __float__(self):
+        return self.value.__class__(self.value*2)
+
+
+class ComplexSubclass(complex):
+    pass
+
+class OtherComplexSubclass(complex):
+    pass
+
+class WithComplex:
+    def __init__(self, value):
+        self.value = value
+
+    def __complex__(self):
+        return self.value
+
+class ComplexLikeSubclass(complex):
+    def __init__(self, value):
+        self.value = value
+
+    def __complex__(self):
+        return self.value.__class__(self.value*2)
diff --git a/Lib/test/test_capi/test_complex.py b/Lib/test/test_capi/test_complex.py
index 97e0eb3f043080..efbb293759e145 100644
--- a/Lib/test/test_capi/test_complex.py
+++ b/Lib/test/test_capi/test_complex.py
@@ -3,10 +3,9 @@
 import unittest
 import warnings
 
-from test.test_capi.test_getargs import (BadComplex, BadComplex2, Complex,
-                                         FloatSubclass, Float, BadFloat,
-                                         BadFloat2, ComplexSubclass)
 from test.support import import_helper
+from test.support.number_helper import (ComplexSubclass, FloatSubclass,
+                                        WithFloat, WithComplex)
 from test.support.testcase import ComplexesAreIdenticalMixin
 
 
@@ -31,7 +30,7 @@ def test_check(self):
 
         self.assertTrue(check(1+2j))
         self.assertTrue(check(ComplexSubclass(1+2j)))
-        self.assertFalse(check(Complex()))
+        self.assertFalse(check(WithComplex(4.25+0.5j)))
         self.assertFalse(check(3))
         self.assertFalse(check(3.0))
         self.assertFalse(check(object()))
@@ -44,7 +43,7 @@ def test_checkexact(self):
 
         self.assertTrue(checkexact(1+2j))
         self.assertFalse(checkexact(ComplexSubclass(1+2j)))
-        self.assertFalse(checkexact(Complex()))
+        self.assertFalse(checkexact(WithComplex(4.25+0.5j)))
         self.assertFalse(checkexact(3))
         self.assertFalse(checkexact(3.0))
         self.assertFalse(checkexact(object()))
@@ -79,20 +78,20 @@ def test_realasdouble(self):
         self.assertEqual(realasdouble(FloatSubclass(4.25)), 4.25)
 
         # Test types with __complex__ dunder method
-        self.assertEqual(realasdouble(Complex()), 4.25)
-        self.assertRaises(TypeError, realasdouble, BadComplex())
+        self.assertEqual(realasdouble(WithComplex(4.25+0.5j)), 4.25)
+        self.assertRaises(TypeError, realasdouble, WithComplex(1.25))
         with self.assertWarns(DeprecationWarning):
-            self.assertEqual(realasdouble(BadComplex2()), 4.25)
+            self.assertEqual(realasdouble(WithComplex(ComplexSubclass(4.25+0.5j))), 4.25)
         with warnings.catch_warnings():
             warnings.simplefilter("error", DeprecationWarning)
-            self.assertRaises(DeprecationWarning, realasdouble, BadComplex2())
+            self.assertRaises(DeprecationWarning, realasdouble, WithComplex(ComplexSubclass(4.25+0.5j)))
         self.assertRaises(RuntimeError, realasdouble, BadComplex3())
 
         # Test types with __float__ dunder method
-        self.assertEqual(realasdouble(Float()), 4.25)
-        self.assertRaises(TypeError, realasdouble, BadFloat())
+        self.assertEqual(realasdouble(WithFloat(4.25)), 4.25)
+        self.assertRaises(TypeError, realasdouble, WithFloat(687))
         with self.assertWarns(DeprecationWarning):
-            self.assertEqual(realasdouble(BadFloat2()), 4.25)
+            self.assertEqual(realasdouble(WithFloat(FloatSubclass(4.25))), 4.25)
 
         self.assertRaises(TypeError, realasdouble, object())
 
@@ -112,20 +111,20 @@ def test_imagasdouble(self):
         self.assertEqual(imagasdouble(FloatSubclass(4.25)), 0.0)
 
         # Test types with __complex__ dunder method
-        self.assertEqual(imagasdouble(Complex()), 0.5)
-        self.assertRaises(TypeError, imagasdouble, BadComplex())
+        self.assertEqual(imagasdouble(WithComplex(4.25+0.5j)), 0.5)
+        self.assertRaises(TypeError, imagasdouble, WithComplex(1.25))
         with self.assertWarns(DeprecationWarning):
-            self.assertEqual(imagasdouble(BadComplex2()), 0.5)
+            self.assertEqual(imagasdouble(WithComplex(ComplexSubclass(4.25+0.5j))), 0.5)
         with warnings.catch_warnings():
             warnings.simplefilter("error", DeprecationWarning)
-            self.assertRaises(DeprecationWarning, imagasdouble, BadComplex2())
+            self.assertRaises(DeprecationWarning, imagasdouble, WithComplex(ComplexSubclass(4.25+0.5j)))
         self.assertRaises(RuntimeError, imagasdouble, BadComplex3())
 
         # Test types with __float__ dunder method
-        self.assertEqual(imagasdouble(Float()), 0.0)
-        self.assertRaises(TypeError, imagasdouble, BadFloat())
+        self.assertEqual(imagasdouble(WithFloat(4.25)), 0.0)
+        self.assertRaises(TypeError, imagasdouble, WithFloat(687))
         with self.assertWarns(DeprecationWarning):
-            self.assertEqual(imagasdouble(BadFloat2()), 0.0)
+            self.assertEqual(imagasdouble(WithFloat(FloatSubclass(4.25))), 0.0)
 
         self.assertRaises(TypeError, imagasdouble, object())
 
@@ -147,20 +146,20 @@ def test_asccomplex(self):
         self.assertEqual(asccomplex(FloatSubclass(4.25)), 4.25+0.0j)
 
         # Test types with __complex__ dunder method
-        self.assertEqual(asccomplex(Complex()), 4.25+0.5j)
-        self.assertRaises(TypeError, asccomplex, BadComplex())
+        self.assertEqual(asccomplex(WithComplex(4.25+0.5j)), 4.25+0.5j)
+        self.assertRaises(TypeError, asccomplex, WithComplex(1.25))
         with self.assertWarns(DeprecationWarning):
-            self.assertEqual(asccomplex(BadComplex2()), 4.25+0.5j)
+            self.assertEqual(asccomplex(WithComplex(ComplexSubclass(4.25+0.5j))), 4.25+0.5j)
         with warnings.catch_warnings():
             warnings.simplefilter("error", DeprecationWarning)
-            self.assertRaises(DeprecationWarning, asccomplex, BadComplex2())
+            self.assertRaises(DeprecationWarning, asccomplex, WithComplex(ComplexSubclass(4.25+0.5j)))
         self.assertRaises(RuntimeError, asccomplex, BadComplex3())
 
         # Test types with __float__ dunder method
-        self.assertEqual(asccomplex(Float()), 4.25+0.0j)
-        self.assertRaises(TypeError, asccomplex, BadFloat())
+        self.assertEqual(asccomplex(WithFloat(4.25)), 4.25+0.0j)
+        self.assertRaises(TypeError, asccomplex, WithFloat(687))
         with self.assertWarns(DeprecationWarning):
-            self.assertEqual(asccomplex(BadFloat2()), 4.25+0.0j)
+            self.assertEqual(asccomplex(WithFloat(FloatSubclass(4.25))), 4.25+0.0j)
 
         self.assertRaises(TypeError, asccomplex, object())
 
diff --git a/Lib/test/test_capi/test_float.py b/Lib/test/test_capi/test_float.py
index 92c987794142c9..7cd8b8f36547be 100644
--- a/Lib/test/test_capi/test_float.py
+++ b/Lib/test/test_capi/test_float.py
@@ -3,10 +3,8 @@
 import unittest
 import warnings
 
-from test.test_capi.test_getargs import (Float, FloatSubclass, FloatSubclass2,
-                                         BadIndex2, BadFloat2, Index, BadIndex,
-                                         BadFloat)
 from test.support import import_helper
+from test.support.number_helper import FloatSubclass, WithIndex, WithFloat
 
 _testcapi = import_helper.import_module('_testcapi')
 _testlimitedcapi = import_helper.import_module('_testlimitedcapi')
@@ -27,6 +25,10 @@
 NAN = float("nan")
 
 
+class FloatSubclass2(WithFloat, FloatSubclass):
+    pass
+
+
 class CAPIFloatTest(unittest.TestCase):
     def test_check(self):
         # Test PyFloat_Check()
@@ -34,7 +36,7 @@ def test_check(self):
 
         self.assertTrue(check(4.25))
         self.assertTrue(check(FloatSubclass(4.25)))
-        self.assertFalse(check(Float()))
+        self.assertFalse(check(WithFloat(4.25)))
         self.assertFalse(check(3))
         self.assertFalse(check(object()))
 
@@ -46,7 +48,7 @@ def test_checkexact(self):
 
         self.assertTrue(checkexact(4.25))
         self.assertFalse(checkexact(FloatSubclass(4.25)))
-        self.assertFalse(checkexact(Float()))
+        self.assertFalse(checkexact(WithFloat(4.25)))
         self.assertFalse(checkexact(3))
         self.assertFalse(checkexact(object()))
 
@@ -93,18 +95,18 @@ def __float__(self):
 
         self.assertEqual(asdouble(FloatSubclass(4.25)), 4.25)
         self.assertEqual(asdouble(FloatSubclass2(4.25)), 4.25)
-        self.assertEqual(asdouble(Index()), 99.)
+        self.assertEqual(asdouble(WithIndex(99)), 99.)
 
-        self.assertRaises(TypeError, asdouble, BadIndex())
-        self.assertRaises(TypeError, asdouble, BadFloat())
+        self.assertRaises(TypeError, asdouble, WithIndex(1.0))
+        self.assertRaises(TypeError, asdouble, WithFloat(687))
         self.assertRaises(RuntimeError, asdouble, BadFloat3())
         with self.assertWarns(DeprecationWarning):
-            self.assertEqual(asdouble(BadIndex2()), 1.)
+            self.assertEqual(asdouble(WithIndex(True)), 1.)
         with self.assertWarns(DeprecationWarning):
-            self.assertEqual(asdouble(BadFloat2()), 4.25)
+            self.assertEqual(asdouble(WithFloat(FloatSubclass(4.25))), 4.25)
         with warnings.catch_warnings():
             warnings.simplefilter("error", DeprecationWarning)
-            self.assertRaises(DeprecationWarning, asdouble, BadFloat2())
+            self.assertRaises(DeprecationWarning, asdouble, WithFloat(FloatSubclass(4.25)))
         self.assertRaises(TypeError, asdouble, object())
         self.assertRaises(TypeError, asdouble, NULL)
 
diff --git a/Lib/test/test_capi/test_getargs.py b/Lib/test/test_capi/test_getargs.py
index b9cad8d2600e56..eb5032ae3817c1 100644
--- a/Lib/test/test_capi/test_getargs.py
+++ b/Lib/test/test_capi/test_getargs.py
@@ -5,6 +5,9 @@
 from test.support import import_helper
 from test.support import script_helper
 from test.support import warnings_helper
+from test.support.number_helper import (ComplexSubclass, FloatSubclass,
+                                        WithComplex, WithFloat, WithIndex,
+                                        WithInt)
 from test.support.testcase import FloatsAreIdenticalMixin
 # Skip this test if the _testcapi module isn't available.
 _testcapi = import_helper.import_module('_testcapi')
@@ -66,91 +69,35 @@
 class CustomError(Exception):
     pass
 
-class Index:
-    def __index__(self):
-        return 99
-
 class IndexIntSubclass(int):
     def __index__(self):
         return 99
 
-class BadIndex:
-    def __index__(self):
-        return 1.0
-
-class BadIndex2:
-    def __index__(self):
-        return True
-
 class BadIndex3(int):
     def __index__(self):
         return True
 
 
-class Int:
-    def __int__(self):
-        return 99
-
 class IntSubclass(int):
     def __int__(self):
         return 99
 
-class BadInt:
-    def __int__(self):
-        return 1.0
-
-class BadInt2:
-    def __int__(self):
-        return True
-
 class BadInt3(int):
     def __int__(self):
         return True
 
-
-class Float:
-    def __float__(self):
-        return 4.25
-
-class FloatSubclass(float):
-    pass
-
 class FloatSubclass2(float):
     def __float__(self):
         return 4.25
 
-class BadFloat:
-    def __float__(self):
-        return 687
-
-class BadFloat2:
-    def __float__(self):
-        return FloatSubclass(4.25)
-
 class BadFloat3(float):
     def __float__(self):
         return FloatSubclass(4.25)
 
-
-class Complex:
-    def __complex__(self):
-        return 4.25+0.5j
-
-class ComplexSubclass(complex):
-    pass
-
 class ComplexSubclass2(complex):
     def __complex__(self):
         return 4.25+0.5j
 
-class BadComplex:
-    def __complex__(self):
-        return 1.25
-
-class BadComplex2:
-    def __complex__(self):
-        return ComplexSubclass(4.25+0.5j)
-
 class BadComplex3(complex):
     def __complex__(self):
         return ComplexSubclass(4.25+0.5j)
@@ -170,16 +117,16 @@ def test_b(self):
         from _testcapi import getargs_b
         # b returns 'unsigned char', and does range checking (0 ... UCHAR_MAX)
         self.assertRaises(TypeError, getargs_b, 3.14)
-        self.assertEqual(99, getargs_b(Index()))
+        self.assertEqual(99, getargs_b(WithIndex(99)))
         self.assertEqual(0, getargs_b(IndexIntSubclass()))
-        self.assertRaises(TypeError, getargs_b, BadIndex())
+        self.assertRaises(TypeError, getargs_b, WithIndex(1.0))
         with self.assertWarns(DeprecationWarning):
-            self.assertEqual(1, getargs_b(BadIndex2()))
+            self.assertEqual(1, getargs_b(WithIndex(True)))
         self.assertEqual(0, getargs_b(BadIndex3()))
-        self.assertRaises(TypeError, getargs_b, Int())
+        self.assertRaises(TypeError, getargs_b, WithInt(99))
         self.assertEqual(0, getargs_b(IntSubclass()))
-        self.assertRaises(TypeError, getargs_b, BadInt())
-        self.assertRaises(TypeError, getargs_b, BadInt2())
+        self.assertRaises(TypeError, getargs_b, WithInt(1.0))
+        self.assertRaises(TypeError, getargs_b, WithInt(True))
         self.assertEqual(0, getargs_b(BadInt3()))
 
         self.assertRaises(OverflowError, getargs_b, -1)
@@ -194,16 +141,16 @@ def test_B(self):
         from _testcapi import getargs_B
         # B returns 'unsigned char', no range checking
         self.assertRaises(TypeError, getargs_B, 3.14)
-        self.assertEqual(99, getargs_B(Index()))
+        self.assertEqual(99, getargs_B(WithIndex(99)))
         self.assertEqual(0, getargs_B(IndexIntSubclass()))
-        self.assertRaises(TypeError, getargs_B, BadIndex())
+        self.assertRaises(TypeError, getargs_B, WithIndex(1.0))
         with self.assertWarns(DeprecationWarning):
-            self.assertEqual(1, getargs_B(BadIndex2()))
+            self.assertEqual(1, getargs_B(WithIndex(True)))
         self.assertEqual(0, getargs_B(BadIndex3()))
-        self.assertRaises(TypeError, getargs_B, Int())
+        self.assertRaises(TypeError, getargs_B, WithInt(99))
         self.assertEqual(0, getargs_B(IntSubclass()))
-        self.assertRaises(TypeError, getargs_B, BadInt())
-        self.assertRaises(TypeError, getargs_B, BadInt2())
+        self.assertRaises(TypeError, getargs_B, WithInt(1.0))
+        self.assertRaises(TypeError, getargs_B, WithInt(True))
         self.assertEqual(0, getargs_B(BadInt3()))
 
         self.assertEqual(UCHAR_MAX, getargs_B(-1))
@@ -218,16 +165,16 @@ def test_H(self):
         from _testcapi import getargs_H
         # H returns 'unsigned short', no range checking
         self.assertRaises(TypeError, getargs_H, 3.14)
-        self.assertEqual(99, getargs_H(Index()))
+        self.assertEqual(99, getargs_H(WithIndex(99)))
         self.assertEqual(0, getargs_H(IndexIntSubclass()))
-        self.assertRaises(TypeError, getargs_H, BadIndex())
+        self.assertRaises(TypeError, getargs_H, WithIndex(1.0))
         with self.assertWarns(DeprecationWarning):
-            self.assertEqual(1, getargs_H(BadIndex2()))
+            self.assertEqual(1, getargs_H(WithIndex(True)))
         self.assertEqual(0, getargs_H(BadIndex3()))
-        self.assertRaises(TypeError, getargs_H, Int())
+        self.assertRaises(TypeError, getargs_H, WithInt(99))
         self.assertEqual(0, getargs_H(IntSubclass()))
-        self.assertRaises(TypeError, getargs_H, BadInt())
-        self.assertRaises(TypeError, getargs_H, BadInt2())
+        self.assertRaises(TypeError, getargs_H, WithInt(1.0))
+        self.assertRaises(TypeError, getargs_H, WithInt(True))
         self.assertEqual(0, getargs_H(BadInt3()))
 
         self.assertEqual(USHRT_MAX, getargs_H(-1))
@@ -243,16 +190,16 @@ def test_I(self):
         from _testcapi import getargs_I
         # I returns 'unsigned int', no range checking
         self.assertRaises(TypeError, getargs_I, 3.14)
-        self.assertEqual(99, getargs_I(Index()))
+        self.assertEqual(99, getargs_I(WithIndex(99)))
         self.assertEqual(0, getargs_I(IndexIntSubclass()))
-        self.assertRaises(TypeError, getargs_I, BadIndex())
+        self.assertRaises(TypeError, getargs_I, WithIndex(1.0))
         with self.assertWarns(DeprecationWarning):
-            self.assertEqual(1, getargs_I(BadIndex2()))
+            self.assertEqual(1, getargs_I(WithIndex(True)))
         self.assertEqual(0, getargs_I(BadIndex3()))
-        self.assertRaises(TypeError, getargs_I, Int())
+        self.assertRaises(TypeError, getargs_I, WithInt(99))
         self.assertEqual(0, getargs_I(IntSubclass()))
-        self.assertRaises(TypeError, getargs_I, BadInt())
-        self.assertRaises(TypeError, getargs_I, BadInt2())
+        self.assertRaises(TypeError, getargs_I, WithInt(1.0))
+        self.assertRaises(TypeError, getargs_I, WithInt(True))
         self.assertEqual(0, getargs_I(BadInt3()))
 
         self.assertEqual(UINT_MAX, getargs_I(-1))
@@ -269,15 +216,15 @@ def test_k(self):
         # k returns 'unsigned long', no range checking
         # it does not accept float, or instances with __int__
         self.assertRaises(TypeError, getargs_k, 3.14)
-        self.assertRaises(TypeError, getargs_k, Index())
+        self.assertRaises(TypeError, getargs_k, WithIndex(99))
         self.assertEqual(0, getargs_k(IndexIntSubclass()))
-        self.assertRaises(TypeError, getargs_k, BadIndex())
-        self.assertRaises(TypeError, getargs_k, BadIndex2())
+        self.assertRaises(TypeError, getargs_k, WithIndex(1.0))
+        self.assertRaises(TypeError, getargs_k, WithIndex(True))
         self.assertEqual(0, getargs_k(BadIndex3()))
-        self.assertRaises(TypeError, getargs_k, Int())
+        self.assertRaises(TypeError, getargs_k, WithInt(99))
         self.assertEqual(0, getargs_k(IntSubclass()))
-        self.assertRaises(TypeError, getargs_k, BadInt())
-        self.assertRaises(TypeError, getargs_k, BadInt2())
+        self.assertRaises(TypeError, getargs_k, WithInt(1.0))
+        self.assertRaises(TypeError, getargs_k, WithInt(True))
         self.assertEqual(0, getargs_k(BadInt3()))
 
         self.assertEqual(ULONG_MAX, getargs_k(-1))
@@ -294,16 +241,16 @@ def test_h(self):
         from _testcapi import getargs_h
         # h returns 'short', and does range checking (SHRT_MIN ... SHRT_MAX)
         self.assertRaises(TypeError, getargs_h, 3.14)
-        self.assertEqual(99, getargs_h(Index()))
+        self.assertEqual(99, getargs_h(WithIndex(99)))
         self.assertEqual(0, getargs_h(IndexIntSubclass()))
-        self.assertRaises(TypeError, getargs_h, BadIndex())
+        self.assertRaises(TypeError, getargs_h, WithIndex(1.0))
         with self.assertWarns(DeprecationWarning):
-            self.assertEqual(1, getargs_h(BadIndex2()))
+            self.assertEqual(1, getargs_h(WithIndex(True)))
         self.assertEqual(0, getargs_h(BadIndex3()))
-        self.assertRaises(TypeError, getargs_h, Int())
+        self.assertRaises(TypeError, getargs_h, WithInt(99))
         self.assertEqual(0, getargs_h(IntSubclass()))
-        self.assertRaises(TypeError, getargs_h, BadInt())
-        self.assertRaises(TypeError, getargs_h, BadInt2())
+        self.assertRaises(TypeError, getargs_h, WithInt(1.0))
+        self.assertRaises(TypeError, getargs_h, WithInt(True))
         self.assertEqual(0, getargs_h(BadInt3()))
 
         self.assertRaises(OverflowError, getargs_h, SHRT_MIN-1)
@@ -318,16 +265,16 @@ def test_i(self):
         from _testcapi import getargs_i
         # i returns 'int', and does range checking (INT_MIN ... INT_MAX)
         self.assertRaises(TypeError, getargs_i, 3.14)
-        self.assertEqual(99, getargs_i(Index()))
+        self.assertEqual(99, getargs_i(WithIndex(99)))
         self.assertEqual(0, getargs_i(IndexIntSubclass()))
-        self.assertRaises(TypeError, getargs_i, BadIndex())
+        self.assertRaises(TypeError, getargs_i, WithIndex(1.0))
         with self.assertWarns(DeprecationWarning):
-            self.assertEqual(1, getargs_i(BadIndex2()))
+            self.assertEqual(1, getargs_i(WithIndex(True)))
         self.assertEqual(0, getargs_i(BadIndex3()))
-        self.assertRaises(TypeError, getargs_i, Int())
+        self.assertRaises(TypeError, getargs_i, WithInt(99))
         self.assertEqual(0, getargs_i(IntSubclass()))
-        self.assertRaises(TypeError, getargs_i, BadInt())
-        self.assertRaises(TypeError, getargs_i, BadInt2())
+        self.assertRaises(TypeError, getargs_i, WithInt(1.0))
+        self.assertRaises(TypeError, getargs_i, WithInt(True))
         self.assertEqual(0, getargs_i(BadInt3()))
 
         self.assertRaises(OverflowError, getargs_i, INT_MIN-1)
@@ -342,16 +289,16 @@ def test_l(self):
         from _testcapi import getargs_l
         # l returns 'long', and does range checking (LONG_MIN ... LONG_MAX)
         self.assertRaises(TypeError, getargs_l, 3.14)
-        self.assertEqual(99, getargs_l(Index()))
+        self.assertEqual(99, getargs_l(WithIndex(99)))
         self.assertEqual(0, getargs_l(IndexIntSubclass()))
-        self.assertRaises(TypeError, getargs_l, BadIndex())
+        self.assertRaises(TypeError, getargs_l, WithIndex(1.0))
         with self.assertWarns(DeprecationWarning):
-            self.assertEqual(1, getargs_l(BadIndex2()))
+            self.assertEqual(1, getargs_l(WithIndex(True)))
         self.assertEqual(0, getargs_l(BadIndex3()))
-        self.assertRaises(TypeError, getargs_l, Int())
+        self.assertRaises(TypeError, getargs_l, WithInt(99))
         self.assertEqual(0, getargs_l(IntSubclass()))
-        self.assertRaises(TypeError, getargs_l, BadInt())
-        self.assertRaises(TypeError, getargs_l, BadInt2())
+        self.assertRaises(TypeError, getargs_l, WithInt(1.0))
+        self.assertRaises(TypeError, getargs_l, WithInt(True))
         self.assertEqual(0, getargs_l(BadInt3()))
 
         self.assertRaises(OverflowError, getargs_l, LONG_MIN-1)
@@ -367,16 +314,16 @@ def test_n(self):
         # n returns 'Py_ssize_t', and does range checking
         # (PY_SSIZE_T_MIN ... PY_SSIZE_T_MAX)
         self.assertRaises(TypeError, getargs_n, 3.14)
-        self.assertEqual(99, getargs_n(Index()))
+        self.assertEqual(99, getargs_n(WithIndex(99)))
         self.assertEqual(0, getargs_n(IndexIntSubclass()))
-        self.assertRaises(TypeError, getargs_n, BadIndex())
+        self.assertRaises(TypeError, getargs_n, WithIndex(1.0))
         with self.assertWarns(DeprecationWarning):
-            self.assertEqual(1, getargs_n(BadIndex2()))
+            self.assertEqual(1, getargs_n(WithIndex(True)))
         self.assertEqual(0, getargs_n(BadIndex3()))
-        self.assertRaises(TypeError, getargs_n, Int())
+        self.assertRaises(TypeError, getargs_n, WithInt(99))
         self.assertEqual(0, getargs_n(IntSubclass()))
-        self.assertRaises(TypeError, getargs_n, BadInt())
-        self.assertRaises(TypeError, getargs_n, BadInt2())
+        self.assertRaises(TypeError, getargs_n, WithInt(1.0))
+        self.assertRaises(TypeError, getargs_n, WithInt(True))
         self.assertEqual(0, getargs_n(BadInt3()))
 
         self.assertRaises(OverflowError, getargs_n, PY_SSIZE_T_MIN-1)
@@ -395,16 +342,16 @@ def test_L(self):
         # ... LLONG_MAX)
         self.assertRaises(TypeError, getargs_L, 3.14)
         self.assertRaises(TypeError, getargs_L, "Hello")
-        self.assertEqual(99, getargs_L(Index()))
+        self.assertEqual(99, getargs_L(WithIndex(99)))
         self.assertEqual(0, getargs_L(IndexIntSubclass()))
-        self.assertRaises(TypeError, getargs_L, BadIndex())
+        self.assertRaises(TypeError, getargs_L, WithIndex(1.0))
         with self.assertWarns(DeprecationWarning):
-            self.assertEqual(1, getargs_L(BadIndex2()))
+            self.assertEqual(1, getargs_L(WithIndex(True)))
         self.assertEqual(0, getargs_L(BadIndex3()))
-        self.assertRaises(TypeError, getargs_L, Int())
+        self.assertRaises(TypeError, getargs_L, WithInt(99))
         self.assertEqual(0, getargs_L(IntSubclass()))
-        self.assertRaises(TypeError, getargs_L, BadInt())
-        self.assertRaises(TypeError, getargs_L, BadInt2())
+        self.assertRaises(TypeError, getargs_L, WithInt(1.0))
+        self.assertRaises(TypeError, getargs_L, WithInt(True))
         self.assertEqual(0, getargs_L(BadInt3()))
 
         self.assertRaises(OverflowError, getargs_L, LLONG_MIN-1)
@@ -419,15 +366,15 @@ def test_K(self):
         from _testcapi import getargs_K
         # K return 'unsigned long long', no range checking
         self.assertRaises(TypeError, getargs_K, 3.14)
-        self.assertRaises(TypeError, getargs_K, Index())
+        self.assertRaises(TypeError, getargs_K, WithIndex(99))
         self.assertEqual(0, getargs_K(IndexIntSubclass()))
-        self.assertRaises(TypeError, getargs_K, BadIndex())
-        self.assertRaises(TypeError, getargs_K, BadIndex2())
+        self.assertRaises(TypeError, getargs_K, WithIndex(1.0))
+        self.assertRaises(TypeError, getargs_K, WithIndex(True))
         self.assertEqual(0, getargs_K(BadIndex3()))
-        self.assertRaises(TypeError, getargs_K, Int())
+        self.assertRaises(TypeError, getargs_K, WithInt(99))
         self.assertEqual(0, getargs_K(IntSubclass()))
-        self.assertRaises(TypeError, getargs_K, BadInt())
-        self.assertRaises(TypeError, getargs_K, BadInt2())
+        self.assertRaises(TypeError, getargs_K, WithInt(1.0))
+        self.assertRaises(TypeError, getargs_K, WithInt(True))
         self.assertEqual(0, getargs_K(BadInt3()))
 
         self.assertEqual(ULLONG_MAX, getargs_K(ULLONG_MAX))
@@ -445,15 +392,15 @@ def test_f(self):
         self.assertEqual(getargs_f(4.25), 4.25)
         self.assertEqual(getargs_f(4), 4.0)
         self.assertRaises(TypeError, getargs_f, 4.25+0j)
-        self.assertEqual(getargs_f(Float()), 4.25)
+        self.assertEqual(getargs_f(WithFloat(4.25)), 4.25)
         self.assertEqual(getargs_f(FloatSubclass(7.5)), 7.5)
         self.assertEqual(getargs_f(FloatSubclass2(7.5)), 7.5)
-        self.assertRaises(TypeError, getargs_f, BadFloat())
+        self.assertRaises(TypeError, getargs_f, WithFloat(687))
         with self.assertWarns(DeprecationWarning):
-            self.assertEqual(getargs_f(BadFloat2()), 4.25)
+            self.assertEqual(getargs_f(WithFloat(FloatSubclass(4.25))), 4.25)
         self.assertEqual(getargs_f(BadFloat3(7.5)), 7.5)
-        self.assertEqual(getargs_f(Index()), 99.0)
-        self.assertRaises(TypeError, getargs_f, Int())
+        self.assertEqual(getargs_f(WithIndex(99)), 99.0)
+        self.assertRaises(TypeError, getargs_f, WithInt(99))
 
         for x in (FLT_MIN, -FLT_MIN, FLT_MAX, -FLT_MAX, INF, -INF):
             self.assertEqual(getargs_f(x), x)
@@ -479,15 +426,15 @@ def test_d(self):
         self.assertEqual(getargs_d(4.25), 4.25)
         self.assertEqual(getargs_d(4), 4.0)
         self.assertRaises(TypeError, getargs_d, 4.25+0j)
-        self.assertEqual(getargs_d(Float()), 4.25)
+        self.assertEqual(getargs_d(WithFloat(4.25)), 4.25)
         self.assertEqual(getargs_d(FloatSubclass(7.5)), 7.5)
         self.assertEqual(getargs_d(FloatSubclass2(7.5)), 7.5)
-        self.assertRaises(TypeError, getargs_d, BadFloat())
+        self.assertRaises(TypeError, getargs_d, WithFloat(687))
         with self.assertWarns(DeprecationWarning):
-            self.assertEqual(getargs_d(BadFloat2()), 4.25)
+            self.assertEqual(getargs_d(WithFloat(FloatSubclass(4.25))), 4.25)
         self.assertEqual(getargs_d(BadFloat3(7.5)), 7.5)
-        self.assertEqual(getargs_d(Index()), 99.0)
-        self.assertRaises(TypeError, getargs_d, Int())
+        self.assertEqual(getargs_d(WithIndex(99)), 99.0)
+        self.assertRaises(TypeError, getargs_d, WithInt(99))
 
         for x in (DBL_MIN, -DBL_MIN, DBL_MAX, -DBL_MAX, INF, -INF):
             self.assertEqual(getargs_d(x), x)
@@ -503,15 +450,15 @@ def test_D(self):
         self.assertEqual(getargs_D(4.25+0.5j), 4.25+0.5j)
         self.assertEqual(getargs_D(4.25), 4.25+0j)
         self.assertEqual(getargs_D(4), 4.0+0j)
-        self.assertEqual(getargs_D(Complex()), 4.25+0.5j)
+        self.assertEqual(getargs_D(WithComplex(4.25+0.5j)), 4.25+0.5j)
         self.assertEqual(getargs_D(ComplexSubclass(7.5+0.25j)), 7.5+0.25j)
         self.assertEqual(getargs_D(ComplexSubclass2(7.5+0.25j)), 7.5+0.25j)
-        self.assertRaises(TypeError, getargs_D, BadComplex())
+        self.assertRaises(TypeError, getargs_D, WithComplex(1.25))
         with self.assertWarns(DeprecationWarning):
-            self.assertEqual(getargs_D(BadComplex2()), 4.25+0.5j)
+            self.assertEqual(getargs_D(WithComplex(ComplexSubclass(4.25+0.5j))), 4.25+0.5j)
         self.assertEqual(getargs_D(BadComplex3(7.5+0.25j)), 7.5+0.25j)
-        self.assertEqual(getargs_D(Index()), 99.0+0j)
-        self.assertRaises(TypeError, getargs_D, Int())
+        self.assertEqual(getargs_D(WithIndex(99)), 99.0+0j)
+        self.assertRaises(TypeError, getargs_D, WithInt(99))
 
         for x in (DBL_MIN, -DBL_MIN, DBL_MAX, -DBL_MAX, INF, -INF):
             c = complex(x, 1.0)
diff --git a/Lib/test/test_capi/test_long.py b/Lib/test/test_capi/test_long.py
index d3156645eeec2d..359207dc053c8e 100644
--- a/Lib/test/test_capi/test_long.py
+++ b/Lib/test/test_capi/test_long.py
@@ -3,6 +3,7 @@
 import test.support as support
 
 from test.support import import_helper
+from test.support.number_helper import IntSubclass, WithIndex, WithIntAndIndex
 
 # Skip this test if the _testcapi and _testlimitedcapi modules isn't available.
 _testcapi = import_helper.import_module('_testcapi')
@@ -11,24 +12,6 @@
 NULL = None
 
 
-class IntSubclass(int):
-    pass
-
-class Index:
-    def __init__(self, value):
-        self.value = value
-
-    def __index__(self):
-        return self.value
-
-# use __index__(), not __int__()
-class MyIndexAndInt:
-    def __index__(self):
-        return 10
-    def __int__(self):
-        return 22
-
-
 class LongTests(unittest.TestCase):
 
     def test_compact(self):
@@ -176,13 +159,13 @@ def check_long_asint(self, func, min_val, max_val, *,
                 self.assertEqual(func(value), value)
                 self.assertEqual(func(IntSubclass(value)), value)
                 if use_index:
-                    self.assertEqual(func(Index(value)), value)
+                    self.assertEqual(func(WithIndex(value)), value)
 
         if use_index:
-            self.assertEqual(func(MyIndexAndInt()), 10)
+            self.assertEqual(func(WithIntAndIndex(10)), 10)
         else:
-            self.assertRaises(TypeError, func, Index(42))
-            self.assertRaises(TypeError, func, MyIndexAndInt())
+            self.assertRaises(TypeError, func, WithIndex(42))
+            self.assertRaises(TypeError, func, WithIntAndIndex(10))
 
         if mask:
             self.assertEqual(func(min_val - 1), max_val)
@@ -205,9 +188,9 @@ def check_long_asintandoverflow(self, func, min_val, max_val):
             with self.subTest(value=value):
                 self.assertEqual(func(value), (value, 0))
                 self.assertEqual(func(IntSubclass(value)), (value, 0))
-                self.assertEqual(func(Index(value)), (value, 0))
+                self.assertEqual(func(WithIndex(value)), (value, 0))
 
-        self.assertEqual(func(MyIndexAndInt()), (10, 0))
+        self.assertEqual(func(WithIntAndIndex(10)), (10, 0))
 
         self.assertEqual(func(min_val - 1), (-1, -1))
         self.assertEqual(func(max_val + 1), (-1, +1))
@@ -292,8 +275,8 @@ def test_long_asdouble(self):
                 self.assertIsInstance(asdouble(value), float)
 
         self.assertEqual(asdouble(IntSubclass(42)), 42.0)
-        self.assertRaises(TypeError, asdouble, Index(42))
-        self.assertRaises(TypeError, asdouble, MyIndexAndInt())
+        self.assertRaises(TypeError, asdouble, WithIndex(42))
+        self.assertRaises(TypeError, asdouble, WithIntAndIndex(10))
 
         self.assertRaises(OverflowError, asdouble, 2 * MAX)
         self.assertRaises(OverflowError, asdouble, -2 * MAX)
@@ -320,7 +303,7 @@ def test_long_asvoidptr(self):
         if y >= M//2:
             self.assertIs(asvoidptr(y - M), NULL)
 
-        self.assertRaises(TypeError, asvoidptr, Index(x))
+        self.assertRaises(TypeError, asvoidptr, WithIndex(x))
         self.assertRaises(TypeError, asvoidptr, object())
         self.assertRaises(OverflowError, asvoidptr, 2**1000)
         self.assertRaises(OverflowError, asvoidptr, -2**1000)
@@ -397,8 +380,8 @@ def test_long_asnativebytes(self):
                     "buffer overwritten when it should not have been")
                 # Also check via the __index__ path.
                 # We pass Py_ASNATIVEBYTES_NATIVE_ENDIAN | ALLOW_INDEX
-                self.assertEqual(expect, asnativebytes(Index(v), buffer, 0, 3 | 16),
-                    "PyLong_AsNativeBytes(Index(v), <unknown>, 0, -1)")
+                self.assertEqual(expect, asnativebytes(WithIndex(v), buffer, 0, 3 | 16),
+                    "PyLong_AsNativeBytes(WithIndex(v), <unknown>, 0, -1)")
                 self.assertEqual(buffer, b"\x5a",
                     "buffer overwritten when it should not have been")
 
@@ -509,9 +492,9 @@ def test_long_asnativebytes(self):
 
         # Ensure omitting Py_ASNATIVEBYTES_ALLOW_INDEX raises on __index__ value
         with self.assertRaises(TypeError):
-            asnativebytes(Index(1), buffer, 0, -1)
+            asnativebytes(WithIndex(1), buffer, 0, -1)
         with self.assertRaises(TypeError):
-            asnativebytes(Index(1), buffer, 0, 3)
+            asnativebytes(WithIndex(1), buffer, 0, 3)
 
         # Check a few error conditions. These are validated in code, but are
         # unspecified in docs, so if we make changes to the implementation, it's
@@ -639,7 +622,7 @@ def test_long_getsign(self):
         self.assertEqual(getsign(False), 0)
 
         self.assertRaises(TypeError, getsign, 1.0)
-        self.assertRaises(TypeError, getsign, Index(123))
+        self.assertRaises(TypeError, getsign, WithIndex(123))
 
         # CRASHES getsign(NULL)
 
@@ -654,7 +637,7 @@ def test_long_ispositive(self):
         self.assertEqual(ispositive(False), 0)
         self.assertEqual(ispositive(IntSubclass(-1)), 0)
         self.assertRaises(TypeError, ispositive, 1.0)
-        self.assertRaises(TypeError, ispositive, Index(123))
+        self.assertRaises(TypeError, ispositive, WithIndex(123))
 
         # CRASHES ispositive(NULL)
 
@@ -669,7 +652,7 @@ def test_long_isnegative(self):
         self.assertEqual(isnegative(False), 0)
         self.assertEqual(isnegative(IntSubclass(-1)), 1)
         self.assertRaises(TypeError, isnegative, 1.0)
-        self.assertRaises(TypeError, isnegative, Index(123))
+        self.assertRaises(TypeError, isnegative, WithIndex(123))
 
         # CRASHES isnegative(NULL)
 
@@ -684,7 +667,7 @@ def test_long_iszero(self):
         self.assertEqual(iszero(IntSubclass(-1)), 0)
         self.assertEqual(iszero(IntSubclass(0)), 1)
         self.assertRaises(TypeError, iszero, 1.0)
-        self.assertRaises(TypeError, iszero, Index(123))
+        self.assertRaises(TypeError, iszero, WithIndex(123))
 
         # CRASHES iszero(NULL)
 
diff --git a/Lib/test/test_complex.py b/Lib/test/test_complex.py
index 0c7e7341f13d4e..7cbe60d41689ef 100644
--- a/Lib/test/test_complex.py
+++ b/Lib/test/test_complex.py
@@ -6,6 +6,9 @@
     VALID_UNDERSCORE_LITERALS,
     INVALID_UNDERSCORE_LITERALS,
 )
+from test.support.number_helper import (ComplexSubclass, WithComplex,
+                                        WithFloat, WithIndex, WithInt,
+                                        OtherComplexSubclass)
 
 from random import random
 from math import isnan, copysign
@@ -24,36 +27,6 @@
     (1, 0+0j),
 )
 
-class WithIndex:
-    def __init__(self, value):
-        self.value = value
-    def __index__(self):
-        return self.value
-
-class WithFloat:
-    def __init__(self, value):
-        self.value = value
-    def __float__(self):
-        return self.value
-
-class ComplexSubclass(complex):
-    pass
-
-class OtherComplexSubclass(complex):
-    pass
-
-class MyInt:
-    def __init__(self, value):
-        self.value = value
-
-    def __int__(self):
-        return self.value
-
-class WithComplex:
-    def __init__(self, value):
-        self.value = value
-    def __complex__(self):
-        return self.value
 
 class ComplexTest(ComplexesAreIdenticalMixin, unittest.TestCase):
 
@@ -599,13 +572,9 @@ def __complex__(self):
         self.assertRaises(TypeError, complex, WithIndex(None), 1.5)
         self.assertRaises(TypeError, complex, 1.5, WithIndex(None))
 
-        class MyInt:
-            def __int__(self):
-                return 42
-
-        self.assertRaises(TypeError, complex, MyInt())
-        self.assertRaises(TypeError, complex, MyInt(), 1.5)
-        self.assertRaises(TypeError, complex, 1.5, MyInt())
+        self.assertRaises(TypeError, complex, WithInt(42))
+        self.assertRaises(TypeError, complex, WithInt(42), 1.5)
+        self.assertRaises(TypeError, complex, 1.5, WithInt(42))
 
         class complex0(complex):
             """Test usage of __complex__() when inheriting from 'complex'"""
@@ -762,7 +731,7 @@ def eq(actual, expected):
 
         self.assertRaises(TypeError, cls.from_number, '3.14')
         self.assertRaises(TypeError, cls.from_number, b'3.14')
-        self.assertRaises(TypeError, cls.from_number, MyInt(314))
+        self.assertRaises(TypeError, cls.from_number, WithInt(314))
         self.assertRaises(TypeError, cls.from_number, {})
         self.assertRaises(TypeError, cls.from_number)
 
diff --git a/Lib/test/test_float.py b/Lib/test/test_float.py
index 237d7b5d35edd7..84d035e02b2541 100644
--- a/Lib/test/test_float.py
+++ b/Lib/test/test_float.py
@@ -13,6 +13,9 @@
     VALID_UNDERSCORE_LITERALS,
     INVALID_UNDERSCORE_LITERALS,
 )
+from test.support.number_helper import (FloatSubclass, OtherFloatSubclass,
+                                        WithFloat, FloatLikeSubclass,
+                                        WithIndex, WithInt)
 from math import isinf, isnan, copysign, ldexp
 import math
 
@@ -29,11 +32,6 @@
 test_dir = os.path.dirname(__file__) or os.curdir
 format_testfile = os.path.join(test_dir, 'mathdata', 'formatfloat_testcases.txt')
 
-class FloatSubclass(float):
-    pass
-
-class OtherFloatSubclass(float):
-    pass
 
 class MyIndex:
     def __init__(self, value):
@@ -206,20 +204,6 @@ def test_float_with_comma(self):
 
     def test_floatconversion(self):
         # Make sure that calls to __float__() work properly
-        class Foo2(float):
-            def __float__(self):
-                return 42.
-
-        class Foo3(float):
-            def __new__(cls, value=0.):
-                return float.__new__(cls, 2*value)
-
-            def __float__(self):
-                return self
-
-        class Foo4(float):
-            def __float__(self):
-                return 42
 
         # Issue 5759: __float__ not called on str subclasses (though it is on
         # unicode subclasses).
@@ -227,17 +211,17 @@ class FooStr(str):
             def __float__(self):
                 return float(str(self)) + 1
 
-        self.assertEqual(float(FloatLike(42.)), 42.)
-        self.assertEqual(float(Foo2()), 42.)
+        self.assertEqual(float(WithFloat(42.)), 42.)
+        self.assertEqual(float(FloatLikeSubclass(21.)), 42.)
         with self.assertWarns(DeprecationWarning):
-            self.assertEqual(float(Foo3(21)), 42.)
-        self.assertRaises(TypeError, float, Foo4(42))
+            self.assertEqual(float(FloatLikeSubclass(FloatSubclass(21))), 42.)
+        self.assertRaises(TypeError, float, FloatLikeSubclass(42))
         self.assertEqual(float(FooStr('8')), 9.)
 
-        self.assertRaises(TypeError, time.sleep, FloatLike(""))
+        self.assertRaises(TypeError, time.sleep, WithFloat(""))
 
         # Issue #24731
-        f = FloatLike(OtherFloatSubclass(42.))
+        f = WithFloat(OtherFloatSubclass(42.))
         with self.assertWarns(DeprecationWarning):
             self.assertEqual(float(f), 42.)
         with self.assertWarns(DeprecationWarning):
@@ -247,22 +231,20 @@ def __float__(self):
         with self.assertWarns(DeprecationWarning):
             self.assertIs(type(FloatSubclass(f)), FloatSubclass)
 
-        self.assertEqual(float(MyIndex(42)), 42.0)
-        self.assertRaises(OverflowError, float, MyIndex(2**2000))
-        self.assertRaises(TypeError, float, MyInt(42))
+        self.assertEqual(float(WithIndex(42)), 42.0)
+        self.assertRaises(OverflowError, float, WithIndex(2**2000))
+        self.assertRaises(TypeError, float, WithInt(42))
 
     def test_keyword_args(self):
         with self.assertRaisesRegex(TypeError, 'keyword argument'):
             float(x='3.14')
 
     def test_keywords_in_subclass(self):
-        class subclass(float):
-            pass
-        u = subclass(2.5)
-        self.assertIs(type(u), subclass)
+        u = FloatSubclass(2.5)
+        self.assertIs(type(u), FloatSubclass)
         self.assertEqual(float(u), 2.5)
         with self.assertRaises(TypeError):
-            subclass(x=0)
+            FloatSubclass(x=0)
 
         class subclass_with_init(float):
             def __init__(self, arg, newarg=None):