def test_names(self):

c_only_names = {'CapsuleType', 'LazyImportType'}

ignored = {'new_class', 'resolve_bases', 'prepare_class',

'get_original_bases', 'DynamicClassAttribute', 'coroutine'}

for name in c_types.__all__:

if name not in c_only_names | ignored:

self.assertIs(getattr(c_types, name), getattr(py_types, name))

all_names = ignored | {

'AsyncGeneratorType', 'BuiltinFunctionType', 'BuiltinMethodType',

'CapsuleType', 'CellType', 'ClassMethodDescriptorType', 'CodeType',

'CoroutineType', 'EllipsisType', 'FrameType', 'FunctionType',

'FrameLocalsProxyType',

'GeneratorType', 'GenericAlias', 'GetSetDescriptorType',

'LambdaType', 'LazyImportType', 'MappingProxyType',

'MemberDescriptorType', 'MethodDescriptorType', 'MethodType',

'MethodWrapperType', 'ModuleType', 'NoneType',

'NotImplementedType', 'SimpleNamespace', 'TracebackType',

'UnionType', 'WrapperDescriptorType',

}

self.assertEqual(all_names, set(c_types.__all__))

self.assertEqual(all_names - c_only_names, set(py_types.__all__))

def test_truth_values(self):

if None: self.fail('None is true instead of false')

if 0: self.fail('0 is true instead of false')

if 0.0: self.fail('0.0 is true instead of false')

if '': self.fail('\'\' is true instead of false')

if not 1: self.fail('1 is false instead of true')

if not 1.0: self.fail('1.0 is false instead of true')

if not 'x': self.fail('\'x\' is false instead of true')

if not {'x': 1}: self.fail('{\'x\': 1} is false instead of true')

def f(): pass

class C: pass

x = C()

if not f: self.fail('f is false instead of true')

if not C: self.fail('C is false instead of true')

if not sys: self.fail('sys is false instead of true')

if not x: self.fail('x is false instead of true')

def test_boolean_ops(self):

if 0 or 0: self.fail('0 or 0 is true instead of false')

if 1 and 1: pass

else: self.fail('1 and 1 is false instead of true')

if not 1: self.fail('not 1 is true instead of false')

def test_comparisons(self):

if 0 < 1 <= 1 == 1 >= 1 > 0 != 1: pass

else: self.fail('int comparisons failed')

if 0.0 < 1.0 <= 1.0 == 1.0 >= 1.0 > 0.0 != 1.0: pass

else: self.fail('float comparisons failed')

if '' < 'a' <= 'a' == 'a' < 'abc' < 'abd' < 'b': pass

else: self.fail('string comparisons failed')

if None is None: pass

else: self.fail('identity test failed')

def test_float_constructor(self):

self.assertRaises(ValueError, float, '')

self.assertRaises(ValueError, float, '5\0')

self.assertRaises(ValueError, float, '5_5\0')

def test_zero_division(self):

try: 5.0 / 0.0

except ZeroDivisionError: pass

else: self.fail("5.0 / 0.0 didn't raise ZeroDivisionError")

try: 5.0 // 0.0

except ZeroDivisionError: pass

else: self.fail("5.0 // 0.0 didn't raise ZeroDivisionError")

try: 5.0 % 0.0

except ZeroDivisionError: pass

else: self.fail("5.0 % 0.0 didn't raise ZeroDivisionError")

try: 5 / 0

except ZeroDivisionError: pass

else: self.fail("5 / 0 didn't raise ZeroDivisionError")

try: 5 // 0

except ZeroDivisionError: pass

else: self.fail("5 // 0 didn't raise ZeroDivisionError")

try: 5 % 0

except ZeroDivisionError: pass

else: self.fail("5 % 0 didn't raise ZeroDivisionError")

def test_numeric_types(self):

if 0 != 0.0 or 1 != 1.0 or -1 != -1.0:

self.fail('int/float value not equal')

# calling built-in types without argument must return 0

if int() != 0: self.fail('int() does not return 0')

if float() != 0.0: self.fail('float() does not return 0.0')

if int(1.9) == 1 == int(1.1) and int(-1.1) == -1 == int(-1.9): pass

else: self.fail('int() does not round properly')

if float(1) == 1.0 and float(-1) == -1.0 and float(0) == 0.0: pass

else: self.fail('float() does not work properly')

def test_float_to_string(self):

def test(f, result):

self.assertEqual(f.__format__('e'), result)

self.assertEqual('%e' % f, result)

# test all 2 digit exponents, both with __format__ and with

# '%' formatting

for i in range(-99, 100):

test(float('1.5e'+str(i)), '1.500000e{0:+03d}'.format(i))

# test some 3 digit exponents

self.assertEqual(1.5e100.__format__('e'), '1.500000e+100')

self.assertEqual('%e' % 1.5e100, '1.500000e+100')

self.assertEqual(1.5e101.__format__('e'), '1.500000e+101')

self.assertEqual('%e' % 1.5e101, '1.500000e+101')

self.assertEqual(1.5e-100.__format__('e'), '1.500000e-100')

self.assertEqual('%e' % 1.5e-100, '1.500000e-100')

self.assertEqual(1.5e-101.__format__('e'), '1.500000e-101')

self.assertEqual('%e' % 1.5e-101, '1.500000e-101')

self.assertEqual('%g' % 1.0, '1')

self.assertEqual('%#g' % 1.0, '1.00000')

def test_normal_integers(self):

# Ensure the first 256 integers are shared

a = 256

b = 128*2

if a is not b: self.fail('256 is not shared')

if 12 + 24 != 36: self.fail('int op')

if 12 + (-24) != -12: self.fail('int op')

if (-12) + 24 != 12: self.fail('int op')

if (-12) + (-24) != -36: self.fail('int op')

if not 12 < 24: self.fail('int op')

if not -24 < -12: self.fail('int op')

# Test for a particular bug in integer multiply

xsize, ysize, zsize = 238, 356, 4

if not (xsize*ysize*zsize == zsize*xsize*ysize == 338912):

self.fail('int mul commutativity')

# And another.

m = -sys.maxsize - 1

for divisor in 1, 2, 4, 8, 16, 32:

j = m // divisor

prod = divisor * j

if prod != m:

self.fail("%r * %r == %r != %r" % (divisor, j, prod, m))

if type(prod) is not int:

self.fail("expected type(prod) to be int, not %r" %

type(prod))

# Check for unified integral type

for divisor in 1, 2, 4, 8, 16, 32:

j = m // divisor - 1

prod = divisor * j

if type(prod) is not int:

self.fail("expected type(%r) to be int, not %r" %

(prod, type(prod)))

# Check for unified integral type

m = sys.maxsize

for divisor in 1, 2, 4, 8, 16, 32:

j = m // divisor + 1

prod = divisor * j

if type(prod) is not int:

self.fail("expected type(%r) to be int, not %r" %

(prod, type(prod)))

x = sys.maxsize

self.assertIsInstance(x + 1, int,

"(sys.maxsize + 1) should have returned int")

self.assertIsInstance(-x - 1, int,

"(-sys.maxsize - 1) should have returned int")

self.assertIsInstance(-x - 2, int,

"(-sys.maxsize - 2) should have returned int")

try: 5 << -5

except ValueError: pass

else: self.fail('int negative shift <<')

try: 5 >> -5

except ValueError: pass

else: self.fail('int negative shift >>')

def test_floats(self):

if 12.0 + 24.0 != 36.0: self.fail('float op')

if 12.0 + (-24.0) != -12.0: self.fail('float op')

if (-12.0) + 24.0 != 12.0: self.fail('float op')

if (-12.0) + (-24.0) != -36.0: self.fail('float op')

if not 12.0 < 24.0: self.fail('float op')

if not -24.0 < -12.0: self.fail('float op')

def test_strings(self):

if len('') != 0: self.fail('len(\'\')')

if len('a') != 1: self.fail('len(\'a\')')

if len('abcdef') != 6: self.fail('len(\'abcdef\')')

if 'xyz' + 'abcde' != 'xyzabcde': self.fail('string concatenation')

if 'xyz'*3 != 'xyzxyzxyz': self.fail('string repetition *3')

if 0*'abcde' != '': self.fail('string repetition 0*')

if min('abc') != 'a' or max('abc') != 'c': self.fail('min/max string')

if 'a' in 'abc' and 'b' in 'abc' and 'c' in 'abc' and 'd' not in 'abc': pass

else: self.fail('in/not in string')

x = 'x'*103

if '%s!'%x != x+'!': self.fail('nasty string formatting bug')

#extended slices for strings

a = '0123456789'

self.assertEqual(a[::], a)

self.assertEqual(a[::2], '02468')

self.assertEqual(a[1::2], '13579')

self.assertEqual(a[::-1],'9876543210')

self.assertEqual(a[::-2], '97531')

self.assertEqual(a[3::-2], '31')

self.assertEqual(a[-100:100:], a)

self.assertEqual(a[100:-100:-1], a[::-1])

self.assertEqual(a[-100:100:2], '02468')

def test_type_function(self):

self.assertRaises(TypeError, type, 1, 2)

self.assertRaises(TypeError, type, 1, 2, 3, 4)

def test_int__format__(self):

def test(i, format_spec, result):

# just make sure we have the unified type for integers

self.assertIs(type(i), int)

self.assertIs(type(format_spec), str)

self.assertEqual(i.__format__(format_spec), result)

test(123456789, 'd', '123456789')

test(123456789, 'd', '123456789')

test(1, 'c', '\01')

# sign and aligning are interdependent

test(1, "-", '1')

test(-1, "-", '-1')

test(1, "-3", ' 1')

test(-1, "-3", ' -1')

test(1, "+3", ' +1')

test(-1, "+3", ' -1')

test(1, " 3", ' 1')

test(-1, " 3", ' -1')

test(1, " ", ' 1')

test(-1, " ", '-1')

# hex

test(3, "x", "3")

test(3, "X", "3")

test(1234, "x", "4d2")

test(-1234, "x", "-4d2")

test(1234, "8x", " 4d2")

test(-1234, "8x", " -4d2")

test(1234, "x", "4d2")

test(-1234, "x", "-4d2")

test(-3, "x", "-3")

test(-3, "X", "-3")

test(int('be', 16), "x", "be")

test(int('be', 16), "X", "BE")

test(-int('be', 16), "x", "-be")

test(-int('be', 16), "X", "-BE")

# octal

test(3, "o", "3")

test(-3, "o", "-3")

test(65, "o", "101")

test(-65, "o", "-101")

test(1234, "o", "2322")

test(-1234, "o", "-2322")

test(1234, "-o", "2322")

test(-1234, "-o", "-2322")

test(1234, " o", " 2322")

test(-1234, " o", "-2322")

test(1234, "+o", "+2322")

test(-1234, "+o", "-2322")

# binary

test(3, "b", "11")

test(-3, "b", "-11")

test(1234, "b", "10011010010")

test(-1234, "b", "-10011010010")

test(1234, "-b", "10011010010")

test(-1234, "-b", "-10011010010")

test(1234, " b", " 10011010010")

test(-1234, " b", "-10011010010")

test(1234, "+b", "+10011010010")

test(-1234, "+b", "-10011010010")

# alternate (#) formatting

test(0, "#b", '0b0')

test(0, "-#b", '0b0')

test(1, "-#b", '0b1')

test(-1, "-#b", '-0b1')

test(-1, "-#5b", ' -0b1')

test(1, "+#5b", ' +0b1')

test(100, "+#b", '+0b1100100')

test(100, "#012b", '0b0001100100')

test(-100, "#012b", '-0b001100100')

test(0, "#o", '0o0')

test(0, "-#o", '0o0')

test(1, "-#o", '0o1')

test(-1, "-#o", '-0o1')

test(-1, "-#5o", ' -0o1')

test(1, "+#5o", ' +0o1')

test(100, "+#o", '+0o144')

test(100, "#012o", '0o0000000144')

test(-100, "#012o", '-0o000000144')

test(0, "#x", '0x0')

test(0, "-#x", '0x0')

test(1, "-#x", '0x1')

test(-1, "-#x", '-0x1')

test(-1, "-#5x", ' -0x1')

test(1, "+#5x", ' +0x1')

test(100, "+#x", '+0x64')

test(100, "#012x", '0x0000000064')

test(-100, "#012x", '-0x000000064')

test(123456, "#012x", '0x000001e240')

test(-123456, "#012x", '-0x00001e240')

test(0, "#X", '0X0')

test(0, "-#X", '0X0')

test(1, "-#X", '0X1')

test(-1, "-#X", '-0X1')

test(-1, "-#5X", ' -0X1')

test(1, "+#5X", ' +0X1')

test(100, "+#X", '+0X64')

test(100, "#012X", '0X0000000064')

test(-100, "#012X", '-0X000000064')

test(123456, "#012X", '0X000001E240')

test(-123456, "#012X", '-0X00001E240')

test(123, ',', '123')

test(-123, ',', '-123')

test(1234, ',', '1,234')

test(-1234, ',', '-1,234')

test(123456, ',', '123,456')

test(-123456, ',', '-123,456')

test(1234567, ',', '1,234,567')

test(-1234567, ',', '-1,234,567')

# issue 5782, commas with no specifier type

test(1234, '010,', '00,001,234')

# Unified type for integers

test(10**100, 'd', '1' + '0' * 100)

test(10**100+100, 'd', '1' + '0' * 97 + '100')

# make sure these are errors

# precision disallowed

self.assertRaises(ValueError, 3 .__format__, "1.3")

# sign not allowed with 'c'

self.assertRaises(ValueError, 3 .__format__, "+c")

# format spec must be string

self.assertRaises(TypeError, 3 .__format__, None)

self.assertRaises(TypeError, 3 .__format__, 0)

# can't have ',' with 'n'

self.assertRaises(ValueError, 3 .__format__, ",n")

# can't have ',' with 'c'

self.assertRaises(ValueError, 3 .__format__, ",c")

# can't have '#' with 'c'

self.assertRaises(ValueError, 3 .__format__, "#c")

# ensure that only int and float type specifiers work

for format_spec in ([chr(x) for x in range(ord('a'), ord('z')+1)] +

[chr(x) for x in range(ord('A'), ord('Z')+1)]):

if not format_spec in 'bcdoxXeEfFgGn%':

self.assertRaises(ValueError, 0 .__format__, format_spec)

self.assertRaises(ValueError, 1 .__format__, format_spec)

self.assertRaises(ValueError, (-1) .__format__, format_spec)

# ensure that float type specifiers work; format converts

# the int to a float

for format_spec in 'eEfFgG%':

for value in [0, 1, -1, 100, -100, 1234567890, -1234567890]:

self.assertEqual(value.__format__(format_spec),

float(value).__format__(format_spec))

# Issue 6902

test(123456, "0<20", '12345600000000000000')

test(123456, "1<20", '12345611111111111111')

test(123456, "*<20", '123456**************')

test(123456, "0>20", '00000000000000123456')

test(123456, "1>20", '11111111111111123456')

test(123456, "*>20", '**************123456')

test(123456, "0=20", '00000000000000123456')

test(123456, "1=20", '11111111111111123456')

test(123456, "*=20", '**************123456')

@run_with_locale('LC_NUMERIC', 'en_US.UTF8', '')

def test_float__format__locale(self):

# test locale support for __format__ code 'n'

for i in range(-10, 10):

x = 1234567890.0 * (10.0 ** i)

self.assertEqual(locale.format_string('%g', x, grouping=True), format(x, 'n'))

self.assertEqual(locale.format_string('%.10g', x, grouping=True), format(x, '.10n'))

@run_with_locale('LC_NUMERIC', 'en_US.UTF8', '')

def test_int__format__locale(self):

# test locale support for __format__ code 'n' for integers

x = 123456789012345678901234567890

for i in range(0, 30):

self.assertEqual(locale.format_string('%d', x, grouping=True), format(x, 'n'))

# move to the next integer to test

x = x // 10

rfmt = ">20n"

lfmt = "<20n"

cfmt = "^20n"

for x in (1234, 12345, 123456, 1234567, 12345678, 123456789, 1234567890, 12345678900):

self.assertEqual(len(format(0, rfmt)), len(format(x, rfmt)))

self.assertEqual(len(format(0, lfmt)), len(format(x, lfmt)))

self.assertEqual(len(format(0, cfmt)), len(format(x, cfmt)))

def test_float__format__(self):

def test(f, format_spec, result):

self.assertEqual(f.__format__(format_spec), result)

self.assertEqual(format(f, format_spec), result)

test(0.0, 'f', '0.000000')

# the default is 'g', except for empty format spec

test(0.0, '', '0.0')

test(0.01, '', '0.01')

test(0.01, 'g', '0.01')

# test for issue 3411

test(1.23, '1', '1.23')

test(-1.23, '1', '-1.23')

test(1.23, '1g', '1.23')

test(-1.23, '1g', '-1.23')

test( 1.0, ' g', ' 1')

test(-1.0, ' g', '-1')

test( 1.0, '+g', '+1')

test(-1.0, '+g', '-1')

test(1.1234e200, 'g', '1.1234e+200')

test(1.1234e200, 'G', '1.1234E+200')

test(1.0, 'f', '1.000000')

test(-1.0, 'f', '-1.000000')

test( 1.0, ' f', ' 1.000000')

test(-1.0, ' f', '-1.000000')

test( 1.0, '+f', '+1.000000')

test(-1.0, '+f', '-1.000000')

# Python versions <= 3.0 switched from 'f' to 'g' formatting for

# values larger than 1e50. No longer.

f = 1.1234e90

for fmt in 'f', 'F':

# don't do a direct equality check, since on some

# platforms only the first few digits of dtoa

# will be reliable

result = f.__format__(fmt)

self.assertEqual(len(result), 98)

self.assertEqual(result[-7], '.')

self.assertIn(result[:12], ('112340000000', '112339999999'))

f = 1.1234e200

for fmt in 'f', 'F':

result = f.__format__(fmt)

self.assertEqual(len(result), 208)

self.assertEqual(result[-7], '.')

self.assertIn(result[:12], ('112340000000', '112339999999'))

test( 1.0, 'e', '1.000000e+00')

test(-1.0, 'e', '-1.000000e+00')

test( 1.0, 'E', '1.000000E+00')

test(-1.0, 'E', '-1.000000E+00')

test(1.1234e20, 'e', '1.123400e+20')

test(1.1234e20, 'E', '1.123400E+20')

# No format code means use g, but must have a decimal

# and a number after the decimal. This is tricky, because

# a totally empty format specifier means something else.

# So, just use a sign flag

test(1.25e200, '+g', '+1.25e+200')

test(1.25e200, '+', '+1.25e+200')

test(1.1e200, '+g', '+1.1e+200')

test(1.1e200, '+', '+1.1e+200')

# 0 padding

test(1234., '010f', '1234.000000')

test(1234., '011f', '1234.000000')

test(1234., '012f', '01234.000000')

test(-1234., '011f', '-1234.000000')

test(-1234., '012f', '-1234.000000')

test(-1234., '013f', '-01234.000000')

test(-1234.12341234, '013f', '-01234.123412')

test(-123456.12341234, '011.2f', '-0123456.12')

# issue 5782, commas with no specifier type

test(1.2, '010,.2', '0,000,001.2')

# 0 padding with commas

test(1234., '011,f', '1,234.000000')

test(1234., '012,f', '1,234.000000')

test(1234., '013,f', '01,234.000000')

test(-1234., '012,f', '-1,234.000000')

test(-1234., '013,f', '-1,234.000000')

test(-1234., '014,f', '-01,234.000000')

test(-12345., '015,f', '-012,345.000000')

test(-123456., '016,f', '-0,123,456.000000')

test(-123456., '017,f', '-0,123,456.000000')

test(-123456.12341234, '017,f', '-0,123,456.123412')

test(-123456.12341234, '013,.2f', '-0,123,456.12')

# % formatting

test(-1.0, '%', '-100.000000%')

# format spec must be string

self.assertRaises(TypeError, 3.0.__format__, None)

self.assertRaises(TypeError, 3.0.__format__, 0)

# confirm format options expected to fail on floats, such as integer

# presentation types

for format_spec in 'sbcdoxX':

self.assertRaises(ValueError, format, 0.0, format_spec)

self.assertRaises(ValueError, format, 1.0, format_spec)

self.assertRaises(ValueError, format, -1.0, format_spec)

self.assertRaises(ValueError, format, 1e100, format_spec)

self.assertRaises(ValueError, format, -1e100, format_spec)

self.assertRaises(ValueError, format, 1e-100, format_spec)

self.assertRaises(ValueError, format, -1e-100, format_spec)

# Alternate float formatting

test(1.0, '.0e', '1e+00')

test(1.0, '#.0e', '1.e+00')

test(1.0, '.0f', '1')

test(1.0, '#.0f', '1.')

test(1.1, 'g', '1.1')

test(1.1, '#g', '1.10000')

test(1.0, '.0%', '100%')

test(1.0, '#.0%', '100.%')

# Issue 7094: Alternate formatting (specified by #)

test(1.0, '0e', '1.000000e+00')

test(1.0, '#0e', '1.000000e+00')

test(1.0, '0f', '1.000000' )

test(1.0, '#0f', '1.000000')

test(1.0, '.1e', '1.0e+00')

test(1.0, '#.1e', '1.0e+00')

test(1.0, '.1f', '1.0')

test(1.0, '#.1f', '1.0')

test(1.0, '.1%', '100.0%')

test(1.0, '#.1%', '100.0%')

# Issue 6902

test(12345.6, "0<20", '12345.60000000000000')

test(12345.6, "1<20", '12345.61111111111111')

test(12345.6, "*<20", '12345.6*************')

test(12345.6, "0>20", '000000000000012345.6')

test(12345.6, "1>20", '111111111111112345.6')

test(12345.6, "*>20", '*************12345.6')

test(12345.6, "0=20", '000000000000012345.6')

test(12345.6, "1=20", '111111111111112345.6')

test(12345.6, "*=20", '*************12345.6')

def test_format_spec_errors(self):

# int, float, and string all share the same format spec

# mini-language parser.

# Check that we can't ask for too many digits. This is

# probably a CPython specific test. It tries to put the width

# into a C long.

self.assertRaises(ValueError, format, 0, '1'*10000 + 'd')

# Similar with the precision.

self.assertRaises(ValueError, format, 0, '.' + '1'*10000 + 'd')

# And may as well test both.

self.assertRaises(ValueError, format, 0, '1'*1000 + '.' + '1'*10000 + 'd')

# Make sure commas aren't allowed with various type codes

for code in 'xXobns':

self.assertRaises(ValueError, format, 0, ',' + code)

def test_internal_sizes(self):

self.assertGreater(object.__basicsize__, 0)

self.assertGreater(tuple.__itemsize__, 0)

def test_slot_wrapper_types(self):

self.assertIsInstance(object.__init__, types.WrapperDescriptorType)

self.assertIsInstance(object.__str__, types.WrapperDescriptorType)

self.assertIsInstance(object.__lt__, types.WrapperDescriptorType)

self.assertIsInstance(int.__lt__, types.WrapperDescriptorType)

@unittest.skipIf(MISSING_C_DOCSTRINGS,

def test_dunder_get_signature(self):

sig = inspect.signature(object.__init__.__get__)

self.assertEqual(list(sig.parameters), ["instance", "owner"])

# gh-93021: Second parameter is optional

self.assertIs(sig.parameters["owner"].default, None)

def test_method_wrapper_types(self):

self.assertIsInstance(object().__init__, types.MethodWrapperType)

self.assertIsInstance(object().__str__, types.MethodWrapperType)

self.assertIsInstance(object().__lt__, types.MethodWrapperType)

self.assertIsInstance((42).__lt__, types.MethodWrapperType)

def test_method_descriptor_types(self):

self.assertIsInstance(str.join, types.MethodDescriptorType)

self.assertIsInstance(list.append, types.MethodDescriptorType)

self.assertIsInstance(''.join, types.BuiltinMethodType)

self.assertIsInstance([].append, types.BuiltinMethodType)

self.assertIsInstance(int.__dict__['from_bytes'], types.ClassMethodDescriptorType)

self.assertIsInstance(int.from_bytes, types.BuiltinMethodType)

self.assertIsInstance(int.__new__, types.BuiltinMethodType)

def test_method_descriptor_crash(self):

# gh-132747: The default __get__() implementation in C was unable

# to handle a second argument of None when called from Python

import _io

import io

import _queue

to_check = [

# (method, instance)

(_io._TextIOBase.read, io.StringIO()),

(_queue.SimpleQueue.put, _queue.SimpleQueue()),

(str.capitalize, "nobody expects the spanish inquisition")

]

for method, instance in to_check:

with self.subTest(method=method, instance=instance):

bound = method.__get__(instance)

self.assertIsInstance(bound, types.BuiltinMethodType)

def test_ellipsis_type(self):

self.assertIsInstance(Ellipsis, types.EllipsisType)

def test_notimplemented_type(self):

self.assertIsInstance(NotImplemented, types.NotImplementedType)

def test_none_type(self):

self.assertIsInstance(None, types.NoneType)

def test_traceback_and_frame_types(self):

try:

raise OSError

except OSError as e:

exc = e

self.assertIsInstance(exc.__traceback__, types.TracebackType)

self.assertIsInstance(exc.__traceback__.tb_frame, types.FrameType)

@unittest.expectedFailure # TODO: RUSTPYTHON; AttributeError: 'NoneType' object has no attribute 'datetime_CAPI'

def test_capsule_type(self):

self.assertIsInstance(_datetime.datetime_CAPI, types.CapsuleType)

def test_call_unbound_crash(self):

# GH-131998: The specialized instruction would get tricked into dereferencing

# a bound "self" that didn't exist if subsequently called unbound.

code = """if True:

assert_python_ok("-c", code)

def test_frame_locals_proxy_type(self):

self.assertIsInstance(types.FrameLocalsProxyType, type)

if MISSING_C_DOCSTRINGS:

self.assertIsNone(types.FrameLocalsProxyType.__doc__)

else:

self.assertIsInstance(types.FrameLocalsProxyType.__doc__, str)

self.assertEqual(types.FrameLocalsProxyType.__module__, 'builtins')

self.assertEqual(types.FrameLocalsProxyType.__name__, 'FrameLocalsProxy')

frame = inspect.currentframe()

self.assertIsNotNone(frame)

def test_or_types_operator(self):

self.assertEqual(int | str, typing.Union[int, str])

self.assertNotEqual(int | list, typing.Union[int, str])

self.assertEqual(str | int, typing.Union[int, str])

self.assertEqual(int | None, typing.Union[int, None])

self.assertEqual(None | int, typing.Union[int, None])

self.assertEqual(int | type(None), int | None)

self.assertEqual(type(None) | int, None | int)

self.assertEqual(int | str | list, typing.Union[int, str, list])

self.assertEqual(int | (str | list), typing.Union[int, str, list])

self.assertEqual(str | (int | list), typing.Union[int, str, list])

self.assertEqual(typing.List | typing.Tuple, typing.Union[typing.List, typing.Tuple])

self.assertEqual(typing.List[int] | typing.Tuple[int], typing.Union[typing.List[int], typing.Tuple[int]])

self.assertEqual(typing.List[int] | None, typing.Union[typing.List[int], None])

self.assertEqual(None | typing.List[int], typing.Union[None, typing.List[int]])

self.assertEqual(str | float | int | complex | int, (int | str) | (float | complex))

self.assertEqual(typing.Union[str, int, typing.List[int]], str | int | typing.List[int])

self.assertIs(int | int, int)

self.assertEqual(

BaseException |

bool |

bytes |

complex |

float |

int |

list |

map |

set,

typing.Union[

BaseException,

bool,

bytes,

complex,

float,

int,

list,

map,

set,

])

with self.assertRaises(TypeError):

int | 3

with self.assertRaises(TypeError):

3 | int

with self.assertRaises(TypeError):

Example() | int

x = int | str

self.assertEqual(x, int | str)

self.assertEqual(x, str | int)

self.assertNotEqual(x, {}) # should not raise exception

with self.assertRaises(TypeError):

x < x

with self.assertRaises(TypeError):

x <= x

y = typing.Union[str, int]

with self.assertRaises(TypeError):

x < y

y = int | bool

with self.assertRaises(TypeError):

x < y

def test_hash(self):

self.assertEqual(hash(int | str), hash(str | int))

self.assertEqual(hash(int | str), hash(typing.Union[int, str]))

def test_union_of_unhashable(self):

class UnhashableMeta(type):

__hash__ = None

class A(metaclass=UnhashableMeta): ...

class B(metaclass=UnhashableMeta): ...

self.assertEqual((A | B).__args__, (A, B))

union1 = A | B

with self.assertRaisesRegex(TypeError, "unhashable type: 'UnhashableMeta'"):

hash(union1)

union2 = int | B

with self.assertRaisesRegex(TypeError, "unhashable type: 'UnhashableMeta'"):

hash(union2)

union3 = A | int

with self.assertRaisesRegex(TypeError, "unhashable type: 'UnhashableMeta'"):

hash(union3)

def test_unhashable_becomes_hashable(self):

is_hashable = False

class UnhashableMeta(type):

def __hash__(self):

if is_hashable:

return 1

else:

raise TypeError("not hashable")

class A(metaclass=UnhashableMeta): ...

class B(metaclass=UnhashableMeta): ...

union = A | B

self.assertEqual(union.__args__, (A, B))

with self.assertRaisesRegex(TypeError, "not hashable"):

hash(union)

is_hashable = True

with self.assertRaisesRegex(TypeError, "union contains 2 unhashable elements"):

hash(union)

def test_instancecheck_and_subclasscheck(self):

for x in (int | str, typing.Union[int, str]):

with self.subTest(x=x):

self.assertIsInstance(1, x)

self.assertIsInstance(True, x)

self.assertIsInstance('a', x)

self.assertNotIsInstance(None, x)

self.assertIsSubclass(int, x)

self.assertIsSubclass(bool, x)

self.assertIsSubclass(str, x)

self.assertNotIsSubclass(type(None), x)

for x in (int | None, typing.Union[int, None]):

with self.subTest(x=x):

self.assertIsInstance(None, x)

self.assertIsSubclass(type(None), x)

for x in (

int | collections.abc.Mapping,

typing.Union[int, collections.abc.Mapping],

):

with self.subTest(x=x):

self.assertIsInstance({}, x)

self.assertNotIsInstance((), x)

self.assertIsSubclass(dict, x)

self.assertNotIsSubclass(list, x)

def test_instancecheck_and_subclasscheck_order(self):

T = typing.TypeVar('T')

will_resolve = (

int | T,

typing.Union[int, T],

)

for x in will_resolve:

with self.subTest(x=x):

self.assertIsInstance(1, x)

self.assertIsSubclass(int, x)

wont_resolve = (

T | int,

typing.Union[T, int],

)

for x in wont_resolve:

with self.subTest(x=x):

with self.assertRaises(TypeError):

issubclass(int, x)

with self.assertRaises(TypeError):

isinstance(1, x)

for x in (*will_resolve, *wont_resolve):

with self.subTest(x=x):

with self.assertRaises(TypeError):

issubclass(object, x)

with self.assertRaises(TypeError):

isinstance(object(), x)

def test_bad_instancecheck(self):

class BadMeta(type):

def __instancecheck__(cls, inst):

1/0

x = int | BadMeta('A', (), {})

self.assertTrue(isinstance(1, x))

self.assertRaises(ZeroDivisionError, isinstance, [], x)

def test_bad_subclasscheck(self):

class BadMeta(type):

def __subclasscheck__(cls, sub):

1/0

x = int | BadMeta('A', (), {})

self.assertIsSubclass(int, x)

self.assertRaises(ZeroDivisionError, issubclass, list, x)

def test_or_type_operator_with_TypeVar(self):

TV = typing.TypeVar('T')

self.assertEqual(TV | str, typing.Union[TV, str])

self.assertEqual(str | TV, typing.Union[str, TV])

self.assertIs((int | TV)[int], int)

self.assertIs((TV | int)[int], int)

def test_union_args(self):

def check(arg, expected):

clear_typing_caches()

self.assertEqual(arg.__args__, expected)

check(int | str, (int, str))

check((int | str) | list, (int, str, list))

check(int | (str | list), (int, str, list))

check((int | str) | int, (int, str))

check(int | (str | int), (int, str))

check((int | str) | (str | int), (int, str))

check(typing.Union[int, str] | list, (int, str, list))

check(int | typing.Union[str, list], (int, str, list))

check((int | str) | (list | int), (int, str, list))

check((int | str) | typing.Union[list, int], (int, str, list))

check(typing.Union[int, str] | (list | int), (int, str, list))

check((str | int) | (int | list), (str, int, list))

check((str | int) | typing.Union[int, list], (str, int, list))

check(typing.Union[str, int] | (int | list), (str, int, list))