TEST: pytest conversion #864 #865

Author: robbisg

nibabel/streamlines/tests/test_array_sequence.py

@@ -5,8 +5,8 @@
 import itertools
 import numpy as np
 
-from nose.tools import assert_equal, assert_raises, assert_true
-from nibabel.testing import assert_arrays_equal
+import pytest
+from nibabel.testing_pytest import assert_arrays_equal
 from numpy.testing import assert_array_equal
 
 import pytest; pytestmark = pytest.mark.skip()
@@ -17,7 +17,7 @@
 SEQ_DATA = {}
 
 
-def setup():
+def setup_module():
     global SEQ_DATA
     rng = np.random.RandomState(42)
     SEQ_DATA['rng'] = rng
@@ -32,22 +32,25 @@ def generate_data(nb_arrays, common_shape, rng):
 
 
 def check_empty_arr_seq(seq):
-    assert_equal(len(seq), 0)
-    assert_equal(len(seq._offsets), 0)
-    assert_equal(len(seq._lengths), 0)
+    assert len(seq) == 0
+    assert len(seq._offsets) == 0
+    assert len(seq._lengths) == 0
     # assert_equal(seq._data.ndim, 0)
-    assert_equal(seq._data.ndim, 1)
-    assert_true(seq.common_shape == ())
+    assert seq._data.ndim == 1
+    
+    # TODO: Check assert_true
+    # assert_true(seq.common_shape == ())
 
 
 def check_arr_seq(seq, arrays):
     lengths = list(map(len, arrays))
-    assert_true(is_array_sequence(seq))
-    assert_equal(len(seq), len(arrays))
-    assert_equal(len(seq._offsets), len(arrays))
-    assert_equal(len(seq._lengths), len(arrays))
-    assert_equal(seq._data.shape[1:], arrays[0].shape[1:])
-    assert_equal(seq.common_shape, arrays[0].shape[1:])
+    assert is_array_sequence(seq) == True
+    assert len(seq) == len(arrays)
+    assert len(seq._offsets) == len(arrays)
+    assert len(seq._lengths) == len(arrays)
+    assert seq._data.shape[1:] == arrays[0].shape[1:]
+    assert seq.common_shape == arrays[0].shape[1:]
+    
     assert_arrays_equal(seq, arrays)
 
     # If seq is a view, then order of internal data is not guaranteed.
@@ -56,18 +59,20 @@ def check_arr_seq(seq, arrays):
         assert_array_equal(sorted(seq._lengths), sorted(lengths))
     else:
         seq.shrink_data()
-        assert_equal(seq._data.shape[0], sum(lengths))
+        
+        assert seq._data.shape[0] == sum(lengths)
+        
         assert_array_equal(seq._data, np.concatenate(arrays, axis=0))
         assert_array_equal(seq._offsets, np.r_[0, np.cumsum(lengths)[:-1]])
         assert_array_equal(seq._lengths, lengths)
 
 
 def check_arr_seq_view(seq_view, seq):
-    assert_true(seq_view._is_view)
-    assert_true(seq_view is not seq)
-    assert_true(np.may_share_memory(seq_view._data, seq._data))
-    assert_true(seq_view._offsets is not seq._offsets)
-    assert_true(seq_view._lengths is not seq._lengths)
+    assert seq_view._is_view is True
+    assert (seq_view is not seq) is True
+    assert (np.may_share_memory(seq_view._data, seq._data)) is True
+    assert seq_view._offsets is not seq._offsets
+    assert seq_view._lengths is not seq._lengths
 
 
 class TestArraySequence(unittest.TestCase):
@@ -99,8 +104,8 @@ def test_creating_arraysequence_from_generator(self):
         seq_with_buffer = ArraySequence(gen_2, buffer_size=256)
 
         # Check buffer size effect
-        assert_equal(seq_with_buffer.data.shape, seq.data.shape)
-        assert_true(seq_with_buffer._buffer_size > seq._buffer_size)
+        assert seq_with_buffer.data.shape == seq.data.shape
+        assert seq_with_buffer._buffer_size > seq._buffer_size
 
         # Check generator result
         check_arr_seq(seq, SEQ_DATA['data'])
@@ -123,26 +128,27 @@ def test_arraysequence_iter(self):
         # Try iterating through a corrupted ArraySequence object.
         seq = SEQ_DATA['seq'].copy()
         seq._lengths = seq._lengths[::2]
-        assert_raises(ValueError, list, seq)
+        with pytest.raises(ValueError):
+            list(seq)
 
     def test_arraysequence_copy(self):
         orig = SEQ_DATA['seq']
         seq = orig.copy()
         n_rows = seq.total_nb_rows
-        assert_equal(n_rows, orig.total_nb_rows)
+        assert n_rows == orig.total_nb_rows
         assert_array_equal(seq._data, orig._data[:n_rows])
-        assert_true(seq._data is not orig._data)
+        assert seq._data is not orig._data
         assert_array_equal(seq._offsets, orig._offsets)
-        assert_true(seq._offsets is not orig._offsets)
+        assert seq._offsets is not orig._offsets
         assert_array_equal(seq._lengths, orig._lengths)
-        assert_true(seq._lengths is not orig._lengths)
-        assert_equal(seq.common_shape, orig.common_shape)
+        assert seq._lengths is not orig._lengths
+        assert seq.common_shape == orig.common_shape
 
         # Taking a copy of an `ArraySequence` generated by slicing.
         # Only keep needed data.
         seq = orig[::2].copy()
         check_arr_seq(seq, SEQ_DATA['data'][::2])
-        assert_true(seq._data is not orig._data)
+        assert seq._data is not orig._data
 
     def test_arraysequence_append(self):
         element = generate_data(nb_arrays=1,
@@ -173,7 +179,9 @@ def test_arraysequence_append(self):
         element = generate_data(nb_arrays=1,
                                 common_shape=SEQ_DATA['seq'].common_shape*2,
                                 rng=SEQ_DATA['rng'])[0]
-        assert_raises(ValueError, seq.append, element)
+
+        with pytest.raises(ValueError):
+            seq.append(element)
 
     def test_arraysequence_extend(self):
         new_data = generate_data(nb_arrays=10,
@@ -219,7 +227,8 @@ def test_arraysequence_extend(self):
                              common_shape=SEQ_DATA['seq'].common_shape*2,
                              rng=SEQ_DATA['rng'])
         seq = SEQ_DATA['seq'].copy()  # Copy because of in-place modification.
-        assert_raises(ValueError, seq.extend, data)
+        with pytest.raises(ValueError):
+            seq.extend(data)
 
         # Extend after extracting some slice
         working_slice = seq[:2]
@@ -264,7 +273,9 @@ def test_arraysequence_getitem(self):
                        for i, keep in enumerate(selection) if keep])
 
         # Test invalid indexing
-        assert_raises(TypeError, SEQ_DATA['seq'].__getitem__, 'abc')
+        with pytest.raises(TypeError):
+            SEQ_DATA['seq'].__getitem__('abc')
+            #SEQ_DATA['seq'].abc
 
         # Get specific columns.
         seq_view = SEQ_DATA['seq'][:, 2]
@@ -287,7 +298,7 @@ def test_arraysequence_setitem(self):
         # Setitem with a scalar.
         seq = SEQ_DATA['seq'].copy()
         seq[:] = 0
-        assert_true(seq._data.sum() == 0)
+        assert seq._data.sum() == 0
 
         # Setitem with a list of ndarray.
         seq = SEQ_DATA['seq'] * 0
@@ -297,12 +308,12 @@ def test_arraysequence_setitem(self):
         # Setitem using tuple indexing.
         seq = ArraySequence(np.arange(900).reshape((50,6,3)))
         seq[:, 0] = 0
-        assert_true(seq._data[:, 0].sum() == 0)
+        assert seq._data[:, 0].sum() == 0
 
         # Setitem using tuple indexing.
         seq = ArraySequence(np.arange(900).reshape((50,6,3)))
         seq[range(len(seq))] = 0
-        assert_true(seq._data.sum() == 0)
+        assert seq._data.sum() == 0
 
         # Setitem of a slice using another slice.
         seq = ArraySequence(np.arange(900).reshape((50,6,3)))
@@ -311,20 +322,26 @@ def test_arraysequence_setitem(self):
 
         # Setitem between array sequences with different number of sequences.
         seq = ArraySequence(np.arange(900).reshape((50,6,3)))
-        assert_raises(ValueError, seq.__setitem__, slice(0, 4), seq[5:10])
+        with pytest.raises(ValueError):
+            seq.__setitem__(slice(0, 4), seq[5:10])
+
 
         # Setitem between array sequences with different amount of points.
         seq1 = ArraySequence(np.arange(10).reshape(5, 2))
         seq2 = ArraySequence(np.arange(15).reshape(5, 3))
-        assert_raises(ValueError, seq1.__setitem__, slice(0, 5), seq2)
+        with pytest.raises(ValueError):
+            seq1.__setitem__(slice(0, 5), seq2)
 
         # Setitem between array sequences with different common shape.
         seq1 = ArraySequence(np.arange(12).reshape(2, 2, 3))
         seq2 = ArraySequence(np.arange(8).reshape(2, 2, 2))
-        assert_raises(ValueError, seq1.__setitem__, slice(0, 2), seq2)
+
+        with pytest.raises(ValueError):
+            seq1.__setitem__(slice(0, 2), seq2)
 
         # Invalid index.
-        assert_raises(TypeError, seq.__setitem__, object(), None)
+        with pytest.raises(TypeError):
+            seq.__setitem__(object(), None)
 
     def test_arraysequence_operators(self):
         # Disable division per zero warnings.
@@ -343,36 +360,45 @@ def test_arraysequence_operators(self):
         def _test_unary(op, arrseq):
             orig = arrseq.copy()
             seq = getattr(orig, op)()
-            assert_true(seq is not orig)
+            assert seq is not orig
             check_arr_seq(seq, [getattr(d, op)() for d in orig])
 
         def _test_binary(op, arrseq, scalars, seqs, inplace=False):
             for scalar in scalars:
                 orig = arrseq.copy()
                 seq = getattr(orig, op)(scalar)
-                assert_true((seq is orig) if inplace else (seq is not orig))
+
+                if inplace:
+                    assert seq is orig
+                else:
+                    assert seq is not orig
+
                 check_arr_seq(seq, [getattr(e, op)(scalar) for e in arrseq])
 
             # Test math operators with another ArraySequence.
             for other in seqs:
                 orig = arrseq.copy()
                 seq = getattr(orig, op)(other)
-                assert_true(seq is not SEQ_DATA['seq'])
+                assert seq is not SEQ_DATA['seq']
                 check_arr_seq(seq, [getattr(e1, op)(e2) for e1, e2 in zip(arrseq, other)])
 
             # Operations between array sequences of different lengths.
             orig = arrseq.copy()
-            assert_raises(ValueError, getattr(orig, op), orig[::2])
+            with pytest.raises(ValueError):
+                getattr(orig, op)(orig[::2])
 
             # Operations between array sequences with different amount of data.
             seq1 = ArraySequence(np.arange(10).reshape(5, 2))
             seq2 = ArraySequence(np.arange(15).reshape(5, 3))
-            assert_raises(ValueError, getattr(seq1, op), seq2)
+            with pytest.raises(ValueError):
+                getattr(seq1, op)(seq2)
 
             # Operations between array sequences with different common shape.
             seq1 = ArraySequence(np.arange(12).reshape(2, 2, 3))
             seq2 = ArraySequence(np.arange(8).reshape(2, 2, 2))
-            assert_raises(ValueError, getattr(seq1, op), seq2)
+            with pytest.raises(ValueError):
+                getattr(seq1, op)(seq2)
+            
 
 
         for op in ["__add__", "__sub__", "__mul__", "__mod__",
@@ -394,24 +420,33 @@ def _test_binary(op, arrseq, scalars, seqs, inplace=False):
                 continue  # Going to deal with it separately.
 
             _test_binary(op, seq_int, [42, -3, True, 0], [seq_int, seq_bool, -seq_int], inplace=True)  # int <-- int
-            assert_raises(TypeError, _test_binary, op, seq_int, [0.5], [], inplace=True)  # int <-- float
-            assert_raises(TypeError, _test_binary, op, seq_int, [], [seq], inplace=True)  # int <-- float
+            
+            with pytest.raises(TypeError):
+                _test_binary(op, seq_int, [0.5], [], inplace=True) # int <-- float
+                _test_binary(op, seq_int, [], [seq], inplace=True) # int <-- float
+            
 
         # __pow__ : Integers to negative integer powers are not allowed.
         _test_binary("__pow__", seq, [42, -3, True, 0], [seq_int, seq_bool, -seq_int])
         _test_binary("__ipow__", seq, [42, -3, True, 0], [seq_int, seq_bool, -seq_int], inplace=True)
-        assert_raises(ValueError, _test_binary, "__pow__", seq_int, [-3], [])
-        assert_raises(ValueError, _test_binary, "__ipow__", seq_int, [-3], [], inplace=True)
-
+        
+        with pytest.raises(ValueError):
+            _test_binary("__pow__", seq_int, [-3], [])
+            _test_binary("__ipow__", seq_int, [-3], [], inplace=True)
+        
         # __itruediv__ is only valid with float arrseq.
         for scalar in SCALARS + ARRSEQS:
-            assert_raises(TypeError, getattr(seq_int.copy(), "__itruediv__"), scalar)
+            with pytest.raises(TypeError):
+                seq_int_cp = seq_int.copy()
+                seq_int_cp.__itruediv__(scalar)
 
         # Bitwise operators
         for op in ("__lshift__", "__rshift__", "__or__", "__and__", "__xor__"):
             _test_binary(op, seq_bool, [42, -3, True, 0], [seq_int, seq_bool, -seq_int])
-            assert_raises(TypeError, _test_binary, op, seq_bool, [0.5], [])
-            assert_raises(TypeError, _test_binary, op, seq, [], [seq])
+            
+            with pytest.raises(TypeError):
+                _test_binary(op, seq_bool, [0.5], [])
+                _test_binary(op, seq, [], [seq])
 
         # Unary operators
         for op in ["__neg__", "__abs__"]:
@@ -422,7 +457,8 @@ def _test_binary(op, arrseq, scalars, seqs, inplace=False):
 
         _test_unary("__abs__", seq_bool)
         _test_unary("__invert__", seq_bool)
-        assert_raises(TypeError, _test_unary, "__invert__", seq)
+        with pytest.raises(TypeError):
+            _test_unary("__invert__", seq)
 
         # Restore flags.
         np.seterr(**flags)
@@ -442,7 +478,7 @@ def test_arraysequence_repr(self):
         txt1 = repr(seq)
         np.set_printoptions(threshold=nb_arrays//2)
         txt2 = repr(seq)
-        assert_true(len(txt2) < len(txt1))
+        assert len(txt2) < len(txt1)
         np.set_printoptions(threshold=bkp_threshold)
 
     def test_save_and_load_arraysequence(self):
@@ -485,10 +521,10 @@ def test_concatenate():
     new_seq = concatenate(seqs, axis=1)
     seq._data += 100  # Modifying the 'seq' shouldn't change 'new_seq'.
     check_arr_seq(new_seq, SEQ_DATA['data'])
-    assert_true(not new_seq._is_view)
+    assert new_seq._is_view is not True
 
     seq = SEQ_DATA['seq']
     seqs = [seq[:, [i]] for i in range(seq.common_shape[0])]
     new_seq = concatenate(seqs, axis=0)
-    assert_true(len(new_seq), seq.common_shape[0] * len(seq))
+    assert len(new_seq) == seq.common_shape[0] * len(seq)
     assert_array_equal(new_seq._data, seq._data.T.reshape((-1, 1)))