Lines Matching refs:self
43 def __init__(self, max):
44 self.max = max
45 self.sofar = []
47 def __len__(self): return len(self.sofar)
49 def __getitem__(self, i):
50 if not 0 <= i < self.max: raise IndexError
51 n = len(self.sofar)
53 self.sofar.append(n*n)
55 return self.sofar[i]
59 def __init__(self, max):
60 self.max = max
61 self.sofar = []
63 def __len__(self):
64 return len(self.sofar)
66 def __getitem__(self, i):
67 if not 0 <= i < self.max:
69 n = len(self.sofar)
71 self.sofar.append(str(n*n))
73 return self.sofar[i]
76 def write(self, line):
124 def __bool__(self):
128 def __iter__(self):
139 def check_iter_pickle(self, it, seq, proto):
143 self.assertEqual(type(itorg), type(it))
144 self.assertEqual(list(it), seq)
154 self.assertEqual(list(it), seq[1:])
156 def test_import(self):
162 self.assertRaises(ModuleNotFoundError, __import__, 'spamspam')
163 self.assertRaises(TypeError, __import__, 1, 2, 3, 4)
164 self.assertRaises(ValueError, __import__, '')
165 self.assertRaises(TypeError, __import__, 'sys', name='sys')
167 with self.assertWarns(ImportWarning):
168 self.assertRaises(ImportError, __import__, '',
172 self.assertRaises(ModuleNotFoundError, __import__, 'string\x00')
174 def test_abs(self):
176 self.assertEqual(abs(0), 0)
177 self.assertEqual(abs(1234), 1234)
178 self.assertEqual(abs(-1234), 1234)
179 self.assertTrue(abs(-sys.maxsize-1) > 0)
181 self.assertEqual(abs(0.0), 0.0)
182 self.assertEqual(abs(3.14), 3.14)
183 self.assertEqual(abs(-3.14), 3.14)
185 self.assertRaises(TypeError, abs, 'a')
187 self.assertEqual(abs(True), 1)
188 self.assertEqual(abs(False), 0)
190 self.assertRaises(TypeError, abs)
191 self.assertRaises(TypeError, abs, None)
193 def __abs__(self):
195 self.assertEqual(abs(AbsClass()), -5)
197 def test_all(self):
198 self.assertEqual(all([2, 4, 6]), True)
199 self.assertEqual(all([2, None, 6]), False)
200 self.assertRaises(RuntimeError, all, [2, TestFailingBool(), 6])
201 self.assertRaises(RuntimeError, all, TestFailingIter())
202 self.assertRaises(TypeError, all, 10) # Non-iterable
203 self.assertRaises(TypeError, all) # No args
204 self.assertRaises(TypeError, all, [2, 4, 6], []) # Too many args
205 self.assertEqual(all([]), True) # Empty iterator
206 self.assertEqual(all([0, TestFailingBool()]), False)# Short-circuit
208 self.assertEqual(all(x > 42 for x in S), True)
210 self.assertEqual(all(x > 42 for x in S), False)
212 def test_any(self):
213 self.assertEqual(any([None, None, None]), False)
214 self.assertEqual(any([None, 4, None]), True)
215 self.assertRaises(RuntimeError, any, [None, TestFailingBool(), 6])
216 self.assertRaises(RuntimeError, any, TestFailingIter())
217 self.assertRaises(TypeError, any, 10) # Non-iterable
218 self.assertRaises(TypeError, any) # No args
219 self.assertRaises(TypeError, any, [2, 4, 6], []) # Too many args
220 self.assertEqual(any([]), False) # Empty iterator
221 self.assertEqual(any([1, TestFailingBool()]), True) # Short-circuit
223 self.assertEqual(any(x > 42 for x in S), True)
225 self.assertEqual(any(x > 42 for x in S), False)
227 def test_ascii(self):
228 self.assertEqual(ascii(''), '\'\'')
229 self.assertEqual(ascii(0), '0')
230 self.assertEqual(ascii(()), '()')
231 self.assertEqual(ascii([]), '[]')
232 self.assertEqual(ascii({}), '{}')
235 self.assertEqual(ascii(a), '[[...]]')
238 self.assertEqual(ascii(a), '{0: {...}}')
241 self.assertEqual(ascii(s), repr(s))
256 self.assertEqual(ascii('\U0001d121'), "'\\U0001d121'")
259 self.assertEqual(ascii(s),
262 def test_neg(self):
264 self.assertTrue(isinstance(x, int))
265 self.assertEqual(-x, sys.maxsize+1)
267 def test_callable(self):
268 self.assertTrue(callable(len))
269 self.assertFalse(callable("a"))
270 self.assertTrue(callable(callable))
271 self.assertTrue(callable(lambda x, y: x + y))
272 self.assertFalse(callable(__builtins__))
274 self.assertTrue(callable(f))
277 def meth(self): pass
278 self.assertTrue(callable(C1))
280 self.assertTrue(callable(c.meth))
281 self.assertFalse(callable(c))
285 self.assertFalse(callable(c))
286 c.__call__ = lambda self: 0
287 self.assertFalse(callable(c))
289 self.assertFalse(callable(c))
292 def __call__(self): pass
294 self.assertTrue(callable(c2))
296 self.assertTrue(callable(c2))
299 self.assertTrue(callable(c3))
301 def test_chr(self):
302 self.assertEqual(chr(32), ' ')
303 self.assertEqual(chr(65), 'A')
304 self.assertEqual(chr(97), 'a')
305 self.assertEqual(chr(0xff), '\xff')
306 self.assertRaises(ValueError, chr, 1<<24)
307 self.assertEqual(chr(sys.maxunicode),
309 self.assertRaises(TypeError, chr)
310 self.assertEqual(chr(0x0000FFFF), "\U0000FFFF")
311 self.assertEqual(chr(0x00010000), "\U00010000")
312 self.assertEqual(chr(0x00010001), "\U00010001")
313 self.assertEqual(chr(0x000FFFFE), "\U000FFFFE")
314 self.assertEqual(chr(0x000FFFFF), "\U000FFFFF")
315 self.assertEqual(chr(0x00100000), "\U00100000")
316 self.assertEqual(chr(0x00100001), "\U00100001")
317 self.assertEqual(chr(0x0010FFFE), "\U0010FFFE")
318 self.assertEqual(chr(0x0010FFFF), "\U0010FFFF")
319 self.assertRaises(ValueError, chr, -1)
320 self.assertRaises(ValueError, chr, 0x00110000)
321 self.assertRaises((OverflowError, ValueError), chr, 2**32)
323 def test_cmp(self):
324 self.assertTrue(not hasattr(builtins, "cmp"))
326 def test_compile(self):
334 self.assertRaises(TypeError, compile)
335 self.assertRaises(ValueError, compile, 'print(42)\n', '<string>', 'badmode')
336 self.assertRaises(ValueError, compile, 'print(42)\n', '<string>', 'single', 0xff)
337 self.assertRaises(TypeError, compile, 'pass', '?', 'exec',
340 self.assertRaises(SyntaxError, compile, chr(0), 'f', 'exec')
341 self.assertRaises(ValueError, compile, str('a = 1'), 'f', 'bad')
372 self.assertEqual(rv, tuple(expected))
374 def test_compile_top_level_await_no_coro(self):
391 self.assertNotEqual(co.co_flags & CO_COROUTINE, CO_COROUTINE,
399 def test_compile_top_level_await(self):
432 with self.assertRaises(
441 self.assertEqual(co.co_flags & CO_COROUTINE, CO_COROUTINE,
448 self.assertEqual(globals_['a'], 1)
453 self.assertEqual(globals_['a'], 1)
457 def test_compile_top_level_await_invalid_cases(self):
481 with self.assertRaises(
485 with self.assertRaises(
495 def test_compile_async_generator(self):
509 self.assertEqual(type(glob['ticker']()), AsyncGeneratorType)
511 def test_delattr(self):
514 self.assertRaises(TypeError, delattr)
515 self.assertRaises(TypeError, delattr, sys)
517 self.assertRaisesRegex(TypeError, msg, delattr, sys, 1)
519 def test_dir(self):
521 self.assertRaises(TypeError, dir, 42, 42)
525 self.assertIn('local_var', dir())
528 self.assertIn('exit', dir(sys))
534 self.assertRaises(TypeError, dir, f)
537 self.assertIn("strip", dir(str))
538 self.assertNotIn("__mro__", dir(str))
542 def __init__(self):
543 self.x = 7
544 self.y = 8
545 self.z = 9
547 self.assertIn("y", dir(f))
553 self.assertIn("__repr__", dir(f))
559 def __init__(self):
560 self.bar = "wow"
562 self.assertNotIn("__repr__", dir(f))
563 self.assertIn("bar", dir(f))
567 def __dir__(self):
570 self.assertTrue(dir(f) == ["ga", "kan", "roo"])
574 def __dir__(self):
577 self.assertIsInstance(res, list)
578 self.assertTrue(res == ["a", "b", "c"])
582 def __dir__(self):
585 self.assertRaises(TypeError, dir, f)
591 self.assertEqual(len(dir(e.__traceback__)), 4)
594 self.assertEqual(sorted([].__dir__()), dir([]))
596 def test_divmod(self):
597 self.assertEqual(divmod(12, 7), (1, 5))
598 self.assertEqual(divmod(-12, 7), (-2, 2))
599 self.assertEqual(divmod(12, -7), (-2, -2))
600 self.assertEqual(divmod(-12, -7), (1, -5))
602 self.assertEqual(divmod(-sys.maxsize-1, -1), (sys.maxsize+1, 0))
609 self.assertAlmostEqual(result[0], exp_result[0])
610 self.assertAlmostEqual(result[1], exp_result[1])
612 self.assertRaises(TypeError, divmod)
614 def test_eval(self):
615 self.assertEqual(eval('1+1'), 2)
616 self.assertEqual(eval(' 1+1\n'), 2)
619 self.assertEqual(eval('a', globals) , 1)
620 self.assertEqual(eval('a', globals, locals), 1)
621 self.assertEqual(eval('b', globals, locals), 200)
622 self.assertEqual(eval('c', globals, locals), 300)
626 self.assertEqual(eval(bom + b'a', globals, locals), 1)
627 self.assertEqual(eval('"\xe5"', globals), "\xe5")
628 self.assertRaises(TypeError, eval)
629 self.assertRaises(TypeError, eval, ())
630 self.assertRaises(SyntaxError, eval, bom[:2] + b'a')
633 def __getitem__(self, key):
635 self.assertRaises(ValueError, eval, "foo", {}, X())
637 def test_general_eval(self):
642 def __getitem__(self, key):
646 def keys(self):
651 self.assertEqual(eval('a', g, m), 12)
652 self.assertRaises(NameError, eval, 'b', g, m)
653 self.assertEqual(eval('dir()', g, m), list('xyz'))
654 self.assertEqual(eval('globals()', g, m), g)
655 self.assertEqual(eval('locals()', g, m), m)
656 self.assertRaises(TypeError, eval, 'a', m)
661 self.assertRaises(TypeError, eval, 'a', g, m)
665 def __getitem__(self, key):
668 return dict.__getitem__(self, key)
669 def keys(self):
673 self.assertEqual(eval('a', g, d), 12)
674 self.assertRaises(NameError, eval, 'b', g, d)
675 self.assertEqual(eval('dir()', g, d), list('xyz'))
676 self.assertEqual(eval('globals()', g, d), g)
677 self.assertEqual(eval('locals()', g, d), d)
686 def __setitem__(self, key, formula):
687 self._cells[key] = formula
688 def __getitem__(self, key):
689 return eval(self._cells[key], globals(), self)
695 self.assertEqual(ss['a3'], 210)
700 def __getitem__(self, item):
702 def keys(self):
704 self.assertRaises(TypeError, eval, 'dir()', globals(), C())
706 def test_exec(self):
711 self.assertEqual(g, {'z': 1})
716 self.assertEqual(g, {'z': 2})
728 self.assertEqual((g, l), ({'a': 1}, {'b': 2}))
730 def test_exec_globals(self):
733 self.assertRaisesRegex(NameError, "name 'print' is not defined",
736 self.assertRaises(TypeError,
739 def test_exec_globals_frozen(self):
744 def __setitem__(self, key, value):
753 self.assertRaises(frozendict_error,
758 self.assertRaisesRegex(NameError, "__build_class__ not found",
762 self.assertRaisesRegex(NameError, "__build_class__ not found",
768 self.assertRaises(frozendict_error,
771 def test_exec_globals_error_on_get(self):
777 def __getitem__(self, key):
782 self.assertRaises(setonlyerror,
787 self.assertRaises(setonlyerror, exec, code,
790 def test_exec_globals_dict_subclass(self):
798 self.assertRaisesRegex(NameError, "name 'superglobal' is not defined",
801 def test_exec_redirected(self):
812 def test_exec_closure(self):
840 self.assertEqual(result, 6)
848 self.assertEqual(result, 2520)
852 self.assertRaises(TypeError,
859 self.assertRaises(TypeError,
866 self.assertRaises(TypeError,
874 self.assertRaises(TypeError,
883 self.assertRaises(TypeError,
890 def test_filter(self):
891 self.assertEqual(list(filter(lambda c: 'a' <= c <= 'z', 'Hello World')), list('elloorld'))
892 self.assertEqual(list(filter(None, [1, 'hello', [], [3], '', None, 9, 0])), [1, 'hello', [3], 9])
893 self.assertEqual(list(filter(lambda x: x > 0, [1, -3, 9, 0, 2])), [1, 9, 2])
894 self.assertEqual(list(filter(None, Squares(10))), [1, 4, 9, 16, 25, 36, 49, 64, 81])
895 self.assertEqual(list(filter(lambda x: x%2, Squares(10))), [1, 9, 25, 49, 81])
899 self.assertRaises(TypeError, filter)
901 def __getitem__(self, index):
905 self.assertRaises(ValueError, list, filter(lambda x: x, BadSeq()))
908 self.assertRaises(TypeError, list, filter(badfunc, range(5)))
911 self.assertEqual(list(filter(None, (1, 2))), [1, 2])
912 self.assertEqual(list(filter(lambda x: x>=3, (1, 2, 3, 4))), [3, 4])
913 self.assertRaises(TypeError, list, filter(42, (1, 2)))
915 def test_filter_pickle(self):
919 self.check_iter_pickle(f1, list(f2), proto)
921 def test_filter_dealloc(self):
931 def test_getattr(self):
932 self.assertTrue(getattr(sys, 'stdout') is sys.stdout)
933 self.assertRaises(TypeError, getattr)
934 self.assertRaises(TypeError, getattr, sys)
936 self.assertRaisesRegex(TypeError, msg, getattr, sys, 1)
937 self.assertRaisesRegex(TypeError, msg, getattr, sys, 1, 'spam')
938 self.assertRaises(AttributeError, getattr, sys, chr(sys.maxunicode))
940 self.assertRaises(AttributeError, getattr, 1, "\uDAD1\uD51E")
942 def test_hasattr(self):
943 self.assertTrue(hasattr(sys, 'stdout'))
944 self.assertRaises(TypeError, hasattr)
945 self.assertRaises(TypeError, hasattr, sys)
947 self.assertRaisesRegex(TypeError, msg, hasattr, sys, 1)
948 self.assertEqual(False, hasattr(sys, chr(sys.maxunicode)))
953 def __getattr__(self, what):
955 self.assertRaises(SystemExit, hasattr, A(), "b")
957 def __getattr__(self, what):
959 self.assertRaises(ValueError, hasattr, B(), "b")
961 def test_hash(self):
963 self.assertEqual(hash(1), hash(1))
964 self.assertEqual(hash(1), hash(1.0))
966 self.assertEqual(hash('spam'), hash(b'spam'))
970 self.assertRaises(TypeError, hash, [])
971 self.assertRaises(TypeError, hash, {})
974 def __hash__(self):
976 self.assertEqual(type(hash(X())), int)
978 def __hash__(self):
979 return self
980 self.assertEqual(hash(Z(42)), hash(42))
982 def test_hex(self):
983 self.assertEqual(hex(16), '0x10')
984 self.assertEqual(hex(-16), '-0x10')
985 self.assertRaises(TypeError, hex, {})
987 def test_id(self):
998 def test_iter(self):
999 self.assertRaises(TypeError, iter)
1000 self.assertRaises(TypeError, iter, 42, 42)
1004 self.assertEqual(next(i), '1')
1005 self.assertEqual(next(i), '2')
1006 self.assertRaises(StopIteration, next, i)
1008 def test_isinstance(self):
1018 self.assertTrue(isinstance(c, C))
1019 self.assertTrue(isinstance(d, C))
1020 self.assertTrue(not isinstance(e, C))
1021 self.assertTrue(not isinstance(c, D))
1022 self.assertTrue(not isinstance('foo', E))
1023 self.assertRaises(TypeError, isinstance, E, 'foo')
1024 self.assertRaises(TypeError, isinstance)
1026 def test_issubclass(self):
1036 self.assertTrue(issubclass(D, C))
1037 self.assertTrue(issubclass(C, C))
1038 self.assertTrue(not issubclass(C, D))
1039 self.assertRaises(TypeError, issubclass, 'foo', E)
1040 self.assertRaises(TypeError, issubclass, E, 'foo')
1041 self.assertRaises(TypeError, issubclass)
1043 def test_len(self):
1044 self.assertEqual(len('123'), 3)
1045 self.assertEqual(len(()), 0)
1046 self.assertEqual(len((1, 2, 3, 4)), 4)
1047 self.assertEqual(len([1, 2, 3, 4]), 4)
1048 self.assertEqual(len({}), 0)
1049 self.assertEqual(len({'a':1, 'b': 2}), 2)
1051 def __len__(self):
1053 self.assertRaises(ValueError, len, BadSeq())
1055 def __len__(self):
1057 self.assertRaises(TypeError, len, InvalidLen())
1059 def __len__(self):
1061 self.assertRaises(TypeError, len, FloatLen())
1063 def __len__(self):
1065 self.assertRaises(ValueError, len, NegativeLen())
1067 def __len__(self):
1069 self.assertRaises(OverflowError, len, HugeLen())
1071 def __len__(self):
1073 self.assertRaises(ValueError, len, HugeNegativeLen())
1075 self.assertRaises(TypeError, len, NoLenMethod())
1077 def test_map(self):
1078 self.assertEqual(
1087 self.assertEqual(
1091 self.assertEqual(
1100 self.assertEqual(
1104 self.assertEqual(
1108 self.assertEqual(
1112 self.assertEqual(
1122 self.assertEqual(
1126 self.assertRaises(TypeError, map)
1127 self.assertRaises(TypeError, map, lambda x: x, 42)
1129 def __iter__(self):
1132 self.assertRaises(ValueError, list, map(lambda x: x, BadSeq()))
1135 self.assertRaises(RuntimeError, list, map(badfunc, range(5)))
1137 def test_map_pickle(self):
1141 self.check_iter_pickle(m1, list(m2), proto)
1143 def test_max(self):
1144 self.assertEqual(max('123123'), '3')
1145 self.assertEqual(max(1, 2, 3), 3)
1146 self.assertEqual(max((1, 2, 3, 1, 2, 3)), 3)
1147 self.assertEqual(max([1, 2, 3, 1, 2, 3]), 3)
1149 self.assertEqual(max(1, 2, 3.0), 3.0)
1150 self.assertEqual(max(1, 2.0, 3), 3)
1151 self.assertEqual(max(1.0, 2, 3), 3)
1153 with self.assertRaisesRegex(
1159 self.assertRaises(TypeError, max, 42)
1160 self.assertRaises(ValueError, max, ())
1162 def __getitem__(self, index):
1164 self.assertRaises(ValueError, max, BadSeq())
1181 self.fail(stmt)
1183 self.assertEqual(max((1,), key=neg), 1) # one elem iterable
1184 self.assertEqual(max((1,2), key=neg), 1) # two elem iterable
1185 self.assertEqual(max(1, 2, key=neg), 1) # two elems
1187 self.assertEqual(max((), default=None), None) # zero elem iterable
1188 self.assertEqual(max((1,), default=None), 1) # one elem iterable
1189 self.assertEqual(max((1,2), default=None), 2) # two elem iterable
1191 self.assertEqual(max((), default=1, key=neg), 1)
1192 self.assertEqual(max((1, 2), default=3, key=neg), 1)
1194 self.assertEqual(max((1, 2), key=None), 2)
1199 self.assertEqual(max(data, key=f),
1202 def test_min(self):
1203 self.assertEqual(min('123123'), '1')
1204 self.assertEqual(min(1, 2, 3), 1)
1205 self.assertEqual(min((1, 2, 3, 1, 2, 3)), 1)
1206 self.assertEqual(min([1, 2, 3, 1, 2, 3]), 1)
1208 self.assertEqual(min(1, 2, 3.0), 1)
1209 self.assertEqual(min(1, 2.0, 3), 1)
1210 self.assertEqual(min(1.0, 2, 3), 1.0)
1212 with self.assertRaisesRegex(
1218 self.assertRaises(TypeError, min, 42)
1219 self.assertRaises(ValueError, min, ())
1221 def __getitem__(self, index):
1223 self.assertRaises(ValueError, min, BadSeq())
1240 self.fail(stmt)
1242 self.assertEqual(min((1,), key=neg), 1) # one elem iterable
1243 self.assertEqual(min((1,2), key=neg), 2) # two elem iterable
1244 self.assertEqual(min(1, 2, key=neg), 2) # two elems
1246 self.assertEqual(min((), default=None), None) # zero elem iterable
1247 self.assertEqual(min((1,), default=None), 1) # one elem iterable
1248 self.assertEqual(min((1,2), default=None), 1) # two elem iterable
1250 self.assertEqual(min((), default=1, key=neg), 1)
1251 self.assertEqual(min((1, 2), default=1, key=neg), 2)
1253 self.assertEqual(min((1, 2), key=None), 1)
1258 self.assertEqual(min(data, key=f),
1261 def test_next(self):
1263 self.assertEqual(next(it), 0)
1264 self.assertEqual(next(it), 1)
1265 self.assertRaises(StopIteration, next, it)
1266 self.assertRaises(StopIteration, next, it)
1267 self.assertEqual(next(it, 42), 42)
1270 def __iter__(self):
1271 return self
1272 def __next__(self):
1276 self.assertEqual(next(it, 42), 42)
1277 self.assertRaises(StopIteration, next, it)
1284 self.assertEqual(next(it), 1)
1285 self.assertRaises(StopIteration, next, it)
1286 self.assertEqual(next(it, 42), 42)
1288 def test_oct(self):
1289 self.assertEqual(oct(100), '0o144')
1290 self.assertEqual(oct(-100), '-0o144')
1291 self.assertRaises(TypeError, oct, ())
1293 def write_testfile(self):
1296 self.addCleanup(unlink, TESTFN)
1305 def test_open(self):
1306 self.write_testfile()
1309 self.assertEqual(fp.readline(4), '1+1\n')
1310 self.assertEqual(fp.readline(), 'The quick brown fox jumps over the lazy dog.\n')
1311 self.assertEqual(fp.readline(4), 'Dear')
1312 self.assertEqual(fp.readline(100), ' John\n')
1313 self.assertEqual(fp.read(300), 'XXX'*100)
1314 self.assertEqual(fp.read(1000), 'YYY'*100)
1317 self.assertRaises(ValueError, open, 'a\x00b')
1318 self.assertRaises(ValueError, open, b'a\x00b')
1321 def test_open_default_encoding(self):
1331 self.write_testfile()
1337 self.assertEqual(fp.encoding, current_locale_encoding)
1343 def test_open_non_inheritable(self):
1346 self.assertFalse(os.get_inheritable(fileobj.fileno()))
1348 def test_ord(self):
1349 self.assertEqual(ord(' '), 32)
1350 self.assertEqual(ord('A'), 65)
1351 self.assertEqual(ord('a'), 97)
1352 self.assertEqual(ord('\x80'), 128)
1353 self.assertEqual(ord('\xff'), 255)
1355 self.assertEqual(ord(b' '), 32)
1356 self.assertEqual(ord(b'A'), 65)
1357 self.assertEqual(ord(b'a'), 97)
1358 self.assertEqual(ord(b'\x80'), 128)
1359 self.assertEqual(ord(b'\xff'), 255)
1361 self.assertEqual(ord(chr(sys.maxunicode)), sys.maxunicode)
1362 self.assertRaises(TypeError, ord, 42)
1364 self.assertEqual(ord(chr(0x10FFFF)), 0x10FFFF)
1365 self.assertEqual(ord("\U0000FFFF"), 0x0000FFFF)
1366 self.assertEqual(ord("\U00010000"), 0x00010000)
1367 self.assertEqual(ord("\U00010001"), 0x00010001)
1368 self.assertEqual(ord("\U000FFFFE"), 0x000FFFFE)
1369 self.assertEqual(ord("\U000FFFFF"), 0x000FFFFF)
1370 self.assertEqual(ord("\U00100000"), 0x00100000)
1371 self.assertEqual(ord("\U00100001"), 0x00100001)
1372 self.assertEqual(ord("\U0010FFFE"), 0x0010FFFE)
1373 self.assertEqual(ord("\U0010FFFF"), 0x0010FFFF)
1375 def test_pow(self):
1376 self.assertEqual(pow(0,0), 1)
1377 self.assertEqual(pow(0,1), 0)
1378 self.assertEqual(pow(1,0), 1)
1379 self.assertEqual(pow(1,1), 1)
1381 self.assertEqual(pow(2,0), 1)
1382 self.assertEqual(pow(2,10), 1024)
1383 self.assertEqual(pow(2,20), 1024*1024)
1384 self.assertEqual(pow(2,30), 1024*1024*1024)
1386 self.assertEqual(pow(-2,0), 1)
1387 self.assertEqual(pow(-2,1), -2)
1388 self.assertEqual(pow(-2,2), 4)
1389 self.assertEqual(pow(-2,3), -8)
1391 self.assertAlmostEqual(pow(0.,0), 1.)
1392 self.assertAlmostEqual(pow(0.,1), 0.)
1393 self.assertAlmostEqual(pow(1.,0), 1.)
1394 self.assertAlmostEqual(pow(1.,1), 1.)
1396 self.assertAlmostEqual(pow(2.,0), 1.)
1397 self.assertAlmostEqual(pow(2.,10), 1024.)
1398 self.assertAlmostEqual(pow(2.,20), 1024.*1024.)
1399 self.assertAlmostEqual(pow(2.,30), 1024.*1024.*1024.)
1401 self.assertAlmostEqual(pow(-2.,0), 1.)
1402 self.assertAlmostEqual(pow(-2.,1), -2.)
1403 self.assertAlmostEqual(pow(-2.,2), 4.)
1404 self.assertAlmostEqual(pow(-2.,3), -8.)
1412 self.assertRaises(TypeError, pow, x, y, z)
1414 self.assertAlmostEqual(pow(x, y, z), 24.0)
1416 self.assertAlmostEqual(pow(-1, 0.5), 1j)
1417 self.assertAlmostEqual(pow(-1, 1/3), 0.5 + 0.8660254037844386j)
1420 self.assertEqual(pow(-1, -2, 3), 1)
1421 self.assertRaises(ValueError, pow, 1, 2, 0)
1423 self.assertRaises(TypeError, pow)
1426 self.assertEqual(pow(0, exp=0), 1)
1427 self.assertEqual(pow(base=2, exp=4), 16)
1428 self.assertEqual(pow(base=5, exp=2, mod=14), 11)
1430 self.assertEqual(twopow(exp=5), 32)
1432 self.assertEqual(fifth_power(2), 32)
1434 self.assertEqual(mod10(2, 6), 4)
1435 self.assertEqual(mod10(exp=6, base=2), 4)
1437 def test_input(self):
1438 self.write_testfile()
1445 self.assertEqual(input(), "1+1")
1446 self.assertEqual(input(), 'The quick brown fox jumps over the lazy dog.')
1447 self.assertEqual(input('testing\n'), 'Dear John')
1453 self.assertRaises(ValueError, input)
1457 self.assertRaises(TypeError, input, 42, 42)
1459 self.assertEqual(input(), " 'whitespace'")
1461 self.assertRaises(EOFError, input)
1464 self.assertRaises(RuntimeError, input, 'prompt')
1466 self.assertRaises(RuntimeError, input, 'prompt')
1474 def test_repr(self):
1475 self.assertEqual(repr(''), '\'\'')
1476 self.assertEqual(repr(0), '0')
1477 self.assertEqual(repr(()), '()')
1478 self.assertEqual(repr([]), '[]')
1479 self.assertEqual(repr({}), '{}')
1482 self.assertEqual(repr(a), '[[...]]')
1485 self.assertEqual(repr(a), '{0: {...}}')
1487 def test_round(self):
1488 self.assertEqual(round(0.0), 0.0)
1489 self.assertEqual(type(round(0.0)), int)
1490 self.assertEqual(round(1.0), 1.0)
1491 self.assertEqual(round(10.0), 10.0)
1492 self.assertEqual(round(1000000000.0), 1000000000.0)
1493 self.assertEqual(round(1e20), 1e20)
1495 self.assertEqual(round(-1.0), -1.0)
1496 self.assertEqual(round(-10.0), -10.0)
1497 self.assertEqual(round(-1000000000.0), -1000000000.0)
1498 self.assertEqual(round(-1e20), -1e20)
1500 self.assertEqual(round(0.1), 0.0)
1501 self.assertEqual(round(1.1), 1.0)
1502 self.assertEqual(round(10.1), 10.0)
1503 self.assertEqual(round(1000000000.1), 1000000000.0)
1505 self.assertEqual(round(-1.1), -1.0)
1506 self.assertEqual(round(-10.1), -10.0)
1507 self.assertEqual(round(-1000000000.1), -1000000000.0)
1509 self.assertEqual(round(0.9), 1.0)
1510 self.assertEqual(round(9.9), 10.0)
1511 self.assertEqual(round(999999999.9), 1000000000.0)
1513 self.assertEqual(round(-0.9), -1.0)
1514 self.assertEqual(round(-9.9), -10.0)
1515 self.assertEqual(round(-999999999.9), -1000000000.0)
1517 self.assertEqual(round(-8.0, -1), -10.0)
1518 self.assertEqual(type(round(-8.0, -1)), float)
1520 self.assertEqual(type(round(-8.0, 0)), float)
1521 self.assertEqual(type(round(-8.0, 1)), float)
1524 self.assertEqual(round(5.5), 6)
1525 self.assertEqual(round(6.5), 6)
1526 self.assertEqual(round(-5.5), -6)
1527 self.assertEqual(round(-6.5), -6)
1530 self.assertEqual(round(0), 0)
1531 self.assertEqual(round(8), 8)
1532 self.assertEqual(round(-8), -8)
1533 self.assertEqual(type(round(0)), int)
1534 self.assertEqual(type(round(-8, -1)), int)
1535 self.assertEqual(type(round(-8, 0)), int)
1536 self.assertEqual(type(round(-8, 1)), int)
1539 self.assertEqual(round(number=-8.0, ndigits=-1), -10.0)
1541 self.assertRaises(TypeError, round)
1545 def __round__(self):
1551 self.assertEqual(round(TestRound()), 23)
1553 self.assertRaises(TypeError, round, 1, 2, 3)
1554 self.assertRaises(TypeError, round, TestNoRound())
1558 self.assertRaises(TypeError, round, t)
1559 self.assertRaises(TypeError, round, t, 0)
1574 def test_round_large(self):
1576 self.assertEqual(round(5e15-1), 5e15-1)
1577 self.assertEqual(round(5e15), 5e15)
1578 self.assertEqual(round(5e15+1), 5e15+1)
1579 self.assertEqual(round(5e15+2), 5e15+2)
1580 self.assertEqual(round(5e15+3), 5e15+3)
1582 def test_bug_27936(self):
1588 self.assertEqual(round(x, None), round(x))
1589 self.assertEqual(type(round(x, None)), type(round(x)))
1591 def test_setattr(self):
1593 self.assertEqual(sys.spam, 1)
1594 self.assertRaises(TypeError, setattr)
1595 self.assertRaises(TypeError, setattr, sys)
1596 self.assertRaises(TypeError, setattr, sys, 'spam')
1598 self.assertRaisesRegex(TypeError, msg, setattr, sys, 1, 'spam')
1602 def test_sum(self):
1603 self.assertEqual(sum([]), 0)
1604 self.assertEqual(sum(list(range(2,8))), 27)
1605 self.assertEqual(sum(iter(list(range(2,8)))), 27)
1606 self.assertEqual(sum(Squares(10)), 285)
1607 self.assertEqual(sum(iter(Squares(10))), 285)
1608 self.assertEqual(sum([[1], [2], [3]], []), [1, 2, 3])
1610 self.assertEqual(sum(range(10), 1000), 1045)
1611 self.assertEqual(sum(range(10), start=1000), 1045)
1612 self.assertEqual(sum(range(10), 2**31-5), 2**31+40)
1613 self.assertEqual(sum(range(10), 2**63-5), 2**63+40)
1615 self.assertEqual(sum(i % 2 != 0 for i in range(10)), 5)
1616 self.assertEqual(sum((i % 2 != 0 for i in range(10)), 2**31-3),
1618 self.assertEqual(sum((i % 2 != 0 for i in range(10)), 2**63-3),
1620 self.assertIs(sum([], False), False)
1622 self.assertEqual(sum(i / 2 for i in range(10)), 22.5)
1623 self.assertEqual(sum((i / 2 for i in range(10)), 1000), 1022.5)
1624 self.assertEqual(sum((i / 2 for i in range(10)), 1000.25), 1022.75)
1625 self.assertEqual(sum([0.5, 1]), 1.5)
1626 self.assertEqual(sum([1, 0.5]), 1.5)
1627 self.assertEqual(repr(sum([-0.0])), '0.0')
1628 self.assertEqual(repr(sum([-0.0], -0.0)), '-0.0')
1629 self.assertEqual(repr(sum([], -0.0)), '-0.0')
1631 self.assertRaises(TypeError, sum)
1632 self.assertRaises(TypeError, sum, 42)
1633 self.assertRaises(TypeError, sum, ['a', 'b', 'c'])
1634 self.assertRaises(TypeError, sum, ['a', 'b', 'c'], '')
1635 self.assertRaises(TypeError, sum, [b'a', b'c'], b'')
1637 self.assertRaises(TypeError, sum, values, bytearray(b''))
1638 self.assertRaises(TypeError, sum, [[1], [2], [3]])
1639 self.assertRaises(TypeError, sum, [{2:3}])
1640 self.assertRaises(TypeError, sum, [{2:3}]*2, {2:3})
1641 self.assertRaises(TypeError, sum, [], '')
1642 self.assertRaises(TypeError, sum, [], b'')
1643 self.assertRaises(TypeError, sum, [], bytearray())
1646 def __getitem__(self, index):
1648 self.assertRaises(ValueError, sum, BadSeq())
1652 self.assertEqual(empty, [])
1654 def test_type(self):
1655 self.assertEqual(type(''), type('123'))
1656 self.assertNotEqual(type(''), type(()))
1658 # We don't want self in vars(), so these are static methods
1672 def getDict(self):
1676 def test_vars(self):
1677 self.assertEqual(set(vars()), set(dir()))
1678 self.assertEqual(set(vars(sys)), set(dir(sys)))
1679 self.assertEqual(self.get_vars_f0(), {})
1680 self.assertEqual(self.get_vars_f2(), {'a': 1, 'b': 2})
1681 self.assertRaises(TypeError, vars, 42, 42)
1682 self.assertRaises(TypeError, vars, 42)
1683 self.assertEqual(vars(self.C_get_vars()), {'a':2})
1685 def iter_error(self, iterable, error):
1688 with self.assertRaises(error):
1693 def test_zip(self):
1697 self.assertEqual(list(zip(a, b)), t)
1699 self.assertEqual(list(zip(a, b)), t)
1701 self.assertEqual(list(zip(a, b)), t)
1703 def __getitem__(self, i):
1706 self.assertEqual(list(zip(a, I())), t)
1707 self.assertEqual(list(zip()), [])
1708 self.assertEqual(list(zip(*[])), [])
1709 self.assertRaises(TypeError, zip, None)
1712 self.assertRaises(TypeError, zip, a, G())
1713 self.assertRaises(RuntimeError, zip, a, TestFailingIter())
1719 def __getitem__(self, i):
1724 self.assertEqual(
1730 def __getitem__(self, i):
1735 self.assertRaises(ValueError, list, zip(BadSeq(), BadSeq()))
1737 def test_zip_pickle(self):
1743 self.check_iter_pickle(z1, t, proto)
1745 def test_zip_pickle_strict(self):
1751 self.check_iter_pickle(z1, t, proto)
1753 def test_zip_pickle_strict_fail(self):
1760 self.assertEqual(self.iter_error(z1, ValueError), t)
1761 self.assertEqual(self.iter_error(z2, ValueError), t)
1763 def test_zip_bad_iterable(self):
1767 def __iter__(self):
1770 with self.assertRaises(TypeError) as cm:
1773 self.assertIs(cm.exception, exception)
1775 def test_zip_strict(self):
1776 self.assertEqual(tuple(zip((1, 2, 3), 'abc', strict=True)),
1778 self.assertRaises(ValueError, tuple,
1780 self.assertRaises(ValueError, tuple,
1782 self.assertRaises(ValueError, tuple,
1785 def test_zip_strict_iterators(self):
1789 self.assertRaises(ValueError, list,
1791 self.assertEqual(next(x), 2)
1792 self.assertEqual(next(z), 1)
1794 def test_zip_strict_error_handling(self):
1800 def __init__(self, size):
1801 self.size = size
1802 def __iter__(self):
1803 return self
1804 def __next__(self):
1805 self.size -= 1
1806 if self.size < 0:
1808 return self.size
1810 l1 = self.iter_error(zip("AB", Iter(1), strict=True), Error)
1811 self.assertEqual(l1, [("A", 0)])
1812 l2 = self.iter_error(zip("AB", Iter(2), "A", strict=True), ValueError)
1813 self.assertEqual(l2, [("A", 1, "A")])
1814 l3 = self.iter_error(zip("AB", Iter(2), "ABC", strict=True), Error)
1815 self.assertEqual(l3, [("A", 1, "A"), ("B", 0, "B")])
1816 l4 = self.iter_error(zip("AB", Iter(3), strict=True), ValueError)
1817 self.assertEqual(l4, [("A", 2), ("B", 1)])
1818 l5 = self.iter_error(zip(Iter(1), "AB", strict=True), Error)
1819 self.assertEqual(l5, [(0, "A")])
1820 l6 = self.iter_error(zip(Iter(2), "A", strict=True), ValueError)
1821 self.assertEqual(l6, [(1, "A")])
1822 l7 = self.iter_error(zip(Iter(2), "ABC", strict=True), Error)
1823 self.assertEqual(l7, [(1, "A"), (0, "B")])
1824 l8 = self.iter_error(zip(Iter(3), "AB", strict=True), ValueError)
1825 self.assertEqual(l8, [(2, "A"), (1, "B")])
1827 def test_zip_strict_error_handling_stopiteration(self):
1830 def __init__(self, size):
1831 self.size = size
1832 def __iter__(self):
1833 return self
1834 def __next__(self):
1835 self.size -= 1
1836 if self.size < 0:
1838 return self.size
1840 l1 = self.iter_error(zip("AB", Iter(1), strict=True), ValueError)
1841 self.assertEqual(l1, [("A", 0)])
1842 l2 = self.iter_error(zip("AB", Iter(2), "A", strict=True), ValueError)
1843 self.assertEqual(l2, [("A", 1, "A")])
1844 l3 = self.iter_error(zip("AB", Iter(2), "ABC", strict=True), ValueError)
1845 self.assertEqual(l3, [("A", 1, "A"), ("B", 0, "B")])
1846 l4 = self.iter_error(zip("AB", Iter(3), strict=True), ValueError)
1847 self.assertEqual(l4, [("A", 2), ("B", 1)])
1848 l5 = self.iter_error(zip(Iter(1), "AB", strict=True), ValueError)
1849 self.assertEqual(l5, [(0, "A")])
1850 l6 = self.iter_error(zip(Iter(2), "A", strict=True), ValueError)
1851 self.assertEqual(l6, [(1, "A")])
1852 l7 = self.iter_error(zip(Iter(2), "ABC", strict=True), ValueError)
1853 self.assertEqual(l7, [(1, "A"), (0, "B")])
1854 l8 = self.iter_error(zip(Iter(3), "AB", strict=True), ValueError)
1855 self.assertEqual(l8, [(2, "A"), (1, "B")])
1858 def test_zip_result_gc(self):
1867 self.assertTrue(gc.is_tracked(next(it)))
1869 def test_format(self):
1872 self.assertEqual(format(3, ''), '3')
1878 def __init__(self, x):
1879 self.x = x
1880 def __format__(self, format_spec):
1881 return str(self.x) + format_spec
1887 def __init__(self, x):
1888 self.x = x
1889 def __format__(self, format_spec):
1890 return str(self.x) + format_spec
1895 self.assertEqual(format(A(3), 'spec'), '3spec')
1896 self.assertEqual(format(DerivedFromA(4), 'spec'), '4spec')
1897 self.assertEqual(format(DerivedFromSimple(5), 'abc'), '5abc')
1898 self.assertEqual(format(DerivedFromSimple2(10), 'abcdef'),
1907 self.assertEqual(format(value, ""), str(value))
1908 self.assertEqual(format(value), str(value))
1920 # TypeError because self.__format__ returns the wrong type
1922 def __format__(self, format_spec):
1924 self.assertRaises(TypeError, format, BadFormatResult(), "")
1927 self.assertRaises(TypeError, format, object(), 4)
1928 self.assertRaises(TypeError, format, object(), object())
1933 self.assertTrue(x.startswith('<object object at'))
1936 self.assertRaises(TypeError, object().__format__, 3)
1937 self.assertRaises(TypeError, object().__format__, object())
1938 self.assertRaises(TypeError, object().__format__, None)
1944 def __format__(self, fmt_str):
1947 self.assertEqual(format(A()), '')
1948 self.assertEqual(format(A(), ''), '')
1949 self.assertEqual(format(A(), 's'), '')
1959 self.assertEqual(format(obj), str(obj))
1960 self.assertEqual(format(obj, ''), str(obj))
1961 with self.assertRaisesRegex(TypeError,
1968 self.assertEqual(format(0, DerivedFromStr('10')), ' 0')
1970 def test_bin(self):
1971 self.assertEqual(bin(0), '0b0')
1972 self.assertEqual(bin(1), '0b1')
1973 self.assertEqual(bin(-1), '-0b1')
1974 self.assertEqual(bin(2**65), '0b1' + '0' * 65)
1975 self.assertEqual(bin(2**65-1), '0b' + '1' * 65)
1976 self.assertEqual(bin(-(2**65)), '-0b1' + '0' * 65)
1977 self.assertEqual(bin(-(2**65-1)), '-0b' + '1' * 65)
1979 def test_bytearray_translate(self):
1981 self.assertRaises(ValueError, x.translate, b"1", 1)
1982 self.assertRaises(TypeError, x.translate, b"1"*256, 1)
1984 def test_bytearray_extend_error(self):
1987 self.assertRaises(ValueError, array.extend, bad_iter)
1989 def test_construct_singletons(self):
1992 self.assertIs(tp(), const)
1993 self.assertRaises(TypeError, tp, 1, 2)
1994 self.assertRaises(TypeError, tp, a=1, b=2)
1996 def test_warning_notimplemented(self):
2004 self.assertWarns(DeprecationWarning, bool, NotImplemented)
2005 with self.assertWarns(DeprecationWarning):
2006 self.assertTrue(NotImplemented)
2007 with self.assertWarns(DeprecationWarning):
2008 self.assertFalse(not NotImplemented)
2012 def setUp(self):
2019 self.resources = ExitStack()
2020 self.addCleanup(self.resources.close)
2021 self.env = self.resources.enter_context(EnvironmentVarGuard())
2022 del self.env['PYTHONBREAKPOINT']
2023 self.resources.enter_context(
2026 def test_breakpoint(self):
2031 def test_breakpoint_with_breakpointhook_set(self):
2037 def test_breakpoint_with_breakpointhook_reset(self):
2049 def test_breakpoint_with_args_and_keywords(self):
2055 def test_breakpoint_with_passthru_error(self):
2059 self.assertRaises(TypeError, breakpoint, 1, 2, 3, four=4, five=5)
2062 def test_envar_good_path_builtin(self):
2063 self.env['PYTHONBREAKPOINT'] = 'int'
2069 def test_envar_good_path_other(self):
2070 self.env['PYTHONBREAKPOINT'] = 'sys.exit'
2076 def test_envar_good_path_noop_0(self):
2077 self.env['PYTHONBREAKPOINT'] = '0'
2082 def test_envar_good_path_empty_string(self):
2084 self.env['PYTHONBREAKPOINT'] = ''
2090 def test_envar_unimportable(self):
2097 with self.subTest(envar=envar):
2098 self.env['PYTHONBREAKPOINT'] = envar
2099 mock = self.resources.enter_context(patch('pdb.set_trace'))
2100 w = self.resources.enter_context(check_warnings(quiet=True))
2102 self.assertEqual(
2105 self.assertEqual(w.category, RuntimeWarning)
2108 def test_envar_ignored_when_hook_is_set(self):
2109 self.env['PYTHONBREAKPOINT'] = 'sys.exit'
2128 def run_child(self, child, terminal_input):
2129 old_sighup = signal.signal(signal.SIGHUP, self.handle_sighup)
2131 return self._run_child(child, terminal_input)
2135 def _run_child(self, child, terminal_input):
2142 self.skipTest("pty.fork() raised {}".format(e))
2188 self.fail("got %d lines in pipe but expected 2, child output was:\n%s"
2199 def check_input_tty(self, prompt, terminal_input, stdio_encoding=None):
2201 self.skipTest("stdin and stdout must be ttys")
2213 lines = self.run_child(child, terminal_input + b"\r\n")
2215 self.assertIn(lines[0], {'tty = True', 'tty = False'})
2217 self.skipTest("standard IO in should have been a tty")
2223 self.assertEqual(input_result, expected)
2225 def test_input_tty(self):
2228 self.check_input_tty("prompt", b"quux")
2230 def skip_if_readline(self):
2238 self.skipTest("the readline module is loaded")
2240 def test_input_tty_non_ascii(self):
2241 self.skip_if_readline()
2243 self.check_input_tty("prompté", b"quux\xe9", "utf-8")
2245 def test_input_tty_non_ascii_unicode_errors(self):
2246 self.skip_if_readline()
2248 self.check_input_tty("prompté", b"quux\xe9", "ascii")
2250 def test_input_no_stdout_fileno(self):
2258 lines = self.run_child(child, b"quux\r")
2263 self.assertSequenceEqual(lines, expected)
2267 def test_basic(self):
2271 self.assertEqual(data, sorted(copy))
2272 self.assertNotEqual(data, copy)
2276 self.assertEqual(data, sorted(copy, key=lambda x: -x))
2277 self.assertNotEqual(data, copy)
2279 self.assertEqual(data, sorted(copy, reverse=True))
2280 self.assertNotEqual(data, copy)
2282 def test_bad_arguments(self):
2285 with self.assertRaises(TypeError):
2289 with self.assertRaises(TypeError):
2292 def test_inputtypes(self):
2296 self.assertEqual(sorted(s), sorted(T(s)))
2301 self.assertEqual(sorted(s), sorted(T(s)))
2303 def test_baddecorator(self):
2305 self.assertRaises(TypeError, sorted, data, None, lambda x,y: 0)
2310 def test_cleanup(self):
2317 def __del__(self):
2339 self.assertEqual(["before", "after"], out.decode().splitlines())
2343 def test_new_type(self):
2345 self.assertEqual(A.__name__, 'A')
2346 self.assertEqual(A.__qualname__, 'A')
2347 self.assertEqual(A.__module__, __name__)
2348 self.assertEqual(A.__bases__, (object,))
2349 self.assertIs(A.__base__, object)
2351 self.assertIs(type(x), A)
2352 self.assertIs(x.__class__, A)
2355 def ham(self):
2356 return 'ham%d' % self
2357 C = type('C', (B, int), {'spam': lambda self: 'spam%s' % self})
2358 self.assertEqual(C.__name__, 'C')
2359 self.assertEqual(C.__qualname__, 'C')
2360 self.assertEqual(C.__module__, __name__)
2361 self.assertEqual(C.__bases__, (B, int))
2362 self.assertIs(C.__base__, int)
2363 self.assertIn('spam', C.__dict__)
2364 self.assertNotIn('ham', C.__dict__)
2366 self.assertEqual(x, 42)
2367 self.assertIs(type(x), C)
2368 self.assertIs(x.__class__, C)
2369 self.assertEqual(x.ham(), 'ham42')
2370 self.assertEqual(x.spam(), 'spam42')
2371 self.assertEqual(x.to_bytes(2, 'little'), b'\x2a\x00')
2373 def test_type_nokwargs(self):
2374 with self.assertRaises(TypeError):
2376 with self.assertRaises(TypeError):
2379 def test_type_name(self):
2381 with self.subTest(name=name):
2383 self.assertEqual(A.__name__, name)
2384 self.assertEqual(A.__qualname__, name)
2385 self.assertEqual(A.__module__, __name__)
2386 with self.assertRaises(ValueError):
2388 with self.assertRaises(UnicodeEncodeError):
2390 with self.assertRaises(TypeError):
2395 with self.subTest(name=name):
2397 self.assertEqual(C.__name__, name)
2398 self.assertEqual(C.__qualname__, 'C')
2399 self.assertEqual(C.__module__, __name__)
2402 with self.assertRaises(ValueError):
2404 self.assertEqual(A.__name__, 'C')
2405 with self.assertRaises(UnicodeEncodeError):
2407 self.assertEqual(A.__name__, 'C')
2408 with self.assertRaises(TypeError):
2410 self.assertEqual(A.__name__, 'C')
2412 def test_type_qualname(self):
2414 self.assertEqual(A.__name__, 'A')
2415 self.assertEqual(A.__qualname__, 'B.C')
2416 self.assertEqual(A.__module__, __name__)
2417 with self.assertRaises(TypeError):
2419 self.assertEqual(A.__qualname__, 'B.C')
2422 self.assertEqual(A.__name__, 'A')
2423 self.assertEqual(A.__qualname__, 'D.E')
2424 with self.assertRaises(TypeError):
2426 self.assertEqual(A.__qualname__, 'D.E')
2428 def test_type_doc(self):
2431 self.assertEqual(A.__doc__, doc)
2432 with self.assertRaises(UnicodeEncodeError):
2436 self.assertEqual(A.__doc__, None)
2439 self.assertEqual(A.__doc__, doc)
2441 def test_bad_args(self):
2442 with self.assertRaises(TypeError):
2444 with self.assertRaises(TypeError):
2446 with self.assertRaises(TypeError):
2448 with self.assertRaises(TypeError):
2450 with self.assertRaises(TypeError):
2452 with self.assertRaises(TypeError):
2454 with self.assertRaises(TypeError):
2456 with self.assertRaises(TypeError):
2458 with self.assertRaises(TypeError):
2461 def test_bad_slots(self):
2462 with self.assertRaises(TypeError):
2464 with self.assertRaises(TypeError):
2466 with self.assertRaises(TypeError):
2468 with self.assertRaises(TypeError):
2470 with self.assertRaises(TypeError):
2472 with self.assertRaises(ValueError):
2474 with self.assertRaises(TypeError):
2476 with self.assertRaises(TypeError):
2481 with self.assertRaises(TypeError):
2483 with self.assertRaises(TypeError):
2486 def test_namespace_order(self):
2493 self.assertEqual(list(C.__dict__.items())[:2], [('b', 2), ('a', 1)])