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-60706,60708-60712,60714-60724 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk
........
r60701 | georg.brandl | 2008-02-09 22:36:15 +0100 (Sat, 09 Feb 2008) | 2 lines
Needs only 2.4 now.
........
r60702 | georg.brandl | 2008-02-09 22:38:54 +0100 (Sat, 09 Feb 2008) | 2 lines
Docs are rst now.
........
r60703 | georg.brandl | 2008-02-09 23:00:00 +0100 (Sat, 09 Feb 2008) | 2 lines
Fix link.
........
r60704 | georg.brandl | 2008-02-10 00:09:25 +0100 (Sun, 10 Feb 2008) | 2 lines
Fix for newest doctools.
........
r60709 | raymond.hettinger | 2008-02-10 08:21:09 +0100 (Sun, 10 Feb 2008) | 1 line
Clarify that decimal also supports fixed-point arithmetic.
........
r60710 | nick.coghlan | 2008-02-10 08:32:52 +0100 (Sun, 10 Feb 2008) | 1 line
Add missing NEWS entry for r60695
........
r60712 | mark.dickinson | 2008-02-10 15:58:38 +0100 (Sun, 10 Feb 2008) | 3 lines
Turn classmethods into staticmethods, and avoid calling the constructor
of subclasses of Rational. (See discussion in issue #1682.)
........
r60715 | mark.dickinson | 2008-02-10 16:19:58 +0100 (Sun, 10 Feb 2008) | 2 lines
Typos in decimal comment and documentation
........
r60716 | skip.montanaro | 2008-02-10 16:31:54 +0100 (Sun, 10 Feb 2008) | 2 lines
Get the saying right. ;-)
........
r60717 | skip.montanaro | 2008-02-10 16:32:16 +0100 (Sun, 10 Feb 2008) | 2 lines
whoops - revert
........
r60718 | mark.dickinson | 2008-02-10 20:23:36 +0100 (Sun, 10 Feb 2008) | 2 lines
Remove reference to Rational
........
r60719 | raymond.hettinger | 2008-02-10 21:35:16 +0100 (Sun, 10 Feb 2008) | 1 line
Complete an open todo on pickletools -- add a pickle optimizer.
........
r60721 | mark.dickinson | 2008-02-10 22:29:51 +0100 (Sun, 10 Feb 2008) | 3 lines
Rename rational.Rational to fractions.Fraction, to avoid name clash
with numbers.Rational. See issue #1682 for related discussion.
........
r60722 | christian.heimes | 2008-02-11 03:26:22 +0100 (Mon, 11 Feb 2008) | 1 line
The test requires the network resource
........
r60723 | mark.dickinson | 2008-02-11 04:11:55 +0100 (Mon, 11 Feb 2008) | 3 lines
Put an extra space into the repr of a Fraction:
Fraction(1, 2) instead of Fraction(1,2).
........
diff --git a/Lib/decimal.py b/Lib/decimal.py
index 55faf99..873f7c0 100644
--- a/Lib/decimal.py
+++ b/Lib/decimal.py
@@ -802,7 +802,7 @@
# != comparisons involving a NaN always return True
# <, >, <= and >= comparisons involving a (quiet or signaling)
# NaN signal InvalidOperation, and return False if the
- # InvalidOperation is trapped.
+ # InvalidOperation is not trapped.
#
# This behavior is designed to conform as closely as possible to
# that specified by IEEE 754.
diff --git a/Lib/rational.py b/Lib/fractions.py
similarity index 83%
rename from Lib/rational.py
rename to Lib/fractions.py
index 6002964..25b9f02 100755
--- a/Lib/rational.py
+++ b/Lib/fractions.py
@@ -1,16 +1,15 @@
# Originally contributed by Sjoerd Mullender.
# Significantly modified by Jeffrey Yasskin <jyasskin at gmail.com>.
-"""Rational, infinite-precision, real numbers."""
+"""Fraction, infinite-precision, real numbers."""
import math
import numbers
import operator
import re
-__all__ = ["Rational"]
+__all__ = ["Fraction"]
-RationalAbc = numbers.Rational
def gcd(a, b):
@@ -38,15 +37,15 @@
""", re.VERBOSE)
-class Rational(RationalAbc):
+class Fraction(numbers.Rational):
"""This class implements rational numbers.
- Rational(8, 6) will produce a rational number equivalent to
+ Fraction(8, 6) will produce a rational number equivalent to
4/3. Both arguments must be Integral. The numerator defaults to 0
- and the denominator defaults to 1 so that Rational(3) == 3 and
- Rational() == 0.
+ and the denominator defaults to 1 so that Fraction(3) == 3 and
+ Fraction() == 0.
- Rationals can also be constructed from strings of the form
+ Fraction can also be constructed from strings of the form
'[-+]?[0-9]+((/|.)[0-9]+)?', optionally surrounded by spaces.
"""
@@ -61,7 +60,7 @@
numerator/denominator pair.
"""
- self = super(Rational, cls).__new__(cls)
+ self = super(Fraction, cls).__new__(cls)
if denominator == 1:
if isinstance(numerator, str):
@@ -69,7 +68,7 @@
input = numerator
m = _RATIONAL_FORMAT.match(input)
if m is None:
- raise ValueError('Invalid literal for Rational: ' + input)
+ raise ValueError('Invalid literal for Fraction: ' + input)
numerator = m.group('num')
decimal = m.group('decimal')
if decimal:
@@ -86,7 +85,7 @@
numerator = -numerator
elif (not isinstance(numerator, numbers.Integral) and
- isinstance(numerator, RationalAbc)):
+ isinstance(numerator, numbers.Rational)):
# Handle copies from other rationals.
other_rational = numerator
numerator = other_rational.numerator
@@ -94,11 +93,11 @@
if (not isinstance(numerator, numbers.Integral) or
not isinstance(denominator, numbers.Integral)):
- raise TypeError("Rational(%(numerator)s, %(denominator)s):"
+ raise TypeError("Fraction(%(numerator)s, %(denominator)s):"
" Both arguments must be integral." % locals())
if denominator == 0:
- raise ZeroDivisionError('Rational(%s, 0)' % numerator)
+ raise ZeroDivisionError('Fraction(%s, 0)' % numerator)
g = gcd(numerator, denominator)
self._numerator = int(numerator // g)
@@ -109,7 +108,7 @@
def from_float(cls, f):
"""Converts a finite float to a rational number, exactly.
- Beware that Rational.from_float(0.3) != Rational(3, 10).
+ Beware that Fraction.from_float(0.3) != Fraction(3, 10).
"""
if not isinstance(f, float):
@@ -141,7 +140,7 @@
@classmethod
def from_continued_fraction(cls, seq):
- 'Build a Rational from a continued fraction expessed as a sequence'
+ 'Build a Fraction from a continued fraction expessed as a sequence'
n, d = 1, 0
for e in reversed(seq):
n, d = d, n
@@ -168,7 +167,7 @@
if self.denominator <= max_denominator:
return self
cf = self.as_continued_fraction()
- result = Rational(0)
+ result = Fraction(0)
for i in range(1, len(cf)):
new = self.from_continued_fraction(cf[:i])
if new.denominator > max_denominator:
@@ -186,7 +185,7 @@
def __repr__(self):
"""repr(self)"""
- return ('Rational(%r,%r)' % (self.numerator, self.denominator))
+ return ('Fraction(%r,%r)' % (self.numerator, self.denominator))
def __str__(self):
"""str(self)"""
@@ -206,13 +205,13 @@
that mixed-mode operations either call an implementation whose
author knew about the types of both arguments, or convert both
to the nearest built in type and do the operation there. In
- Rational, that means that we define __add__ and __radd__ as:
+ Fraction, that means that we define __add__ and __radd__ as:
def __add__(self, other):
# Both types have numerators/denominator attributes,
# so do the operation directly
- if isinstance(other, (int, Rational)):
- return Rational(self.numerator * other.denominator +
+ if isinstance(other, (int, Fraction)):
+ return Fraction(self.numerator * other.denominator +
other.numerator * self.denominator,
self.denominator * other.denominator)
# float and complex don't have those operations, but we
@@ -227,8 +226,8 @@
def __radd__(self, other):
# radd handles more types than add because there's
# nothing left to fall back to.
- if isinstance(other, RationalAbc):
- return Rational(self.numerator * other.denominator +
+ if isinstance(other, numbers.Rational):
+ return Fraction(self.numerator * other.denominator +
other.numerator * self.denominator,
self.denominator * other.denominator)
elif isinstance(other, Real):
@@ -239,32 +238,32 @@
There are 5 different cases for a mixed-type addition on
- Rational. I'll refer to all of the above code that doesn't
- refer to Rational, float, or complex as "boilerplate". 'r'
- will be an instance of Rational, which is a subtype of
- RationalAbc (r : Rational <: RationalAbc), and b : B <:
+ Fraction. I'll refer to all of the above code that doesn't
+ refer to Fraction, float, or complex as "boilerplate". 'r'
+ will be an instance of Fraction, which is a subtype of
+ Rational (r : Fraction <: Rational), and b : B <:
Complex. The first three involve 'r + b':
- 1. If B <: Rational, int, float, or complex, we handle
+ 1. If B <: Fraction, int, float, or complex, we handle
that specially, and all is well.
- 2. If Rational falls back to the boilerplate code, and it
+ 2. If Fraction falls back to the boilerplate code, and it
were to return a value from __add__, we'd miss the
possibility that B defines a more intelligent __radd__,
so the boilerplate should return NotImplemented from
- __add__. In particular, we don't handle RationalAbc
+ __add__. In particular, we don't handle Rational
here, even though we could get an exact answer, in case
the other type wants to do something special.
- 3. If B <: Rational, Python tries B.__radd__ before
- Rational.__add__. This is ok, because it was
- implemented with knowledge of Rational, so it can
+ 3. If B <: Fraction, Python tries B.__radd__ before
+ Fraction.__add__. This is ok, because it was
+ implemented with knowledge of Fraction, so it can
handle those instances before delegating to Real or
Complex.
The next two situations describe 'b + r'. We assume that b
- didn't know about Rational in its implementation, and that it
+ didn't know about Fraction in its implementation, and that it
uses similar boilerplate code:
- 4. If B <: RationalAbc, then __radd_ converts both to the
+ 4. If B <: Rational, then __radd_ converts both to the
builtin rational type (hey look, that's us) and
proceeds.
5. Otherwise, __radd__ tries to find the nearest common
@@ -276,7 +275,7 @@
"""
def forward(a, b):
- if isinstance(b, (int, Rational)):
+ if isinstance(b, (int, Fraction)):
return monomorphic_operator(a, b)
elif isinstance(b, float):
return fallback_operator(float(a), b)
@@ -288,7 +287,7 @@
forward.__doc__ = monomorphic_operator.__doc__
def reverse(b, a):
- if isinstance(a, RationalAbc):
+ if isinstance(a, numbers.Rational):
# Includes ints.
return monomorphic_operator(a, b)
elif isinstance(a, numbers.Real):
@@ -304,7 +303,7 @@
def _add(a, b):
"""a + b"""
- return Rational(a.numerator * b.denominator +
+ return Fraction(a.numerator * b.denominator +
b.numerator * a.denominator,
a.denominator * b.denominator)
@@ -312,7 +311,7 @@
def _sub(a, b):
"""a - b"""
- return Rational(a.numerator * b.denominator -
+ return Fraction(a.numerator * b.denominator -
b.numerator * a.denominator,
a.denominator * b.denominator)
@@ -320,13 +319,13 @@
def _mul(a, b):
"""a * b"""
- return Rational(a.numerator * b.numerator, a.denominator * b.denominator)
+ return Fraction(a.numerator * b.numerator, a.denominator * b.denominator)
__mul__, __rmul__ = _operator_fallbacks(_mul, operator.mul)
def _div(a, b):
"""a / b"""
- return Rational(a.numerator * b.denominator,
+ return Fraction(a.numerator * b.denominator,
a.denominator * b.numerator)
__truediv__, __rtruediv__ = _operator_fallbacks(_div, operator.truediv)
@@ -357,14 +356,14 @@
result will be rational.
"""
- if isinstance(b, RationalAbc):
+ if isinstance(b, numbers.Rational):
if b.denominator == 1:
power = b.numerator
if power >= 0:
- return Rational(a.numerator ** power,
+ return Fraction(a.numerator ** power,
a.denominator ** power)
else:
- return Rational(a.denominator ** -power,
+ return Fraction(a.denominator ** -power,
a.numerator ** -power)
else:
# A fractional power will generally produce an
@@ -379,8 +378,8 @@
# If a is an int, keep it that way if possible.
return a ** b.numerator
- if isinstance(a, RationalAbc):
- return Rational(a.numerator, a.denominator) ** b
+ if isinstance(a, numbers.Rational):
+ return Fraction(a.numerator, a.denominator) ** b
if b.denominator == 1:
return a ** b.numerator
@@ -388,16 +387,16 @@
return a ** float(b)
def __pos__(a):
- """+a: Coerces a subclass instance to Rational"""
- return Rational(a.numerator, a.denominator)
+ """+a: Coerces a subclass instance to Fraction"""
+ return Fraction(a.numerator, a.denominator)
def __neg__(a):
"""-a"""
- return Rational(-a.numerator, a.denominator)
+ return Fraction(-a.numerator, a.denominator)
def __abs__(a):
"""abs(a)"""
- return Rational(abs(a.numerator), a.denominator)
+ return Fraction(abs(a.numerator), a.denominator)
def __trunc__(a):
"""trunc(a)"""
@@ -433,12 +432,12 @@
return floor + 1
shift = 10**abs(ndigits)
# See _operator_fallbacks.forward to check that the results of
- # these operations will always be Rational and therefore have
+ # these operations will always be Fraction and therefore have
# round().
if ndigits > 0:
- return Rational(round(self * shift), shift)
+ return Fraction(round(self * shift), shift)
else:
- return Rational(round(self / shift) * shift)
+ return Fraction(round(self / shift) * shift)
def __hash__(self):
"""hash(self)
@@ -461,7 +460,7 @@
def __eq__(a, b):
"""a == b"""
- if isinstance(b, RationalAbc):
+ if isinstance(b, numbers.Rational):
return (a.numerator == b.numerator and
a.denominator == b.denominator)
if isinstance(b, numbers.Complex) and b.imag == 0:
@@ -488,7 +487,7 @@
if isinstance(b, float):
b = a.from_float(b)
try:
- # XXX: If b <: Real but not <: RationalAbc, this is likely
+ # XXX: If b <: Real but not <: Rational, this is likely
# to fall back to a float. If the actual values differ by
# less than MIN_FLOAT, this could falsely call them equal,
# which would make <= inconsistent with ==. Better ways of
@@ -496,7 +495,7 @@
diff = a - b
except TypeError:
return NotImplemented
- if isinstance(diff, RationalAbc):
+ if isinstance(diff, numbers.Rational):
return op(diff.numerator, 0)
return op(diff, 0)
@@ -526,11 +525,11 @@
return (self.__class__, (str(self),))
def __copy__(self):
- if type(self) == Rational:
+ if type(self) == Fraction:
return self # I'm immutable; therefore I am my own clone
return self.__class__(self.numerator, self.denominator)
def __deepcopy__(self, memo):
- if type(self) == Rational:
+ if type(self) == Fraction:
return self # My components are also immutable
return self.__class__(self.numerator, self.denominator)
diff --git a/Lib/pickletools.py b/Lib/pickletools.py
index 0665cd0..1b6967a 100644
--- a/Lib/pickletools.py
+++ b/Lib/pickletools.py
@@ -14,9 +14,7 @@
import pickle
import re
-__all__ = ['dis',
- 'genops',
- ]
+__all__ = ['dis', 'genops', 'optimize']
bytes_types = pickle.bytes_types
@@ -1836,6 +1834,33 @@
break
##############################################################################
+# A pickle optimizer.
+
+def optimize(p):
+ 'Optimize a pickle string by removing unused PUT opcodes'
+ gets = set() # set of args used by a GET opcode
+ puts = [] # (arg, startpos, stoppos) for the PUT opcodes
+ prevpos = None # set to pos if previous opcode was a PUT
+ for opcode, arg, pos in genops(p):
+ if prevpos is not None:
+ puts.append((prevarg, prevpos, pos))
+ prevpos = None
+ if 'PUT' in opcode.name:
+ prevarg, prevpos = arg, pos
+ elif 'GET' in opcode.name:
+ gets.add(arg)
+
+ # Copy the pickle string except for PUTS without a corresponding GET
+ s = []
+ i = 0
+ for arg, start, stop in puts:
+ j = stop if (arg in gets) else start
+ s.append(p[i:j])
+ i = stop
+ s.append(p[i:])
+ return ''.join(s)
+
+##############################################################################
# A symbolic pickle disassembler.
def dis(pickle, out=None, memo=None, indentlevel=4):
diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py
index b17133a..f781db3 100644
--- a/Lib/test/test_builtin.py
+++ b/Lib/test/test_builtin.py
@@ -5,7 +5,7 @@
run_with_locale
from operator import neg
-import sys, warnings, random, collections, io, rational
+import sys, warnings, random, collections, io, rational, fractions
warnings.filterwarnings("ignore", "hex../oct.. of negative int",
FutureWarning, __name__)
warnings.filterwarnings("ignore", "integer argument expected",
@@ -607,7 +607,7 @@
n, d = f.as_integer_ratio()
self.assertEqual(float(n).__truediv__(d), f)
- R = rational.Rational
+ R = fractions.Fraction
self.assertEqual(R(0, 1),
R(*float(0.0).as_integer_ratio()))
self.assertEqual(R(5, 2),
diff --git a/Lib/test/test_rational.py b/Lib/test/test_fractions.py
similarity index 90%
rename from Lib/test/test_rational.py
rename to Lib/test/test_fractions.py
index 92d8a14..00fd549 100644
--- a/Lib/test/test_rational.py
+++ b/Lib/test/test_fractions.py
@@ -1,15 +1,15 @@
-"""Tests for Lib/rational.py."""
+"""Tests for Lib/fractions.py."""
from decimal import Decimal
from test.test_support import run_unittest, verbose
import math
import operator
-import rational
+import fractions
import unittest
from copy import copy, deepcopy
from pickle import dumps, loads
-R = rational.Rational
-gcd = rational.gcd
+R = fractions.Fraction
+gcd = fractions.gcd
class GcdTest(unittest.TestCase):
@@ -31,7 +31,7 @@
return (r.numerator, r.denominator)
-class RationalTest(unittest.TestCase):
+class FractionTest(unittest.TestCase):
def assertTypedEquals(self, expected, actual):
"""Asserts that both the types and values are the same."""
@@ -60,7 +60,7 @@
self.assertEquals((7, 15), _components(R(7, 15)))
self.assertEquals((10**23, 1), _components(R(10**23)))
- self.assertRaisesMessage(ZeroDivisionError, "Rational(12, 0)",
+ self.assertRaisesMessage(ZeroDivisionError, "Fraction(12, 0)",
R, 12, 0)
self.assertRaises(TypeError, R, 1.5)
self.assertRaises(TypeError, R, 1.5 + 3j)
@@ -81,41 +81,41 @@
self.assertEquals((3, 5), _components(R(" .6 ")))
self.assertRaisesMessage(
- ZeroDivisionError, "Rational(3, 0)",
+ ZeroDivisionError, "Fraction(3, 0)",
R, "3/0")
self.assertRaisesMessage(
- ValueError, "Invalid literal for Rational: 3/",
+ ValueError, "Invalid literal for Fraction: 3/",
R, "3/")
self.assertRaisesMessage(
- ValueError, "Invalid literal for Rational: 3 /2",
+ ValueError, "Invalid literal for Fraction: 3 /2",
R, "3 /2")
self.assertRaisesMessage(
# Denominators don't need a sign.
- ValueError, "Invalid literal for Rational: 3/+2",
+ ValueError, "Invalid literal for Fraction: 3/+2",
R, "3/+2")
self.assertRaisesMessage(
# Imitate float's parsing.
- ValueError, "Invalid literal for Rational: + 3/2",
+ ValueError, "Invalid literal for Fraction: + 3/2",
R, "+ 3/2")
self.assertRaisesMessage(
# Avoid treating '.' as a regex special character.
- ValueError, "Invalid literal for Rational: 3a2",
+ ValueError, "Invalid literal for Fraction: 3a2",
R, "3a2")
self.assertRaisesMessage(
# Only parse ordinary decimals, not scientific form.
- ValueError, "Invalid literal for Rational: 3.2e4",
+ ValueError, "Invalid literal for Fraction: 3.2e4",
R, "3.2e4")
self.assertRaisesMessage(
# Don't accept combinations of decimals and rationals.
- ValueError, "Invalid literal for Rational: 3/7.2",
+ ValueError, "Invalid literal for Fraction: 3/7.2",
R, "3/7.2")
self.assertRaisesMessage(
# Don't accept combinations of decimals and rationals.
- ValueError, "Invalid literal for Rational: 3.2/7",
+ ValueError, "Invalid literal for Fraction: 3.2/7",
R, "3.2/7")
self.assertRaisesMessage(
# Allow 3. and .3, but not .
- ValueError, "Invalid literal for Rational: .",
+ ValueError, "Invalid literal for Fraction: .",
R, ".")
def testImmutable(self):
@@ -136,7 +136,7 @@
def testFromFloat(self):
self.assertRaisesMessage(
- TypeError, "Rational.from_float() only takes floats, not 3 (int)",
+ TypeError, "Fraction.from_float() only takes floats, not 3 (int)",
R.from_float, 3)
self.assertEquals((0, 1), _components(R.from_float(-0.0)))
@@ -152,19 +152,19 @@
inf = 1e1000
nan = inf - inf
self.assertRaisesMessage(
- TypeError, "Cannot convert inf to Rational.",
+ TypeError, "Cannot convert inf to Fraction.",
R.from_float, inf)
self.assertRaisesMessage(
- TypeError, "Cannot convert -inf to Rational.",
+ TypeError, "Cannot convert -inf to Fraction.",
R.from_float, -inf)
self.assertRaisesMessage(
- TypeError, "Cannot convert nan to Rational.",
+ TypeError, "Cannot convert nan to Fraction.",
R.from_float, nan)
def testFromDecimal(self):
self.assertRaisesMessage(
TypeError,
- "Rational.from_decimal() only takes Decimals, not 3 (int)",
+ "Fraction.from_decimal() only takes Decimals, not 3 (int)",
R.from_decimal, 3)
self.assertEquals(R(0), R.from_decimal(Decimal("-0")))
self.assertEquals(R(5, 10), R.from_decimal(Decimal("0.5")))
@@ -174,16 +174,16 @@
R.from_decimal(Decimal("0." + "9" * 30)))
self.assertRaisesMessage(
- TypeError, "Cannot convert Infinity to Rational.",
+ TypeError, "Cannot convert Infinity to Fraction.",
R.from_decimal, Decimal("inf"))
self.assertRaisesMessage(
- TypeError, "Cannot convert -Infinity to Rational.",
+ TypeError, "Cannot convert -Infinity to Fraction.",
R.from_decimal, Decimal("-inf"))
self.assertRaisesMessage(
- TypeError, "Cannot convert NaN to Rational.",
+ TypeError, "Cannot convert NaN to Fraction.",
R.from_decimal, Decimal("nan"))
self.assertRaisesMessage(
- TypeError, "Cannot convert sNaN to Rational.",
+ TypeError, "Cannot convert sNaN to Fraction.",
R.from_decimal, Decimal("snan"))
def testFromContinuedFraction(self):
@@ -316,7 +316,7 @@
# Decimal refuses mixed comparisons.
self.assertRaisesMessage(
TypeError,
- "unsupported operand type(s) for +: 'Rational' and 'Decimal'",
+ "unsupported operand type(s) for +: 'Fraction' and 'Decimal'",
operator.add, R(3,11), Decimal('3.1415926'))
self.assertNotEquals(R(5, 2), Decimal('2.5'))
@@ -378,7 +378,7 @@
self.assertFalse(R(5, 2) == 2)
def testStringification(self):
- self.assertEquals("Rational(7,3)", repr(R(7, 3)))
+ self.assertEquals("Fraction(7,3)", repr(R(7, 3)))
self.assertEquals("7/3", str(R(7, 3)))
self.assertEquals("7", str(R(7, 1)))
@@ -421,7 +421,7 @@
self.assertEqual(id(r), id(deepcopy(r)))
def test_main():
- run_unittest(RationalTest, GcdTest)
+ run_unittest(FractionTest, GcdTest)
if __name__ == '__main__':
test_main()