Lines Matching refs:self
25 def assertAlmostEqual(self, a, b):
28 unittest.TestCase.assertAlmostEqual(self, a.real, b.real)
29 unittest.TestCase.assertAlmostEqual(self, a.imag, b.imag)
31 unittest.TestCase.assertAlmostEqual(self, a.real, b)
32 unittest.TestCase.assertAlmostEqual(self, a.imag, 0.)
35 unittest.TestCase.assertAlmostEqual(self, a, b.real)
36 unittest.TestCase.assertAlmostEqual(self, 0., b.imag)
38 unittest.TestCase.assertAlmostEqual(self, a, b)
40 def assertCloseAbs(self, x, y, eps=1e-9):
50 self.assertTrue(abs((x-y)/y) < eps)
52 def assertFloatsAreIdentical(self, x, y):
73 self.fail(msg.format(x, y))
75 def assertClose(self, x, y, eps=1e-9):
77 self.assertCloseAbs(x.real, y.real, eps)
78 self.assertCloseAbs(x.imag, y.imag, eps)
80 def check_div(self, x, y):
85 self.assertClose(q, y)
87 self.assertClose(q, y)
90 self.assertClose(q, x)
92 self.assertClose(q, x)
94 def test_truediv(self):
99 self.check_div(x, y)
103 self.check_div(complex(1e200, 1e200), 1+0j)
104 self.check_div(complex(1e-200, 1e-200), 1+0j)
108 self.check_div(complex(random(), random()),
111 self.assertAlmostEqual(complex.__truediv__(2+0j, 1+1j), 1-1j)
115 self.assertTrue(isnan(z.real))
116 self.assertTrue(isnan(z.imag))
118 def test_truediv_zero_division(self):
120 with self.assertRaises(ZeroDivisionError):
123 def test_floordiv(self):
124 with self.assertRaises(TypeError):
126 with self.assertRaises(TypeError):
128 with self.assertRaises(TypeError):
130 with self.assertRaises(TypeError):
132 with self.assertRaises(TypeError):
135 def test_floordiv_zero_division(self):
137 with self.assertRaises(TypeError):
140 def test_richcompare(self):
141 self.assertIs(complex.__eq__(1+1j, 1<<10000), False)
142 self.assertIs(complex.__lt__(1+1j, None), NotImplemented)
143 self.assertIs(complex.__eq__(1+1j, 1+1j), True)
144 self.assertIs(complex.__eq__(1+1j, 2+2j), False)
145 self.assertIs(complex.__ne__(1+1j, 1+1j), False)
146 self.assertIs(complex.__ne__(1+1j, 2+2j), True)
149 self.assertIs(complex.__eq__(f+0j, f), True)
150 self.assertIs(complex.__ne__(f+0j, f), False)
151 self.assertIs(complex.__eq__(complex(f, f), f), False)
152 self.assertIs(complex.__ne__(complex(f, f), f), True)
153 self.assertIs(complex.__lt__(1+1j, 2+2j), NotImplemented)
154 self.assertIs(complex.__le__(1+1j, 2+2j), NotImplemented)
155 self.assertIs(complex.__gt__(1+1j, 2+2j), NotImplemented)
156 self.assertIs(complex.__ge__(1+1j, 2+2j), NotImplemented)
157 self.assertRaises(TypeError, operator.lt, 1+1j, 2+2j)
158 self.assertRaises(TypeError, operator.le, 1+1j, 2+2j)
159 self.assertRaises(TypeError, operator.gt, 1+1j, 2+2j)
160 self.assertRaises(TypeError, operator.ge, 1+1j, 2+2j)
161 self.assertIs(operator.eq(1+1j, 1+1j), True)
162 self.assertIs(operator.eq(1+1j, 2+2j), False)
163 self.assertIs(operator.ne(1+1j, 1+1j), False)
164 self.assertIs(operator.ne(1+1j, 2+2j), True)
166 def test_richcompare_boundaries(self):
171 self.assertIs(complex.__eq__(z, i), is_equal(delta))
172 self.assertIs(complex.__ne__(z, i), not is_equal(delta))
183 def test_mod(self):
185 with self.assertRaises(TypeError):
187 with self.assertRaises(TypeError):
189 with self.assertRaises(TypeError):
191 with self.assertRaises(TypeError):
193 with self.assertRaises(TypeError):
196 def test_mod_zero_division(self):
198 with self.assertRaises(TypeError):
201 def test_divmod(self):
202 self.assertRaises(TypeError, divmod, 1+1j, 1+0j)
203 self.assertRaises(TypeError, divmod, 1+1j, 1.0)
204 self.assertRaises(TypeError, divmod, 1+1j, 1)
205 self.assertRaises(TypeError, divmod, 1.0, 1+0j)
206 self.assertRaises(TypeError, divmod, 1, 1+0j)
208 def test_divmod_zero_division(self):
210 self.assertRaises(TypeError, divmod, a, b)
212 def test_pow(self):
213 self.assertAlmostEqual(pow(1+1j, 0+0j), 1.0)
214 self.assertAlmostEqual(pow(0+0j, 2+0j), 0.0)
215 self.assertRaises(ZeroDivisionError, pow, 0+0j, 1j)
216 self.assertAlmostEqual(pow(1j, -1), 1/1j)
217 self.assertAlmostEqual(pow(1j, 200), 1)
218 self.assertRaises(ValueError, pow, 1+1j, 1+1j, 1+1j)
219 self.assertRaises(OverflowError, pow, 1e200+1j, 1e200+1j)
222 self.assertEqual(a ** 0j, 1)
223 self.assertEqual(a ** 0.+0.j, 1)
225 self.assertEqual(3j ** 0j, 1)
226 self.assertEqual(3j ** 0, 1)
233 self.fail("should fail 0.0 to negative or complex power")
240 self.fail("should fail 0.0 to negative or complex power")
243 self.assertEqual(a ** 105, a ** 105)
244 self.assertEqual(a ** -105, a ** -105)
245 self.assertEqual(a ** -30, a ** -30)
247 self.assertEqual(0.0j ** 0, 1)
250 self.assertRaises(ValueError, pow, a, b, 0)
261 with self.subTest(real=real, imag=imag):
272 def test_pow_with_small_integer_exponents(self):
284 with self.subTest(value=value, exponent=exponent):
297 self.assertEqual(str(float_pow), str(int_pow))
298 self.assertEqual(str(complex_pow), str(int_pow))
300 def test_boolcontext(self):
302 self.assertTrue(complex(random() + 1e-6, random() + 1e-6))
303 self.assertTrue(not complex(0.0, 0.0))
305 def test_conjugate(self):
306 self.assertClose(complex(5.3, 9.8).conjugate(), 5.3-9.8j)
308 def test_constructor(self):
310 def __init__(self, value): self.value = value
311 def __complex__(self): return self.value
312 self.assertEqual(complex(NS(1+10j)), 1+10j)
313 self.assertRaises(TypeError, complex, NS(None))
314 self.assertRaises(TypeError, complex, {})
315 self.assertRaises(TypeError, complex, NS(1.5))
316 self.assertRaises(TypeError, complex, NS(1))
318 self.assertAlmostEqual(complex("1+10j"), 1+10j)
319 self.assertAlmostEqual(complex(10), 10+0j)
320 self.assertAlmostEqual(complex(10.0), 10+0j)
321 self.assertAlmostEqual(complex(10), 10+0j)
322 self.assertAlmostEqual(complex(10+0j), 10+0j)
323 self.assertAlmostEqual(complex(1,10), 1+10j)
324 self.assertAlmostEqual(complex(1,10), 1+10j)
325 self.assertAlmostEqual(complex(1,10.0), 1+10j)
326 self.assertAlmostEqual(complex(1,10), 1+10j)
327 self.assertAlmostEqual(complex(1,10), 1+10j)
328 self.assertAlmostEqual(complex(1,10.0), 1+10j)
329 self.assertAlmostEqual(complex(1.0,10), 1+10j)
330 self.assertAlmostEqual(complex(1.0,10), 1+10j)
331 self.assertAlmostEqual(complex(1.0,10.0), 1+10j)
332 self.assertAlmostEqual(complex(3.14+0j), 3.14+0j)
333 self.assertAlmostEqual(complex(3.14), 3.14+0j)
334 self.assertAlmostEqual(complex(314), 314.0+0j)
335 self.assertAlmostEqual(complex(314), 314.0+0j)
336 self.assertAlmostEqual(complex(3.14+0j, 0j), 3.14+0j)
337 self.assertAlmostEqual(complex(3.14, 0.0), 3.14+0j)
338 self.assertAlmostEqual(complex(314, 0), 314.0+0j)
339 self.assertAlmostEqual(complex(314, 0), 314.0+0j)
340 self.assertAlmostEqual(complex(0j, 3.14j), -3.14+0j)
341 self.assertAlmostEqual(complex(0.0, 3.14j), -3.14+0j)
342 self.assertAlmostEqual(complex(0j, 3.14), 3.14j)
343 self.assertAlmostEqual(complex(0.0, 3.14), 3.14j)
344 self.assertAlmostEqual(complex("1"), 1+0j)
345 self.assertAlmostEqual(complex("1j"), 1j)
346 self.assertAlmostEqual(complex(), 0)
347 self.assertAlmostEqual(complex("-1"), -1)
348 self.assertAlmostEqual(complex("+1"), +1)
349 self.assertAlmostEqual(complex("(1+2j)"), 1+2j)
350 self.assertAlmostEqual(complex("(1.3+2.2j)"), 1.3+2.2j)
351 self.assertAlmostEqual(complex("3.14+1J"), 3.14+1j)
352 self.assertAlmostEqual(complex(" ( +3.14-6J )"), 3.14-6j)
353 self.assertAlmostEqual(complex(" ( +3.14-J )"), 3.14-1j)
354 self.assertAlmostEqual(complex(" ( +3.14+j )"), 3.14+1j)
355 self.assertAlmostEqual(complex("J"), 1j)
356 self.assertAlmostEqual(complex("( j )"), 1j)
357 self.assertAlmostEqual(complex("+J"), 1j)
358 self.assertAlmostEqual(complex("( -j)"), -1j)
359 self.assertAlmostEqual(complex('1e-500'), 0.0 + 0.0j)
360 self.assertAlmostEqual(complex('-1e-500j'), 0.0 - 0.0j)
361 self.assertAlmostEqual(complex('-1e-500+1e-500j'), -0.0 + 0.0j)
364 self.assertAlmostEqual(complex(complex2(1+1j)), 1+1j)
365 self.assertAlmostEqual(complex(real=17, imag=23), 17+23j)
366 self.assertAlmostEqual(complex(real=17+23j), 17+23j)
367 self.assertAlmostEqual(complex(real=17+23j, imag=23), 17+46j)
368 self.assertAlmostEqual(complex(real=1+2j, imag=3+4j), -3+5j)
377 self.assertEqual(split_zeros(complex(1., 0.).imag), split_zeros(0.))
378 self.assertEqual(split_zeros(complex(1., -0.).imag), split_zeros(-0.))
379 self.assertEqual(split_zeros(complex(0., 1.).real), split_zeros(0.))
380 self.assertEqual(split_zeros(complex(-0., 1.).real), split_zeros(-0.))
383 self.assertTrue(complex(c) is c)
386 self.assertRaises(TypeError, complex, "1", "1")
387 self.assertRaises(TypeError, complex, 1, "1")
391 self.assertRaises(ValueError, complex, '1+1j\0j')
393 self.assertRaises(TypeError, int, 5+3j)
394 self.assertRaises(TypeError, int, 5+3j)
395 self.assertRaises(TypeError, float, 5+3j)
396 self.assertRaises(ValueError, complex, "")
397 self.assertRaises(TypeError, complex, None)
398 self.assertRaisesRegex(TypeError, "not 'NoneType'", complex, None)
399 self.assertRaises(ValueError, complex, "\0")
400 self.assertRaises(ValueError, complex, "3\09")
401 self.assertRaises(TypeError, complex, "1", "2")
402 self.assertRaises(TypeError, complex, "1", 42)
403 self.assertRaises(TypeError, complex, 1, "2")
404 self.assertRaises(ValueError, complex, "1+")
405 self.assertRaises(ValueError, complex, "1+1j+1j")
406 self.assertRaises(ValueError, complex, "--")
407 self.assertRaises(ValueError, complex, "(1+2j")
408 self.assertRaises(ValueError, complex, "1+2j)")
409 self.assertRaises(ValueError, complex, "1+(2j)")
410 self.assertRaises(ValueError, complex, "(1+2j)123")
411 self.assertRaises(ValueError, complex, "x")
412 self.assertRaises(ValueError, complex, "1j+2")
413 self.assertRaises(ValueError, complex, "1e1ej")
414 self.assertRaises(ValueError, complex, "1e++1ej")
415 self.assertRaises(ValueError, complex, ")1+2j(")
416 self.assertRaisesRegex(
420 self.assertRaisesRegex(
425 self.assertRaises(ValueError, complex, "1..1j")
426 self.assertRaises(ValueError, complex, "1.11.1j")
427 self.assertRaises(ValueError, complex, "1e1.1j")
430 self.assertEqual(type(complex("1"*500)), complex)
432 self.assertEqual(complex('\N{EM SPACE}(\N{EN SPACE}1+1j ) '), 1+1j)
435 self.assertRaises(ValueError, complex, '\u3053\u3093\u306b\u3061\u306f')
441 def __complex__(self):
444 self.assertRaises(EvilExc, complex, evilcomplex())
447 def __init__(self, value):
448 self.value = value
449 def __float__(self):
450 return self.value
452 self.assertAlmostEqual(complex(float2(42.)), 42)
453 self.assertAlmostEqual(complex(real=float2(17.), imag=float2(23.)), 17+23j)
454 self.assertRaises(TypeError, complex, float2(None))
457 def __init__(self, value):
458 self.value = value
459 def __index__(self):
460 return self.value
462 self.assertAlmostEqual(complex(MyIndex(42)), 42.0+0.0j)
463 self.assertAlmostEqual(complex(123, MyIndex(42)), 123.0+42.0j)
464 self.assertRaises(OverflowError, complex, MyIndex(2**2000))
465 self.assertRaises(OverflowError, complex, 123, MyIndex(2**2000))
468 def __int__(self):
471 self.assertRaises(TypeError, complex, MyInt())
472 self.assertRaises(TypeError, complex, 123, MyInt())
476 def __complex__(self):
481 def __new__(self, value=0j):
482 return complex.__new__(self, 2*value)
483 def __complex__(self):
484 return self
489 def __complex__(self):
492 self.assertEqual(complex(complex0(1j)), 42j)
493 with self.assertWarns(DeprecationWarning):
494 self.assertEqual(complex(complex1(1j)), 2j)
495 self.assertRaises(TypeError, complex, complex2(1j))
497 def test___complex__(self):
499 self.assertEqual(z.__complex__(), z)
500 self.assertEqual(type(z.__complex__()), complex)
506 self.assertEqual(z.__complex__(), 3 + 4j)
507 self.assertEqual(type(z.__complex__()), complex)
510 def test_constructor_special_numbers(self):
515 with self.subTest(x=x, y=y):
517 self.assertFloatsAreIdentical(z.real, x)
518 self.assertFloatsAreIdentical(z.imag, y)
520 self.assertIs(type(z), complex2)
521 self.assertFloatsAreIdentical(z.real, x)
522 self.assertFloatsAreIdentical(z.imag, y)
524 self.assertIs(type(z), complex)
525 self.assertFloatsAreIdentical(z.real, x)
526 self.assertFloatsAreIdentical(z.imag, y)
528 self.assertIs(type(z), complex2)
529 self.assertFloatsAreIdentical(z.real, x)
530 self.assertFloatsAreIdentical(z.imag, y)
532 def test_underscores(self):
536 self.assertEqual(complex(lit), eval(lit))
537 self.assertEqual(complex(lit), complex(lit.replace('_', '')))
542 self.assertRaises(ValueError, complex, lit)
544 def test_hash(self):
546 self.assertEqual(hash(x), hash(complex(x, 0)))
548 self.assertEqual(hash(x), hash(complex(x, 0.)))
550 def test_abs(self):
553 self.assertAlmostEqual((num.real**2 + num.imag**2) ** 0.5, abs(num))
555 def test_repr_str(self):
556 def test(v, expected, test_fn=self.assertEqual):
563 test(-(1+0j), '(-1+-0j)', test_fn=self.assertNotEqual)
577 self.assertEqual(1-6j,complex(repr(1-6j)))
578 self.assertEqual(1+6j,complex(repr(1+6j)))
579 self.assertEqual(-6j,complex(repr(-6j)))
580 self.assertEqual(6j,complex(repr(6j)))
583 def test_negative_zero_repr_str(self):
584 def test(v, expected, test_fn=self.assertEqual):
598 def test_neg(self):
599 self.assertEqual(-(1+6j), -1-6j)
601 def test_getnewargs(self):
602 self.assertEqual((1+2j).__getnewargs__(), (1.0, 2.0))
603 self.assertEqual((1-2j).__getnewargs__(), (1.0, -2.0))
604 self.assertEqual((2j).__getnewargs__(), (0.0, 2.0))
605 self.assertEqual((-0j).__getnewargs__(), (0.0, -0.0))
606 self.assertEqual(complex(0, INF).__getnewargs__(), (0.0, INF))
607 self.assertEqual(complex(INF, 0).__getnewargs__(), (INF, 0.0))
610 def test_plus_minus_0j(self):
613 self.assertEqual(atan2(z1.imag, -1.), atan2(0., -1.))
614 self.assertEqual(atan2(z2.imag, -1.), atan2(-0., -1.))
617 def test_negated_imaginary_literal(self):
625 self.assertFloatsAreIdentical(z0.real, -0.0)
626 self.assertFloatsAreIdentical(z0.imag, -0.0)
627 self.assertFloatsAreIdentical(z1.real, -0.0)
628 self.assertFloatsAreIdentical(z1.imag, -7.0)
629 self.assertFloatsAreIdentical(z2.real, -0.0)
630 self.assertFloatsAreIdentical(z2.imag, -INF)
633 def test_overflow(self):
634 self.assertEqual(complex("1e500"), complex(INF, 0.0))
635 self.assertEqual(complex("-1e500j"), complex(0.0, -INF))
636 self.assertEqual(complex("-1e500+1.8e308j"), complex(-INF, INF))
639 def test_repr_roundtrip(self):
649 self.assertFloatsAreIdentical(z.real, roundtrip.real)
650 self.assertFloatsAreIdentical(z.imag, roundtrip.imag)
661 self.assertFloatsAreIdentical(0.0 + z.real,
663 self.assertFloatsAreIdentical(0.0 + z.imag,
666 def test_format(self):
668 self.assertEqual(format(1+3j, ''), str(1+3j))
669 self.assertEqual(format(1.5+3.5j, ''), str(1.5+3.5j))
670 self.assertEqual(format(3j, ''), str(3j))
671 self.assertEqual(format(3.2j, ''), str(3.2j))
672 self.assertEqual(format(3+0j, ''), str(3+0j))
673 self.assertEqual(format(3.2+0j, ''), str(3.2+0j))
677 self.assertEqual(format(3.2+0j, '-'), str(3.2+0j))
678 self.assertEqual(format(3.2+0j, '<'), str(3.2+0j))
680 self.assertEqual(format(z, ''), str(z))
681 self.assertEqual(format(z, '-'), str(z))
682 self.assertEqual(format(z, '<'), str(z))
683 self.assertEqual(format(z, '10'), str(z))
685 self.assertEqual(format(z, ''), str(z))
686 self.assertEqual(format(z, '-'), str(z))
687 self.assertEqual(format(z, '<'), str(z))
688 self.assertEqual(format(z, '2'), str(z))
690 self.assertEqual(format(z, ''), str(z))
691 self.assertEqual(format(z, '-'), str(z))
692 self.assertEqual(format(z, '<'), str(z))
693 self.assertEqual(format(z, '3'), str(z))
695 self.assertEqual(format(1+3j, 'g'), '1+3j')
696 self.assertEqual(format(3j, 'g'), '0+3j')
697 self.assertEqual(format(1.5+3.5j, 'g'), '1.5+3.5j')
699 self.assertEqual(format(1.5+3.5j, '+g'), '+1.5+3.5j')
700 self.assertEqual(format(1.5-3.5j, '+g'), '+1.5-3.5j')
701 self.assertEqual(format(1.5-3.5j, '-g'), '1.5-3.5j')
702 self.assertEqual(format(1.5+3.5j, ' g'), ' 1.5+3.5j')
703 self.assertEqual(format(1.5-3.5j, ' g'), ' 1.5-3.5j')
704 self.assertEqual(format(-1.5+3.5j, ' g'), '-1.5+3.5j')
705 self.assertEqual(format(-1.5-3.5j, ' g'), '-1.5-3.5j')
707 self.assertEqual(format(-1.5-3.5e-20j, 'g'), '-1.5-3.5e-20j')
708 self.assertEqual(format(-1.5-3.5j, 'f'), '-1.500000-3.500000j')
709 self.assertEqual(format(-1.5-3.5j, 'F'), '-1.500000-3.500000j')
710 self.assertEqual(format(-1.5-3.5j, 'e'), '-1.500000e+00-3.500000e+00j')
711 self.assertEqual(format(-1.5-3.5j, '.2e'), '-1.50e+00-3.50e+00j')
712 self.assertEqual(format(-1.5-3.5j, '.2E'), '-1.50E+00-3.50E+00j')
713 self.assertEqual(format(-1.5e10-3.5e5j, '.2G'), '-1.5E+10-3.5E+05j')
715 self.assertEqual(format(1.5+3j, '<20g'), '1.5+3j ')
716 self.assertEqual(format(1.5+3j, '*<20g'), '1.5+3j**************')
717 self.assertEqual(format(1.5+3j, '>20g'), ' 1.5+3j')
718 self.assertEqual(format(1.5+3j, '^20g'), ' 1.5+3j ')
719 self.assertEqual(format(1.5+3j, '<20'), '(1.5+3j) ')
720 self.assertEqual(format(1.5+3j, '>20'), ' (1.5+3j)')
721 self.assertEqual(format(1.5+3j, '^20'), ' (1.5+3j) ')
722 self.assertEqual(format(1.123-3.123j, '^20.2'), ' (1.1-3.1j) ')
724 self.assertEqual(format(1.5+3j, '20.2f'), ' 1.50+3.00j')
725 self.assertEqual(format(1.5+3j, '>20.2f'), ' 1.50+3.00j')
726 self.assertEqual(format(1.5+3j, '<20.2f'), '1.50+3.00j ')
727 self.assertEqual(format(1.5e20+3j, '<20.2f'), '150000000000000000000.00+3.00j')
728 self.assertEqual(format(1.5e20+3j, '>40.2f'), ' 150000000000000000000.00+3.00j')
729 self.assertEqual(format(1.5e20+3j, '^40,.2f'), ' 150,000,000,000,000,000,000.00+3.00j ')
730 self.assertEqual(format(1.5e21+3j, '^40,.2f'), ' 1,500,000,000,000,000,000,000.00+3.00j ')
731 self.assertEqual(format(1.5e21+3000j, ',.2f'), '1,500,000,000,000,000,000,000.00+3,000.00j')
734 self.assertEqual(format(1+1j, '.0e'), '1e+00+1e+00j')
735 self.assertEqual(format(1+1j, '#.0e'), '1.e+00+1.e+00j')
736 self.assertEqual(format(1+1j, '.0f'), '1+1j')
737 self.assertEqual(format(1+1j, '#.0f'), '1.+1.j')
738 self.assertEqual(format(1.1+1.1j, 'g'), '1.1+1.1j')
739 self.assertEqual(format(1.1+1.1j, '#g'), '1.10000+1.10000j')
742 self.assertEqual(format(1+1j, '.1e'), '1.0e+00+1.0e+00j')
743 self.assertEqual(format(1+1j, '#.1e'), '1.0e+00+1.0e+00j')
744 self.assertEqual(format(1+1j, '.1f'), '1.0+1.0j')
745 self.assertEqual(format(1+1j, '#.1f'), '1.0+1.0j')
748 self.assertEqual(format((-1.5+0.5j), '#f'), '-1.500000+0.500000j')
749 self.assertEqual(format((-1.5+0.5j), '#.0f'), '-2.+0.j')
750 self.assertEqual(format((-1.5+0.5j), '#e'), '-1.500000e+00+5.000000e-01j')
751 self.assertEqual(format((-1.5+0.5j), '#.0e'), '-2.e+00+5.e-01j')
752 self.assertEqual(format((-1.5+0.5j), '#g'), '-1.50000+0.500000j')
753 self.assertEqual(format((-1.5+0.5j), '.0g'), '-2+0.5j')
754 self.assertEqual(format((-1.5+0.5j), '#.0g'), '-2.+0.5j')
757 self.assertRaises(ValueError, (1.5+0.5j).__format__, '010f')
760 self.assertRaises(ValueError, (1.5+3j).__format__, '=20')
764 self.assertRaises(ValueError, (1.5+0.5j).__format__, t)
767 self.assertEqual('*{0:.3f}*'.format(3.14159+2.71828j), '*3.142+2.718j*')
770 self.assertEqual(format(complex(NAN, NAN), 'f'), 'nan+nanj')
771 self.assertEqual(format(complex(1, NAN), 'f'), '1.000000+nanj')
772 self.assertEqual(format(complex(NAN, 1), 'f'), 'nan+1.000000j')
773 self.assertEqual(format(complex(NAN, -1), 'f'), 'nan-1.000000j')
774 self.assertEqual(format(complex(NAN, NAN), 'F'), 'NAN+NANj')
775 self.assertEqual(format(complex(1, NAN), 'F'), '1.000000+NANj')
776 self.assertEqual(format(complex(NAN, 1), 'F'), 'NAN+1.000000j')
777 self.assertEqual(format(complex(NAN, -1), 'F'), 'NAN-1.000000j')
778 self.assertEqual(format(complex(INF, INF), 'f'), 'inf+infj')
779 self.assertEqual(format(complex(1, INF), 'f'), '1.000000+infj')
780 self.assertEqual(format(complex(INF, 1), 'f'), 'inf+1.000000j')
781 self.assertEqual(format(complex(INF, -1), 'f'), 'inf-1.000000j')
782 self.assertEqual(format(complex(INF, INF), 'F'), 'INF+INFj')
783 self.assertEqual(format(complex(1, INF), 'F'), '1.000000+INFj')
784 self.assertEqual(format(complex(INF, 1), 'F'), 'INF+1.000000j')
785 self.assertEqual(format(complex(INF, -1), 'F'), 'INF-1.000000j')