From 188f36f712643db3accfe4724419ed68a8aaec8c Mon Sep 17 00:00:00 2001 From: Scott Lowe Date: Thu, 24 Jun 2021 23:00:42 +0100 Subject: [PATCH 1/5] TST:MNT: assert_allclose_ragged accept list(s) in desired --- fissa/tests/base_test.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/fissa/tests/base_test.py b/fissa/tests/base_test.py index 3189469f..9342d999 100644 --- a/fissa/tests/base_test.py +++ b/fissa/tests/base_test.py @@ -30,7 +30,7 @@ def assert_allclose_ragged(actual, desired): assert_equal(np.shape(actual), np.shape(desired)) for desired_i, actual_i in zip(desired, actual): - if desired.dtype == object: + if np.asarray(desired).dtype == object: assert_allclose_ragged(actual_i, desired_i) else: assert_allclose(actual_i, desired_i) From bb0c122f13ff2fd28607157fe1e3684e54cb8d93 Mon Sep 17 00:00:00 2001 From: Scott Lowe Date: Thu, 24 Jun 2021 23:01:25 +0100 Subject: [PATCH 2/5] TST:MNT: assert_allclose_ragged accept None as desired value --- fissa/tests/base_test.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/fissa/tests/base_test.py b/fissa/tests/base_test.py index 9342d999..47c10338 100644 --- a/fissa/tests/base_test.py +++ b/fissa/tests/base_test.py @@ -175,6 +175,8 @@ def assert_equal(self, actual, desired, *args, **kwargs): return assert_equal(actual, desired, *args, **kwargs) def assert_allclose_ragged(self, actual, desired): + if desired is None: + return self.assertIs(actual, desired) return assert_allclose_ragged(actual, desired) def assert_equal_list_of_array_perm_inv(self, actual, desired): From 85dd37ee0042f82f9501ae705280461d28303857 Mon Sep 17 00:00:00 2001 From: Scott Lowe Date: Thu, 24 Jun 2021 23:03:02 +0100 Subject: [PATCH 3/5] TST:RF: Move comparisons in core to helper methods --- fissa/tests/test_core.py | 290 ++++++++++++++++----------------------- 1 file changed, 119 insertions(+), 171 deletions(-) diff --git a/fissa/tests/test_core.py b/fissa/tests/test_core.py index 0b0ddcdf..02724b61 100644 --- a/fissa/tests/test_core.py +++ b/fissa/tests/test_core.py @@ -68,15 +68,98 @@ def tearDown(self): if os.path.isdir(self.output_dir): shutil.rmtree(self.output_dir) + def compare_output(self, experiment, separated=True): + """ + Compare experiment output against expected from test attributes. + + Parameters + ---------- + experiment : fissa.Experiment + Actual experiment. + separated : bool + Whether to compare results of :meth:`fissa.Experiment.separate`. + Default is ``True``. + """ + if separated: + self.assert_equal(len(experiment.result), 1) + self.assert_equal(len(experiment.result[0]), 1) + self.assert_allclose(experiment.result[0][0], self.expected_00) + self.assert_equal(len(experiment.means), len(self.image_names)) + self.assert_equal(experiment.means[0].shape, self.image_shape) + self.assert_equal(experiment.means[-1].shape, self.image_shape) + + def compare_experiments(self, actual, expected, prepared=True, separated=True): + """ + Compare attributes of two experiments. + + Parameters + ---------- + actual : fissa.Experiment + Actual experiment. + expected : fissa.Experiment + Expected experiment. + prepared : bool + Whether to compare results of :meth:`fissa.Experiment.separation_prep`. + Default is ``True``. + separated : bool + Whether to compare results of :meth:`fissa.Experiment.separate`. + Default is ``True``. + """ + if prepared: + if expected.raw is None: + self.assertIs(actual.raw, expected.raw) + else: + self.assert_allclose_ragged(actual.raw, expected.raw) + self.assert_allclose_ragged(actual.means, expected.means) + if separated: + self.assert_allclose_ragged(actual.result, expected.result) + + def compare_matlab(self, fname, experiment, compare_deltaf=None): + """ + Compare experiment output against expected from test attributes. + + Parameters + ---------- + fname : str + Path to .mat file to test. + experiment : fissa.Experiment + Experiment with expected values to compare against. + compare_deltaf : bool or None + Whether to compare ``experiment.deltaf_raw`` against + ``experiment.raw`` and ``experiment.deltaf_result`` against + ``experiment.result``. + If ``None`` (default), this is automatically determined based on + whether ``experiment.deltaf_result`` is not ``None``. + """ + if compare_deltaf is None: + compare_deltaf = experiment.deltaf_result is not None + self.assertTrue(os.path.isfile(fname)) + # Check contents of the .mat file + M = loadmat(fname) + self.assert_allclose(M["raw"][0, 0][0][0, 0][0], experiment.raw[0, 0]) + self.assert_allclose(M["result"][0, 0][0][0, 0][0], experiment.result[0, 0]) + self.assert_allclose( + M["ROIs"][0, 0][0][0, 0][0][0][0], + experiment.roi_polys[0, 0][0][0], + ) + if compare_deltaf: + self.assert_allclose( + M["df_result"][0, 0][0][0, 0][0], + experiment.deltaf_result[0, 0], + ) + # Row and column vectors on MATLAB are 2d instead of 1d, and df_raw + # is a vector, not a matrix, so has an extra dimension. + # N.B. This extra dimension is in the wrong place as it doesn't align + # with the other attributes. + self.assert_allclose( + M["df_raw"][0, 0][0][0, 0][0][0, :], + experiment.deltaf_raw[0, 0], + ) + def test_imagedir_roizip(self): exp = core.Experiment(self.images_dir, self.roi_zip_path) exp.separate() - actual = exp.result - self.assert_equal(len(actual), 1) - self.assert_equal(len(actual[0]), 1) - self.assert_allclose(actual[0][0], self.expected_00) - self.assert_equal(exp.means[0].shape, self.image_shape) - self.assert_equal(exp.means[-1].shape, self.image_shape) + self.compare_output(exp) def test_imagelist_roizip(self): image_paths = [ @@ -85,13 +168,7 @@ def test_imagelist_roizip(self): ] exp = core.Experiment(image_paths, self.roi_zip_path) exp.separate() - actual = exp.result - self.assert_equal(len(actual), 1) - self.assert_equal(len(actual[0]), 1) - self.assert_allclose(actual[0][0], self.expected_00) - self.assert_equal(len(exp.means), len(image_paths)) - self.assert_equal(exp.means[0].shape, self.image_shape) - self.assert_equal(exp.means[-1].shape, self.image_shape) + self.compare_output(exp) def test_imagelistloaded_roizip(self): image_paths = [ @@ -102,13 +179,7 @@ def test_imagelistloaded_roizip(self): images = [datahandler.image2array(pth) for pth in image_paths] exp = core.Experiment(images, self.roi_zip_path) exp.separate() - actual = exp.result - self.assert_equal(len(actual), 1) - self.assert_equal(len(actual[0]), 1) - self.assert_allclose(actual[0][0], self.expected_00) - self.assert_equal(len(exp.means), len(image_paths)) - self.assert_equal(exp.means[0].shape, self.image_shape) - self.assert_equal(exp.means[-1].shape, self.image_shape) + self.compare_output(exp) @unittest.expectedFailure def test_imagedir_roilistpath(self): @@ -118,12 +189,7 @@ def test_imagedir_roilistpath(self): ] exp = core.Experiment(self.images_dir, roi_paths) exp.separate() - actual = exp.result - self.assert_equal(len(actual), 1) - self.assert_equal(len(actual[0]), 1) - self.assert_allclose(actual[0][0], self.expected_00) - self.assert_equal(exp.means[0].shape, self.image_shape) - self.assert_equal(exp.means[-1].shape, self.image_shape) + self.compare_output(exp) @unittest.expectedFailure def test_imagelist_roilistpath(self): @@ -137,23 +203,12 @@ def test_imagelist_roilistpath(self): ] exp = core.Experiment(image_paths, roi_paths) exp.separate() - actual = exp.result - self.assert_equal(len(actual), 1) - self.assert_equal(len(actual[0]), 1) - self.assert_allclose(actual[0][0], self.expected_00) - self.assert_equal(len(exp.means), len(image_paths)) - self.assert_equal(exp.means[0].shape, self.image_shape) - self.assert_equal(exp.means[-1].shape, self.image_shape) + self.compare_output(exp) def test_nocache(self): exp = core.Experiment(self.images_dir, self.roi_zip_path) exp.separate() - actual = exp.result - self.assert_equal(len(actual), 1) - self.assert_equal(len(actual[0]), 1) - self.assert_allclose(actual[0][0], self.expected_00) - self.assert_equal(exp.means[0].shape, self.image_shape) - self.assert_equal(exp.means[-1].shape, self.image_shape) + self.compare_output(exp) def test_ncores_preparation_1(self): exp = core.Experiment( @@ -162,12 +217,7 @@ def test_ncores_preparation_1(self): ncores_preparation=1, ) exp.separate() - actual = exp.result - self.assert_equal(len(actual), 1) - self.assert_equal(len(actual[0]), 1) - self.assert_allclose(actual[0][0], self.expected_00) - self.assert_equal(exp.means[0].shape, self.image_shape) - self.assert_equal(exp.means[-1].shape, self.image_shape) + self.compare_output(exp) def test_ncores_preparation_2(self): exp = core.Experiment( @@ -176,12 +226,7 @@ def test_ncores_preparation_2(self): ncores_preparation=2, ) exp.separate() - actual = exp.result - self.assert_equal(len(actual), 1) - self.assert_equal(len(actual[0]), 1) - self.assert_allclose(actual[0][0], self.expected_00) - self.assert_equal(exp.means[0].shape, self.image_shape) - self.assert_equal(exp.means[-1].shape, self.image_shape) + self.compare_output(exp) def test_ncores_separate_1(self): exp = core.Experiment( @@ -190,12 +235,7 @@ def test_ncores_separate_1(self): ncores_separation=1, ) exp.separate() - actual = exp.result - self.assert_equal(len(actual), 1) - self.assert_equal(len(actual[0]), 1) - self.assert_allclose(actual[0][0], self.expected_00) - self.assert_equal(exp.means[0].shape, self.image_shape) - self.assert_equal(exp.means[-1].shape, self.image_shape) + self.compare_output(exp) def test_ncores_separate_2(self): exp = core.Experiment( @@ -204,12 +244,7 @@ def test_ncores_separate_2(self): ncores_separation=2, ) exp.separate() - actual = exp.result - self.assert_equal(len(actual), 1) - self.assert_equal(len(actual[0]), 1) - self.assert_allclose(actual[0][0], self.expected_00) - self.assert_equal(exp.means[0].shape, self.image_shape) - self.assert_equal(exp.means[-1].shape, self.image_shape) + self.compare_output(exp) def test_lowmemorymode(self): exp = core.Experiment( @@ -218,12 +253,7 @@ def test_lowmemorymode(self): lowmemory_mode=True, ) exp.separate() - actual = exp.result - self.assert_equal(len(actual), 1) - self.assert_equal(len(actual[0]), 1) - self.assert_allclose(actual[0][0], self.expected_00) - self.assert_equal(exp.means[0].shape, self.image_shape) - self.assert_equal(exp.means[-1].shape, self.image_shape) + self.compare_output(exp) def test_manualhandler_Tifffile(self): exp = core.Experiment( @@ -233,10 +263,7 @@ def test_manualhandler_Tifffile(self): datahandler=extraction.DataHandlerTifffile(), ) exp.separate() - actual = exp.result - self.assert_equal(len(actual), 1) - self.assert_equal(len(actual[0]), 1) - self.assert_allclose(actual[0][0], self.expected_00) + self.compare_output(exp) def test_manualhandler_TifffileLazy(self): exp = core.Experiment( @@ -246,10 +273,7 @@ def test_manualhandler_TifffileLazy(self): datahandler=extraction.DataHandlerTifffileLazy(), ) exp.separate() - actual = exp.result - self.assert_equal(len(actual), 1) - self.assert_equal(len(actual[0]), 1) - self.assert_allclose(actual[0][0], self.expected_00) + self.compare_output(exp) def test_manualhandler_Pillow(self): exp = core.Experiment( @@ -259,12 +283,7 @@ def test_manualhandler_Pillow(self): datahandler=extraction.DataHandlerPillow(), ) exp.separate() - actual = exp.result - self.assert_equal(len(actual), 1) - self.assert_equal(len(actual[0]), 1) - self.assert_allclose(actual[0][0], self.expected_00) - self.assert_equal(exp.means[0].shape, self.image_shape) - self.assert_equal(exp.means[-1].shape, self.image_shape) + self.compare_output(exp) def test_caching(self): exp = core.Experiment(self.images_dir, self.roi_zip_path, self.output_dir) @@ -324,12 +343,7 @@ def test_prepfirst(self): exp = core.Experiment(self.images_dir, self.roi_zip_path, self.output_dir) exp.separation_prep() exp.separate() - actual = exp.result - self.assert_equal(len(actual), 1) - self.assert_equal(len(actual[0]), 1) - self.assert_allclose(actual[0][0], self.expected_00) - self.assert_equal(exp.means[0].shape, self.image_shape) - self.assert_equal(exp.means[-1].shape, self.image_shape) + self.compare_output(exp) def test_redo(self): """Test whether experiment redoes work when requested.""" @@ -342,6 +356,7 @@ def test_redo(self): exp.separate(redo_prep=True, redo_sep=True) capture_post = self.recapsys(capture_pre) self.assert_starts_with(capture_post.out, "Doing") + self.compare_output(exp) def test_load_cache(self): """Test whether cached output is loaded during init.""" @@ -353,12 +368,7 @@ def test_load_cache(self): # Make a new experiment we will test exp = core.Experiment(image_path, roi_path, self.output_dir) # Cache should be loaded without calling separate - actual = exp.result - self.assert_equal(len(actual), 1) - self.assert_equal(len(actual[0]), 1) - self.assert_allclose(actual[0][0], self.expected_00) - self.assert_equal(exp.means[0].shape, self.image_shape) - self.assert_equal(exp.means[-1].shape, self.image_shape) + self.compare_output(exp) def test_load_cache_piecemeal(self): """ @@ -385,12 +395,7 @@ def test_load_cache_piecemeal(self): capture_post = self.recapsys(capture_pre) self.assert_starts_with(capture_post.out, "Reloading data") # Check the contents loaded from cache - actual = exp.result - self.assert_equal(len(actual), 1) - self.assert_equal(len(actual[0]), 1) - self.assert_allclose(actual[0][0], self.expected_00) - self.assert_equal(exp.means[0].shape, self.image_shape) - self.assert_equal(exp.means[-1].shape, self.image_shape) + self.compare_output(exp) def test_load_cached_prep(self): """ @@ -417,12 +422,7 @@ def test_load_cached_prep(self): capture_post = self.recapsys(capture_pre) self.assert_starts_with(capture_post.out, "Doing signal separation") # Check the contents loaded from cache - actual = exp.result - self.assert_equal(len(actual), 1) - self.assert_equal(len(actual[0]), 1) - self.assert_allclose(actual[0][0], self.expected_00) - self.assert_equal(exp.means[0].shape, self.image_shape) - self.assert_equal(exp.means[-1].shape, self.image_shape) + self.compare_output(exp) def test_load_manual_prep(self): """Loading prep results from a different folder.""" @@ -437,7 +437,7 @@ def test_load_manual_prep(self): exp = core.Experiment(image_path, roi_path, new_folder) exp.load(os.path.join(prev_folder, "preparation.npz")) # Cached prep should now be loaded correctly - self.assert_allclose_ragged(exp.raw, exp1.raw) + self.compare_experiments(exp, exp1) def test_load_manual_sep(self): """Loading prep results from a different folder.""" @@ -452,7 +452,7 @@ def test_load_manual_sep(self): exp = core.Experiment(image_path, roi_path, new_folder) exp.load(os.path.join(prev_folder, "separated.npz")) # Cached results should now be loaded correctly - self.assert_allclose_ragged(exp.result, exp1.result) + self.compare_experiments(exp, exp1, prepared=False) def test_load_manual_directory(self): """Loading results from a different folder.""" @@ -467,8 +467,7 @@ def test_load_manual_directory(self): exp = core.Experiment(image_path, roi_path, new_folder) exp.load(prev_folder) # Cache should now be loaded correctly - self.assert_allclose_ragged(exp.raw, exp1.raw) - self.assert_allclose_ragged(exp.result, exp1.result) + self.compare_experiments(exp, exp1) def test_load_manual(self): """Loading results from a different folder.""" @@ -487,8 +486,7 @@ def test_load_manual(self): # Manually trigger loading the new cache exp.load() # Cache should now be loaded correctly - self.assert_allclose_ragged(exp.raw, exp1.raw) - self.assert_allclose_ragged(exp.result, exp1.result) + self.compare_experiments(exp, exp1) def test_load_empty_prep(self): """Behaviour when loading a prep cache that is empty.""" @@ -496,10 +494,7 @@ def test_load_empty_prep(self): # Make an empty prep save file np.savez_compressed(os.path.join(self.output_dir, "preparation.npz")) exp.separation_prep() - actual = exp.raw - self.assert_equal(len(actual), 1) - self.assert_equal(len(actual[0]), 1) - self.assert_allclose(actual[0][0].shape, self.expected_00.shape) + self.compare_output(exp, separated=False) def test_load_empty_sep(self): """Behaviour when loading a separated cache that is empty.""" @@ -507,12 +502,7 @@ def test_load_empty_sep(self): # Make an empty separated save file np.savez_compressed(os.path.join(self.output_dir, "separated.npz")) exp.separate() - actual = exp.result - self.assert_equal(len(actual), 1) - self.assert_equal(len(actual[0]), 1) - self.assert_allclose(actual[0][0], self.expected_00) - self.assert_equal(exp.means[0].shape, self.image_shape) - self.assert_equal(exp.means[-1].shape, self.image_shape) + self.compare_output(exp) def test_load_none(self): """Behaviour when loading a cache containing None.""" @@ -595,10 +585,7 @@ def test_badprepcache(self): capture_post = self.recapsys(capture_pre) # Capture and then re-output self.assert_starts_with(capture_post.out, "Doing signal separation") - actual = exp.result - self.assert_equal(len(actual), 1) - self.assert_equal(len(actual[0]), 1) - self.assert_allclose(actual[0][0], self.expected_00) + self.compare_output(exp) def test_badsepcache(self): """ @@ -619,12 +606,7 @@ def test_badsepcache(self): capture_post = self.recapsys(capture_pre) # Capture and then re-output self.assertTrue("An error occurred" in capture_post.out) - actual = exp.result - self.assert_equal(len(actual), 1) - self.assert_equal(len(actual[0]), 1) - self.assert_allclose(actual[0][0], self.expected_00) - self.assert_equal(exp.means[0].shape, self.image_shape) - self.assert_equal(exp.means[-1].shape, self.image_shape) + self.compare_output(exp) def test_manual_save_prep(self): """Saving prep results with manually specified filename.""" @@ -714,30 +696,16 @@ def test_matlab(self): exp.separate() exp.save_to_matlab() fname = os.path.join(self.output_dir, "matlab.mat") - self.assertTrue(os.path.isfile(fname)) # Check contents of the .mat file - M = loadmat(fname) - for field in ["raw", "result"]: - self.assert_allclose(M[field][0, 0][0][0, 0][0], getattr(exp, field)[0, 0]) - self.assert_allclose( - M["ROIs"][0, 0][0][0, 0][0][0][0], - exp.roi_polys[0, 0][0][0], - ) + self.compare_matlab(fname, exp) def test_matlab_custom_fname(self): exp = core.Experiment(self.images_dir, self.roi_zip_path, self.output_dir) exp.separate() fname = os.path.join(self.output_dir, "test_output.mat") exp.save_to_matlab(fname) - self.assertTrue(os.path.isfile(fname)) # Check contents of the .mat file - M = loadmat(fname) - for field in ["raw", "result"]: - self.assert_allclose(M[field][0, 0][0][0, 0][0], getattr(exp, field)[0, 0]) - self.assert_allclose( - M["ROIs"][0, 0][0][0, 0][0][0][0], - exp.roi_polys[0, 0][0][0], - ) + self.compare_matlab(fname, exp) def test_matlab_no_cache_no_fname(self): exp = core.Experiment(self.images_dir, self.roi_zip_path) @@ -754,15 +722,7 @@ def test_matlab_from_cache(self): # Cache should be loaded without calling separate exp.save_to_matlab() fname = os.path.join(self.output_dir, "matlab.mat") - self.assertTrue(os.path.isfile(fname)) - # Check contents of the .mat file - M = loadmat(fname) - for field in ["raw", "result"]: - self.assert_allclose(M[field][0, 0][0][0, 0][0], getattr(exp, field)[0, 0]) - self.assert_allclose( - M["ROIs"][0, 0][0][0, 0][0][0][0], - exp.roi_polys[0, 0][0][0], - ) + self.compare_matlab(fname, exp) def test_matlab_deltaf(self): exp = core.Experiment(self.images_dir, self.roi_zip_path, self.output_dir) @@ -770,17 +730,5 @@ def test_matlab_deltaf(self): exp.calc_deltaf(4) exp.save_to_matlab() fname = os.path.join(self.output_dir, "matlab.mat") - self.assertTrue(os.path.isfile(fname)) # Check contents of the .mat file - M = loadmat(fname) - for kmt, kpy in [("raw",) * 2, ("result",) * 2, ("df_result", "deltaf_result")]: - self.assert_allclose(M[kmt][0, 0][0][0, 0][0], getattr(exp, kpy)[0, 0]) - # Row and column vectors on MATLAB are 2d instead of 1d, and df_raw - # is a vector, not a matrix, so has an extra dimension. - # N.B. This extra dimension is in the wrong place as it doesn't align - # with the other attributes. - self.assert_allclose(M["df_raw"][0, 0][0][0, 0][0][0, :], exp.deltaf_raw[0, 0]) - self.assert_allclose( - M["ROIs"][0, 0][0][0, 0][0][0][0], - exp.roi_polys[0, 0][0][0], - ) + self.compare_matlab(fname, exp, compare_deltaf=True) From 6b2ed529b5fb1a7392549cbbefab7e50edc826fd Mon Sep 17 00:00:00 2001 From: Scott Lowe Date: Thu, 24 Jun 2021 23:35:11 +0100 Subject: [PATCH 4/5] TST:ENH: Test shape of raw as well as result --- fissa/tests/test_core.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/fissa/tests/test_core.py b/fissa/tests/test_core.py index 02724b61..08315724 100644 --- a/fissa/tests/test_core.py +++ b/fissa/tests/test_core.py @@ -80,6 +80,8 @@ def compare_output(self, experiment, separated=True): Whether to compare results of :meth:`fissa.Experiment.separate`. Default is ``True``. """ + self.assert_equal(len(experiment.raw), 1) + self.assert_equal(len(experiment.raw[0]), 1) if separated: self.assert_equal(len(experiment.result), 1) self.assert_equal(len(experiment.result[0]), 1) From d6ecce2b5e51473e916453eb19429cf32672442d Mon Sep 17 00:00:00 2001 From: Scott Lowe Date: Thu, 24 Jun 2021 23:36:03 +0100 Subject: [PATCH 5/5] TST:RF: Move deltaf comparisons into compare_output --- fissa/tests/test_core.py | 64 +++++++++++++++++++++++++++------------- 1 file changed, 43 insertions(+), 21 deletions(-) diff --git a/fissa/tests/test_core.py b/fissa/tests/test_core.py index 08315724..98f6dccd 100644 --- a/fissa/tests/test_core.py +++ b/fissa/tests/test_core.py @@ -68,7 +68,7 @@ def tearDown(self): if os.path.isdir(self.output_dir): shutil.rmtree(self.output_dir) - def compare_output(self, experiment, separated=True): + def compare_output(self, experiment, separated=True, compare_deltaf=None): """ Compare experiment output against expected from test attributes. @@ -79,7 +79,19 @@ def compare_output(self, experiment, separated=True): separated : bool Whether to compare results of :meth:`fissa.Experiment.separate`. Default is ``True``. + compare_deltaf : bool or None + Whether to compare ``experiment.deltaf_raw`` against + ``experiment.raw`` and, if ``separated=True``, + ``experiment.deltaf_result`` against ``experiment.result``. + If ``None`` (default), this is automatically determined based on + whether ``experiment.deltaf_result`` (if ``separated=True``) or + ``experiment.deltaf_raw`` (otherwise) is not ``None``. """ + if compare_deltaf is None: + if separated: + compare_deltaf = experiment.deltaf_result is not None + else: + compare_deltaf = experiment.deltaf_raw is not None self.assert_equal(len(experiment.raw), 1) self.assert_equal(len(experiment.raw[0]), 1) if separated: @@ -89,6 +101,31 @@ def compare_output(self, experiment, separated=True): self.assert_equal(len(experiment.means), len(self.image_names)) self.assert_equal(experiment.means[0].shape, self.image_shape) self.assert_equal(experiment.means[-1].shape, self.image_shape) + # TODO: Check contents of exp.deltaf_result instead of just the shape + if compare_deltaf: + if experiment.raw is None: + self.assertIs(experiment.deltaf_raw, experiment.raw) + else: + self.assert_equal( + np.shape(experiment.deltaf_raw), + np.shape(experiment.raw), + ) + self.assert_equal( + np.shape(experiment.deltaf_raw[0]), + np.shape(experiment.raw[0]), + ) + if compare_deltaf and separated: + if experiment.result is None: + self.assertIs(experiment.deltaf_result, experiment.result) + else: + self.assert_equal( + np.shape(experiment.deltaf_result), + np.shape(experiment.result), + ) + self.assert_equal( + np.shape(experiment.deltaf_result[0]), + np.shape(experiment.result[0]), + ) def compare_experiments(self, actual, expected, prepared=True, separated=True): """ @@ -652,46 +689,31 @@ def test_calcdeltaf(self): exp = core.Experiment(self.images_dir, self.roi_zip_path) exp.separate() exp.calc_deltaf(4) - actual = exp.deltaf_result - self.assert_equal(len(actual), 1) - self.assert_equal(len(actual[0]), 1) - #TODO: Check contents of exp.deltaf_result + self.compare_output(exp, compare_deltaf=True) def test_calcdeltaf_cache(self): exp = core.Experiment(self.images_dir, self.roi_zip_path, self.output_dir) exp.separate() exp.calc_deltaf(4) - actual = exp.deltaf_result - self.assert_equal(len(actual), 1) - self.assert_equal(len(actual[0]), 1) - #TODO: Check contents of exp.deltaf_result + self.compare_output(exp, compare_deltaf=True) def test_calcdeltaf_notrawf0(self): exp = core.Experiment(self.images_dir, self.roi_zip_path) exp.separate() exp.calc_deltaf(4, use_raw_f0=False) - actual = exp.deltaf_result - self.assert_equal(len(actual), 1) - self.assert_equal(len(actual[0]), 1) - #TODO: Check contents of exp.deltaf_result + self.compare_output(exp, compare_deltaf=True) def test_calcdeltaf_notacrosstrials(self): exp = core.Experiment(self.images_dir, self.roi_zip_path) exp.separate() exp.calc_deltaf(4, across_trials=False) - actual = exp.deltaf_result - self.assert_equal(len(actual), 1) - self.assert_equal(len(actual[0]), 1) - #TODO: Check contents of exp.deltaf_result + self.compare_output(exp, compare_deltaf=True) def test_calcdeltaf_notrawf0_notacrosstrials(self): exp = core.Experiment(self.images_dir, self.roi_zip_path) exp.separate() exp.calc_deltaf(4, use_raw_f0=False, across_trials=False) - actual = exp.deltaf_result - self.assert_equal(len(actual), 1) - self.assert_equal(len(actual[0]), 1) - #TODO: Check contents of exp.deltaf_result + self.compare_output(exp, compare_deltaf=True) def test_matlab(self): exp = core.Experiment(self.images_dir, self.roi_zip_path, self.output_dir)