MAINT: clean up assert_array_compare a bit further.

This brought to light two bugs in tests, which are fixed here, viz.,
that a sample ndarray subclass that tested propagation of an added
parameter was incomplete, in that in propagating the parameter in
__array_wrap__ it assumed it was there on self, but that assumption
could be broken when a view of self was taken (as is done by
x[~flagged] in the test routine), since there was no
__array_finalize__ defined.

The other subclass bug counted, incorrectly, on only needing to provide
one type of comparison, the __lt__ being explicitly tested.  But flags
are compared with __eq__ and those flags will have the same subclass.

1 files changed, 13 insertions, 10 deletions

diff --git a/numpy/testing/_private/utils.py b/numpy/testing/_private/utils.py
index 5b7e35366..f8bfe0ba9 100644
--- a/numpy/testing/_private/utils.py
+++ b/numpy/testing/_private/utils.py
@@ -685,7 +685,7 @@ def assert_array_compare(comparison, x, y, err_msg='', verbose=True,
                          header='', precision=6, equal_nan=True,
                          equal_inf=True):
     __tracebackhide__ = True  # Hide traceback for py.test
-    from numpy.core import array, isnan, any, inf, ndim
+    from numpy.core import array, isnan, inf, bool_
     x = array(x, copy=False, subok=True)
     y = array(y, copy=False, subok=True)
 
@@ -698,14 +698,12 @@ def assert_array_compare(comparison, x, y, err_msg='', verbose=True,
     def func_assert_same_pos(x, y, func=isnan, hasval='nan'):
         """Handling nan/inf: combine results of running func on x and y,
         checking that they are True at the same locations."""
+        # Both the != True comparison here and the cast to bool_ at
+        # the end are done to deal with `masked`, which cannot be
+        # compared usefully, and for which .all() yields masked.
         x_id = func(x)
         y_id = func(y)
-        if not any(x_id) and not any(y_id):
-            return False
-
-        try:
-            assert_array_equal(x_id, y_id)
-        except AssertionError:
+        if (x_id == y_id).all() != True:
             msg = build_err_msg([x, y],
                                 err_msg + '\nx and y %s location mismatch:'
                                 % (hasval), verbose=verbose, header=header,
@@ -713,7 +711,12 @@ def assert_array_compare(comparison, x, y, err_msg='', verbose=True,
             raise AssertionError(msg)
         # If there is a scalar, then here we know the array has the same
         # flag as it everywhere, so we should return the scalar flag.
-        return x_id if x_id.ndim == 0 else y_id
+        if x_id.ndim == 0:
+            return bool_(x_id)
+        elif y_id.ndim == 0:
+            return bool_(y_id)
+        else:
+            return y_id
 
     try:
         cond = (x.shape == () or y.shape == ()) or x.shape == y.shape
@@ -726,7 +729,7 @@ def assert_array_compare(comparison, x, y, err_msg='', verbose=True,
                                 names=('x', 'y'), precision=precision)
             raise AssertionError(msg)
 
-        flagged = False
+        flagged = bool_(False)
         if isnumber(x) and isnumber(y):
             if equal_nan:
                 flagged = func_assert_same_pos(x, y, func=isnan, hasval='nan')
@@ -744,7 +747,7 @@ def assert_array_compare(comparison, x, y, err_msg='', verbose=True,
             if equal_nan and x.dtype.type == y.dtype.type:
                 flagged = func_assert_same_pos(x, y, func=isnat, hasval="NaT")
 
-        if ndim(flagged):
+        if flagged.ndim > 0:
             x, y = x[~flagged], y[~flagged]
             # Only do the comparison if actual values are left
             if x.size == 0: