cpython-lru_cache-weakref: Lib/test/test

annotate Lib/test/test_complex.py @ 62799:dcc2e8bf64cf

Fix: Issue9091 Minor documentation clarification.

author	Senthil Kumaran <orsenthil@gmail.com>
date	Mon, 05 Jul 2010 11:41:42 +0000
parents	2bc54da4b82c
children	897fd51051bb

rev	line source
60174 255a401c19b0 (partially) Florent Xicluna <florent.xicluna@gmail.com> parents: 59563 diff changeset	1 import unittest
47201 9c930a32cebb #2621 rename test.test_support to test.support Benjamin Peterson <benjamin@python.org> parents: 45371 diff changeset	2 from test import support
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	3
17066 2c1be7924b04 SF bug [ #409448 ] Complex division is braindead Tim Peters <tim.peters@gmail.com> parents: diff changeset	4 from random import random
53332 330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	5 from math import atan2, isnan, copysign
59563 f65977dcf21a Issue #7845: Make 1j.__le__(2j) return NotImplemented rather than raising TypeError. Mark Dickinson <dickinsm@gmail.com> parents: 59027 diff changeset	6 import operator
17066 2c1be7924b04 SF bug [ #409448 ] Complex division is braindead Tim Peters <tim.peters@gmail.com> parents: diff changeset	7
45371 7c4c46342137 Merged revisions 60481,60485,60489-60492,60494-60496,60498-60499,60501-60503,60505-60506,60508-60509,60523-60524,60532,60543,60545,60547-60548,60552,60554,60556-60559,60561-60562,60569,60571-60572,60574,60576-60583,60585-60586,60589,60591,60594-60595,60597-60598,60600-60601,60606-60612,60615,60617,60619-60621,60623-60625,60627-60629,60631,60633,60635,60647,60650,60652,60654,60656,60658-60659,60664-60666,60668-60670,60672,60676,60678,60680-60683,60685-60686,60688,60690,60692-60694,60697-60700,60705-60706,60708,60711,60714,60720,60724-60730,60732,60736,60742,60744,60746,60748,60750-60751,60753,60756-60757,60759-60761,60763-60764,60766,60769-60770,60774-60784,60787-60845 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45082 diff changeset	8 INF = float("inf")
7c4c46342137 Merged revisions 60481,60485,60489-60492,60494-60496,60498-60499,60501-60503,60505-60506,60508-60509,60523-60524,60532,60543,60545,60547-60548,60552,60554,60556-60559,60561-60562,60569,60571-60572,60574,60576-60583,60585-60586,60589,60591,60594-60595,60597-60598,60600-60601,60606-60612,60615,60617,60619-60621,60623-60625,60627-60629,60631,60633,60635,60647,60650,60652,60654,60656,60658-60659,60664-60666,60668-60670,60672,60676,60678,60680-60683,60685-60686,60688,60690,60692-60694,60697-60700,60705-60706,60708,60711,60714,60720,60724-60730,60732,60736,60742,60744,60746,60748,60750-60751,60753,60756-60757,60759-60761,60763-60764,60766,60769-60770,60774-60784,60787-60845 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45082 diff changeset	9 NAN = float("nan")
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	10 # These tests ensure that complex math does the right thing
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	11
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	12 class ComplexTest(unittest.TestCase):
21401 6da6091a31ee Add a comment explaining what these tests are for, and where to look for Fred Drake <fdrake@acm.org> parents: 19791 diff changeset	13
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	14 def assertAlmostEqual(self, a, b):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	15 if isinstance(a, complex):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	16 if isinstance(b, complex):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	17 unittest.TestCase.assertAlmostEqual(self, a.real, b.real)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	18 unittest.TestCase.assertAlmostEqual(self, a.imag, b.imag)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	19 else:
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	20 unittest.TestCase.assertAlmostEqual(self, a.real, b)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	21 unittest.TestCase.assertAlmostEqual(self, a.imag, 0.)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	22 else:
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	23 if isinstance(b, complex):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	24 unittest.TestCase.assertAlmostEqual(self, a, b.real)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	25 unittest.TestCase.assertAlmostEqual(self, 0., b.imag)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	26 else:
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	27 unittest.TestCase.assertAlmostEqual(self, a, b)
17066 2c1be7924b04 SF bug [ #409448 ] Complex division is braindead Tim Peters <tim.peters@gmail.com> parents: diff changeset	28
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	29 def assertCloseAbs(self, x, y, eps=1e-9):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	30 """Return true iff floats x and y "are close\""""
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	31 # put the one with larger magnitude second
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	32 if abs(x) > abs(y):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	33 x, y = y, x
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	34 if y == 0:
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	35 return abs(x) < eps
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	36 if x == 0:
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	37 return abs(y) < eps
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	38 # check that relative difference < eps
55593 0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 54225 diff changeset	39 self.assertTrue(abs((x-y)/y) < eps)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	40
53332 330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	41 def assertFloatsAreIdentical(self, x, y):
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	42 """assert that floats x and y are identical, in the sense that:
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	43 (1) both x and y are nans, or
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	44 (2) both x and y are infinities, with the same sign, or
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	45 (3) both x and y are zeros, with the same sign, or
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	46 (4) x and y are both finite and nonzero, and x == y
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	47
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	48 """
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	49 msg = 'floats {!r} and {!r} are not identical'
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	50
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	51 if isnan(x) or isnan(y):
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	52 if isnan(x) and isnan(y):
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	53 return
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	54 elif x == y:
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	55 if x != 0.0:
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	56 return
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	57 # both zero; check that signs match
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	58 elif copysign(1.0, x) == copysign(1.0, y):
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	59 return
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	60 else:
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	61 msg += ': zeros have different signs'
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	62 self.fail(msg.format(x, y))
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	63
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	64 def assertClose(self, x, y, eps=1e-9):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	65 """Return true iff complexes x and y "are close\""""
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	66 self.assertCloseAbs(x.real, y.real, eps)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	67 self.assertCloseAbs(x.imag, y.imag, eps)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	68
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	69 def check_div(self, x, y):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	70 """Compute complex z=x*y, and check that z/x==y and z/y==x."""
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	71 z = x * y
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	72 if x != 0:
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	73 q = z / x
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	74 self.assertClose(q, y)
30070 061d86fc11bb Check both __div__ and __truediv__ in division tests. Walter Dörwald <walter@livinglogic.de> parents: 29867 diff changeset	75 q = z.__truediv__(x)
061d86fc11bb Check both __div__ and __truediv__ in division tests. Walter Dörwald <walter@livinglogic.de> parents: 29867 diff changeset	76 self.assertClose(q, y)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	77 if y != 0:
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	78 q = z / y
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	79 self.assertClose(q, x)
30070 061d86fc11bb Check both __div__ and __truediv__ in division tests. Walter Dörwald <walter@livinglogic.de> parents: 29867 diff changeset	80 q = z.__truediv__(y)
061d86fc11bb Check both __div__ and __truediv__ in division tests. Walter Dörwald <walter@livinglogic.de> parents: 29867 diff changeset	81 self.assertClose(q, x)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	82
37191 4bfe8afe8f65 Get rid of remnants of integer division Neal Norwitz <nnorwitz@gmail.com> parents: 35586 diff changeset	83 def test_truediv(self):
41642 a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from Guido van Rossum <guido@python.org> parents: 41575 diff changeset	84 simple_real = [float(i) for i in range(-5, 6)]
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	85 simple_complex = [complex(x, y) for x in simple_real for y in simple_real]
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	86 for x in simple_complex:
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	87 for y in simple_complex:
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	88 self.check_div(x, y)
19791 c97dda238b36 Reverting to rev 1.2. Apparently gcc doesn't use the extended-precision Tim Peters <tim.peters@gmail.com> parents: 19790 diff changeset	89
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	90 # A naive complex division algorithm (such as in 2.0) is very prone to
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	91 # nonsense errors for these (overflows and underflows).
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	92 self.check_div(complex(1e200, 1e200), 1+0j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	93 self.check_div(complex(1e-200, 1e-200), 1+0j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	94
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	95 # Just for fun.
41642 a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from Guido van Rossum <guido@python.org> parents: 41575 diff changeset	96 for i in range(100):
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	97 self.check_div(complex(random(), random()),
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	98 complex(random(), random()))
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	99
37191 4bfe8afe8f65 Get rid of remnants of integer division Neal Norwitz <nnorwitz@gmail.com> parents: 35586 diff changeset	100 self.assertRaises(ZeroDivisionError, complex.__truediv__, 1+1j, 0+0j)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	101 # FIXME: The following currently crashes on Alpha
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	102 # self.assertRaises(OverflowError, pow, 1e200+1j, 1e200+1j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	103
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	104 def test_truediv(self):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	105 self.assertAlmostEqual(complex.__truediv__(2+0j, 1+1j), 1-1j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	106 self.assertRaises(ZeroDivisionError, complex.__truediv__, 1+1j, 0+0j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	107
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	108 def test_floordiv(self):
42435 f6cc76e4ca25 Make test_complex pass again now that floordiv and mod are illegal. Guido van Rossum <guido@python.org> parents: 41904 diff changeset	109 self.assertRaises(TypeError, complex.__floordiv__, 3+0j, 1.5+0j)
f6cc76e4ca25 Make test_complex pass again now that floordiv and mod are illegal. Guido van Rossum <guido@python.org> parents: 41904 diff changeset	110 self.assertRaises(TypeError, complex.__floordiv__, 3+0j, 0+0j)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	111
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	112 def test_richcompare(self):
61787 d6016fa58df6 Issue #8748: Fix two issues with comparisons between complex and integer Mark Dickinson <dickinsm@gmail.com> parents: 60174 diff changeset	113 self.assertIs(complex.__eq__(1+1j, 1<<10000), False)
59563 f65977dcf21a Issue #7845: Make 1j.__le__(2j) return NotImplemented rather than raising TypeError. Mark Dickinson <dickinsm@gmail.com> parents: 59027 diff changeset	114 self.assertIs(complex.__lt__(1+1j, None), NotImplemented)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	115 self.assertIs(complex.__eq__(1+1j, 1+1j), True)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	116 self.assertIs(complex.__eq__(1+1j, 2+2j), False)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	117 self.assertIs(complex.__ne__(1+1j, 1+1j), False)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	118 self.assertIs(complex.__ne__(1+1j, 2+2j), True)
61787 d6016fa58df6 Issue #8748: Fix two issues with comparisons between complex and integer Mark Dickinson <dickinsm@gmail.com> parents: 60174 diff changeset	119 for i in range(1, 100):
d6016fa58df6 Issue #8748: Fix two issues with comparisons between complex and integer Mark Dickinson <dickinsm@gmail.com> parents: 60174 diff changeset	120 f = i / 100.0
d6016fa58df6 Issue #8748: Fix two issues with comparisons between complex and integer Mark Dickinson <dickinsm@gmail.com> parents: 60174 diff changeset	121 self.assertIs(complex.__eq__(f+0j, f), True)
d6016fa58df6 Issue #8748: Fix two issues with comparisons between complex and integer Mark Dickinson <dickinsm@gmail.com> parents: 60174 diff changeset	122 self.assertIs(complex.__ne__(f+0j, f), False)
d6016fa58df6 Issue #8748: Fix two issues with comparisons between complex and integer Mark Dickinson <dickinsm@gmail.com> parents: 60174 diff changeset	123 self.assertIs(complex.__eq__(complex(f, f), f), False)
d6016fa58df6 Issue #8748: Fix two issues with comparisons between complex and integer Mark Dickinson <dickinsm@gmail.com> parents: 60174 diff changeset	124 self.assertIs(complex.__ne__(complex(f, f), f), True)
59563 f65977dcf21a Issue #7845: Make 1j.__le__(2j) return NotImplemented rather than raising TypeError. Mark Dickinson <dickinsm@gmail.com> parents: 59027 diff changeset	125 self.assertIs(complex.__lt__(1+1j, 2+2j), NotImplemented)
f65977dcf21a Issue #7845: Make 1j.__le__(2j) return NotImplemented rather than raising TypeError. Mark Dickinson <dickinsm@gmail.com> parents: 59027 diff changeset	126 self.assertIs(complex.__le__(1+1j, 2+2j), NotImplemented)
f65977dcf21a Issue #7845: Make 1j.__le__(2j) return NotImplemented rather than raising TypeError. Mark Dickinson <dickinsm@gmail.com> parents: 59027 diff changeset	127 self.assertIs(complex.__gt__(1+1j, 2+2j), NotImplemented)
f65977dcf21a Issue #7845: Make 1j.__le__(2j) return NotImplemented rather than raising TypeError. Mark Dickinson <dickinsm@gmail.com> parents: 59027 diff changeset	128 self.assertIs(complex.__ge__(1+1j, 2+2j), NotImplemented)
f65977dcf21a Issue #7845: Make 1j.__le__(2j) return NotImplemented rather than raising TypeError. Mark Dickinson <dickinsm@gmail.com> parents: 59027 diff changeset	129 self.assertRaises(TypeError, operator.lt, 1+1j, 2+2j)
f65977dcf21a Issue #7845: Make 1j.__le__(2j) return NotImplemented rather than raising TypeError. Mark Dickinson <dickinsm@gmail.com> parents: 59027 diff changeset	130 self.assertRaises(TypeError, operator.le, 1+1j, 2+2j)
f65977dcf21a Issue #7845: Make 1j.__le__(2j) return NotImplemented rather than raising TypeError. Mark Dickinson <dickinsm@gmail.com> parents: 59027 diff changeset	131 self.assertRaises(TypeError, operator.gt, 1+1j, 2+2j)
f65977dcf21a Issue #7845: Make 1j.__le__(2j) return NotImplemented rather than raising TypeError. Mark Dickinson <dickinsm@gmail.com> parents: 59027 diff changeset	132 self.assertRaises(TypeError, operator.ge, 1+1j, 2+2j)
f65977dcf21a Issue #7845: Make 1j.__le__(2j) return NotImplemented rather than raising TypeError. Mark Dickinson <dickinsm@gmail.com> parents: 59027 diff changeset	133 self.assertIs(operator.eq(1+1j, 1+1j), True)
f65977dcf21a Issue #7845: Make 1j.__le__(2j) return NotImplemented rather than raising TypeError. Mark Dickinson <dickinsm@gmail.com> parents: 59027 diff changeset	134 self.assertIs(operator.eq(1+1j, 2+2j), False)
f65977dcf21a Issue #7845: Make 1j.__le__(2j) return NotImplemented rather than raising TypeError. Mark Dickinson <dickinsm@gmail.com> parents: 59027 diff changeset	135 self.assertIs(operator.ne(1+1j, 1+1j), False)
f65977dcf21a Issue #7845: Make 1j.__le__(2j) return NotImplemented rather than raising TypeError. Mark Dickinson <dickinsm@gmail.com> parents: 59027 diff changeset	136 self.assertIs(operator.ne(1+1j, 2+2j), True)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	137
61787 d6016fa58df6 Issue #8748: Fix two issues with comparisons between complex and integer Mark Dickinson <dickinsm@gmail.com> parents: 60174 diff changeset	138 def test_richcompare_boundaries(self):
d6016fa58df6 Issue #8748: Fix two issues with comparisons between complex and integer Mark Dickinson <dickinsm@gmail.com> parents: 60174 diff changeset	139 def check(n, deltas, is_equal, imag = 0.0):
d6016fa58df6 Issue #8748: Fix two issues with comparisons between complex and integer Mark Dickinson <dickinsm@gmail.com> parents: 60174 diff changeset	140 for delta in deltas:
d6016fa58df6 Issue #8748: Fix two issues with comparisons between complex and integer Mark Dickinson <dickinsm@gmail.com> parents: 60174 diff changeset	141 i = n + delta
d6016fa58df6 Issue #8748: Fix two issues with comparisons between complex and integer Mark Dickinson <dickinsm@gmail.com> parents: 60174 diff changeset	142 z = complex(i, imag)
d6016fa58df6 Issue #8748: Fix two issues with comparisons between complex and integer Mark Dickinson <dickinsm@gmail.com> parents: 60174 diff changeset	143 self.assertIs(complex.__eq__(z, i), is_equal(delta))
d6016fa58df6 Issue #8748: Fix two issues with comparisons between complex and integer Mark Dickinson <dickinsm@gmail.com> parents: 60174 diff changeset	144 self.assertIs(complex.__ne__(z, i), not is_equal(delta))
d6016fa58df6 Issue #8748: Fix two issues with comparisons between complex and integer Mark Dickinson <dickinsm@gmail.com> parents: 60174 diff changeset	145 # For IEEE-754 doubles the following should hold:
d6016fa58df6 Issue #8748: Fix two issues with comparisons between complex and integer Mark Dickinson <dickinsm@gmail.com> parents: 60174 diff changeset	146 # x in [2 (52 + i), 2 (53 + i + 1)] -> x mod 2 ** i == 0
d6016fa58df6 Issue #8748: Fix two issues with comparisons between complex and integer Mark Dickinson <dickinsm@gmail.com> parents: 60174 diff changeset	147 # where the interval is representable, of course.
d6016fa58df6 Issue #8748: Fix two issues with comparisons between complex and integer Mark Dickinson <dickinsm@gmail.com> parents: 60174 diff changeset	148 for i in range(1, 10):
d6016fa58df6 Issue #8748: Fix two issues with comparisons between complex and integer Mark Dickinson <dickinsm@gmail.com> parents: 60174 diff changeset	149 pow = 52 + i
d6016fa58df6 Issue #8748: Fix two issues with comparisons between complex and integer Mark Dickinson <dickinsm@gmail.com> parents: 60174 diff changeset	150 mult = 2 ** i
d6016fa58df6 Issue #8748: Fix two issues with comparisons between complex and integer Mark Dickinson <dickinsm@gmail.com> parents: 60174 diff changeset	151 check(2 ** pow, range(1, 101), lambda delta: delta % mult == 0)
d6016fa58df6 Issue #8748: Fix two issues with comparisons between complex and integer Mark Dickinson <dickinsm@gmail.com> parents: 60174 diff changeset	152 check(2 ** pow, range(1, 101), lambda delta: False, float(i))
d6016fa58df6 Issue #8748: Fix two issues with comparisons between complex and integer Mark Dickinson <dickinsm@gmail.com> parents: 60174 diff changeset	153 check(2 ** 53, range(-100, 0), lambda delta: True)
d6016fa58df6 Issue #8748: Fix two issues with comparisons between complex and integer Mark Dickinson <dickinsm@gmail.com> parents: 60174 diff changeset	154
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	155 def test_mod(self):
42435 f6cc76e4ca25 Make test_complex pass again now that floordiv and mod are illegal. Guido van Rossum <guido@python.org> parents: 41904 diff changeset	156 # % is no longer supported on complex numbers
f6cc76e4ca25 Make test_complex pass again now that floordiv and mod are illegal. Guido van Rossum <guido@python.org> parents: 41904 diff changeset	157 self.assertRaises(TypeError, (1+1j).__mod__, 0+0j)
f6cc76e4ca25 Make test_complex pass again now that floordiv and mod are illegal. Guido van Rossum <guido@python.org> parents: 41904 diff changeset	158 self.assertRaises(TypeError, lambda: (3.33+4.43j) % 0)
43284 1f9eee08ab35 Check in some documentation tweaks for PEP 3141, add some tests, and implement Jeffrey Yasskin <jyasskin@gmail.com> parents: 42911 diff changeset	159 self.assertRaises(TypeError, (1+1j).__mod__, 4.3j)
29867 199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	160
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	161 def test_divmod(self):
42435 f6cc76e4ca25 Make test_complex pass again now that floordiv and mod are illegal. Guido van Rossum <guido@python.org> parents: 41904 diff changeset	162 self.assertRaises(TypeError, divmod, 1+1j, 1+0j)
f6cc76e4ca25 Make test_complex pass again now that floordiv and mod are illegal. Guido van Rossum <guido@python.org> parents: 41904 diff changeset	163 self.assertRaises(TypeError, divmod, 1+1j, 0+0j)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	164
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	165 def test_pow(self):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	166 self.assertAlmostEqual(pow(1+1j, 0+0j), 1.0)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	167 self.assertAlmostEqual(pow(0+0j, 2+0j), 0.0)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	168 self.assertRaises(ZeroDivisionError, pow, 0+0j, 1j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	169 self.assertAlmostEqual(pow(1j, -1), 1/1j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	170 self.assertAlmostEqual(pow(1j, 200), 1)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	171 self.assertRaises(ValueError, pow, 1+1j, 1+1j, 1+1j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	172
29867 199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	173 a = 3.33+4.43j
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	174 self.assertEqual(a ** 0j, 1)
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	175 self.assertEqual(a ** 0.+0.j, 1)
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	176
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	177 self.assertEqual(3j ** 0j, 1)
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	178 self.assertEqual(3j ** 0, 1)
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	179
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	180 try:
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	181 0j ** a
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	182 except ZeroDivisionError:
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	183 pass
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	184 else:
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	185 self.fail("should fail 0.0 to negative or complex power")
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	186
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	187 try:
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	188 0j ** (3-2j)
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	189 except ZeroDivisionError:
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	190 pass
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	191 else:
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	192 self.fail("should fail 0.0 to negative or complex power")
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	193
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	194 # The following is used to exercise certain code paths
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	195 self.assertEqual(a 105, a 105)
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	196 self.assertEqual(a -105, a -105)
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	197 self.assertEqual(a -30, a -30)
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	198
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	199 self.assertEqual(0.0j ** 0, 1)
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	200
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	201 b = 5.1+2.3j
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	202 self.assertRaises(ValueError, pow, a, b, 0)
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	203
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	204 def test_boolcontext(self):
41642 a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from Guido van Rossum <guido@python.org> parents: 41575 diff changeset	205 for i in range(100):
55593 0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 54225 diff changeset	206 self.assertTrue(complex(random() + 1e-6, random() + 1e-6))
0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 54225 diff changeset	207 self.assertTrue(not complex(0.0, 0.0))
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	208
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	209 def test_conjugate(self):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	210 self.assertClose(complex(5.3, 9.8).conjugate(), 5.3-9.8j)
17066 2c1be7924b04 SF bug [ #409448 ] Complex division is braindead Tim Peters <tim.peters@gmail.com> parents: diff changeset	211
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	212 def test_constructor(self):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	213 class OS:
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	214 def __init__(self, value): self.value = value
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	215 def __complex__(self): return self.value
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	216 class NS(object):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	217 def __init__(self, value): self.value = value
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	218 def __complex__(self): return self.value
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	219 self.assertEqual(complex(OS(1+10j)), 1+10j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	220 self.assertEqual(complex(NS(1+10j)), 1+10j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	221 self.assertRaises(TypeError, complex, OS(None))
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	222 self.assertRaises(TypeError, complex, NS(None))
17066 2c1be7924b04 SF bug [ #409448 ] Complex division is braindead Tim Peters <tim.peters@gmail.com> parents: diff changeset	223
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	224 self.assertAlmostEqual(complex("1+10j"), 1+10j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	225 self.assertAlmostEqual(complex(10), 10+0j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	226 self.assertAlmostEqual(complex(10.0), 10+0j)
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 39603 diff changeset	227 self.assertAlmostEqual(complex(10), 10+0j)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	228 self.assertAlmostEqual(complex(10+0j), 10+0j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	229 self.assertAlmostEqual(complex(1,10), 1+10j)
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 39603 diff changeset	230 self.assertAlmostEqual(complex(1,10), 1+10j)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	231 self.assertAlmostEqual(complex(1,10.0), 1+10j)
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 39603 diff changeset	232 self.assertAlmostEqual(complex(1,10), 1+10j)
1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 39603 diff changeset	233 self.assertAlmostEqual(complex(1,10), 1+10j)
1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 39603 diff changeset	234 self.assertAlmostEqual(complex(1,10.0), 1+10j)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	235 self.assertAlmostEqual(complex(1.0,10), 1+10j)
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 39603 diff changeset	236 self.assertAlmostEqual(complex(1.0,10), 1+10j)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	237 self.assertAlmostEqual(complex(1.0,10.0), 1+10j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	238 self.assertAlmostEqual(complex(3.14+0j), 3.14+0j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	239 self.assertAlmostEqual(complex(3.14), 3.14+0j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	240 self.assertAlmostEqual(complex(314), 314.0+0j)
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 39603 diff changeset	241 self.assertAlmostEqual(complex(314), 314.0+0j)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	242 self.assertAlmostEqual(complex(3.14+0j, 0j), 3.14+0j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	243 self.assertAlmostEqual(complex(3.14, 0.0), 3.14+0j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	244 self.assertAlmostEqual(complex(314, 0), 314.0+0j)
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 39603 diff changeset	245 self.assertAlmostEqual(complex(314, 0), 314.0+0j)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	246 self.assertAlmostEqual(complex(0j, 3.14j), -3.14+0j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	247 self.assertAlmostEqual(complex(0.0, 3.14j), -3.14+0j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	248 self.assertAlmostEqual(complex(0j, 3.14), 3.14j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	249 self.assertAlmostEqual(complex(0.0, 3.14), 3.14j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	250 self.assertAlmostEqual(complex("1"), 1+0j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	251 self.assertAlmostEqual(complex("1j"), 1j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	252 self.assertAlmostEqual(complex(), 0)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	253 self.assertAlmostEqual(complex("-1"), -1)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	254 self.assertAlmostEqual(complex("+1"), +1)
41554 06145fbc7ab9 Merged revisions 53952-54987 via svnmerge from Guido van Rossum <guido@python.org> parents: 40775 diff changeset	255 self.assertAlmostEqual(complex("(1+2j)"), 1+2j)
06145fbc7ab9 Merged revisions 53952-54987 via svnmerge from Guido van Rossum <guido@python.org> parents: 40775 diff changeset	256 self.assertAlmostEqual(complex("(1.3+2.2j)"), 1.3+2.2j)
53332 330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	257 self.assertAlmostEqual(complex("3.14+1J"), 3.14+1j)
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	258 self.assertAlmostEqual(complex(" ( +3.14-6J )"), 3.14-6j)
53343 06db1d9d255f Make sure that complex parsing code and corresponding tests Mark Dickinson <dickinsm@gmail.com> parents: 53332 diff changeset	259 self.assertAlmostEqual(complex(" ( +3.14-J )"), 3.14-1j)
06db1d9d255f Make sure that complex parsing code and corresponding tests Mark Dickinson <dickinsm@gmail.com> parents: 53332 diff changeset	260 self.assertAlmostEqual(complex(" ( +3.14+j )"), 3.14+1j)
06db1d9d255f Make sure that complex parsing code and corresponding tests Mark Dickinson <dickinsm@gmail.com> parents: 53332 diff changeset	261 self.assertAlmostEqual(complex("J"), 1j)
06db1d9d255f Make sure that complex parsing code and corresponding tests Mark Dickinson <dickinsm@gmail.com> parents: 53332 diff changeset	262 self.assertAlmostEqual(complex("( j )"), 1j)
06db1d9d255f Make sure that complex parsing code and corresponding tests Mark Dickinson <dickinsm@gmail.com> parents: 53332 diff changeset	263 self.assertAlmostEqual(complex("+J"), 1j)
06db1d9d255f Make sure that complex parsing code and corresponding tests Mark Dickinson <dickinsm@gmail.com> parents: 53332 diff changeset	264 self.assertAlmostEqual(complex("( -j)"), -1j)
06db1d9d255f Make sure that complex parsing code and corresponding tests Mark Dickinson <dickinsm@gmail.com> parents: 53332 diff changeset	265 self.assertAlmostEqual(complex('1e-500'), 0.0 + 0.0j)
06db1d9d255f Make sure that complex parsing code and corresponding tests Mark Dickinson <dickinsm@gmail.com> parents: 53332 diff changeset	266 self.assertAlmostEqual(complex('-1e-500j'), 0.0 - 0.0j)
06db1d9d255f Make sure that complex parsing code and corresponding tests Mark Dickinson <dickinsm@gmail.com> parents: 53332 diff changeset	267 self.assertAlmostEqual(complex('-1e-500+1e-500j'), -0.0 + 0.0j)
17066 2c1be7924b04 SF bug [ #409448 ] Complex division is braindead Tim Peters <tim.peters@gmail.com> parents: diff changeset	268
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	269 class complex2(complex): pass
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	270 self.assertAlmostEqual(complex(complex2(1+1j)), 1+1j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	271 self.assertAlmostEqual(complex(real=17, imag=23), 17+23j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	272 self.assertAlmostEqual(complex(real=17+23j), 17+23j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	273 self.assertAlmostEqual(complex(real=17+23j, imag=23), 17+46j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	274 self.assertAlmostEqual(complex(real=1+2j, imag=3+4j), -3+5j)
21593 ff70e5634ae9 SF Patch #494873 add tests for complex numbers including calls to int()/long() Neal Norwitz <nnorwitz@gmail.com> parents: 21401 diff changeset	275
44045 530fb9852c50 Merged revisions 59202-59211 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 43284 diff changeset	276 # check that the sign of a zero in the real or imaginary part
530fb9852c50 Merged revisions 59202-59211 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 43284 diff changeset	277 # is preserved when constructing from two floats. (These checks
530fb9852c50 Merged revisions 59202-59211 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 43284 diff changeset	278 # are harmless on systems without support for signed zeros.)
530fb9852c50 Merged revisions 59202-59211 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 43284 diff changeset	279 def split_zeros(x):
530fb9852c50 Merged revisions 59202-59211 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 43284 diff changeset	280 """Function that produces different results for 0. and -0."""
530fb9852c50 Merged revisions 59202-59211 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 43284 diff changeset	281 return atan2(x, -1.)
530fb9852c50 Merged revisions 59202-59211 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 43284 diff changeset	282
530fb9852c50 Merged revisions 59202-59211 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 43284 diff changeset	283 self.assertEqual(split_zeros(complex(1., 0.).imag), split_zeros(0.))
530fb9852c50 Merged revisions 59202-59211 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 43284 diff changeset	284 self.assertEqual(split_zeros(complex(1., -0.).imag), split_zeros(-0.))
530fb9852c50 Merged revisions 59202-59211 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 43284 diff changeset	285 self.assertEqual(split_zeros(complex(0., 1.).real), split_zeros(0.))
530fb9852c50 Merged revisions 59202-59211 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 43284 diff changeset	286 self.assertEqual(split_zeros(complex(-0., 1.).real), split_zeros(-0.))
530fb9852c50 Merged revisions 59202-59211 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 43284 diff changeset	287
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	288 c = 3.14 + 1j
55593 0bb232078b8c Merged revisions 73715 via svnmerge from Georg Brandl <georg@python.org> parents: 54225 diff changeset	289 self.assertTrue(complex(c) is c)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	290 del c
21593 ff70e5634ae9 SF Patch #494873 add tests for complex numbers including calls to int()/long() Neal Norwitz <nnorwitz@gmail.com> parents: 21401 diff changeset	291
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	292 self.assertRaises(TypeError, complex, "1", "1")
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	293 self.assertRaises(TypeError, complex, 1, "1")
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	294
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	295 # SF bug 543840: complex(string) accepts strings with \0
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	296 # Fixed in 2.3.
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	297 self.assertRaises(ValueError, complex, '1+1j\0j')
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	298
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	299 self.assertRaises(TypeError, int, 5+3j)
40644 1c26505c1de6 Rip out 'long' and 'L'-suffixed integer literals. Guido van Rossum <guido@python.org> parents: 39603 diff changeset	300 self.assertRaises(TypeError, int, 5+3j)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	301 self.assertRaises(TypeError, float, 5+3j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	302 self.assertRaises(ValueError, complex, "")
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	303 self.assertRaises(TypeError, complex, None)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	304 self.assertRaises(ValueError, complex, "\0")
41554 06145fbc7ab9 Merged revisions 53952-54987 via svnmerge from Guido van Rossum <guido@python.org> parents: 40775 diff changeset	305 self.assertRaises(ValueError, complex, "3\09")
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	306 self.assertRaises(TypeError, complex, "1", "2")
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	307 self.assertRaises(TypeError, complex, "1", 42)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	308 self.assertRaises(TypeError, complex, 1, "2")
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	309 self.assertRaises(ValueError, complex, "1+")
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	310 self.assertRaises(ValueError, complex, "1+1j+1j")
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	311 self.assertRaises(ValueError, complex, "--")
41554 06145fbc7ab9 Merged revisions 53952-54987 via svnmerge from Guido van Rossum <guido@python.org> parents: 40775 diff changeset	312 self.assertRaises(ValueError, complex, "(1+2j")
06145fbc7ab9 Merged revisions 53952-54987 via svnmerge from Guido van Rossum <guido@python.org> parents: 40775 diff changeset	313 self.assertRaises(ValueError, complex, "1+2j)")
06145fbc7ab9 Merged revisions 53952-54987 via svnmerge from Guido van Rossum <guido@python.org> parents: 40775 diff changeset	314 self.assertRaises(ValueError, complex, "1+(2j)")
06145fbc7ab9 Merged revisions 53952-54987 via svnmerge from Guido van Rossum <guido@python.org> parents: 40775 diff changeset	315 self.assertRaises(ValueError, complex, "(1+2j)123")
41821 ae691227fd34 Remove have_unicode checks and merge those tests into the Walter Dörwald <walter@livinglogic.de> parents: 41642 diff changeset	316 self.assertRaises(ValueError, complex, "x")
53332 330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	317 self.assertRaises(ValueError, complex, "1j+2")
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	318 self.assertRaises(ValueError, complex, "1e1ej")
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	319 self.assertRaises(ValueError, complex, "1e++1ej")
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	320 self.assertRaises(ValueError, complex, ")1+2j(")
53343 06db1d9d255f Make sure that complex parsing code and corresponding tests Mark Dickinson <dickinsm@gmail.com> parents: 53332 diff changeset	321 # the following three are accepted by Python 2.6
06db1d9d255f Make sure that complex parsing code and corresponding tests Mark Dickinson <dickinsm@gmail.com> parents: 53332 diff changeset	322 self.assertRaises(ValueError, complex, "1..1j")
06db1d9d255f Make sure that complex parsing code and corresponding tests Mark Dickinson <dickinsm@gmail.com> parents: 53332 diff changeset	323 self.assertRaises(ValueError, complex, "1.11.1j")
06db1d9d255f Make sure that complex parsing code and corresponding tests Mark Dickinson <dickinsm@gmail.com> parents: 53332 diff changeset	324 self.assertRaises(ValueError, complex, "1e1.1j")
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	325
56769 4cbea9e78356 Remove length limitation on string arguments to complex() Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	326 # check that complex accepts long unicode strings
4cbea9e78356 Remove length limitation on string arguments to complex() Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	327 self.assertEqual(type(complex("1"*500)), complex)
4cbea9e78356 Remove length limitation on string arguments to complex() Mark Dickinson <dickinsm@gmail.com> parents: 55593 diff changeset	328
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	329 class EvilExc(Exception):
29668 36a17904a3ed Whitespace normalization. Tim Peters <tim.peters@gmail.com> parents: 29532 diff changeset	330 pass
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	331
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	332 class evilcomplex:
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	333 def __complex__(self):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	334 raise EvilExc
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	335
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	336 self.assertRaises(EvilExc, complex, evilcomplex())
21593 ff70e5634ae9 SF Patch #494873 add tests for complex numbers including calls to int()/long() Neal Norwitz <nnorwitz@gmail.com> parents: 21401 diff changeset	337
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	338 class float2:
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	339 def __init__(self, value):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	340 self.value = value
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	341 def __float__(self):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	342 return self.value
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	343
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	344 self.assertAlmostEqual(complex(float2(42.)), 42)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	345 self.assertAlmostEqual(complex(real=float2(17.), imag=float2(23.)), 17+23j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	346 self.assertRaises(TypeError, complex, float2(None))
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	347
34931 9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	348 class complex0(complex):
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	349 """Test usage of __complex__() when inheriting from 'complex'"""
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	350 def __complex__(self):
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	351 return 42j
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	352
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	353 class complex1(complex):
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	354 """Test usage of __complex__() with a __new__() method"""
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	355 def __new__(self, value=0j):
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	356 return complex.__new__(self, 2*value)
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	357 def __complex__(self):
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	358 return self
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	359
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	360 class complex2(complex):
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	361 """Make sure that __complex__() calls fail if anything other than a
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	362 complex is returned"""
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	363 def __complex__(self):
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	364 return None
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	365
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	366 self.assertAlmostEqual(complex(complex0(1j)), 42j)
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	367 self.assertAlmostEqual(complex(complex1(1j)), 2j)
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	368 self.assertRaises(TypeError, complex, complex2(1j))
9a1b1e1ae653 Make subclasses of int, long, complex, float, and unicode perform type Brett Cannon <bcannon@gmail.com> parents: 33233 diff changeset	369
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	370 def test_hash(self):
41642 a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from Guido van Rossum <guido@python.org> parents: 41575 diff changeset	371 for x in range(-30, 30):
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	372 self.assertEqual(hash(x), hash(complex(x, 0)))
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	373 x /= 3.0 # now check against floating point
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	374 self.assertEqual(hash(x), hash(complex(x, 0.)))
21593 ff70e5634ae9 SF Patch #494873 add tests for complex numbers including calls to int()/long() Neal Norwitz <nnorwitz@gmail.com> parents: 21401 diff changeset	375
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	376 def test_abs(self):
41642 a6eb6acfe04a Merged revisions 55007-55179 via svnmerge from Guido van Rossum <guido@python.org> parents: 41575 diff changeset	377 nums = [complex(x/3., y/7.) for x in range(-9,9) for y in range(-9,9)]
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	378 for num in nums:
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	379 self.assertAlmostEqual((num.real2 + num.imag2) ** 0.5, abs(num))
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	380
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	381 def test_repr(self):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	382 self.assertEqual(repr(1+6j), '(1+6j)')
33233 77d3642eb87b Fix repr for negative imaginary part. Fixes #1013908. Martin v. Löwis <martin@v.loewis.de> parents: 30071 diff changeset	383 self.assertEqual(repr(1-6j), '(1-6j)')
17066 2c1be7924b04 SF bug [ #409448 ] Complex division is braindead Tim Peters <tim.peters@gmail.com> parents: diff changeset	384
35586 e6119d577cd3 Test case for latest complexobject fix. Georg Brandl <georg@python.org> parents: 34931 diff changeset	385 self.assertNotEqual(repr(-(1+0j)), '(-1+-0j)')
e6119d577cd3 Test case for latest complexobject fix. Georg Brandl <georg@python.org> parents: 34931 diff changeset	386
41554 06145fbc7ab9 Merged revisions 53952-54987 via svnmerge from Guido van Rossum <guido@python.org> parents: 40775 diff changeset	387 self.assertEqual(1-6j,complex(repr(1-6j)))
06145fbc7ab9 Merged revisions 53952-54987 via svnmerge from Guido van Rossum <guido@python.org> parents: 40775 diff changeset	388 self.assertEqual(1+6j,complex(repr(1+6j)))
06145fbc7ab9 Merged revisions 53952-54987 via svnmerge from Guido van Rossum <guido@python.org> parents: 40775 diff changeset	389 self.assertEqual(-6j,complex(repr(-6j)))
06145fbc7ab9 Merged revisions 53952-54987 via svnmerge from Guido van Rossum <guido@python.org> parents: 40775 diff changeset	390 self.assertEqual(6j,complex(repr(6j)))
06145fbc7ab9 Merged revisions 53952-54987 via svnmerge from Guido van Rossum <guido@python.org> parents: 40775 diff changeset	391
53332 330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	392 self.assertEqual(repr(complex(1., INF)), "(1+infj)")
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	393 self.assertEqual(repr(complex(1., -INF)), "(1-infj)")
45371 7c4c46342137 Merged revisions 60481,60485,60489-60492,60494-60496,60498-60499,60501-60503,60505-60506,60508-60509,60523-60524,60532,60543,60545,60547-60548,60552,60554,60556-60559,60561-60562,60569,60571-60572,60574,60576-60583,60585-60586,60589,60591,60594-60595,60597-60598,60600-60601,60606-60612,60615,60617,60619-60621,60623-60625,60627-60629,60631,60633,60635,60647,60650,60652,60654,60656,60658-60659,60664-60666,60668-60670,60672,60676,60678,60680-60683,60685-60686,60688,60690,60692-60694,60697-60700,60705-60706,60708,60711,60714,60720,60724-60730,60732,60736,60742,60744,60746,60748,60750-60751,60753,60756-60757,60759-60761,60763-60764,60766,60769-60770,60774-60784,60787-60845 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45082 diff changeset	394 self.assertEqual(repr(complex(INF, 1)), "(inf+1j)")
53332 330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	395 self.assertEqual(repr(complex(-INF, INF)), "(-inf+infj)")
45371 7c4c46342137 Merged revisions 60481,60485,60489-60492,60494-60496,60498-60499,60501-60503,60505-60506,60508-60509,60523-60524,60532,60543,60545,60547-60548,60552,60554,60556-60559,60561-60562,60569,60571-60572,60574,60576-60583,60585-60586,60589,60591,60594-60595,60597-60598,60600-60601,60606-60612,60615,60617,60619-60621,60623-60625,60627-60629,60631,60633,60635,60647,60650,60652,60654,60656,60658-60659,60664-60666,60668-60670,60672,60676,60678,60680-60683,60685-60686,60688,60690,60692-60694,60697-60700,60705-60706,60708,60711,60714,60720,60724-60730,60732,60736,60742,60744,60746,60748,60750-60751,60753,60756-60757,60759-60761,60763-60764,60766,60769-60770,60774-60784,60787-60845 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45082 diff changeset	396 self.assertEqual(repr(complex(NAN, 1)), "(nan+1j)")
53332 330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	397 self.assertEqual(repr(complex(1, NAN)), "(1+nanj)")
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	398 self.assertEqual(repr(complex(NAN, NAN)), "(nan+nanj)")
45371 7c4c46342137 Merged revisions 60481,60485,60489-60492,60494-60496,60498-60499,60501-60503,60505-60506,60508-60509,60523-60524,60532,60543,60545,60547-60548,60552,60554,60556-60559,60561-60562,60569,60571-60572,60574,60576-60583,60585-60586,60589,60591,60594-60595,60597-60598,60600-60601,60606-60612,60615,60617,60619-60621,60623-60625,60627-60629,60631,60633,60635,60647,60650,60652,60654,60656,60658-60659,60664-60666,60668-60670,60672,60676,60678,60680-60683,60685-60686,60688,60690,60692-60694,60697-60700,60705-60706,60708,60711,60714,60720,60724-60730,60732,60736,60742,60744,60746,60748,60750-60751,60753,60756-60757,60759-60761,60763-60764,60766,60769-60770,60774-60784,60787-60845 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45082 diff changeset	399
53332 330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	400 self.assertEqual(repr(complex(0, INF)), "infj")
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	401 self.assertEqual(repr(complex(0, -INF)), "-infj")
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	402 self.assertEqual(repr(complex(0, NAN)), "nanj")
45371 7c4c46342137 Merged revisions 60481,60485,60489-60492,60494-60496,60498-60499,60501-60503,60505-60506,60508-60509,60523-60524,60532,60543,60545,60547-60548,60552,60554,60556-60559,60561-60562,60569,60571-60572,60574,60576-60583,60585-60586,60589,60591,60594-60595,60597-60598,60600-60601,60606-60612,60615,60617,60619-60621,60623-60625,60627-60629,60631,60633,60635,60647,60650,60652,60654,60656,60658-60659,60664-60666,60668-60670,60672,60676,60678,60680-60683,60685-60686,60688,60690,60692-60694,60697-60700,60705-60706,60708,60711,60714,60720,60724-60730,60732,60736,60742,60744,60746,60748,60750-60751,60753,60756-60757,60759-60761,60763-60764,60766,60769-60770,60774-60784,60787-60845 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 45082 diff changeset	403
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	404 def test_neg(self):
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	405 self.assertEqual(-(1+6j), -1-6j)
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	406
29867 199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	407 def test_file(self):
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	408 a = 3.33+4.43j
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	409 b = 5.1+2.3j
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	410
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	411 fo = None
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	412 try:
47201 9c930a32cebb #2621 rename test.test_support to test.support Benjamin Peterson <benjamin@python.org> parents: 45371 diff changeset	413 fo = open(support.TESTFN, "w")
40775 4cdf21a0dbbc Fix most trivially-findable print statements. Guido van Rossum <guido@python.org> parents: 40644 diff changeset	414 print(a, b, file=fo)
29867 199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	415 fo.close()
47201 9c930a32cebb #2621 rename test.test_support to test.support Benjamin Peterson <benjamin@python.org> parents: 45371 diff changeset	416 fo = open(support.TESTFN, "r")
42911 cb28e14ee808 Changes in anticipation of stricter str vs. bytes enforcement. Guido van Rossum <guido@python.org> parents: 42902 diff changeset	417 self.assertEqual(fo.read(), ("%s %s\n" % (a, b)))
29867 199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	418 finally:
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	419 if (fo is not None) and (not fo.closed):
199cd78d6d78 Add various test cases from SF patch 543867. Walter Dörwald <walter@livinglogic.de> parents: 29668 diff changeset	420 fo.close()
60174 255a401c19b0 (partially) Florent Xicluna <florent.xicluna@gmail.com> parents: 59563 diff changeset	421 support.unlink(support.TESTFN)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	422
47555 7d824fd131ad Merged revisions 63829-63831,63858,63865,63879,63882,63948,63970-63972,63976,63989,64014-64015,64021-64022,64063-64065,64067 via svnmerge from Georg Brandl <georg@python.org> parents: 47201 diff changeset	423 def test_getnewargs(self):
7d824fd131ad Merged revisions 63829-63831,63858,63865,63879,63882,63948,63970-63972,63976,63989,64014-64015,64021-64022,64063-64065,64067 via svnmerge from Georg Brandl <georg@python.org> parents: 47201 diff changeset	424 self.assertEqual((1+2j).__getnewargs__(), (1.0, 2.0))
7d824fd131ad Merged revisions 63829-63831,63858,63865,63879,63882,63948,63970-63972,63976,63989,64014-64015,64021-64022,64063-64065,64067 via svnmerge from Georg Brandl <georg@python.org> parents: 47201 diff changeset	425 self.assertEqual((1-2j).__getnewargs__(), (1.0, -2.0))
7d824fd131ad Merged revisions 63829-63831,63858,63865,63879,63882,63948,63970-63972,63976,63989,64014-64015,64021-64022,64063-64065,64067 via svnmerge from Georg Brandl <georg@python.org> parents: 47201 diff changeset	426 self.assertEqual((2j).__getnewargs__(), (0.0, 2.0))
7d824fd131ad Merged revisions 63829-63831,63858,63865,63879,63882,63948,63970-63972,63976,63989,64014-64015,64021-64022,64063-64065,64067 via svnmerge from Georg Brandl <georg@python.org> parents: 47201 diff changeset	427 self.assertEqual((-0j).__getnewargs__(), (0.0, -0.0))
7d824fd131ad Merged revisions 63829-63831,63858,63865,63879,63882,63948,63970-63972,63976,63989,64014-64015,64021-64022,64063-64065,64067 via svnmerge from Georg Brandl <georg@python.org> parents: 47201 diff changeset	428 self.assertEqual(complex(0, INF).__getnewargs__(), (0.0, INF))
7d824fd131ad Merged revisions 63829-63831,63858,63865,63879,63882,63948,63970-63972,63976,63989,64014-64015,64021-64022,64063-64065,64067 via svnmerge from Georg Brandl <georg@python.org> parents: 47201 diff changeset	429 self.assertEqual(complex(INF, 0).__getnewargs__(), (INF, 0.0))
7d824fd131ad Merged revisions 63829-63831,63858,63865,63879,63882,63948,63970-63972,63976,63989,64014-64015,64021-64022,64063-64065,64067 via svnmerge from Georg Brandl <georg@python.org> parents: 47201 diff changeset	430
45082 d7540031b959 Merged revisions 60475-60479,60481-60488 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 44045 diff changeset	431 if float.__getformat__("double").startswith("IEEE"):
d7540031b959 Merged revisions 60475-60479,60481-60488 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 44045 diff changeset	432 def test_plus_minus_0j(self):
d7540031b959 Merged revisions 60475-60479,60481-60488 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 44045 diff changeset	433 # test that -0j and 0j literals are not identified
d7540031b959 Merged revisions 60475-60479,60481-60488 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 44045 diff changeset	434 z1, z2 = 0j, -0j
d7540031b959 Merged revisions 60475-60479,60481-60488 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 44045 diff changeset	435 self.assertEquals(atan2(z1.imag, -1.), atan2(0., -1.))
d7540031b959 Merged revisions 60475-60479,60481-60488 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 44045 diff changeset	436 self.assertEquals(atan2(z2.imag, -1.), atan2(-0., -1.))
d7540031b959 Merged revisions 60475-60479,60481-60488 via svnmerge from Christian Heimes <christian@cheimes.de> parents: 44045 diff changeset	437
53332 330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	438 @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"),
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	439 "test requires IEEE 754 doubles")
62649 2bc54da4b82c Issue #9011: Tests for Python 3.2's treatment of negated imaginary literals. Mark Dickinson <dickinsm@gmail.com> parents: 61787 diff changeset	440 def test_negated_imaginary_literal(self):
2bc54da4b82c Issue #9011: Tests for Python 3.2's treatment of negated imaginary literals. Mark Dickinson <dickinsm@gmail.com> parents: 61787 diff changeset	441 z0 = -0j
2bc54da4b82c Issue #9011: Tests for Python 3.2's treatment of negated imaginary literals. Mark Dickinson <dickinsm@gmail.com> parents: 61787 diff changeset	442 z1 = -7j
2bc54da4b82c Issue #9011: Tests for Python 3.2's treatment of negated imaginary literals. Mark Dickinson <dickinsm@gmail.com> parents: 61787 diff changeset	443 z2 = -1e1000j
2bc54da4b82c Issue #9011: Tests for Python 3.2's treatment of negated imaginary literals. Mark Dickinson <dickinsm@gmail.com> parents: 61787 diff changeset	444 # Note: In versions of Python < 3.2, a negated imaginary literal
2bc54da4b82c Issue #9011: Tests for Python 3.2's treatment of negated imaginary literals. Mark Dickinson <dickinsm@gmail.com> parents: 61787 diff changeset	445 # accidentally ended up with real part 0.0 instead of -0.0, thanks to a
2bc54da4b82c Issue #9011: Tests for Python 3.2's treatment of negated imaginary literals. Mark Dickinson <dickinsm@gmail.com> parents: 61787 diff changeset	446 # modification during CST -> AST translation (see issue #9011). That's
2bc54da4b82c Issue #9011: Tests for Python 3.2's treatment of negated imaginary literals. Mark Dickinson <dickinsm@gmail.com> parents: 61787 diff changeset	447 # fixed in Python 3.2.
2bc54da4b82c Issue #9011: Tests for Python 3.2's treatment of negated imaginary literals. Mark Dickinson <dickinsm@gmail.com> parents: 61787 diff changeset	448 self.assertFloatsAreIdentical(z0.real, -0.0)
2bc54da4b82c Issue #9011: Tests for Python 3.2's treatment of negated imaginary literals. Mark Dickinson <dickinsm@gmail.com> parents: 61787 diff changeset	449 self.assertFloatsAreIdentical(z0.imag, -0.0)
2bc54da4b82c Issue #9011: Tests for Python 3.2's treatment of negated imaginary literals. Mark Dickinson <dickinsm@gmail.com> parents: 61787 diff changeset	450 self.assertFloatsAreIdentical(z1.real, -0.0)
2bc54da4b82c Issue #9011: Tests for Python 3.2's treatment of negated imaginary literals. Mark Dickinson <dickinsm@gmail.com> parents: 61787 diff changeset	451 self.assertFloatsAreIdentical(z1.imag, -7.0)
2bc54da4b82c Issue #9011: Tests for Python 3.2's treatment of negated imaginary literals. Mark Dickinson <dickinsm@gmail.com> parents: 61787 diff changeset	452 self.assertFloatsAreIdentical(z2.real, -0.0)
2bc54da4b82c Issue #9011: Tests for Python 3.2's treatment of negated imaginary literals. Mark Dickinson <dickinsm@gmail.com> parents: 61787 diff changeset	453 self.assertFloatsAreIdentical(z2.imag, -INF)
2bc54da4b82c Issue #9011: Tests for Python 3.2's treatment of negated imaginary literals. Mark Dickinson <dickinsm@gmail.com> parents: 61787 diff changeset	454
2bc54da4b82c Issue #9011: Tests for Python 3.2's treatment of negated imaginary literals. Mark Dickinson <dickinsm@gmail.com> parents: 61787 diff changeset	455 @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"),
2bc54da4b82c Issue #9011: Tests for Python 3.2's treatment of negated imaginary literals. Mark Dickinson <dickinsm@gmail.com> parents: 61787 diff changeset	456 "test requires IEEE 754 doubles")
54225 670fa0c0ff9a Issue #5829: complex('1e500') shouldn't raise OverflowError Mark Dickinson <dickinsm@gmail.com> parents: 53849 diff changeset	457 def test_overflow(self):
670fa0c0ff9a Issue #5829: complex('1e500') shouldn't raise OverflowError Mark Dickinson <dickinsm@gmail.com> parents: 53849 diff changeset	458 self.assertEqual(complex("1e500"), complex(INF, 0.0))
670fa0c0ff9a Issue #5829: complex('1e500') shouldn't raise OverflowError Mark Dickinson <dickinsm@gmail.com> parents: 53849 diff changeset	459 self.assertEqual(complex("-1e500j"), complex(0.0, -INF))
670fa0c0ff9a Issue #5829: complex('1e500') shouldn't raise OverflowError Mark Dickinson <dickinsm@gmail.com> parents: 53849 diff changeset	460 self.assertEqual(complex("-1e500+1.8e308j"), complex(-INF, INF))
670fa0c0ff9a Issue #5829: complex('1e500') shouldn't raise OverflowError Mark Dickinson <dickinsm@gmail.com> parents: 53849 diff changeset	461
670fa0c0ff9a Issue #5829: complex('1e500') shouldn't raise OverflowError Mark Dickinson <dickinsm@gmail.com> parents: 53849 diff changeset	462 @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"),
670fa0c0ff9a Issue #5829: complex('1e500') shouldn't raise OverflowError Mark Dickinson <dickinsm@gmail.com> parents: 53849 diff changeset	463 "test requires IEEE 754 doubles")
53332 330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	464 def test_repr_roundtrip(self):
53377 a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	465 vals = [0.0, 1e-500, 1e-315, 1e-200, 0.0123, 3.1415, 1e50, INF, NAN]
53332 330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	466 vals += [-v for v in vals]
53377 a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	467
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	468 # complex(repr(z)) should recover z exactly, even for complex
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	469 # numbers involving an infinity, nan, or negative zero
53332 330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	470 for x in vals:
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	471 for y in vals:
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	472 z = complex(x, y)
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	473 roundtrip = complex(repr(z))
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	474 self.assertFloatsAreIdentical(z.real, roundtrip.real)
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	475 self.assertFloatsAreIdentical(z.imag, roundtrip.imag)
330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	476
53377 a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	477 # if we predefine some constants, then eval(repr(z)) should
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	478 # also work, except that it might change the sign of zeros
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	479 inf, nan = float('inf'), float('nan')
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	480 infj, nanj = complex(0.0, inf), complex(0.0, nan)
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	481 for x in vals:
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	482 for y in vals:
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	483 z = complex(x, y)
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	484 roundtrip = eval(repr(z))
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	485 # adding 0.0 has no effect beside changing -0.0 to 0.0
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	486 self.assertFloatsAreIdentical(0.0 + z.real,
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	487 0.0 + roundtrip.real)
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	488 self.assertFloatsAreIdentical(0.0 + z.imag,
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	489 0.0 + roundtrip.imag)
a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	490
53632 2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	491 def test_format(self):
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	492 # empty format string is same as str()
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	493 self.assertEqual(format(1+3j, ''), str(1+3j))
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	494 self.assertEqual(format(1.5+3.5j, ''), str(1.5+3.5j))
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	495 self.assertEqual(format(3j, ''), str(3j))
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	496 self.assertEqual(format(3.2j, ''), str(3.2j))
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	497 self.assertEqual(format(3+0j, ''), str(3+0j))
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	498 self.assertEqual(format(3.2+0j, ''), str(3.2+0j))
53377 a34d945c07ed Merged revisions 71869 via svnmerge from Mark Dickinson <dickinsm@gmail.com> parents: 53343 diff changeset	499
53787 c6376d3fa968 Issue #5920: Changed format.__float__ and complex.__float__ to use a precision of 12 when using the empty presentation type. This more closely matches str()'s behavior and reduces surprises when adding alignment flags to an empty format string. Patch by Mark Dickinson. Eric Smith <eric@trueblade.com> parents: 53632 diff changeset	500 # empty presentation type should still be analogous to str,
c6376d3fa968 Issue #5920: Changed format.__float__ and complex.__float__ to use a precision of 12 when using the empty presentation type. This more closely matches str()'s behavior and reduces surprises when adding alignment flags to an empty format string. Patch by Mark Dickinson. Eric Smith <eric@trueblade.com> parents: 53632 diff changeset	501 # even when format string is nonempty (issue #5920).
c6376d3fa968 Issue #5920: Changed format.__float__ and complex.__float__ to use a precision of 12 when using the empty presentation type. This more closely matches str()'s behavior and reduces surprises when adding alignment flags to an empty format string. Patch by Mark Dickinson. Eric Smith <eric@trueblade.com> parents: 53632 diff changeset	502 self.assertEqual(format(3.2+0j, '-'), str(3.2+0j))
c6376d3fa968 Issue #5920: Changed format.__float__ and complex.__float__ to use a precision of 12 when using the empty presentation type. This more closely matches str()'s behavior and reduces surprises when adding alignment flags to an empty format string. Patch by Mark Dickinson. Eric Smith <eric@trueblade.com> parents: 53632 diff changeset	503 self.assertEqual(format(3.2+0j, '<'), str(3.2+0j))
c6376d3fa968 Issue #5920: Changed format.__float__ and complex.__float__ to use a precision of 12 when using the empty presentation type. This more closely matches str()'s behavior and reduces surprises when adding alignment flags to an empty format string. Patch by Mark Dickinson. Eric Smith <eric@trueblade.com> parents: 53632 diff changeset	504 z = 4/7. - 100j/7.
c6376d3fa968 Issue #5920: Changed format.__float__ and complex.__float__ to use a precision of 12 when using the empty presentation type. This more closely matches str()'s behavior and reduces surprises when adding alignment flags to an empty format string. Patch by Mark Dickinson. Eric Smith <eric@trueblade.com> parents: 53632 diff changeset	505 self.assertEqual(format(z, ''), str(z))
c6376d3fa968 Issue #5920: Changed format.__float__ and complex.__float__ to use a precision of 12 when using the empty presentation type. This more closely matches str()'s behavior and reduces surprises when adding alignment flags to an empty format string. Patch by Mark Dickinson. Eric Smith <eric@trueblade.com> parents: 53632 diff changeset	506 self.assertEqual(format(z, '-'), str(z))
c6376d3fa968 Issue #5920: Changed format.__float__ and complex.__float__ to use a precision of 12 when using the empty presentation type. This more closely matches str()'s behavior and reduces surprises when adding alignment flags to an empty format string. Patch by Mark Dickinson. Eric Smith <eric@trueblade.com> parents: 53632 diff changeset	507 self.assertEqual(format(z, '<'), str(z))
c6376d3fa968 Issue #5920: Changed format.__float__ and complex.__float__ to use a precision of 12 when using the empty presentation type. This more closely matches str()'s behavior and reduces surprises when adding alignment flags to an empty format string. Patch by Mark Dickinson. Eric Smith <eric@trueblade.com> parents: 53632 diff changeset	508 self.assertEqual(format(z, '10'), str(z))
c6376d3fa968 Issue #5920: Changed format.__float__ and complex.__float__ to use a precision of 12 when using the empty presentation type. This more closely matches str()'s behavior and reduces surprises when adding alignment flags to an empty format string. Patch by Mark Dickinson. Eric Smith <eric@trueblade.com> parents: 53632 diff changeset	509
53632 2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	510 self.assertEqual(format(1+3j, 'g'), '1+3j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	511 self.assertEqual(format(3j, 'g'), '0+3j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	512 self.assertEqual(format(1.5+3.5j, 'g'), '1.5+3.5j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	513
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	514 self.assertEqual(format(1.5+3.5j, '+g'), '+1.5+3.5j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	515 self.assertEqual(format(1.5-3.5j, '+g'), '+1.5-3.5j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	516 self.assertEqual(format(1.5-3.5j, '-g'), '1.5-3.5j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	517 self.assertEqual(format(1.5+3.5j, ' g'), ' 1.5+3.5j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	518 self.assertEqual(format(1.5-3.5j, ' g'), ' 1.5-3.5j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	519 self.assertEqual(format(-1.5+3.5j, ' g'), '-1.5+3.5j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	520 self.assertEqual(format(-1.5-3.5j, ' g'), '-1.5-3.5j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	521
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	522 self.assertEqual(format(-1.5-3.5e-20j, 'g'), '-1.5-3.5e-20j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	523 self.assertEqual(format(-1.5-3.5j, 'f'), '-1.500000-3.500000j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	524 self.assertEqual(format(-1.5-3.5j, 'F'), '-1.500000-3.500000j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	525 self.assertEqual(format(-1.5-3.5j, 'e'), '-1.500000e+00-3.500000e+00j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	526 self.assertEqual(format(-1.5-3.5j, '.2e'), '-1.50e+00-3.50e+00j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	527 self.assertEqual(format(-1.5-3.5j, '.2E'), '-1.50E+00-3.50E+00j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	528 self.assertEqual(format(-1.5e10-3.5e5j, '.2G'), '-1.5E+10-3.5E+05j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	529
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	530 self.assertEqual(format(1.5+3j, '<20g'), '1.5+3j ')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	531 self.assertEqual(format(1.5+3j, '<20g'), '1.5+3j*************')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	532 self.assertEqual(format(1.5+3j, '>20g'), ' 1.5+3j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	533 self.assertEqual(format(1.5+3j, '^20g'), ' 1.5+3j ')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	534 self.assertEqual(format(1.5+3j, '<20'), '(1.5+3j) ')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	535 self.assertEqual(format(1.5+3j, '>20'), ' (1.5+3j)')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	536 self.assertEqual(format(1.5+3j, '^20'), ' (1.5+3j) ')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	537 self.assertEqual(format(1.123-3.123j, '^20.2'), ' (1.1-3.1j) ')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	538
59027 5c4466b16d6d Merged revisions 78329 via svnmerge from Eric Smith <eric@trueblade.com> parents: 58966 diff changeset	539 self.assertEqual(format(1.5+3j, '20.2f'), ' 1.50+3.00j')
5c4466b16d6d Merged revisions 78329 via svnmerge from Eric Smith <eric@trueblade.com> parents: 58966 diff changeset	540 self.assertEqual(format(1.5+3j, '>20.2f'), ' 1.50+3.00j')
53632 2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	541 self.assertEqual(format(1.5+3j, '<20.2f'), '1.50+3.00j ')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	542 self.assertEqual(format(1.5e20+3j, '<20.2f'), '150000000000000000000.00+3.00j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	543 self.assertEqual(format(1.5e20+3j, '>40.2f'), ' 150000000000000000000.00+3.00j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	544 self.assertEqual(format(1.5e20+3j, '^40,.2f'), ' 150,000,000,000,000,000,000.00+3.00j ')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	545 self.assertEqual(format(1.5e21+3j, '^40,.2f'), ' 1,500,000,000,000,000,000,000.00+3.00j ')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	546 self.assertEqual(format(1.5e21+3000j, ',.2f'), '1,500,000,000,000,000,000,000.00+3,000.00j')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	547
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	548 # alternate is invalid
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	549 self.assertRaises(ValueError, (1.5+0.5j).__format__, '#f')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	550
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	551 # zero padding is invalid
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	552 self.assertRaises(ValueError, (1.5+0.5j).__format__, '010f')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	553
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	554 # '=' alignment is invalid
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	555 self.assertRaises(ValueError, (1.5+3j).__format__, '=20')
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	556
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	557 # integer presentation types are an error
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	558 for t in 'bcdoxX':
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	559 self.assertRaises(ValueError, (1.5+0.5j).__format__, t)
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	560
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	561 # make sure everything works in ''.format()
2cde0d003ffc Issue #1588: Add complex.__format__. Eric Smith <eric@trueblade.com> parents: 53377 diff changeset	562 self.assertEqual('{0:.3f}'.format(3.14159+2.71828j), '3.142+2.718j')
53332 330115137414 Issue #5816: Simplify code for parsing and printing of complex numbers. Mark Dickinson <dickinsm@gmail.com> parents: 47555 diff changeset	563
53849 04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	564 # issue 3382
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	565 self.assertEqual(format(complex(NAN, NAN), 'f'), 'nan+nanj')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	566 self.assertEqual(format(complex(1, NAN), 'f'), '1.000000+nanj')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	567 self.assertEqual(format(complex(NAN, 1), 'f'), 'nan+1.000000j')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	568 self.assertEqual(format(complex(NAN, -1), 'f'), 'nan-1.000000j')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	569 self.assertEqual(format(complex(NAN, NAN), 'F'), 'NAN+NANj')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	570 self.assertEqual(format(complex(1, NAN), 'F'), '1.000000+NANj')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	571 self.assertEqual(format(complex(NAN, 1), 'F'), 'NAN+1.000000j')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	572 self.assertEqual(format(complex(NAN, -1), 'F'), 'NAN-1.000000j')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	573 self.assertEqual(format(complex(INF, INF), 'f'), 'inf+infj')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	574 self.assertEqual(format(complex(1, INF), 'f'), '1.000000+infj')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	575 self.assertEqual(format(complex(INF, 1), 'f'), 'inf+1.000000j')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	576 self.assertEqual(format(complex(INF, -1), 'f'), 'inf-1.000000j')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	577 self.assertEqual(format(complex(INF, INF), 'F'), 'INF+INFj')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	578 self.assertEqual(format(complex(1, INF), 'F'), '1.000000+INFj')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	579 self.assertEqual(format(complex(INF, 1), 'F'), 'INF+1.000000j')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	580 self.assertEqual(format(complex(INF, -1), 'F'), 'INF-1.000000j')
04bdc944718a Issue #3382. float 'F' formatting no longer maps to 'f'. This only affects nan and inf. Eric Smith <eric@trueblade.com> parents: 53787 diff changeset	581
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	582 def test_main():
47201 9c930a32cebb #2621 rename test.test_support to test.support Benjamin Peterson <benjamin@python.org> parents: 45371 diff changeset	583 support.run_unittest(ComplexTest)
29532 2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	584
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	585 if __name__ == "__main__":
2fbd256a1db2 Port test_complex.py to unittest. Walter Dörwald <walter@livinglogic.de> parents: 24442 diff changeset	586 test_main()

Mercurial > cpython-lru_cache-weakref

annotate Lib/test/test_complex.py @ 62799:dcc2e8bf64cf