From d79af8b9a800204731339c6314268aa005f978ea Mon Sep 17 00:00:00 2001 From: Anibal Solon Date: Tue, 4 Feb 2020 15:26:13 -0500 Subject: [PATCH 1/2] pytest port --- nibabel/gifti/tests/test_gifti.py | 187 +++++++++++++++--------------- 1 file changed, 93 insertions(+), 94 deletions(-) diff --git a/nibabel/gifti/tests/test_gifti.py b/nibabel/gifti/tests/test_gifti.py index 167e56d6cf..8a0b3d327d 100644 --- a/nibabel/gifti/tests/test_gifti.py +++ b/nibabel/gifti/tests/test_gifti.py @@ -16,7 +16,7 @@ from numpy.testing import (assert_array_almost_equal, assert_array_equal) -from nose.tools import (assert_true, assert_false, assert_equal, assert_raises) +import pytest from nibabel.testing import clear_and_catch_warnings, test_data from .test_parse_gifti_fast import (DATA_FILE1, DATA_FILE2, DATA_FILE3, DATA_FILE4, DATA_FILE5, DATA_FILE6) @@ -35,7 +35,7 @@ def test_agg_data(): func_data = np.column_stack(tuple(da.data for da in func_da)) shape_data = shape_gii_img.get_arrays_from_intent('shape')[0].data - assert_equal(surf_gii_img.agg_data(), (point_data, triangle_data)) + assert surf_gii_img.agg_data() == (point_data, triangle_data) assert_array_equal(func_gii_img.agg_data(), func_data) assert_array_equal(shape_gii_img.agg_data(), shape_data) @@ -44,45 +44,45 @@ def test_agg_data(): assert_array_equal(func_gii_img.agg_data('time series'), func_data) assert_array_equal(shape_gii_img.agg_data('shape'), shape_data) - assert_equal(surf_gii_img.agg_data('time series'), ()) - assert_equal(func_gii_img.agg_data('triangle'), ()) - assert_equal(shape_gii_img.agg_data('pointset'), ()) + assert surf_gii_img.agg_data('time series') == () + assert func_gii_img.agg_data('triangle') == () + assert shape_gii_img.agg_data('pointset') == () - assert_equal(surf_gii_img.agg_data(('pointset', 'triangle')), (point_data, triangle_data)) - assert_equal(surf_gii_img.agg_data(('triangle', 'pointset')), (triangle_data, point_data)) + assert surf_gii_img.agg_data(('pointset', 'triangle')) == (point_data, triangle_data) + assert surf_gii_img.agg_data(('triangle', 'pointset')) == (triangle_data, point_data) def test_gifti_image(): # Check that we're not modifying the default empty list in the default # arguments. gi = GiftiImage() - assert_equal(gi.darrays, []) - assert_equal(gi.meta.metadata, {}) - assert_equal(gi.labeltable.labels, []) + assert gi.darrays == [] + assert gi.meta.metadata == {} + assert gi.labeltable.labels == [] arr = np.zeros((2, 3)) gi.darrays.append(arr) # Now check we didn't overwrite the default arg gi = GiftiImage() - assert_equal(gi.darrays, []) + assert gi.darrays == [] # Test darrays / numDA gi = GiftiImage() - assert_equal(gi.numDA, 0) + assert gi.numDA == 0 # Test from numpy numeric array data = np.random.random((5,)) da = GiftiDataArray(data) gi.add_gifti_data_array(da) - assert_equal(gi.numDA, 1) + assert gi.numDA == 1 assert_array_equal(gi.darrays[0].data, data) # Test removing gi.remove_gifti_data_array(0) - assert_equal(gi.numDA, 0) + assert gi.numDA == 0 # Remove from empty gi = GiftiImage() gi.remove_gifti_data_array_by_intent(0) - assert_equal(gi.numDA, 0) + assert gi.numDA == 0 # Remove one gi = GiftiImage() @@ -90,113 +90,112 @@ def test_gifti_image(): gi.add_gifti_data_array(da) gi.remove_gifti_data_array_by_intent(3) - assert_equal(gi.numDA, 1, "data array should exist on 'missed' remove") + assert gi.numDA == 1, "data array should exist on 'missed' remove" gi.remove_gifti_data_array_by_intent(da.intent) - assert_equal(gi.numDA, 0) + assert gi.numDA == 0 def test_gifti_image_bad_inputs(): img = GiftiImage() # Try to set a non-data-array - assert_raises(TypeError, img.add_gifti_data_array, 'not-a-data-array') + pytest.raises(TypeError, img.add_gifti_data_array, 'not-a-data-array') # Try to set to non-table def assign_labeltable(val): img.labeltable = val - assert_raises(TypeError, assign_labeltable, 'not-a-table') + pytest.raises(TypeError, assign_labeltable, 'not-a-table') # Try to set to non-table def assign_metadata(val): img.meta = val - assert_raises(TypeError, assign_metadata, 'not-a-meta') + pytest.raises(TypeError, assign_metadata, 'not-a-meta') def test_dataarray_empty(): # Test default initialization of DataArray null_da = GiftiDataArray() - assert_equal(null_da.data, None) - assert_equal(null_da.intent, 0) - assert_equal(null_da.datatype, 0) - assert_equal(null_da.encoding, 3) - assert_equal(null_da.endian, 2 if sys.byteorder == 'little' else 1) - assert_equal(null_da.coordsys.dataspace, 0) - assert_equal(null_da.coordsys.xformspace, 0) + assert null_da.data is None + assert null_da.intent == 0 + assert null_da.datatype == 0 + assert null_da.encoding == 3 + assert null_da.endian == (2 if sys.byteorder == 'little' else 1) + assert null_da.coordsys.dataspace == 0 + assert null_da.coordsys.xformspace == 0 assert_array_equal(null_da.coordsys.xform, np.eye(4)) - assert_equal(null_da.ind_ord, 1) - assert_equal(null_da.meta.metadata, {}) - assert_equal(null_da.ext_fname, '') - assert_equal(null_da.ext_offset, 0) + assert null_da.ind_ord == 1 + assert null_da.meta.metadata == {} + assert null_da.ext_fname == '' + assert null_da.ext_offset == 0 def test_dataarray_init(): # Test non-default dataarray initialization gda = GiftiDataArray # shortcut - assert_equal(gda(None).data, None) + assert gda(None).data is None arr = np.arange(12, dtype=np.float32).reshape((3, 4)) assert_array_equal(gda(arr).data, arr) # Intents - assert_raises(KeyError, gda, intent=1) # Invalid code - assert_raises(KeyError, gda, intent='not an intent') # Invalid string - assert_equal(gda(intent=2).intent, 2) - assert_equal(gda(intent='correlation').intent, 2) - assert_equal(gda(intent='NIFTI_INTENT_CORREL').intent, 2) + pytest.raises(KeyError, gda, intent=1) # Invalid code + pytest.raises(KeyError, gda, intent='not an intent') # Invalid string + assert gda(intent=2).intent == 2 + assert gda(intent='correlation').intent == 2 + assert gda(intent='NIFTI_INTENT_CORREL').intent == 2 # Datatype - assert_equal(gda(datatype=2).datatype, 2) - assert_equal(gda(datatype='uint8').datatype, 2) - assert_raises(KeyError, gda, datatype='not_datatype') + assert gda(datatype=2).datatype == 2 + assert gda(datatype='uint8').datatype == 2 + pytest.raises(KeyError, gda, datatype='not_datatype') # Float32 datatype comes from array if datatype not set - assert_equal(gda(arr).datatype, 16) + assert gda(arr).datatype == 16 # Can be overriden by init - assert_equal(gda(arr, datatype='uint8').datatype, 2) + assert gda(arr, datatype='uint8').datatype == 2 # Encoding - assert_equal(gda(encoding=1).encoding, 1) - assert_equal(gda(encoding='ASCII').encoding, 1) - assert_equal(gda(encoding='GIFTI_ENCODING_ASCII').encoding, 1) - assert_raises(KeyError, gda, encoding='not an encoding') + assert gda(encoding=1).encoding == 1 + assert gda(encoding='ASCII').encoding == 1 + assert gda(encoding='GIFTI_ENCODING_ASCII').encoding == 1 + pytest.raises(KeyError, gda, encoding='not an encoding') # Endian - assert_equal(gda(endian=1).endian, 1) - assert_equal(gda(endian='big').endian, 1) - assert_equal(gda(endian='GIFTI_ENDIAN_BIG').endian, 1) - assert_raises(KeyError, gda, endian='not endian code') + assert gda(endian=1).endian == 1 + assert gda(endian='big').endian == 1 + assert gda(endian='GIFTI_ENDIAN_BIG').endian == 1 + pytest.raises(KeyError, gda, endian='not endian code') # CoordSys aff = np.diag([2, 3, 4, 1]) cs = GiftiCoordSystem(1, 2, aff) da = gda(coordsys=cs) - assert_equal(da.coordsys.dataspace, 1) - assert_equal(da.coordsys.xformspace, 2) + assert da.coordsys.dataspace == 1 + assert da.coordsys.xformspace == 2 assert_array_equal(da.coordsys.xform, aff) # Ordering - assert_equal(gda(ordering=2).ind_ord, 2) - assert_equal(gda(ordering='F').ind_ord, 2) - assert_equal(gda(ordering='ColumnMajorOrder').ind_ord, 2) - assert_raises(KeyError, gda, ordering='not an ordering') + assert gda(ordering=2).ind_ord == 2 + assert gda(ordering='F').ind_ord == 2 + assert gda(ordering='ColumnMajorOrder').ind_ord == 2 + pytest.raises(KeyError, gda, ordering='not an ordering') # metadata meta_dict=dict(one=1, two=2) - assert_equal(gda(meta=GiftiMetaData.from_dict(meta_dict)).meta.metadata, - meta_dict) - assert_equal(gda(meta=meta_dict).meta.metadata, meta_dict) - assert_equal(gda(meta=None).meta.metadata, {}) + assert gda(meta=GiftiMetaData.from_dict(meta_dict)).meta.metadata == meta_dict + assert gda(meta=meta_dict).meta.metadata == meta_dict + assert gda(meta=None).meta.metadata == {} # ext_fname and ext_offset - assert_equal(gda(ext_fname='foo').ext_fname, 'foo') - assert_equal(gda(ext_offset=12).ext_offset, 12) + assert gda(ext_fname='foo').ext_fname == 'foo' + assert gda(ext_offset=12).ext_offset == 12 def test_dataarray_from_array(): with clear_and_catch_warnings() as w: warnings.filterwarnings('always', category=DeprecationWarning) da = GiftiDataArray.from_array(np.ones((3, 4))) - assert_equal(len(w), 1) + assert len(w) == 1 for dt_code in data_type_codes.value_set(): data_type = data_type_codes.type[dt_code] if data_type is np.void: # not supported continue arr = np.zeros((10, 3), dtype=data_type) da = GiftiDataArray.from_array(arr, 'triangle') - assert_equal(da.datatype, data_type_codes[arr.dtype]) + assert da.datatype == data_type_codes[arr.dtype] bs_arr = arr.byteswap().newbyteorder() da = GiftiDataArray.from_array(bs_arr, 'triangle') - assert_equal(da.datatype, data_type_codes[arr.dtype]) + assert da.datatype == data_type_codes[arr.dtype] def test_to_xml_open_close_deprecations(): @@ -204,35 +203,35 @@ def test_to_xml_open_close_deprecations(): da = GiftiDataArray(np.ones((1,)), 'triangle') with clear_and_catch_warnings() as w: warnings.filterwarnings('always', category=DeprecationWarning) - assert_true(isinstance(da.to_xml_open(), str)) - assert_equal(len(w), 1) + assert isinstance(da.to_xml_open(), str) + assert len(w) == 1 with clear_and_catch_warnings() as w: warnings.filterwarnings('once', category=DeprecationWarning) - assert_true(isinstance(da.to_xml_close(), str)) - assert_equal(len(w), 1) + assert isinstance(da.to_xml_close(), str) + assert len(w) == 1 def test_num_dim_deprecation(): da = GiftiDataArray(np.ones((2, 3, 4))) # num_dim is property, set automatically from len(da.dims) - assert_equal(da.num_dim, 3) + assert da.num_dim == 3 with clear_and_catch_warnings() as w: warnings.filterwarnings('always', category=DeprecationWarning) # OK setting num_dim to correct value, but raises DeprecationWarning da.num_dim = 3 - assert_equal(len(w), 1) + assert len(w) == 1 # Any other value gives a ValueError - assert_raises(ValueError, setattr, da, 'num_dim', 4) + pytest.raises(ValueError, setattr, da, 'num_dim', 4) def test_labeltable(): img = GiftiImage() - assert_equal(len(img.labeltable.labels), 0) + assert len(img.labeltable.labels) == 0 new_table = GiftiLabelTable() new_table.labels += ['test', 'me'] img.labeltable = new_table - assert_equal(len(img.labeltable.labels), 2) + assert len(img.labeltable.labels) == 2 # Test deprecations with clear_and_catch_warnings() as w: @@ -240,23 +239,23 @@ def test_labeltable(): newer_table = GiftiLabelTable() newer_table.labels += ['test', 'me', 'again'] img.set_labeltable(newer_table) - assert_equal(len(w), 1) - assert_equal(len(img.get_labeltable().labels), 3) - assert_equal(len(w), 2) + assert len(w) == 1 + assert len(img.get_labeltable().labels) == 3 + assert len(w) == 2 def test_metadata(): nvpair = GiftiNVPairs('key', 'value') md = GiftiMetaData(nvpair=nvpair) - assert_equal(md.data[0].name, 'key') - assert_equal(md.data[0].value, 'value') + assert md.data[0].name == 'key' + assert md.data[0].value == 'value' # Test deprecation with clear_and_catch_warnings() as w: warnings.filterwarnings('always', category=DeprecationWarning) - assert_equal(md.get_metadata(), dict(key='value')) - assert_equal(len(w), 1) - assert_equal(len(GiftiDataArray().get_metadata()), 0) - assert_equal(len(w), 2) + assert md.get_metadata() == dict(key='value') + assert len(w) == 1 + assert len(GiftiDataArray().get_metadata()) == 0 + assert len(w) == 2 def test_gifti_label_rgba(): @@ -267,31 +266,31 @@ def test_gifti_label_rgba(): assert_array_equal(rgba, gl1.rgba) gl1.red = 2 * gl1.red - assert_false(np.allclose(rgba, gl1.rgba)) # don't just store the list! + assert not np.allclose(rgba, gl1.rgba) # don't just store the list! gl2 = GiftiLabel() gl2.rgba = rgba assert_array_equal(rgba, gl2.rgba) gl2.blue = 2 * gl2.blue - assert_false(np.allclose(rgba, gl2.rgba)) # don't just store the list! + assert not np.allclose(rgba, gl2.rgba) # don't just store the list! def assign_rgba(gl, val): gl.rgba = val gl3 = GiftiLabel(**kwargs) - assert_raises(ValueError, assign_rgba, gl3, rgba[:2]) - assert_raises(ValueError, assign_rgba, gl3, rgba.tolist() + rgba.tolist()) + pytest.raises(ValueError, assign_rgba, gl3, rgba[:2]) + pytest.raises(ValueError, assign_rgba, gl3, rgba.tolist() + rgba.tolist()) # Test deprecation with clear_and_catch_warnings() as w: warnings.filterwarnings('once', category=DeprecationWarning) - assert_equal(kwargs['red'], gl3.get_rgba()[0]) - assert_equal(len(w), 1) + assert kwargs['red'] == gl3.get_rgba()[0] + assert len(w) == 1 # Test default value gl4 = GiftiLabel() - assert_equal(len(gl4.rgba), 4) - assert_true(np.all([elem is None for elem in gl4.rgba])) + assert len(gl4.rgba) == 4 + assert np.all([elem is None for elem in gl4.rgba]) def test_print_summary(): @@ -304,7 +303,7 @@ def test_print_summary(): def test_gifti_coord(): from ..gifti import GiftiCoordSystem gcs = GiftiCoordSystem() - assert_true(gcs.xform is not None) + assert gcs.xform is not None # Smoke test gcs.xform = None @@ -316,7 +315,7 @@ def test_data_tag_deprecated(): with clear_and_catch_warnings() as w: warnings.filterwarnings('once', category=DeprecationWarning) data_tag(np.array([]), 'ASCII', '%i', 1) - assert_equal(len(w), 1) + assert len(w) == 1 def test_gifti_round_trip(): @@ -443,5 +442,5 @@ def test_darray_dtype_coercion_failures(): gii = GiftiImage(darrays=[da]) gii_copy = GiftiImage.from_bytes(gii.to_bytes()) da_copy = gii_copy.darrays[0] - assert_equal(np.dtype(da_copy.data.dtype), np.dtype(darray_dtype)) + assert np.dtype(da_copy.data.dtype) == np.dtype(darray_dtype) assert_array_equal(da_copy.data, da.data) From 62d53c3712fe3a268849d4cc5f2feae1a02fd52c Mon Sep 17 00:00:00 2001 From: Anibal Solon Date: Tue, 4 Feb 2020 15:35:28 -0500 Subject: [PATCH 2/2] finish porting gifti module tests to pytest --- nibabel/gifti/tests/test_giftiio.py | 8 +- nibabel/gifti/tests/test_parse_gifti_fast.py | 115 +++++++++---------- 2 files changed, 60 insertions(+), 63 deletions(-) diff --git a/nibabel/gifti/tests/test_giftiio.py b/nibabel/gifti/tests/test_giftiio.py index 90fe3e4d37..87d28b00c4 100644 --- a/nibabel/gifti/tests/test_giftiio.py +++ b/nibabel/gifti/tests/test_giftiio.py @@ -9,8 +9,6 @@ import warnings -from nose.tools import (assert_true, assert_false, assert_equal, - assert_raises) from nibabel.testing import clear_and_catch_warnings from nibabel.tmpdirs import InTemporaryDirectory @@ -24,7 +22,7 @@ class TestGiftiIO(object): def setUp(self): with clear_and_catch_warnings() as w: warnings.simplefilter('always', DeprecationWarning) - assert_equal(len(w), 1) + assert len(w) == 1 def test_read_deprecated(): @@ -33,7 +31,7 @@ def test_read_deprecated(): from nibabel.gifti.giftiio import read, write img = read(DATA_FILE1) - assert_equal(len(w), 1) + assert len(w) == 1 with InTemporaryDirectory(): write(img, 'test.gii') - assert_equal(len(w), 2) + assert len(w) == 2 diff --git a/nibabel/gifti/tests/test_parse_gifti_fast.py b/nibabel/gifti/tests/test_parse_gifti_fast.py index a06180a964..15a2c69f1c 100644 --- a/nibabel/gifti/tests/test_parse_gifti_fast.py +++ b/nibabel/gifti/tests/test_parse_gifti_fast.py @@ -22,8 +22,7 @@ from numpy.testing import assert_array_almost_equal -from nose.tools import (assert_true, assert_false, assert_equal, - assert_raises) +import pytest from ...testing import clear_and_catch_warnings @@ -106,9 +105,9 @@ def assert_default_types(loaded): if defaulttype is type(None): continue loadedtype = type(getattr(loaded, attr)) - assert_equal(loadedtype, defaulttype, - "Type mismatch for attribute: {} ({!s} != {!s})".format( - attr, loadedtype, defaulttype)) + assert loadedtype == defaulttype, ( + "Type mismatch for attribute: {} ({!s} != {!s})".format( + attr, loadedtype, defaulttype)) def test_default_types(): @@ -142,18 +141,18 @@ def test_read_ordering(): # read another image first (DATA_FILE2) then the shape is wrong # Read an image img2 = load(DATA_FILE2) - assert_equal(img2.darrays[0].data.shape, (143479, 1)) + assert img2.darrays[0].data.shape == (143479, 1) # Read image for which we know output shape img = load(DATA_FILE1) - assert_equal(img.darrays[0].data.shape, (3, 3)) + assert img.darrays[0].data.shape == (3, 3) def test_load_metadata(): for i, dat in enumerate(datafiles): img = load(dat) img.meta - assert_equal(numDA[i], img.numDA) - assert_equal(img.version, '1.0') + assert numDA[i] == img.numDA + assert img.version == '1.0' def test_metadata_deprecations(): @@ -163,12 +162,12 @@ def test_metadata_deprecations(): # Test deprecation with clear_and_catch_warnings() as w: warnings.filterwarnings('once', category=DeprecationWarning) - assert_equal(me, img.get_meta()) + assert me == img.get_meta() with clear_and_catch_warnings() as w: warnings.filterwarnings('once', category=DeprecationWarning) img.set_metadata(me) - assert_equal(me, img.meta) + assert me == img.meta def test_load_dataarray1(): @@ -181,14 +180,14 @@ def test_load_dataarray1(): assert_array_almost_equal(img.darrays[0].data, DATA_FILE1_darr1) assert_array_almost_equal(img.darrays[1].data, DATA_FILE1_darr2) me = img.darrays[0].meta.metadata - assert_true('AnatomicalStructurePrimary' in me) - assert_true('AnatomicalStructureSecondary' in me) - assert_equal(me['AnatomicalStructurePrimary'], 'CortexLeft') + assert 'AnatomicalStructurePrimary' in me + assert 'AnatomicalStructureSecondary' in me + me['AnatomicalStructurePrimary'] == 'CortexLeft' assert_array_almost_equal(img.darrays[0].coordsys.xform, np.eye(4, 4)) - assert_equal(xform_codes.niistring[img.darrays[ - 0].coordsys.dataspace], 'NIFTI_XFORM_TALAIRACH') - assert_equal(xform_codes.niistring[img.darrays[ - 0].coordsys.xformspace], 'NIFTI_XFORM_TALAIRACH') + assert xform_codes.niistring[ + img.darrays[0].coordsys.dataspace] == 'NIFTI_XFORM_TALAIRACH' + assert xform_codes.niistring[img.darrays[ + 0].coordsys.xformspace] == 'NIFTI_XFORM_TALAIRACH' def test_load_dataarray2(): @@ -223,7 +222,7 @@ def test_load_dataarray4(): def test_dataarray5(): img5 = load(DATA_FILE5) for da in img5.darrays: - assert_equal(gifti_endian_codes.byteorder[da.endian], 'little') + gifti_endian_codes.byteorder[da.endian] == 'little' assert_array_almost_equal(img5.darrays[0].data, DATA_FILE5_darr1) assert_array_almost_equal(img5.darrays[1].data, DATA_FILE5_darr2) # Round trip tested below @@ -234,24 +233,24 @@ def test_base64_written(): with open(DATA_FILE5, 'rb') as fobj: contents = fobj.read() # Confirm the bad tags are still in the file - assert_true(b'GIFTI_ENCODING_B64BIN' in contents) - assert_true(b'GIFTI_ENDIAN_LITTLE' in contents) + assert b'GIFTI_ENCODING_B64BIN' in contents + assert b'GIFTI_ENDIAN_LITTLE' in contents # The good ones are missing - assert_false(b'Base64Binary' in contents) - assert_false(b'LittleEndian' in contents) + assert b'Base64Binary' not in contents + assert b'LittleEndian' not in contents # Round trip img5 = load(DATA_FILE5) save(img5, 'fixed.gii') with open('fixed.gii', 'rb') as fobj: contents = fobj.read() # The bad codes have gone, replaced by the good ones - assert_false(b'GIFTI_ENCODING_B64BIN' in contents) - assert_false(b'GIFTI_ENDIAN_LITTLE' in contents) - assert_true(b'Base64Binary' in contents) + assert b'GIFTI_ENCODING_B64BIN' not in contents + assert b'GIFTI_ENDIAN_LITTLE' not in contents + assert b'Base64Binary' in contents if sys.byteorder == 'little': - assert_true(b'LittleEndian' in contents) + assert b'LittleEndian' in contents else: - assert_true(b'BigEndian' in contents) + assert b'BigEndian' in contents img5_fixed = load('fixed.gii') darrays = img5_fixed.darrays assert_array_almost_equal(darrays[0].data, DATA_FILE5_darr1) @@ -263,7 +262,7 @@ def test_readwritedata(): with InTemporaryDirectory(): save(img, 'test.gii') img2 = load('test.gii') - assert_equal(img.numDA, img2.numDA) + assert img.numDA == img2.numDA assert_array_almost_equal(img.darrays[0].data, img2.darrays[0].data) @@ -272,7 +271,7 @@ def test_modify_darray(): img = load(fname) darray = img.darrays[0] darray.data[:] = 0 - assert_true(np.array_equiv(darray.data, 0)) + assert np.array_equiv(darray.data, 0) def test_write_newmetadata(): @@ -281,32 +280,32 @@ def test_write_newmetadata(): newmeta = gi.GiftiMetaData(attr) img.meta = newmeta myme = img.meta.metadata - assert_true('mykey' in myme) + assert 'mykey' in myme newmeta = gi.GiftiMetaData.from_dict({'mykey1': 'val2'}) img.meta = newmeta myme = img.meta.metadata - assert_true('mykey1' in myme) - assert_false('mykey' in myme) + assert 'mykey1' in myme + assert 'mykey' not in myme def test_load_getbyintent(): img = load(DATA_FILE1) da = img.get_arrays_from_intent("NIFTI_INTENT_POINTSET") - assert_equal(len(da), 1) + assert len(da) == 1 with clear_and_catch_warnings() as w: warnings.filterwarnings('once', category=DeprecationWarning) da = img.getArraysFromIntent("NIFTI_INTENT_POINTSET") - assert_equal(len(da), 1) - assert_equal(len(w), 1) - assert_equal(w[0].category, DeprecationWarning) + assert len(da) == 1 + assert len(w) == 1 + w[0].category == DeprecationWarning da = img.get_arrays_from_intent("NIFTI_INTENT_TRIANGLE") - assert_equal(len(da), 1) + assert len(da) == 1 da = img.get_arrays_from_intent("NIFTI_INTENT_CORREL") - assert_equal(len(da), 0) - assert_equal(da, []) + assert len(da) == 0 + assert da == [] def test_load_labeltable(): @@ -317,15 +316,15 @@ def test_load_labeltable(): bimg = load('test.gii') for img in (img6, bimg): assert_array_almost_equal(img.darrays[0].data[:3], DATA_FILE6_darr1) - assert_equal(len(img.labeltable.labels), 36) + assert len(img.labeltable.labels) == 36 labeldict = img.labeltable.get_labels_as_dict() - assert_true(660700 in labeldict) - assert_equal(labeldict[660700], 'entorhinal') - assert_equal(img.labeltable.labels[1].key, 2647065) - assert_equal(img.labeltable.labels[1].red, 0.0980392) - assert_equal(img.labeltable.labels[1].green, 0.392157) - assert_equal(img.labeltable.labels[1].blue, 0.156863) - assert_equal(img.labeltable.labels[1].alpha, 1) + assert 660700 in labeldict + assert labeldict[660700] == 'entorhinal' + assert img.labeltable.labels[1].key == 2647065 + assert img.labeltable.labels[1].red == 0.0980392 + assert img.labeltable.labels[1].green == 0.392157 + assert img.labeltable.labels[1].blue == 0.156863 + assert img.labeltable.labels[1].alpha == 1 def test_labeltable_deprecations(): @@ -335,14 +334,14 @@ def test_labeltable_deprecations(): # Test deprecation with clear_and_catch_warnings() as w: warnings.filterwarnings('always', category=DeprecationWarning) - assert_equal(lt, img.get_labeltable()) - assert_equal(len(w), 1) + assert lt == img.get_labeltable() + assert len(w) == 1 with clear_and_catch_warnings() as w: warnings.filterwarnings('always', category=DeprecationWarning) img.set_labeltable(lt) - assert_equal(len(w), 1) - assert_equal(lt, img.labeltable) + assert len(w) == 1 + assert lt == img.labeltable def test_parse_dataarrays(): @@ -361,8 +360,8 @@ def test_parse_dataarrays(): with clear_and_catch_warnings() as w: warnings.filterwarnings('once', category=UserWarning) load(fn) - assert_equal(len(w), 1) - assert_equal(img.numDA, 0) + assert len(w) == 1 + assert img.numDA == 0 def test_parse_deprecated(): @@ -371,16 +370,16 @@ def test_parse_deprecated(): with clear_and_catch_warnings() as w: warnings.filterwarnings('always', category=DeprecationWarning) op = Outputter() - assert_equal(len(w), 1) + assert len(w) == 1 op.initialize() # smoke test--no error. with clear_and_catch_warnings() as w: warnings.filterwarnings('always', category=DeprecationWarning) - assert_raises(ValueError, parse_gifti_file) - assert_equal(len(w), 1) + pytest.raises(ValueError, parse_gifti_file) + assert len(w) == 1 def test_parse_with_buffersize(): for buff_sz in [None, 1, 2**12]: img2 = load(DATA_FILE2, buffer_size=buff_sz) - assert_equal(img2.darrays[0].data.shape, (143479, 1)) + assert img2.darrays[0].data.shape == (143479, 1)