TST+RF: adapt to new numpy memmap behavior

Numpy memmap behavior changed in upcoming 1.12.  Adapt the tests to the
new behavior when we detect it.  In the process, make the test function
more explicit in input arguments and document the test function.

Author: matthew-brett

nibabel/tests/test_arrayproxy.py

@@ -23,6 +23,7 @@
 from numpy.testing import assert_array_equal, assert_array_almost_equal
 from nose.tools import (assert_true, assert_false, assert_equal,
                         assert_not_equal, assert_raises)
+from nibabel.testing import VIRAL_MEMMAP
 
 from .test_fileslice import slicer_samples
 
@@ -182,10 +183,37 @@ def test_mmap():
     check_mmap(hdr, hdr.get_data_offset(), ArrayProxy)
 
 
-def check_mmap(hdr, offset, proxy_class, check_mode=True):
+def check_mmap(hdr, offset, proxy_class,
+               has_scaling=False,
+               unscaled_is_view=True):
+    """ Assert that array proxies return memory maps as expected
+
+    Parameters
+    ----------
+    hdr : object
+        Image header instance
+    offset : int
+        Offset in bytes of image data in file (that we will write)
+    proxy_class : class
+        Class of image array proxy to test
+    has_scaling : {False, True}
+        True if the `hdr` says to apply scaling to the output data, False
+        otherwise.
+    unscaled_is_view : {True, False}
+        True if getting the unscaled data returns a view of the array.  If
+        False, then type of returned array will depend on whether numpy has the
+        old viral (< 1.12) memmap behavior (returns memmap) or the new behavior
+        (returns ndarray).  See: https://github.com/numpy/numpy/pull/7406
+    """
     shape = hdr.get_data_shape()
     arr = np.arange(np.prod(shape), dtype=hdr.get_data_dtype()).reshape(shape)
     fname = 'test.bin'
+    # Whether unscaled array memory backed by memory map (regardless of what
+    # numpy says).
+    unscaled_really_mmap = unscaled_is_view
+    # Whether scaled array memory backed by memory map (regardless of what
+    # numpy says).
+    scaled_really_mmap = unscaled_really_mmap and not has_scaling
     with InTemporaryDirectory():
         with open(fname, 'wb') as fobj:
             fobj.write(b' ' * offset)
@@ -205,13 +233,17 @@ def check_mmap(hdr, offset, proxy_class, check_mode=True):
             prox = proxy_class(fname, hdr, **kwargs)
             unscaled = prox.get_unscaled()
             back_data = np.asanyarray(prox)
+            unscaled_is_mmap = isinstance(unscaled, np.memmap)
+            back_is_mmap =  isinstance(back_data, np.memmap)
             if expected_mode is None:
-                assert_false(isinstance(unscaled, np.memmap))
-                assert_false(isinstance(back_data, np.memmap))
+                assert_false(unscaled_is_mmap)
+                assert_false(back_is_mmap)
             else:
-                assert_true(isinstance(unscaled, np.memmap))
-                assert_true(isinstance(back_data, np.memmap))
-                if check_mode:
+                assert_equal(unscaled_is_mmap,
+                             VIRAL_MEMMAP or unscaled_really_mmap)
+                assert_equal(back_is_mmap,
+                             VIRAL_MEMMAP or scaled_really_mmap)
+                if scaled_really_mmap:
                     assert_equal(back_data.mode, expected_mode)
             del prox, back_data
             # Check that mmap is keyword-only

nibabel/tests/test_parrec.py

@@ -728,7 +728,9 @@ def test_parrec_proxy():
     # Test PAR / REC proxy class, including mmap flags
     shape = (10, 20, 30, 5)
     hdr = FakeHeader(shape, np.int32)
-    check_mmap(hdr, 0, PARRECArrayProxy, check_mode=False)
+    check_mmap(hdr, 0, PARRECArrayProxy,
+               has_scaling=True,
+               unscaled_is_view=False)
 
 
 class TestPARRECImage(tsi.MmapImageMixin):

nibabel/tests/test_spatialimages.py

@@ -24,7 +24,8 @@
 from numpy.testing import assert_array_equal, assert_array_almost_equal
 
 from .test_helpers import bytesio_round_trip
-from ..testing import clear_and_catch_warnings, suppress_warnings
+from ..testing import (clear_and_catch_warnings, suppress_warnings,
+                       VIRAL_MEMMAP)
 from ..tmpdirs import InTemporaryDirectory
 from .. import load as top_load
 
@@ -384,6 +385,13 @@ def test_load_mmap(self):
                         ('c', 'c'),
                         ('r', 'r'),
                         (False, None)):
+                    # If the image has scaling, then numpy 1.12 will not return
+                    # a memmap, regardless of the input flags.  Previous
+                    # numpies returned a memmap object, even though the array
+                    # has no mmap memory backing.  See:
+                    # https://github.com/numpy/numpy/pull/7406
+                    if has_scaling and not VIRAL_MEMMAP:
+                        expected_mode = None
                     kwargs = {}
                     if mmap is not None:
                         kwargs['mmap'] = mmap