TEST: Suppress and check warnings in streamlines

Author: effigies

nibabel/streamlines/tests/test_array_sequence.py

@@ -100,7 +100,8 @@ def test_creating_arraysequence_from_generator(self):
         seq_with_buffer = ArraySequence(gen_2, buffer_size=256)
 
         # Check buffer size effect
-        assert seq_with_buffer.data.shape == seq.data.shape
+        with pytest.warns(Warning):
+            assert seq_with_buffer.data.shape == seq.data.shape
         assert seq_with_buffer._buffer_size > seq._buffer_size
 
         # Check generator result

nibabel/streamlines/tests/test_streamlines.py

@@ -3,6 +3,8 @@
 import tempfile
 import numpy as np
 
+import pytest
+
 from os.path import join as pjoin
 
 import nibabel as nib
@@ -140,8 +142,10 @@ def test_load_empty_file(self):
                 else:
                     assert type(tfile.tractogram), LazyTractogram
 
-                assert_tractogram_equal(tfile.tractogram,
-                                        DATA['empty_tractogram'])
+                with pytest.warns(None) as w:
+                    assert_tractogram_equal(tfile.tractogram,
+                                            DATA['empty_tractogram'])
+                assert len(w) == lazy_load
 
     def test_load_simple_file(self):
         for lazy_load in [False, True]:
@@ -155,8 +159,10 @@ def test_load_simple_file(self):
                 else:
                     assert type(tfile.tractogram), LazyTractogram
 
-                assert_tractogram_equal(tfile.tractogram,
-                                        DATA['simple_tractogram'])
+                with pytest.warns(None) as w:
+                    assert_tractogram_equal(tfile.tractogram,
+                                            DATA['simple_tractogram'])
+                assert len(w) == lazy_load
 
     def test_load_complex_file(self):
         for lazy_load in [False, True]:
@@ -180,8 +186,10 @@ def test_load_complex_file(self):
                     data = DATA['data_per_streamline']
                     tractogram.data_per_streamline = data
 
-                assert_tractogram_equal(tfile.tractogram,
-                                        tractogram)
+                with pytest.warns(None) as w:
+                    assert_tractogram_equal(tfile.tractogram,
+                                            tractogram)
+                assert len(w) == lazy_load
 
     def test_save_tractogram_file(self):
         tractogram = Tractogram(DATA['streamlines'],
@@ -193,15 +201,14 @@ def test_save_tractogram_file(self):
             nib.streamlines.save(trk_file, "dummy.trk", header={})
 
         # Wrong extension.
-        with clear_and_catch_warnings(record=True,
-                                      modules=[nib.streamlines]) as w:
+        with pytest.warns(None) as w:
             trk_file = trk.TrkFile(tractogram)
             with self.assertRaises(ValueError):
                 nib.streamlines.save(trk_file, "dummy.tck", header={})
 
-            assert len(w) == 1
-            assert issubclass(w[0].category, ExtensionWarning)
-            assert "extension" in str(w[0].message)
+        assert len(w) == 1
+        assert issubclass(w[0].category, ExtensionWarning)
+        assert "extension" in str(w[0].message)
 
         with InTemporaryDirectory():
             nib.streamlines.save(trk_file, "dummy.trk")
@@ -237,33 +244,32 @@ def test_save_complex_file(self):
             with InTemporaryDirectory():
                 filename = 'streamlines' + ext
 
-                with clear_and_catch_warnings(record=True,
-                                              modules=[trk]) as w:
+                with pytest.warns(None) as w:
                     nib.streamlines.save(complex_tractogram, filename)
 
-                    # If streamlines format does not support saving data
-                    # per point or data per streamline, warning messages
-                    # should be issued.
-                    nb_expected_warnings = \
-                        ((not cls.SUPPORTS_DATA_PER_POINT) +
-                         (not cls.SUPPORTS_DATA_PER_STREAMLINE))
+                # If streamlines format does not support saving data
+                # per point or data per streamline, warning messages
+                # should be issued.
+                nb_expected_warnings = \
+                    ((not cls.SUPPORTS_DATA_PER_POINT) +
+                     (not cls.SUPPORTS_DATA_PER_STREAMLINE))
 
-                    assert len(w) == nb_expected_warnings
-                    for i in range(nb_expected_warnings):
-                        assert issubclass(w[i].category, Warning)
+                assert len(w) == nb_expected_warnings
+                for i in range(nb_expected_warnings):
+                    assert issubclass(w[i].category, Warning)
 
-                    tractogram = Tractogram(DATA['streamlines'],
-                                            affine_to_rasmm=np.eye(4))
+                tractogram = Tractogram(DATA['streamlines'],
+                                        affine_to_rasmm=np.eye(4))
 
-                    if cls.SUPPORTS_DATA_PER_POINT:
-                        tractogram.data_per_point = DATA['data_per_point']
+                if cls.SUPPORTS_DATA_PER_POINT:
+                    tractogram.data_per_point = DATA['data_per_point']
 
-                    if cls.SUPPORTS_DATA_PER_STREAMLINE:
-                        data = DATA['data_per_streamline']
-                        tractogram.data_per_streamline = data
+                if cls.SUPPORTS_DATA_PER_STREAMLINE:
+                    data = DATA['data_per_streamline']
+                    tractogram.data_per_streamline = data
 
-                    tfile = nib.streamlines.load(filename, lazy_load=False)
-                    assert_tractogram_equal(tfile.tractogram, tractogram)
+                tfile = nib.streamlines.load(filename, lazy_load=False)
+                assert_tractogram_equal(tfile.tractogram, tractogram)
 
     def test_save_sliced_tractogram(self):
         tractogram = Tractogram(DATA['streamlines'],

nibabel/streamlines/tests/test_tck.py

@@ -4,7 +4,6 @@
 from os.path import join as pjoin
 
 from io import BytesIO
-from nibabel.py3k import asbytes
 
 from ..array_sequence import ArraySequence
 from ..tractogram import Tractogram
@@ -48,12 +47,16 @@ class TestTCK(unittest.TestCase):
     def test_load_empty_file(self):
         for lazy_load in [False, True]:
             tck = TckFile.load(DATA['empty_tck_fname'], lazy_load=lazy_load)
-            assert_tractogram_equal(tck.tractogram, DATA['empty_tractogram'])
+            with pytest.warns(None) as w:
+                assert_tractogram_equal(tck.tractogram, DATA['empty_tractogram'])
+            assert len(w) == lazy_load
 
     def test_load_simple_file(self):
         for lazy_load in [False, True]:
             tck = TckFile.load(DATA['simple_tck_fname'], lazy_load=lazy_load)
-            assert_tractogram_equal(tck.tractogram, DATA['simple_tractogram'])
+            with pytest.warns(None) as w:
+                assert_tractogram_equal(tck.tractogram, DATA['simple_tractogram'])
+            assert len(w) == lazy_load
 
         # Force TCK loading to use buffering.
         buffer_size = 1. / 1024**2  # 1 bytes
@@ -87,44 +90,42 @@ def test_load_simple_file_in_big_endian(self):
         for lazy_load in [False, True]:
             tck = TckFile.load(DATA['simple_tck_big_endian_fname'],
                                lazy_load=lazy_load)
-            assert_tractogram_equal(tck.tractogram, DATA['simple_tractogram'])
+            with pytest.warns(None) as w:
+                assert_tractogram_equal(tck.tractogram, DATA['simple_tractogram'])
+            assert len(w) == lazy_load
             assert tck.header['datatype'] == 'Float32BE'
 
     def test_load_file_with_wrong_information(self):
         tck_file = open(DATA['simple_tck_fname'], 'rb').read()
 
         # Simulate a TCK file where `datatype` has not the right endianness.
-        new_tck_file = tck_file.replace(asbytes("Float32LE"),
-                                        asbytes("Float32BE"))
+        new_tck_file = tck_file.replace(b"Float32LE", b"Float32BE")
 
         with pytest.raises(DataError):
             TckFile.load(BytesIO(new_tck_file))
 
         # Simulate a TCK file with unsupported `datatype`.
-        new_tck_file = tck_file.replace(asbytes("Float32LE"),
-                                        asbytes("int32"))
+        new_tck_file = tck_file.replace(b"Float32LE", b"int32")
         with pytest.raises(HeaderError):
             TckFile.load(BytesIO(new_tck_file))
 
         # Simulate a TCK file with no `datatype` field.
         new_tck_file = tck_file.replace(b"datatype: Float32LE\n", b"")
         # Need to adjust data offset.
         new_tck_file = new_tck_file.replace(b"file: . 67\n", b"file: . 47\n")
-        with clear_and_catch_warnings(record=True, modules=[tck_module]) as w:
+        with pytest.warns(HeaderWarning) as w:
             tck = TckFile.load(BytesIO(new_tck_file))
-            assert len(w) == 1
-            assert issubclass(w[0].category, HeaderWarning)
-            assert "Missing 'datatype'" in str(w[0].message)
-            assert_array_equal(tck.header['datatype'], "Float32LE")
+        assert len(w) == 1
+        assert "Missing 'datatype'" in str(w[0].message)
+        assert_array_equal(tck.header['datatype'], "Float32LE")
 
         # Simulate a TCK file with no `file` field.
         new_tck_file = tck_file.replace(b"\nfile: . 67", b"")
-        with clear_and_catch_warnings(record=True, modules=[tck_module]) as w:
+        with pytest.warns(HeaderWarning) as w:
             tck = TckFile.load(BytesIO(new_tck_file))
-            assert len(w) == 1
-            assert issubclass(w[0].category, HeaderWarning)
-            assert "Missing 'file'" in str(w[0].message)
-            assert_array_equal(tck.header['file'], ". 56")
+        assert len(w) == 1
+        assert "Missing 'file'" in str(w[0].message)
+        assert_array_equal(tck.header['file'], ". 56")
 
         # Simulate a TCK file with `file` field pointing to another file.
         new_tck_file = tck_file.replace(b"file: . 67\n",

nibabel/streamlines/tests/test_tractogram.py

@@ -811,7 +811,8 @@ def test_lazy_tractogram_creation(self):
 
         # Empty `LazyTractogram`
         tractogram = LazyTractogram()
-        check_tractogram(tractogram)
+        with pytest.warns(Warning):
+            check_tractogram(tractogram)
         assert tractogram.affine_to_rasmm is None
 
         # Create tractogram with streamlines and other data
@@ -832,7 +833,8 @@ def test_lazy_tractogram_creation(self):
     def test_lazy_tractogram_from_data_func(self):
         # Create an empty `LazyTractogram` yielding nothing.
         tractogram = LazyTractogram.from_data_func(lambda: iter([]))
-        check_tractogram(tractogram)
+        with pytest.warns(Warning):
+            check_tractogram(tractogram)
 
         # Create `LazyTractogram` from a generator function yielding
         # TractogramItem.
@@ -852,7 +854,8 @@ def _data_gen():
                                      data_for_points)
 
         tractogram = LazyTractogram.from_data_func(_data_gen)
-        assert_tractogram_equal(tractogram, DATA['tractogram'])
+        with pytest.warns(Warning):
+            assert_tractogram_equal(tractogram, DATA['tractogram'])
 
         # Creating a LazyTractogram from not a corouting should raise an error.
         with pytest.raises(TypeError):
@@ -921,10 +924,11 @@ def test_lazy_tractogram_apply_affine(self):
         assert_array_equal(transformed_tractogram._affine_to_apply, affine)
         assert_array_equal(transformed_tractogram.affine_to_rasmm,
                            np.dot(np.eye(4), np.linalg.inv(affine)))
-        check_tractogram(transformed_tractogram,
-                         streamlines=[s*scaling for s in DATA['streamlines']],
-                         data_per_streamline=DATA['data_per_streamline'],
-                         data_per_point=DATA['data_per_point'])
+        with pytest.warns(Warning):
+            check_tractogram(transformed_tractogram,
+                             streamlines=[s*scaling for s in DATA['streamlines']],
+                             data_per_streamline=DATA['data_per_streamline'],
+                             data_per_point=DATA['data_per_point'])
 
         # Apply affine again and check the affine_to_rasmm.
         transformed_tractogram = transformed_tractogram.apply_affine(affine)
@@ -946,10 +950,11 @@ def test_lazy_tractogram_apply_affine(self):
         transformed_tractogram = tractogram.apply_affine(affine)
         assert_array_equal(transformed_tractogram._affine_to_apply, affine)
         assert transformed_tractogram.affine_to_rasmm is None
-        check_tractogram(transformed_tractogram,
-                         streamlines=[s*scaling for s in DATA['streamlines']],
-                         data_per_streamline=DATA['data_per_streamline'],
-                         data_per_point=DATA['data_per_point'])
+        with pytest.warns(Warning):
+            check_tractogram(transformed_tractogram,
+                             streamlines=[s*scaling for s in DATA['streamlines']],
+                             data_per_streamline=DATA['data_per_streamline'],
+                             data_per_point=DATA['data_per_point'])
 
         # Calling apply_affine with lazy=False should fail for LazyTractogram.
         tractogram = DATA['lazy_tractogram'].copy()
@@ -1019,4 +1024,5 @@ def test_lazy_tractogram_copy(self):
                            DATA['lazy_tractogram']._affine_to_apply)
 
         # Check the data are the equivalent.
-        assert_tractogram_equal(tractogram, DATA['tractogram'])
+        with pytest.warns(Warning):
+            assert_tractogram_equal(tractogram, DATA['tractogram'])

nibabel/streamlines/tests/test_trk.py

@@ -87,17 +87,23 @@ class TestTRK(unittest.TestCase):
     def test_load_empty_file(self):
         for lazy_load in [False, True]:
             trk = TrkFile.load(DATA['empty_trk_fname'], lazy_load=lazy_load)
-            assert_tractogram_equal(trk.tractogram, DATA['empty_tractogram'])
+            with pytest.warns(None) as w:
+                assert_tractogram_equal(trk.tractogram, DATA['empty_tractogram'])
+            assert len(w) == lazy_load
 
     def test_load_simple_file(self):
         for lazy_load in [False, True]:
             trk = TrkFile.load(DATA['simple_trk_fname'], lazy_load=lazy_load)
-            assert_tractogram_equal(trk.tractogram, DATA['simple_tractogram'])
+            with pytest.warns(None) as w:
+                assert_tractogram_equal(trk.tractogram, DATA['simple_tractogram'])
+            assert len(w) == lazy_load
 
     def test_load_complex_file(self):
         for lazy_load in [False, True]:
             trk = TrkFile.load(DATA['complex_trk_fname'], lazy_load=lazy_load)
-            assert_tractogram_equal(trk.tractogram, DATA['complex_tractogram'])
+            with pytest.warns(None) as w:
+                assert_tractogram_equal(trk.tractogram, DATA['complex_tractogram'])
+            assert len(w) == lazy_load
 
     def trk_with_bytes(self, trk_key='simple_trk_fname', endian='<'):
         """ Return example trk file bytes and struct view onto bytes """
@@ -129,12 +135,11 @@ def test_load_file_with_wrong_information(self):
         # Simulate a TRK where `vox_to_ras` is not recorded (i.e. all zeros).
         trk_struct, trk_bytes = self.trk_with_bytes()
         trk_struct[Field.VOXEL_TO_RASMM] = np.zeros((4, 4))
-        with clear_and_catch_warnings(record=True, modules=[trk_module]) as w:
+        with pytest.warns(HeaderWarning) as w:
             trk = TrkFile.load(BytesIO(trk_bytes))
-            assert len(w) == 1
-            assert issubclass(w[0].category, HeaderWarning)
-            assert "identity" in str(w[0].message)
-            assert_array_equal(trk.affine, np.eye(4))
+        assert len(w) == 1
+        assert "identity" in str(w[0].message)
+        assert_array_equal(trk.affine, np.eye(4))
 
         # Simulate a TRK where `vox_to_ras` is invalid.
         trk_struct, trk_bytes = self.trk_with_bytes()
@@ -146,11 +151,10 @@ def test_load_file_with_wrong_information(self):
         # Simulate a TRK file where `voxel_order` was not provided.
         trk_struct, trk_bytes = self.trk_with_bytes()
         trk_struct[Field.VOXEL_ORDER] = b''
-        with clear_and_catch_warnings(record=True, modules=[trk_module]) as w:
+        with pytest.warns(HeaderWarning) as w:
             TrkFile.load(BytesIO(trk_bytes))
-            assert len(w) == 1
-            assert issubclass(w[0].category, HeaderWarning)
-            assert "LPS" in str(w[0].message)
+        assert len(w) == 1
+        assert "LPS" in str(w[0].message)
 
         # Simulate a TRK file with an unsupported version.
         trk_struct, trk_bytes = self.trk_with_bytes()
@@ -186,13 +190,12 @@ def test_load_trk_version_1(self):
         assert_array_equal(trk.affine, np.diag([2, 3, 4, 1]))
         # Next check that affine assumed identity if version 1.
         trk_struct['version'] = 1
-        with clear_and_catch_warnings(record=True, modules=[trk_module]) as w:
+        with pytest.warns(HeaderWarning) as w:
             trk = TrkFile.load(BytesIO(trk_bytes))
-            assert len(w) == 1
-            assert issubclass(w[0].category, HeaderWarning)
-            assert "identity" in str(w[0].message)
-            assert_array_equal(trk.affine, np.eye(4))
-            assert_array_equal(trk.header['version'], 1)
+        assert len(w) == 1
+        assert "identity" in str(w[0].message)
+        assert_array_equal(trk.affine, np.eye(4))
+        assert_array_equal(trk.header['version'], 1)
 
     def test_load_complex_file_in_big_endian(self):
         trk_struct, trk_bytes = self.trk_with_bytes(
@@ -206,7 +209,9 @@ def test_load_complex_file_in_big_endian(self):
         for lazy_load in [False, True]:
             trk = TrkFile.load(DATA['complex_trk_big_endian_fname'],
                                lazy_load=lazy_load)
-            assert_tractogram_equal(trk.tractogram, DATA['complex_tractogram'])
+            with pytest.warns(None) as w:
+                assert_tractogram_equal(trk.tractogram, DATA['complex_tractogram'])
+            assert len(w) == lazy_load
 
     def test_tractogram_file_properties(self):
         trk = TrkFile.load(DATA['simple_trk_fname'])