Ignore:
Timestamp:
Mar 19, 2014, 11:31:01 PM (11 years ago)
Author:
dmik
Message:

python: Merge vendor 2.7.6 to trunk.

Location:
python/trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • python/trunk

  • python/trunk/Lib/test/test_fractions.py

    r2 r391  
    44from test.test_support import run_unittest
    55import math
     6import numbers
    67import operator
    78import fractions
     9import sys
    810import unittest
    911from copy import copy, deepcopy
    … …  
    1214gcd = fractions.gcd
    1315
     16# decorator for skipping tests on non-IEEE 754 platforms
     17requires_IEEE_754 = unittest.skipUnless(
     18    float.__getformat__("double").startswith("IEEE"),
     19    "test requires IEEE 754 doubles")
     20
     21class DummyFloat(object):
     22    """Dummy float class for testing comparisons with Fractions"""
     23
     24    def __init__(self, value):
     25        if not isinstance(value, float):
     26            raise TypeError("DummyFloat can only be initialized from float")
     27        self.value = value
     28
     29    def _richcmp(self, other, op):
     30        if isinstance(other, numbers.Rational):
     31            return op(F.from_float(self.value), other)
     32        elif isinstance(other, DummyFloat):
     33            return op(self.value, other.value)
     34        else:
     35            return NotImplemented
     36
     37    def __eq__(self, other): return self._richcmp(other, operator.eq)
     38    def __le__(self, other): return self._richcmp(other, operator.le)
     39    def __lt__(self, other): return self._richcmp(other, operator.lt)
     40    def __ge__(self, other): return self._richcmp(other, operator.ge)
     41    def __gt__(self, other): return self._richcmp(other, operator.gt)
     42
     43    # shouldn't be calling __float__ at all when doing comparisons
     44    def __float__(self):
     45        assert False, "__float__ should not be invoked for comparisons"
     46
     47    # same goes for subtraction
     48    def __sub__(self, other):
     49        assert False, "__sub__ should not be invoked for comparisons"
     50    __rsub__ = __sub__
     51
     52    # Silence Py3k warning
     53    __hash__ = None
     54
     55
     56class DummyRational(object):
     57    """Test comparison of Fraction with a naive rational implementation."""
     58
     59    def __init__(self, num, den):
     60        g = gcd(num, den)
     61        self.num = num // g
     62        self.den = den // g
     63
     64    def __eq__(self, other):
     65        if isinstance(other, fractions.Fraction):
     66            return (self.num == other._numerator and
     67                    self.den == other._denominator)
     68        else:
     69            return NotImplemented
     70
     71    def __lt__(self, other):
     72        return(self.num * other._denominator < self.den * other._numerator)
     73
     74    def __gt__(self, other):
     75        return(self.num * other._denominator > self.den * other._numerator)
     76
     77    def __le__(self, other):
     78        return(self.num * other._denominator <= self.den * other._numerator)
     79
     80    def __ge__(self, other):
     81        return(self.num * other._denominator >= self.den * other._numerator)
     82
     83    # this class is for testing comparisons; conversion to float
     84    # should never be used for a comparison, since it loses accuracy
     85    def __float__(self):
     86        assert False, "__float__ should not be invoked"
     87
     88    # Silence Py3k warning
     89    __hash__ = None
     90
     91
     92class DummyFraction(fractions.Fraction):
     93    """Dummy Fraction subclass for copy and deepcopy testing."""
    1494
    1595class GcdTest(unittest.TestCase):
    1696
    1797    def testMisc(self):
    18         self.assertEquals(0, gcd(0, 0))
    19         self.assertEquals(1, gcd(1, 0))
    20         self.assertEquals(-1, gcd(-1, 0))
    21         self.assertEquals(1, gcd(0, 1))
    22         self.assertEquals(-1, gcd(0, -1))
    23         self.assertEquals(1, gcd(7, 1))
    24         self.assertEquals(-1, gcd(7, -1))
    25         self.assertEquals(1, gcd(-23, 15))
    26         self.assertEquals(12, gcd(120, 84))
    27         self.assertEquals(-12, gcd(84, -120))
     98        self.assertEqual(0, gcd(0, 0))
     99        self.assertEqual(1, gcd(1, 0))
     100        self.assertEqual(-1, gcd(-1, 0))
     101        self.assertEqual(1, gcd(0, 1))
     102        self.assertEqual(-1, gcd(0, -1))
     103        self.assertEqual(1, gcd(7, 1))
     104        self.assertEqual(-1, gcd(7, -1))
     105        self.assertEqual(1, gcd(-23, 15))
     106        self.assertEqual(12, gcd(120, 84))
     107        self.assertEqual(-12, gcd(84, -120))
    28108
    29109
    … …  
    36116    def assertTypedEquals(self, expected, actual):
    37117        """Asserts that both the types and values are the same."""
    38         self.assertEquals(type(expected), type(actual))
    39         self.assertEquals(expected, actual)
     118        self.assertEqual(type(expected), type(actual))
     119        self.assertEqual(expected, actual)
    40120
    41121    def assertRaisesMessage(self, exc_type, message,
    … …  
    45125            callable(*args, **kwargs)
    46126        except exc_type, e:
    47             self.assertEquals(message, str(e))
     127            self.assertEqual(message, str(e))
    48128        else:
    49129            self.fail("%s not raised" % exc_type.__name__)
    50130
    51131    def testInit(self):
    52         self.assertEquals((0, 1), _components(F()))
    53         self.assertEquals((7, 1), _components(F(7)))
    54         self.assertEquals((7, 3), _components(F(F(7, 3))))
    55 
    56         self.assertEquals((-1, 1), _components(F(-1, 1)))
    57         self.assertEquals((-1, 1), _components(F(1, -1)))
    58         self.assertEquals((1, 1), _components(F(-2, -2)))
    59         self.assertEquals((1, 2), _components(F(5, 10)))
    60         self.assertEquals((7, 15), _components(F(7, 15)))
    61         self.assertEquals((10**23, 1), _components(F(10**23)))
     132        self.assertEqual((0, 1), _components(F()))
     133        self.assertEqual((7, 1), _components(F(7)))
     134        self.assertEqual((7, 3), _components(F(F(7, 3))))
     135
     136        self.assertEqual((-1, 1), _components(F(-1, 1)))
     137        self.assertEqual((-1, 1), _components(F(1, -1)))
     138        self.assertEqual((1, 1), _components(F(-2, -2)))
     139        self.assertEqual((1, 2), _components(F(5, 10)))
     140        self.assertEqual((7, 15), _components(F(7, 15)))
     141        self.assertEqual((10**23, 1), _components(F(10**23)))
     142
     143        self.assertEqual((3, 77), _components(F(F(3, 7), 11)))
     144        self.assertEqual((-9, 5), _components(F(2, F(-10, 9))))
     145        self.assertEqual((2486, 2485), _components(F(F(22, 7), F(355, 113))))
    62146
    63147        self.assertRaisesMessage(ZeroDivisionError, "Fraction(12, 0)",
    64148                                 F, 12, 0)
    65         self.assertRaises(TypeError, F, 1.5)
    66149        self.assertRaises(TypeError, F, 1.5 + 3j)
    67150
    68         self.assertRaises(TypeError, F, F(1, 2), 3)
    69151        self.assertRaises(TypeError, F, "3/2", 3)
     152        self.assertRaises(TypeError, F, 3, 0j)
     153        self.assertRaises(TypeError, F, 3, 1j)
     154
     155    @requires_IEEE_754
     156    def testInitFromFloat(self):
     157        self.assertEqual((5, 2), _components(F(2.5)))
     158        self.assertEqual((0, 1), _components(F(-0.0)))
     159        self.assertEqual((3602879701896397, 36028797018963968),
     160                         _components(F(0.1)))
     161        self.assertRaises(TypeError, F, float('nan'))
     162        self.assertRaises(TypeError, F, float('inf'))
     163        self.assertRaises(TypeError, F, float('-inf'))
     164
     165    def testInitFromDecimal(self):
     166        self.assertEqual((11, 10),
     167                         _components(F(Decimal('1.1'))))
     168        self.assertEqual((7, 200),
     169                         _components(F(Decimal('3.5e-2'))))
     170        self.assertEqual((0, 1),
     171                         _components(F(Decimal('.000e20'))))
     172        self.assertRaises(TypeError, F, Decimal('nan'))
     173        self.assertRaises(TypeError, F, Decimal('snan'))
     174        self.assertRaises(TypeError, F, Decimal('inf'))
     175        self.assertRaises(TypeError, F, Decimal('-inf'))
    70176
    71177    def testFromString(self):
    72         self.assertEquals((5, 1), _components(F("5")))
    73         self.assertEquals((3, 2), _components(F("3/2")))
    74         self.assertEquals((3, 2), _components(F(" \n  +3/2")))
    75         self.assertEquals((-3, 2), _components(F("-3/2  ")))
    76         self.assertEquals((13, 2), _components(F("    013/02 \n  ")))
    77         self.assertEquals((13, 2), _components(F(u"    013/02 \n  ")))
    78 
    79         self.assertEquals((16, 5), _components(F(" 3.2 ")))
    80         self.assertEquals((-16, 5), _components(F(u" -3.2 ")))
    81         self.assertEquals((-3, 1), _components(F(u" -3. ")))
    82         self.assertEquals((3, 5), _components(F(u" .6 ")))
     178        self.assertEqual((5, 1), _components(F("5")))
     179        self.assertEqual((3, 2), _components(F("3/2")))
     180        self.assertEqual((3, 2), _components(F(" \n  +3/2")))
     181        self.assertEqual((-3, 2), _components(F("-3/2  ")))
     182        self.assertEqual((13, 2), _components(F("    013/02 \n  ")))
     183        self.assertEqual((13, 2), _components(F(u"    013/02 \n  ")))
     184
     185        self.assertEqual((16, 5), _components(F(" 3.2 ")))
     186        self.assertEqual((-16, 5), _components(F(u" -3.2 ")))
     187        self.assertEqual((-3, 1), _components(F(u" -3. ")))
     188        self.assertEqual((3, 5), _components(F(u" .6 ")))
     189        self.assertEqual((1, 3125), _components(F("32.e-5")))
     190        self.assertEqual((1000000, 1), _components(F("1E+06")))
     191        self.assertEqual((-12300, 1), _components(F("-1.23e4")))
     192        self.assertEqual((0, 1), _components(F(" .0e+0\t")))
     193        self.assertEqual((0, 1), _components(F("-0.000e0")))
    83194
    84195
    … …  
    89200            ValueError, "Invalid literal for Fraction: '3/'",
    90201            F, "3/")
     202        self.assertRaisesMessage(
     203            ValueError, "Invalid literal for Fraction: '/2'",
     204            F, "/2")
    91205        self.assertRaisesMessage(
    92206            ValueError, "Invalid literal for Fraction: '3 /2'",
    … …  
    105219            F, "3a2")
    106220        self.assertRaisesMessage(
    107             # Only parse ordinary decimals, not scientific form.
    108             ValueError, "Invalid literal for Fraction: '3.2e4'",
    109             F, "3.2e4")
    110         self.assertRaisesMessage(
    111221            # Don't accept combinations of decimals and fractions.
    112222            ValueError, "Invalid literal for Fraction: '3/7.2'",
    … …  
    124234        r = F(7, 3)
    125235        r.__init__(2, 15)
    126         self.assertEquals((7, 3), _components(r))
     236        self.assertEqual((7, 3), _components(r))
    127237
    128238        self.assertRaises(AttributeError, setattr, r, 'numerator', 12)
    129239        self.assertRaises(AttributeError, setattr, r, 'denominator', 6)
    130         self.assertEquals((7, 3), _components(r))
     240        self.assertEqual((7, 3), _components(r))
    131241
    132242        # But if you _really_ need to:
    133243        r._numerator = 4
    134244        r._denominator = 2
    135         self.assertEquals((4, 2), _components(r))
     245        self.assertEqual((4, 2), _components(r))
    136246        # Which breaks some important operations:
    137         self.assertNotEquals(F(4, 2), r)
     247        self.assertNotEqual(F(4, 2), r)
    138248
    139249    def testFromFloat(self):
    140250        self.assertRaises(TypeError, F.from_float, 3+4j)
    141         self.assertEquals((10, 1), _components(F.from_float(10)))
     251        self.assertEqual((10, 1), _components(F.from_float(10)))
    142252        bigint = 1234567890123456789
    143         self.assertEquals((bigint, 1), _components(F.from_float(bigint)))
    144         self.assertEquals((0, 1), _components(F.from_float(-0.0)))
    145         self.assertEquals((10, 1), _components(F.from_float(10.0)))
    146         self.assertEquals((-5, 2), _components(F.from_float(-2.5)))
    147         self.assertEquals((99999999999999991611392, 1),
    148                           _components(F.from_float(1e23)))
    149         self.assertEquals(float(10**23), float(F.from_float(1e23)))
    150         self.assertEquals((3602879701896397, 1125899906842624),
    151                           _components(F.from_float(3.2)))
    152         self.assertEquals(3.2, float(F.from_float(3.2)))
     253        self.assertEqual((bigint, 1), _components(F.from_float(bigint)))
     254        self.assertEqual((0, 1), _components(F.from_float(-0.0)))
     255        self.assertEqual((10, 1), _components(F.from_float(10.0)))
     256        self.assertEqual((-5, 2), _components(F.from_float(-2.5)))
     257        self.assertEqual((99999999999999991611392, 1),
     258                         _components(F.from_float(1e23)))
     259        self.assertEqual(float(10**23), float(F.from_float(1e23)))
     260        self.assertEqual((3602879701896397, 1125899906842624),
     261                         _components(F.from_float(3.2)))
     262        self.assertEqual(3.2, float(F.from_float(3.2)))
    153263
    154264        inf = 1e1000
    … …  
    166276    def testFromDecimal(self):
    167277        self.assertRaises(TypeError, F.from_decimal, 3+4j)
    168         self.assertEquals(F(10, 1), F.from_decimal(10))
    169         self.assertEquals(F(0), F.from_decimal(Decimal("-0")))
    170         self.assertEquals(F(5, 10), F.from_decimal(Decimal("0.5")))
    171         self.assertEquals(F(5, 1000), F.from_decimal(Decimal("5e-3")))
    172         self.assertEquals(F(5000), F.from_decimal(Decimal("5e3")))
    173         self.assertEquals(1 - F(1, 10**30),
    174                           F.from_decimal(Decimal("0." + "9" * 30)))
     278        self.assertEqual(F(10, 1), F.from_decimal(10))
     279        self.assertEqual(F(0), F.from_decimal(Decimal("-0")))
     280        self.assertEqual(F(5, 10), F.from_decimal(Decimal("0.5")))
     281        self.assertEqual(F(5, 1000), F.from_decimal(Decimal("5e-3")))
     282        self.assertEqual(F(5000), F.from_decimal(Decimal("5e3")))
     283        self.assertEqual(1 - F(1, 10**30),
     284                         F.from_decimal(Decimal("0." + "9" * 30)))
    175285
    176286        self.assertRaisesMessage(
    … …  
    196306        self.assertEqual(F(201, 200).limit_denominator(101), F(102, 101))
    197307        self.assertEqual(F(0).limit_denominator(10000), F(0))
     308        for i in (0, -1):
     309            self.assertRaisesMessage(
     310                ValueError, "max_denominator should be at least 1",
     311                F(1).limit_denominator, i)
    198312
    199313    def testConversions(self):
    200314        self.assertTypedEquals(-1, math.trunc(F(-11, 10)))
    201315        self.assertTypedEquals(-1, int(F(-11, 10)))
    202 
    203         self.assertEquals(False, bool(F(0, 1)))
    204         self.assertEquals(True, bool(F(3, 2)))
     316        self.assertTypedEquals(1, math.trunc(F(11, 10)))
     317        self.assertEqual(False, bool(F(0, 1)))
     318        self.assertEqual(True, bool(F(3, 2)))
    205319        self.assertTypedEquals(0.1, float(F(1, 10)))
    206320
    … …  
    208322        # numerator and denominator to float before dividing.
    209323        self.assertRaises(OverflowError, float, long('2'*400+'7'))
    210         self.assertAlmostEquals(2.0/3,
     324        self.assertAlmostEqual(2.0/3,
    211325                                float(F(long('2'*400+'7'), long('3'*400+'1'))))
    212326
    … …  
    215329
    216330    def testArithmetic(self):
    217         self.assertEquals(F(1, 2), F(1, 10) + F(2, 5))
    218         self.assertEquals(F(-3, 10), F(1, 10) - F(2, 5))
    219         self.assertEquals(F(1, 25), F(1, 10) * F(2, 5))
    220         self.assertEquals(F(1, 4), F(1, 10) / F(2, 5))
     331        self.assertEqual(F(1, 2), F(1, 10) + F(2, 5))
     332        self.assertEqual(F(-3, 10), F(1, 10) - F(2, 5))
     333        self.assertEqual(F(1, 25), F(1, 10) * F(2, 5))
     334        self.assertEqual(F(1, 4), F(1, 10) / F(2, 5))
    221335        self.assertTypedEquals(2, F(9, 10) // F(2, 5))
    222336        self.assertTypedEquals(10**23, F(10**23, 1) // F(1))
    223         self.assertEquals(F(2, 3), F(-7, 3) % F(3, 2))
    224         self.assertEquals(F(8, 27), F(2, 3) ** F(3))
    225         self.assertEquals(F(27, 8), F(2, 3) ** F(-3))
     337        self.assertEqual(F(2, 3), F(-7, 3) % F(3, 2))
     338        self.assertEqual(F(8, 27), F(2, 3) ** F(3))
     339        self.assertEqual(F(27, 8), F(2, 3) ** F(-3))
    226340        self.assertTypedEquals(2.0, F(4) ** F(1, 2))
     341        self.assertEqual(F(1, 1), +F(1, 1))
    227342        # Will return 1j in 3.0:
    228343        self.assertRaises(ValueError, pow, F(-1), F(1, 2))
    … …  
    289404            "unsupported operand type(s) for +: 'Fraction' and 'Decimal'",
    290405            operator.add, F(3,11), Decimal('3.1415926'))
    291         self.assertNotEquals(F(5, 2), Decimal('2.5'))
     406        self.assertRaisesMessage(
     407            TypeError,
     408            "unsupported operand type(s) for +: 'Decimal' and 'Fraction'",
     409            operator.add, Decimal('3.1415926'), F(3,11))
     410        self.assertNotEqual(F(5, 2), Decimal('2.5'))
    292411
    293412    def testComparisons(self):
    … …  
    302421        self.assertTrue(F(1, 2) != F(1, 3))
    303422
     423    def testComparisonsDummyRational(self):
     424        self.assertTrue(F(1, 2) == DummyRational(1, 2))
     425        self.assertTrue(DummyRational(1, 2) == F(1, 2))
     426        self.assertFalse(F(1, 2) == DummyRational(3, 4))
     427        self.assertFalse(DummyRational(3, 4) == F(1, 2))
     428
     429        self.assertTrue(F(1, 2) < DummyRational(3, 4))
     430        self.assertFalse(F(1, 2) < DummyRational(1, 2))
     431        self.assertFalse(F(1, 2) < DummyRational(1, 7))
     432        self.assertFalse(F(1, 2) > DummyRational(3, 4))
     433        self.assertFalse(F(1, 2) > DummyRational(1, 2))
     434        self.assertTrue(F(1, 2) > DummyRational(1, 7))
     435        self.assertTrue(F(1, 2) <= DummyRational(3, 4))
     436        self.assertTrue(F(1, 2) <= DummyRational(1, 2))
     437        self.assertFalse(F(1, 2) <= DummyRational(1, 7))
     438        self.assertFalse(F(1, 2) >= DummyRational(3, 4))
     439        self.assertTrue(F(1, 2) >= DummyRational(1, 2))
     440        self.assertTrue(F(1, 2) >= DummyRational(1, 7))
     441
     442        self.assertTrue(DummyRational(1, 2) < F(3, 4))
     443        self.assertFalse(DummyRational(1, 2) < F(1, 2))
     444        self.assertFalse(DummyRational(1, 2) < F(1, 7))
     445        self.assertFalse(DummyRational(1, 2) > F(3, 4))
     446        self.assertFalse(DummyRational(1, 2) > F(1, 2))
     447        self.assertTrue(DummyRational(1, 2) > F(1, 7))
     448        self.assertTrue(DummyRational(1, 2) <= F(3, 4))
     449        self.assertTrue(DummyRational(1, 2) <= F(1, 2))
     450        self.assertFalse(DummyRational(1, 2) <= F(1, 7))
     451        self.assertFalse(DummyRational(1, 2) >= F(3, 4))
     452        self.assertTrue(DummyRational(1, 2) >= F(1, 2))
     453        self.assertTrue(DummyRational(1, 2) >= F(1, 7))
     454
     455    def testComparisonsDummyFloat(self):
     456        x = DummyFloat(1./3.)
     457        y = F(1, 3)
     458        self.assertTrue(x != y)
     459        self.assertTrue(x < y or x > y)
     460        self.assertFalse(x == y)
     461        self.assertFalse(x <= y and x >= y)
     462        self.assertTrue(y != x)
     463        self.assertTrue(y < x or y > x)
     464        self.assertFalse(y == x)
     465        self.assertFalse(y <= x and y >= x)
     466
    304467    def testMixedLess(self):
    305468        self.assertTrue(2 < F(5, 2))
    … …  
    312475        self.assertTrue(0.4 < F(1, 2))
    313476        self.assertFalse(0.5 < F(1, 2))
     477
     478        self.assertFalse(float('inf') < F(1, 2))
     479        self.assertTrue(float('-inf') < F(0, 10))
     480        self.assertFalse(float('nan') < F(-3, 7))
     481        self.assertTrue(F(1, 2) < float('inf'))
     482        self.assertFalse(F(17, 12) < float('-inf'))
     483        self.assertFalse(F(144, -89) < float('nan'))
    314484
    315485    def testMixedLessEqual(self):
    … …  
    323493        self.assertFalse(F(5, 2) <= 2)
    324494
     495        self.assertFalse(float('inf') <= F(1, 2))
     496        self.assertTrue(float('-inf') <= F(0, 10))
     497        self.assertFalse(float('nan') <= F(-3, 7))
     498        self.assertTrue(F(1, 2) <= float('inf'))
     499        self.assertFalse(F(17, 12) <= float('-inf'))
     500        self.assertFalse(F(144, -89) <= float('nan'))
     501
    325502    def testBigFloatComparisons(self):
    326503        # Because 10**23 can't be represented exactly as a float:
    … …  
    335512    def testBigComplexComparisons(self):
    336513        self.assertFalse(F(10**23) == complex(10**23))
    337         self.assertTrue(F(10**23) > complex(10**23))
    338         self.assertFalse(F(10**23) <= complex(10**23))
     514        self.assertRaises(TypeError, operator.gt, F(10**23), complex(10**23))
     515        self.assertRaises(TypeError, operator.le, F(10**23), complex(10**23))
     516
     517        x = F(3, 8)
     518        z = complex(0.375, 0.0)
     519        w = complex(0.375, 0.2)
     520        self.assertTrue(x == z)
     521        self.assertFalse(x != z)
     522        self.assertFalse(x == w)
     523        self.assertTrue(x != w)
     524        for op in operator.lt, operator.le, operator.gt, operator.ge:
     525            self.assertRaises(TypeError, op, x, z)
     526            self.assertRaises(TypeError, op, z, x)
     527            self.assertRaises(TypeError, op, x, w)
     528            self.assertRaises(TypeError, op, w, x)
    339529
    340530    def testMixedEqual(self):
    … …  
    347537        self.assertTrue(F(4, 2) == 2)
    348538        self.assertFalse(F(5, 2) == 2)
     539        self.assertFalse(F(5, 2) == float('nan'))
     540        self.assertFalse(float('nan') == F(3, 7))
     541        self.assertFalse(F(5, 2) == float('inf'))
     542        self.assertFalse(float('-inf') == F(2, 5))
    349543
    350544    def testStringification(self):
    351         self.assertEquals("Fraction(7, 3)", repr(F(7, 3)))
    352         self.assertEquals("Fraction(6283185307, 2000000000)",
    353                           repr(F('3.1415926535')))
    354         self.assertEquals("Fraction(-1, 100000000000000000000)",
    355                           repr(F(1, -10**20)))
    356         self.assertEquals("7/3", str(F(7, 3)))
    357         self.assertEquals("7", str(F(7, 1)))
     545        self.assertEqual("Fraction(7, 3)", repr(F(7, 3)))
     546        self.assertEqual("Fraction(6283185307, 2000000000)",
     547                         repr(F('3.1415926535')))
     548        self.assertEqual("Fraction(-1, 100000000000000000000)",
     549                         repr(F(1, -10**20)))
     550        self.assertEqual("7/3", str(F(7, 3)))
     551        self.assertEqual("7", str(F(7, 1)))
    358552
    359553    def testHash(self):
    360         self.assertEquals(hash(2.5), hash(F(5, 2)))
    361         self.assertEquals(hash(10**50), hash(F(10**50)))
    362         self.assertNotEquals(hash(float(10**23)), hash(F(10**23)))
     554        self.assertEqual(hash(2.5), hash(F(5, 2)))
     555        self.assertEqual(hash(10**50), hash(F(10**50)))
     556        self.assertNotEqual(hash(float(10**23)), hash(F(10**23)))
    363557
    364558    def testApproximatePi(self):
    … …  
    373567            t = (t * n) / d
    374568            s += t
    375         self.assertAlmostEquals(math.pi, s)
     569        self.assertAlmostEqual(math.pi, s)
    376570
    377571    def testApproximateCos1(self):
    … …  
    387581            sign *= -1
    388582            s += num / fact * sign
    389         self.assertAlmostEquals(math.cos(1), s)
     583        self.assertAlmostEqual(math.cos(1), s)
    390584
    391585    def test_copy_deepcopy_pickle(self):
    392586        r = F(13, 7)
     587        dr = DummyFraction(13, 7)
    393588        self.assertEqual(r, loads(dumps(r)))
    394589        self.assertEqual(id(r), id(copy(r)))
    395590        self.assertEqual(id(r), id(deepcopy(r)))
     591        self.assertNotEqual(id(dr), id(copy(dr)))
     592        self.assertNotEqual(id(dr), id(deepcopy(dr)))
     593        self.assertTypedEquals(dr, copy(dr))
     594        self.assertTypedEquals(dr, deepcopy(dr))
    396595
    397596    def test_slots(self):
Note: See TracChangeset for help on using the changeset viewer.