Do not sanitize no-op masks on ndarrays during test assertions.

The existence of a mask is part of the return contract and should be
tested, even if the mask itself is a no-op.

Author: LTLA

tests/test_SparseNdarray.py

@@ -5,7 +5,7 @@
 import numpy
 import pytest
 
-from utils import sanitize_ndarray, assert_identical_ndarrays, assert_close_ndarrays, safe_concatenate, mock_SparseNdarray_contents, simulate_SparseNdarray
+from utils import assert_identical_ndarrays, assert_close_ndarrays, safe_concatenate, mock_SparseNdarray_contents, simulate_SparseNdarray
 
 #######################################################
 #######################################################
@@ -40,12 +40,12 @@ def convert_SparseNdarray_to_numpy(x):
     elif contents is not None:
         _recursive_compute_reference(contents, ndim, triplets)
 
-    output = numpy.ma.MaskedArray(numpy.zeros(shape))
+    output = numpy.zeros(shape)
+    if x.is_masked:
+        output = numpy.ma.MaskedArray(output)
     for pos, val in triplets:
         output[pos] = val
 
-    if isinstance(output.mask, bool) and not output.mask:
-        output = output.data
     return output
 
 
@@ -55,13 +55,10 @@ def _compare_sparse_vectors(left, right):
 
     assert len(idx_l) == len(idx_r)
     assert (idx_l == idx_r).all()
-
-    val_l = sanitize_ndarray(val_l)
-    val_r = sanitize_ndarray(val_r)
     comp = (val_l == val_r)
 
-    masked = numpy.ma.is_masked(val_l) 
-    assert masked == numpy.ma.is_masked(val_r) 
+    masked = numpy.ma.isMaskedArray(val_l) 
+    assert masked == numpy.ma.isMaskedArray(val_r) 
     if masked:
         assert (val_l.mask == val_r.mask).all()
         assert numpy.logical_or(comp, val_r.mask).all()

tests/utils.py

@@ -4,22 +4,9 @@
 import delayedarray
 
 
-def sanitize_ndarray(x: numpy.ndarray):
-    if numpy.ma.is_masked(x):
-        if isinstance(x.mask, bool):
-            if not x.mask:
-                return x.data
-        else:
-            if not x.mask.any():
-                return x.data
-    return x
-
-
 def assert_identical_ndarrays(x: numpy.ndarray, y: numpy.ndarray): 
-    x = sanitize_ndarray(x)
-    y = sanitize_ndarray(y)
-    assert numpy.ma.is_masked(x) == numpy.ma.is_masked(y)
-    if numpy.ma.is_masked(x):
+    assert numpy.ma.isMaskedArray(x) == numpy.ma.isMaskedArray(y)
+    if numpy.ma.isMaskedArray(x):
         assert (x.mask == y.mask).all()
         comp = is_equal_with_nan(x.data, y.data)
         remask = numpy.logical_or(numpy.zeros(x.shape), x.mask) # using an OR to force broadcasting of buggy masks of different shape.
@@ -38,10 +25,8 @@ def is_equal_with_nan(left: numpy.ndarray, right: numpy.ndarray):
 
 
 def assert_close_ndarrays(x: numpy.ndarray, y: numpy.ndarray): 
-    x = sanitize_ndarray(x)
-    y = sanitize_ndarray(y)
-    assert numpy.ma.is_masked(x) == numpy.ma.is_masked(y)
-    if numpy.ma.is_masked(x):
+    assert numpy.ma.isMaskedArray(x) == numpy.ma.isMaskedArray(y)
+    if numpy.ma.isMaskedArray(x):
         assert (x.mask == y.mask).all()
         comp = is_close_with_nan(x.data, y.data)
         remask = numpy.logical_or(numpy.zeros(x.shape, dtype=numpy.bool_), x.mask) # using an OR to force broadcasting of buggy masks of different shape.
@@ -60,7 +45,7 @@ def is_close_with_nan(left: numpy.ndarray, right: numpy.ndarray):
 
 
 def safe_concatenate(x: List[numpy.ndarray], axis: int = 0):
-    if any(numpy.ma.is_masked(y) for y in x):
+    if any(numpy.ma.isMaskedArray(y) for y in x):
         return numpy.ma.concatenate(x, axis=axis)
     else:
         return numpy.concatenate(x, axis=axis)