TEST: Convert FreeSurfer tests to pytest

nibabel/freesurfer/tests/test_io.py

@@ -9,17 +9,18 @@
 
 from ...tmpdirs import InTemporaryDirectory
 
-from nose.tools import assert_true
+
+import pytest
 import numpy as np
-from numpy.testing import assert_equal, assert_raises, dec, assert_allclose, assert_array_equal
+from numpy.testing import assert_allclose, assert_array_equal
 
 from .. import (read_geometry, read_morph_data, read_annot, read_label,
                 write_geometry, write_morph_data, write_annot)
 from ..io import _pack_rgb
 
 from ...tests.nibabel_data import get_nibabel_data, needs_nibabel_data
 from ...fileslice import strided_scalar
-from ...testing import clear_and_catch_warnings
+from ...testing_pytest import clear_and_catch_warnings
 
 DATA_SDIR = 'fsaverage'
 
@@ -35,10 +36,7 @@
         data_path = pjoin(nib_data, 'nitest-freesurfer', DATA_SDIR)
         have_freesurfer = isdir(data_path)
 
-freesurfer_test = dec.skipif(
-    not have_freesurfer,
-    'cannot find freesurfer {0} directory'.format(DATA_SDIR))
-
+freesurfer_test = pytest.mark.skipif(not have_freesurfer, reason='cannot find freesurfer {0} directory'.format(DATA_SDIR))
 
 def _hash_file_content(fname):
     hasher = hashlib.md5()
@@ -53,19 +51,19 @@ def test_geometry():
     """Test IO of .surf"""
     surf_path = pjoin(data_path, "surf", "%s.%s" % ("lh", "inflated"))
     coords, faces = read_geometry(surf_path)
-    assert_equal(0, faces.min())
-    assert_equal(coords.shape[0], faces.max() + 1)
+    assert 0 == faces.min()
+    assert coords.shape[0] == faces.max() + 1
 
     surf_path = pjoin(data_path, "surf", "%s.%s" % ("lh", "sphere"))
     coords, faces, volume_info, create_stamp = read_geometry(
         surf_path, read_metadata=True, read_stamp=True)
 
-    assert_equal(0, faces.min())
-    assert_equal(coords.shape[0], faces.max() + 1)
-    assert_equal(9, len(volume_info))
-    assert_equal([2, 0, 20], volume_info['head'])
-    assert_equal(u'created by greve on Thu Jun  8 19:17:51 2006',
-                 create_stamp)
+    assert 0 == faces.min()
+    assert coords.shape[0] == (faces.max() + 1)
+    assert 9 == len(volume_info)
+   # assert np.array_equal([2, 0, 20],volume_info['head'])
+    np.testing.assert_array_equal([2, 0, 20],volume_info['head'])
+    assert create_stamp == ['created by greve on Thu Jun  8 19:17:51 2006'] # this creates assertion error - should we just remove it?
 
     # Test equivalence of freesurfer- and nibabel-generated triangular files
     # with respect to read_geometry()
@@ -82,7 +80,8 @@ def test_geometry():
         for key in ('xras', 'yras', 'zras', 'cras'):
             assert_allclose(volume_info2[key], volume_info[key],
                             rtol=1e-7, atol=1e-30)
-        assert_equal(volume_info2['cras'], volume_info['cras'])
+        #assert.array_equal(volume_info2['cras'], volume_info['cras'])
+        np.testing.assert_array_equal(volume_info2['cras'], volume_info['cras'])
         with open(surf_path, 'rb') as fobj:
             np.fromfile(fobj, ">u1", 3)
             read_create_stamp = fobj.readline().decode().rstrip('\n')
@@ -92,18 +91,19 @@ def test_geometry():
         with clear_and_catch_warnings() as w:
             warnings.filterwarnings('always', category=DeprecationWarning)
             read_geometry(surf_path, read_metadata=True)
-        assert_true(any('volume information contained' in str(ww.message)
+        assert(any('volume information contained' in str(ww.message)
                         for ww in w))
-        assert_true(any('extension code' in str(ww.message) for ww in w))
+        assert(any('extension code' in str(ww.message) for ww in w))
         volume_info['head'] = [1, 2]
         with clear_and_catch_warnings() as w:
             write_geometry(surf_path, coords, faces, create_stamp, volume_info)
-        assert_true(any('Unknown extension' in str(ww.message) for ww in w))
+        assert(any('Unknown extension' in str(ww.message) for ww in w))
         volume_info['a'] = 0
-        assert_raises(ValueError, write_geometry, surf_path, coords,
-                      faces, create_stamp, volume_info)
+        with pytest.raises(ValueError):
+            write_geometry(surf_path, coords, faces, create_stamp, volume_info)
+
 
-    assert_equal(create_stamp, read_create_stamp)
+    assert create_stamp == read_create_stamp
 
     np.testing.assert_array_equal(coords, coords2)
     np.testing.assert_array_equal(faces, faces2)
@@ -122,28 +122,28 @@ def test_quad_geometry():
     new_quad = pjoin(get_nibabel_data(), 'nitest-freesurfer', 'subjects',
                      'bert', 'surf', 'lh.inflated.nofix')
     coords, faces = read_geometry(new_quad)
-    assert_equal(0, faces.min())
-    assert_equal(coords.shape[0], faces.max() + 1)
+    assert 0 == faces.min()
+    assert coords.shape[0] == (faces.max() + 1)
     with InTemporaryDirectory():
         new_path = 'test'
         write_geometry(new_path, coords, faces)
         coords2, faces2 = read_geometry(new_path)
-        assert_equal(coords, coords2)
-        assert_equal(faces, faces2)
+        assert np.array_equal(coords,coords2)
+        assert np.array_equal(faces, faces2)
 
 
 @freesurfer_test
 def test_morph_data():
     """Test IO of morphometry data file (eg. curvature)."""
     curv_path = pjoin(data_path, "surf", "%s.%s" % ("lh", "curv"))
     curv = read_morph_data(curv_path)
-    assert_true(-1.0 < curv.min() < 0)
-    assert_true(0 < curv.max() < 1.0)
+    assert -1.0 < curv.min() < 0
+    assert 0 < curv.max() < 1.0
     with InTemporaryDirectory():
         new_path = 'test'
         write_morph_data(new_path, curv)
         curv2 = read_morph_data(new_path)
-        assert_equal(curv2, curv)
+        assert np.array_equal (curv2, curv)
 
 
 def test_write_morph_data():
@@ -156,17 +156,17 @@ def test_write_morph_data():
         for shape in okay_shapes:
             write_morph_data('test.curv', values.reshape(shape))
             # Check ordering is preserved, regardless of shape
-            assert_equal(values, read_morph_data('test.curv'))
-        assert_raises(ValueError, write_morph_data, 'test.curv',
-                      np.zeros(shape), big_num)
-        # Windows 32-bit overflows Python int
+            assert np.array_equal(read_morph_data('test.curv') ,values)
+        with pytest.raises(ValueError):
+            write_morph_data('test.curv', np.zeros(shape), big_num)
+                # Windows 32-bit overflows Python int
         if np.dtype(np.int) != np.dtype(np.int32):
-            assert_raises(ValueError, write_morph_data, 'test.curv',
-                          strided_scalar((big_num,)))
+            with pytest.raises(ValueError):
+                write_morph_data('test.curv',  strided_scalar((big_num,)))
         for shape in bad_shapes:
-            assert_raises(ValueError, write_morph_data, 'test.curv',
-                          values.reshape(shape))
-
+            with pytest.raises(ValueError):
+                write_morph_data('test.curv', values.reshape(shape))
+            
 
 @freesurfer_test
 def test_annot():
@@ -177,18 +177,18 @@ def test_annot():
         hash_ = _hash_file_content(annot_path)
 
         labels, ctab, names = read_annot(annot_path)
-        assert_true(labels.shape == (163842, ))
-        assert_true(ctab.shape == (len(names), 5))
+        assert labels.shape == (163842, )
+        assert ctab.shape == (len(names), 5)
 
         labels_orig = None
         if a == 'aparc':
             labels_orig, _, _ = read_annot(annot_path, orig_ids=True)
             np.testing.assert_array_equal(labels == -1, labels_orig == 0)
             # Handle different version of fsaverage
             if hash_ == 'bf0b488994657435cdddac5f107d21e8':
-                assert_true(np.sum(labels_orig == 0) == 13887)
+                assert np.sum(labels_orig == 0) == 13887
             elif hash_ == 'd4f5b7cbc2ed363ac6fcf89e19353504':
-                assert_true(np.sum(labels_orig == 1639705) == 13327)
+                assert np.sum(labels_orig == 1639705) == 13327
             else:
                 raise RuntimeError("Unknown freesurfer file. Please report "
                                    "the problem to the maintainer of nibabel.")
@@ -207,7 +207,7 @@ def test_annot():
         if labels_orig is not None:
             np.testing.assert_array_equal(labels_orig, labels_orig_2)
         np.testing.assert_array_equal(ctab, ctab2)
-        assert_equal(names, names2)
+        assert names == names2
 
 
 def test_read_write_annot():
@@ -272,7 +272,7 @@ def test_write_annot_fill_ctab():
         print(labels)
         with clear_and_catch_warnings() as w:
             write_annot(annot_path, labels, rgbal, names, fill_ctab=False)
-        assert_true(
+        assert (
             any('Annotation values in {} will be incorrect'.format(
                 annot_path) == str(ww.message) for ww in w))
         labels2, rgbal2, names2 = read_annot(annot_path, orig_ids=True)
@@ -288,7 +288,7 @@ def test_write_annot_fill_ctab():
                        rgbal[:, 2] * (2 ** 16))
         with clear_and_catch_warnings() as w:
             write_annot(annot_path, labels, rgbal, names, fill_ctab=False)
-        assert_true(
+        assert(
             not any('Annotation values in {} will be incorrect'.format(
                 annot_path) == str(ww.message) for ww in w))
         labels2, rgbal2, names2 = read_annot(annot_path)
@@ -348,13 +348,13 @@ def test_label():
     label_path = pjoin(data_path, "label", "lh.cortex.label")
     label = read_label(label_path)
     # XXX : test more
-    assert_true(label.min() >= 0)
-    assert_true(label.max() <= 163841)
-    assert_true(label.shape[0] <= 163842)
+    assert label.min() >= 0
+    assert label.max() <= 163841
+    assert label.shape[0] <= 163842
 
     labels, scalars = read_label(label_path, True)
-    assert_true(np.all(labels == label))
-    assert_true(len(labels) == len(scalars))
+    assert (np.all(labels == label))
+    assert len(labels) == len(scalars)
 
 
 def test_write_annot_maxstruct():
@@ -373,4 +373,4 @@ def test_write_annot_maxstruct():
         # Check round-trip
         assert_array_equal(labels, rt_labels)
         assert_array_equal(rgba, rt_ctab[:, :4])
-        assert_equal(names, [n.decode('ascii') for n in rt_names])
+        assert names == [n.decode('ascii') for n in rt_names]