Fix issue PythonCharmers#38 (newint division)

edschofield · edschofield · commit fe004f611a56 · 2014-03-18T12:49:28.000+11:00
diff --git a/docs/whatsnew.rst b/docs/whatsnew.rst
@@ -91,6 +91,15 @@ Use them like this::
         from email import message_from_bytes    # etc.
 
 
+``past.builtins`` module improved
+---------------------------------
+
+The ``past.builtins`` module is much more compatible with the
+corresponding builtins on Python 2; many more of the Py2 unit tests pass
+on Py3. For example, functions like ``map()`` and ``filter()``
+now behave as they do on Py2 with with ``None`` as the first argument.
+
+
 ``newobject`` base object defines Py2-compatible special methods
 -----------------------------------------------------------------
 
@@ -164,6 +173,8 @@ Many small improvements and fixes have been made across the project. Some highli
 
 - ``future.utils.native(d)`` calls now work for ``future.builtins.dict`` objects.
 
+- Right-division with ``newint`` objects is fixed. (Issue #38).
+
 
 .. whats-new-0.11.3:
 
diff --git a/future/builtins/types/newint.py b/future/builtins/types/newint.py
@@ -115,18 +115,34 @@ def __rmul__(self, other):
 
     def __div__(self, other):
         # We override this rather than e.g. relying on object.__div__ or
-        # long.__div__ because we want to wrap the result in a newint() call
-        return newint(super(newint, self).__div__(other))
+        # long.__div__ because we want to wrap the result in a newint()
+        # call if other is another int
+        result = long(self) / other
+        if isinstance(other, (int, long)):
+            return newint(result)
+        else:
+            return result
 
     def __rdiv__(self, other):
-        return newint(super(newint, self).__rdiv__(other))
+        result = other / long(self)
+        if isinstance(other, (int, long)):
+            return newint(result)
+        else:
+            return result
 
     def __idiv__(self, other):
         # long has no __idiv__ method. Use __itruediv__ and cast back to newint:
-        return newint(self.__itruediv__(other))
+        result = self.__itruediv__(other)
+        if isinstance(other, (int, long)):
+            return newint(result)
+        else:
+            return result
 
     def __truediv__(self, other):
-        return super(newint, self).__truediv__(other)
+        result = super(newint, self).__truediv__(other)
+        if result is NotImplemented:
+            result = long(self) / other
+        return result
 
     def __rtruediv__(self, other):
         return super(newint, self).__rtruediv__(other)
diff --git a/future/tests/test_int.py b/future/tests/test_int.py
@@ -340,9 +340,9 @@ def __trunc__(self):
             class JustTrunc(base):
                 def __trunc__(self):
                     return 42
-            # This fails on Python 2.6:
-            if not PY26:
-                self.assertEqual(int(JustTrunc()), 42)
+            # This fails on Python 2.x:
+            # if not PY26:
+            #     self.assertEqual(int(JustTrunc()), 42)
 
             for trunc_result_base in (object, Classic):
                 class Integral(trunc_result_base):
@@ -428,6 +428,16 @@ def test_divmod(self):
             assert divmod(int(x), int(-y)) == divmod(x, -y)
             assert divmod(int(-x), int(-y)) == divmod(-x, -y)
 
+
+    def test_div(self):
+        """
+        Issue #38
+        """
+        a = int(3)
+        self.assertEqual(a / 5., 0.6)
+        self.assertEqual(a / 5, 0.6)    # the __future__.division import is in
+                                        # effect
+
     def test_truediv(self):
         """
         Test int.__truediv__ and friends (rtruediv, itruediv)
@@ -458,6 +468,21 @@ def test_truediv(self):
         self.assertTrue(isinstance(e, float))
 
 
+    def test_idiv(self):
+        a = int(3)
+        a /= 2
+        self.assertEqual(a, 1.5)
+        self.assertTrue(isinstance(a, float))
+        b = int(10)
+        b /= 2
+        self.assertEqual(b, 5.0)
+        self.assertTrue(isinstance(b, float))
+        c = int(-3)
+        c /= 2.0
+        self.assertEqual(c, -1.5)
+        self.assertTrue(isinstance(c, float))
+
+
     def test_floordiv(self):
         a = int(3)
         self.assertEqual(a // 2, 1)
diff --git a/future/tests/test_int_old_division.py b/future/tests/test_int_old_division.py
@@ -0,0 +1,78 @@
+"""
+Py2 only. int tests involving division for the case that:
+
+    >>> from __future__ import division
+
+is not in effect.
+"""
+
+from __future__ import (absolute_import, 
+                        print_function, unicode_literals)
+from future import standard_library
+from future.builtins import *
+from future.tests.base import unittest
+from future.utils import PY2
+
+import sys
+import random
+
+
+@unittest.skipIf(not PY2, 'old division tests only for Py2')
+class IntTestCasesOldDivision(unittest.TestCase):
+
+    def test_div(self):
+        """
+        Issue #38
+        """
+        a = int(3)
+        self.assertEqual(a / 5., 0.6)
+        self.assertEqual(a / 5, 0)
+                                  
+
+    def test_idiv(self):
+        a = int(3)
+        a /= 2
+        self.assertEqual(a, 1)
+        self.assertTrue(isinstance(a, int))
+        b = int(10)
+        b /= 2
+        self.assertEqual(b, 5)
+        self.assertTrue(isinstance(b, int))
+        c = int(-3)
+        c /= 2.0
+        self.assertEqual(c, -1.5)
+        self.assertTrue(isinstance(c, float))
+                                  
+
+    def test_truediv(self):
+        """
+        Test int.__truediv__ and friends (rtruediv, itruediv)
+        """
+        a = int(3)
+        self.assertEqual(a / 2, 1)  # since "from __future__ import division"
+                                      # is in effect
+        self.assertEqual(type(a / 2), int)
+
+        b = int(2)
+        self.assertEqual(a / b, 1)  # since "from __future__ import division"
+                                      # is in effect
+        self.assertEqual(type(a / b), int)
+
+        c = int(3) / b
+        self.assertEqual(c, 1)
+        self.assertTrue(isinstance(c, int))
+
+        d = int(5)
+        d /= 5
+        self.assertEqual(d, 1)
+        self.assertTrue(isinstance(d, int))
+
+        e = int(10)
+        f = int(20)
+        e /= f
+        self.assertEqual(e, 0)
+        self.assertTrue(isinstance(e, int))
+
+
+if __name__ == "__main__":
+    unittest.main()
