TST: Fix edge cases in assert_almost_equal() + tests #4398

Many of the edge cases were related to ordering of the items, but in
some cases there were also issues with type checking.  This fixes both
of those issues and massively expands the testing for this function.

Author: danbirken

pandas/src/testing.pyx

@@ -3,16 +3,47 @@ import numpy as np
 from pandas import compat
 from pandas.core.common import isnull
 
+cdef NUMERIC_TYPES = (
+    bool,
+    int,
+    float,
+    np.bool,
+    np.int8,
+    np.int16,
+    np.int32,
+    np.int64,
+    np.uint8,
+    np.uint16,
+    np.uint32,
+    np.uint64,
+    np.float16,
+    np.float32,
+    np.float64,
+)
+
+cdef bint is_comparable_as_number(obj):
+    return isinstance(obj, NUMERIC_TYPES)
+
 cdef bint isiterable(obj):
     return hasattr(obj, '__iter__')
 
+cdef bint has_length(obj):
+    return hasattr(obj, '__len__')
+
+cdef bint is_dictlike(obj):
+    return hasattr(obj, 'keys') and hasattr(obj, '__getitem__')
+
 cdef bint decimal_almost_equal(double desired, double actual, int decimal):
     # Code from
     # http://docs.scipy.org/doc/numpy/reference/generated
     # /numpy.testing.assert_almost_equal.html
     return abs(desired - actual) < (0.5 * 10.0 ** -decimal)
 
 cpdef assert_dict_equal(a, b, bint compare_keys=True):
+    assert is_dictlike(a) and is_dictlike(b), (
+        "Cannot compare dict objects, one or both is not dict-like"
+    )
+
     a_keys = frozenset(a.keys())
     b_keys = frozenset(b.keys())
 
@@ -33,14 +64,24 @@ cpdef assert_almost_equal(a, b, bint check_less_precise=False):
     if isinstance(a, dict) or isinstance(b, dict):
         return assert_dict_equal(a, b)
 
-    if isinstance(a, compat.string_types):
+    if (isinstance(a, compat.string_types) or
+            isinstance(b, compat.string_types)):
         assert a == b, "%r != %r" % (a, b)
         return True
 
     if isiterable(a):
-        assert isiterable(b), "First object is iterable, second isn't"
+        assert isiterable(b), (
+            "First object is iterable, second isn't: %r != %r" % (a, b)
+        )
+        assert has_length(a) and has_length(b), (
+            "Can't compare objects without length, one or both is invalid: "
+            "(%r, %r)" % (a, b)
+        )
+
         na, nb = len(a), len(b)
-        assert na == nb, "%s != %s" % (na, nb)
+        assert na == nb, (
+            "Length of two iterators not the same: %r != %r" % (na, nb)
+        )
         if (isinstance(a, np.ndarray) and
                 isinstance(b, np.ndarray) and
                 np.array_equal(a, b)):
@@ -49,12 +90,27 @@ cpdef assert_almost_equal(a, b, bint check_less_precise=False):
             for i in xrange(na):
                 assert_almost_equal(a[i], b[i], check_less_precise)
         return True
+    elif isiterable(b):
+        assert False, (
+            "Second object is iterable, first isn't: %r != %r" % (a, b)
+        )
 
     if isnull(a):
-        assert isnull(b), "First object is null, second isn't"
+        assert isnull(b), (
+            "First object is null, second isn't: %r != %r" % (a, b)
+        )
+        return True
+    elif isnull(b):
+        assert isnull(a), (
+            "First object is not null, second is null: %r != %r" % (a, b)
+        )
         return True
 
-    if isinstance(a, (bool, float, int, np.float32)):
+    if is_comparable_as_number(a):
+        assert is_comparable_as_number(b), (
+            "First object is numeric, second is not: %r != %r" % (a, b)
+        )
+
         decimal = 5
 
         # deal with differing dtypes
@@ -81,6 +137,6 @@ cpdef assert_almost_equal(a, b, bint check_less_precise=False):
                     assert False, 'expected %.5f but got %.5f' % (b, a)
 
     else:
-        assert a == b, "%s != %s" % (a, b)
+        assert a == b, "%r != %r" % (a, b)
 
     return True

pandas/tests/test_tests.py

@@ -4,6 +4,7 @@
 import unittest
 import warnings
 import nose
+import numpy as np
 import sys
 
 from pandas.util.testing import (
@@ -12,12 +13,99 @@
 
 # let's get meta.
 
-class TestUtilTesting(unittest.TestCase):
+class TestAssertAlmostEqual(unittest.TestCase):
     _multiprocess_can_split_ = True
 
-    def test_assert_almost_equal(self):
-        # don't die because values are not ndarrays
-        assert_almost_equal(1.1,1.1,check_less_precise=True)
+    def _assert_almost_equal_both(self, a, b, **kwargs):
+        assert_almost_equal(a, b, **kwargs)
+        assert_almost_equal(b, a, **kwargs)
+
+    def _assert_not_almost_equal_both(self, a, b, **kwargs):
+        self.assertRaises(AssertionError, assert_almost_equal, a, b, **kwargs)
+        self.assertRaises(AssertionError, assert_almost_equal, b, a, **kwargs)
+
+    def test_assert_almost_equal_numbers(self):
+        self._assert_almost_equal_both(1.1, 1.1)
+        self._assert_almost_equal_both(1.1, 1.100001)
+        self._assert_almost_equal_both(np.int16(1), 1.000001)
+        self._assert_almost_equal_both(np.float64(1.1), 1.1)
+        self._assert_almost_equal_both(np.uint32(5), 5)
+
+        self._assert_not_almost_equal_both(1.1, 1)
+        self._assert_not_almost_equal_both(1.1, True)
+        self._assert_not_almost_equal_both(1, 2)
+        self._assert_not_almost_equal_both(1.0001, np.int16(1))
+
+    def test_assert_almost_equal_numbers_with_zeros(self):
+        self._assert_almost_equal_both(0, 0)
+        self._assert_almost_equal_both(0.000001, 0)
+
+        self._assert_not_almost_equal_both(0.001, 0)
+        self._assert_not_almost_equal_both(1, 0)
+
+    def test_assert_almost_equal_numbers_with_mixed(self):
+        self._assert_not_almost_equal_both(1, 'abc')
+        self._assert_not_almost_equal_both(1, [1,])
+        self._assert_not_almost_equal_both(1, object())
+
+    def test_assert_almost_equal_dicts(self):
+        self._assert_almost_equal_both({'a': 1, 'b': 2}, {'a': 1, 'b': 2})
+
+        self._assert_not_almost_equal_both({'a': 1, 'b': 2}, {'a': 1, 'b': 3})
+        self._assert_not_almost_equal_both(
+            {'a': 1, 'b': 2}, {'a': 1, 'b': 2, 'c': 3}
+        )
+        self._assert_not_almost_equal_both({'a': 1}, 1)
+        self._assert_not_almost_equal_both({'a': 1}, 'abc')
+        self._assert_not_almost_equal_both({'a': 1}, [1,])
+
+    def test_assert_almost_equal_dict_like_object(self):
+        class DictLikeObj(object):
+            def keys(self):
+                return ('a',)
+
+            def __getitem__(self, item):
+                if item == 'a':
+                    return 1
+
+        self._assert_almost_equal_both({'a': 1}, DictLikeObj())
+
+        self._assert_not_almost_equal_both({'a': 2}, DictLikeObj())
+
+    def test_assert_almost_equal_strings(self):
+        self._assert_almost_equal_both('abc', 'abc')
+
+        self._assert_not_almost_equal_both('abc', 'abcd')
+        self._assert_not_almost_equal_both('abc', 'abd')
+        self._assert_not_almost_equal_both('abc', 1)
+        self._assert_not_almost_equal_both('abc', [1,])
+
+    def test_assert_almost_equal_iterables(self):
+        self._assert_almost_equal_both([1, 2, 3], [1, 2, 3])
+        self._assert_almost_equal_both(np.array([1, 2, 3]), [1, 2, 3])
+
+        # Can't compare generators
+        self._assert_not_almost_equal_both(iter([1, 2, 3]), [1, 2, 3])
+
+        self._assert_not_almost_equal_both([1, 2, 3], [1, 2, 4])
+        self._assert_not_almost_equal_both([1, 2, 3], [1, 2, 3, 4])
+        self._assert_not_almost_equal_both([1, 2, 3], 1)
+
+    def test_assert_almost_equal_null(self):
+        self._assert_almost_equal_both(None, None)
+        self._assert_almost_equal_both(None, np.NaN)
+
+        self._assert_not_almost_equal_both(None, 0)
+        self._assert_not_almost_equal_both(np.NaN, 0)
+
+    def test_assert_almost_equal_inf(self):
+        self._assert_almost_equal_both(np.inf, np.inf)
+        self._assert_almost_equal_both(np.inf, float("inf"))
+
+        self._assert_not_almost_equal_both(np.inf, 0)
+
+class TestUtilTesting(unittest.TestCase):
+    _multiprocess_can_split_ = True
 
     def test_raise_with_traceback(self):
         with assertRaisesRegexp(LookupError, "error_text"):