From 58b96c3ce8106f1ff5b88d973dbfc32c59a090a6 Mon Sep 17 00:00:00 2001 From: nordme Date: Tue, 26 Sep 2023 08:45:40 -0700 Subject: [PATCH 01/10] test draft --- mne/preprocessing/tests/test_unify_bads.py | 58 ++++++++++++++++++++++ 1 file changed, 58 insertions(+) create mode 100644 mne/preprocessing/tests/test_unify_bads.py diff --git a/mne/preprocessing/tests/test_unify_bads.py b/mne/preprocessing/tests/test_unify_bads.py new file mode 100644 index 00000000000..8c696ba6e36 --- /dev/null +++ b/mne/preprocessing/tests/test_unify_bads.py @@ -0,0 +1,58 @@ +from pathlib import Path + +import numpy as np +import pytest + +import mne +from mne.preprocessing import unify_bad_channels +from ..io import BaseRaw +from ..epochs import Epochs +from ..evoked import Evoked +from ..time_frequency.spectrum import BaseSpectrum + + +raw_fname = ( + Path(__file__).parent.parent.parent / "io" / "tests" / "data" / "test_raw.fif" +) +@pytest.mark.parametrize('instance', ('raw', 'epochs', 'evoked', 'spectrum')) +def test_instance_support(instance): + # test unify_bads function on instance (single input, no bads scenario) + unify_bad_channels(instance) + + +def test_bads_order(raw): + +def test_unify_bads(raw, epochs): + ## test error raising + # err 1: no instance passed to function + with pytest.raises(UserWarning): # FIX RAISE TYPE + unify_bad_channels([]) + # err 2: bad instance passed to function + bad_inst = 'bad_instance' + with pytest.raises(UserWarning): # FIX RAISE TYPE + unify_bad_channels(bad_inst) + # err 3: mixed instance types passed to function + with pytest.raises(ValueError): + unify_bad_channels([raw, epochs]) + ## check unification scenarios + # scnario 1: single instance with actual bads (already tested no bads) + raw.info['bads'] += raw.info['ch_names'][0] + s_unified = unify_bad_channels(raw) + assert len(s_unified) == 1 + assert s_unified[0].info['bads'] == raw.info['ch_names'][0] + # scenario 2: multiple instances + # a) empty bads list, b) unique bads, c) overlapping out-of-order bads, + # d) channel name not included in raw channels + chns = raw.info['ch_names'][0:3] + raws = [raw, raw.copy(), raw.copy(), raw.copy(), raw.copy()] + assert raws[0].info['bads'] == [chns[0]] + raws[1].info['bads'] = [] + raws[2].info['bads'] = [chns[2]] + raws[3].info['bads'] = [chns[2], chns[1]] + raws[4].info['bads'] = ['nonsense_ch_name'] + # use unify_bads function + m_unified = unify_bad_channels(raws) + assert len(m_unified) == len(raws) + # check results + for i in np.arange(len(m_unified)): + assert m_unified[i].info['bads'] == From 7c28118dbf77ccc1f13e4443ad13aa35a40cb70b Mon Sep 17 00:00:00 2001 From: nordme Date: Tue, 26 Sep 2023 12:57:20 -0700 Subject: [PATCH 02/10] make functions work --- mne/preprocessing/tests/test_unify_bads.py | 67 +++++++++++----------- 1 file changed, 32 insertions(+), 35 deletions(-) diff --git a/mne/preprocessing/tests/test_unify_bads.py b/mne/preprocessing/tests/test_unify_bads.py index 8c696ba6e36..f01a9d58809 100644 --- a/mne/preprocessing/tests/test_unify_bads.py +++ b/mne/preprocessing/tests/test_unify_bads.py @@ -1,49 +1,45 @@ -from pathlib import Path - import numpy as np import pytest -import mne -from mne.preprocessing import unify_bad_channels -from ..io import BaseRaw -from ..epochs import Epochs -from ..evoked import Evoked -from ..time_frequency.spectrum import BaseSpectrum - +from mne.preprocessing.unify_bads import unify_bad_channels +from mne.time_frequency.tests.test_spectrum import _get_inst() -raw_fname = ( - Path(__file__).parent.parent.parent / "io" / "tests" / "data" / "test_raw.fif" -) -@pytest.mark.parametrize('instance', ('raw', 'epochs', 'evoked', 'spectrum')) -def test_instance_support(instance): +@pytest.mark.parametrize('instance', ('raw', 'epochs', 'evoked', 'raw_spectrum', 'epochs_spectrum')) +def test_instance_support(instance, request, evoked): + '''Tests support of different classes.''' # test unify_bads function on instance (single input, no bads scenario) - unify_bad_channels(instance) + inst = _get_inst(instance, request, evoked) + inst_out = unify_bad_channels([inst]) + assert inst_out == [inst] + +@pytest.mark.parametrize('instance', ([], ['bad_instance'], 'mixed')) +def test_error_raising(instance, request, evoked): + '''Tests input checking.''' + if instance == 'mixed': + instance = [_get_inst('raw', request, evoked), + _get_inst('epochs', request, evoked)] + with pytest.raises(TypeError): + unify_bad_channels(instance) -def test_bads_order(raw): -def test_unify_bads(raw, epochs): - ## test error raising - # err 1: no instance passed to function - with pytest.raises(UserWarning): # FIX RAISE TYPE - unify_bad_channels([]) - # err 2: bad instance passed to function - bad_inst = 'bad_instance' - with pytest.raises(UserWarning): # FIX RAISE TYPE - unify_bad_channels(bad_inst) - # err 3: mixed instance types passed to function - with pytest.raises(ValueError): - unify_bad_channels([raw, epochs]) +def test_bads_compilation(raw): + '''Tests that bads are compiled properly in two cases: a) single instance + passed to function with an existing bad, and b) multiple instances passed + to function with varying compilation scenarios including empty bads, + unique bads, partially duplicated bads listed out-of-order, and + nonsense channel names.''' ## check unification scenarios - # scnario 1: single instance with actual bads (already tested no bads) - raw.info['bads'] += raw.info['ch_names'][0] - s_unified = unify_bad_channels(raw) + chns = raw.info['ch_names'][0:3] + # scnario 1: single instance passed with actual bads (already tested no bads) + assert raw.info['bads'] == [] + raw.info['bads'] += [chns[0]] + s_unified = unify_bad_channels([raw]) assert len(s_unified) == 1 - assert s_unified[0].info['bads'] == raw.info['ch_names'][0] - # scenario 2: multiple instances + assert s_unified[0].info['bads'] == [chns[0]], (s_unified[0].info['bads'], chns[0]) + # scenario 2: multiple instances passed, bads types as follows: # a) empty bads list, b) unique bads, c) overlapping out-of-order bads, # d) channel name not included in raw channels - chns = raw.info['ch_names'][0:3] raws = [raw, raw.copy(), raw.copy(), raw.copy(), raw.copy()] assert raws[0].info['bads'] == [chns[0]] raws[1].info['bads'] = [] @@ -54,5 +50,6 @@ def test_unify_bads(raw, epochs): m_unified = unify_bad_channels(raws) assert len(m_unified) == len(raws) # check results + correct_bads = [chns[0], chns[2], chns[1], 'nonsense_ch_name'] for i in np.arange(len(m_unified)): - assert m_unified[i].info['bads'] == + assert m_unified[i].info['bads'] == correct_bads From d89431e313e0595f16184be9f3cb7a94c93c8397 Mon Sep 17 00:00:00 2001 From: nordme Date: Tue, 26 Sep 2023 13:55:16 -0700 Subject: [PATCH 03/10] style fixes --- mne/preprocessing/tests/test_unify_bads.py | 59 ++++++++++++---------- 1 file changed, 33 insertions(+), 26 deletions(-) diff --git a/mne/preprocessing/tests/test_unify_bads.py b/mne/preprocessing/tests/test_unify_bads.py index f01a9d58809..96edf86c1ae 100644 --- a/mne/preprocessing/tests/test_unify_bads.py +++ b/mne/preprocessing/tests/test_unify_bads.py @@ -1,55 +1,62 @@ import numpy as np import pytest -from mne.preprocessing.unify_bads import unify_bad_channels -from mne.time_frequency.tests.test_spectrum import _get_inst() +from mne.preprocessing import unify_bad_channels +from mne.time_frequency.tests.test_spectrum import _get_inst -@pytest.mark.parametrize('instance', ('raw', 'epochs', 'evoked', 'raw_spectrum', 'epochs_spectrum')) + +@pytest.mark.parametrize( + "instance", ("raw", "epochs", "evoked", "raw_spectrum", "epochs_spectrum") +) def test_instance_support(instance, request, evoked): - '''Tests support of different classes.''' + """Tests support of different classes.""" # test unify_bads function on instance (single input, no bads scenario) inst = _get_inst(instance, request, evoked) inst_out = unify_bad_channels([inst]) assert inst_out == [inst] -@pytest.mark.parametrize('instance', ([], ['bad_instance'], 'mixed')) +@pytest.mark.parametrize("instance", ([], ["bad_instance"], "mixed")) def test_error_raising(instance, request, evoked): - '''Tests input checking.''' - if instance == 'mixed': - instance = [_get_inst('raw', request, evoked), - _get_inst('epochs', request, evoked)] + """Tests input checking.""" + if instance == "mixed": + instance = [ + _get_inst("raw", request, evoked), + _get_inst("epochs", request, evoked), + ] with pytest.raises(TypeError): unify_bad_channels(instance) def test_bads_compilation(raw): - '''Tests that bads are compiled properly in two cases: a) single instance - passed to function with an existing bad, and b) multiple instances passed - to function with varying compilation scenarios including empty bads, - unique bads, partially duplicated bads listed out-of-order, and - nonsense channel names.''' + """Tests that bads are compiled properly. + + Tests two cases: a) single instance passed to function with an existing + bad, and b) multiple instances passed to function with varying compilation + scenarios including empty bads, unique bads, partially duplicated bads + listed out-of-order, and nonsense channel names. + """ ## check unification scenarios - chns = raw.info['ch_names'][0:3] - # scnario 1: single instance passed with actual bads (already tested no bads) - assert raw.info['bads'] == [] - raw.info['bads'] += [chns[0]] + chns = raw.info["ch_names"][0:3] + # scenario 1: single instance passed with actual bads (already tested no bads) + assert raw.info["bads"] == [] + raw.info["bads"] += [chns[0]] s_unified = unify_bad_channels([raw]) assert len(s_unified) == 1 - assert s_unified[0].info['bads'] == [chns[0]], (s_unified[0].info['bads'], chns[0]) + assert s_unified[0].info["bads"] == [chns[0]], (s_unified[0].info["bads"], chns[0]) # scenario 2: multiple instances passed, bads types as follows: # a) empty bads list, b) unique bads, c) overlapping out-of-order bads, # d) channel name not included in raw channels raws = [raw, raw.copy(), raw.copy(), raw.copy(), raw.copy()] - assert raws[0].info['bads'] == [chns[0]] - raws[1].info['bads'] = [] - raws[2].info['bads'] = [chns[2]] - raws[3].info['bads'] = [chns[2], chns[1]] - raws[4].info['bads'] = ['nonsense_ch_name'] + assert raws[0].info["bads"] == [chns[0]] + raws[1].info["bads"] = [] + raws[2].info["bads"] = [chns[2]] + raws[3].info["bads"] = [chns[2], chns[1]] + raws[4].info["bads"] = ["nonsense_ch_name"] # use unify_bads function m_unified = unify_bad_channels(raws) assert len(m_unified) == len(raws) # check results - correct_bads = [chns[0], chns[2], chns[1], 'nonsense_ch_name'] + correct_bads = [chns[0], chns[2], chns[1], "nonsense_ch_name"] for i in np.arange(len(m_unified)): - assert m_unified[i].info['bads'] == correct_bads + assert m_unified[i].info["bads"] == correct_bads From 9b745cb6ece743d857fc5692f6223a645b23dd39 Mon Sep 17 00:00:00 2001 From: nordme Date: Wed, 27 Sep 2023 09:54:21 -0700 Subject: [PATCH 04/10] style fix --- mne/preprocessing/tests/test_unify_bads.py | 63 ++++++++++------------ 1 file changed, 29 insertions(+), 34 deletions(-) diff --git a/mne/preprocessing/tests/test_unify_bads.py b/mne/preprocessing/tests/test_unify_bads.py index 96edf86c1ae..da4d01716de 100644 --- a/mne/preprocessing/tests/test_unify_bads.py +++ b/mne/preprocessing/tests/test_unify_bads.py @@ -16,16 +16,18 @@ def test_instance_support(instance, request, evoked): assert inst_out == [inst] -@pytest.mark.parametrize("instance", ([], ["bad_instance"], "mixed")) -def test_error_raising(instance, request, evoked): +def test_error_raising(raw, epochs): """Tests input checking.""" - if instance == "mixed": - instance = [ - _get_inst("raw", request, evoked), - _get_inst("epochs", request, evoked), - ] - with pytest.raises(TypeError): - unify_bad_channels(instance) + with pytest.raises(IndexError, match=r"empty list"): + unify_bad_channels([]) + with pytest.raises(TypeError, match=r"must be an instance of"): + unify_bad_channels(["bad_instance"]) + with pytest.raises(ValueError, match=r"same type"): + unify_bad_channels([raw, epochs]) + with pytest.raises(AssertionError): + raw_alt = raw.copy() + raw_alt.info["ch_names"] = raw.info["ch_names"][0] + unify_bad_channels([raw, raw_alt]) def test_bads_compilation(raw): @@ -33,30 +35,23 @@ def test_bads_compilation(raw): Tests two cases: a) single instance passed to function with an existing bad, and b) multiple instances passed to function with varying compilation - scenarios including empty bads, unique bads, partially duplicated bads - listed out-of-order, and nonsense channel names. + scenarios including empty bads, unique bads, and partially duplicated bads + listed out-of-order. """ - ## check unification scenarios - chns = raw.info["ch_names"][0:3] - # scenario 1: single instance passed with actual bads (already tested no bads) assert raw.info["bads"] == [] - raw.info["bads"] += [chns[0]] - s_unified = unify_bad_channels([raw]) - assert len(s_unified) == 1 - assert s_unified[0].info["bads"] == [chns[0]], (s_unified[0].info["bads"], chns[0]) - # scenario 2: multiple instances passed, bads types as follows: - # a) empty bads list, b) unique bads, c) overlapping out-of-order bads, - # d) channel name not included in raw channels - raws = [raw, raw.copy(), raw.copy(), raw.copy(), raw.copy()] - assert raws[0].info["bads"] == [chns[0]] - raws[1].info["bads"] = [] - raws[2].info["bads"] = [chns[2]] - raws[3].info["bads"] = [chns[2], chns[1]] - raws[4].info["bads"] = ["nonsense_ch_name"] - # use unify_bads function - m_unified = unify_bad_channels(raws) - assert len(m_unified) == len(raws) - # check results - correct_bads = [chns[0], chns[2], chns[1], "nonsense_ch_name"] - for i in np.arange(len(m_unified)): - assert m_unified[i].info["bads"] == correct_bads + chns = raw.info["ch_names"][0:3] + no_bad = raw.copy() + one_bad = raw.copy() + one_bad.info["bads"] = chns[1] + three_bad = raw.copy() + three_bad.info["bads"] = chns + # scenario 1: single instance passed with actual bads + s_out = unify_bad_channels([one_bad]) + assert len(s_out) == 1 + assert s_out[0].info["bads"] == [chns[1]], (s_out[0].info["bads"], chns[1]) + # scenario 2: multiple instances passed + m_out = unify_bad_channels([one_bad, no_bad, three_bad]) + assert len(m_out) == 3 + correct_bads = [chns[1], chns[0], chns[2]] + for i in np.arange(len(m_out)): + assert m_out[i].info["bads"] == correct_bads From b32f318d83548e47c18bb9c6be0fd629a3eac5f8 Mon Sep 17 00:00:00 2001 From: nordme Date: Wed, 27 Sep 2023 10:12:16 -0700 Subject: [PATCH 05/10] fixes --- mne/preprocessing/tests/test_unify_bads.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/mne/preprocessing/tests/test_unify_bads.py b/mne/preprocessing/tests/test_unify_bads.py index da4d01716de..6ca9d60fa72 100644 --- a/mne/preprocessing/tests/test_unify_bads.py +++ b/mne/preprocessing/tests/test_unify_bads.py @@ -18,7 +18,7 @@ def test_instance_support(instance, request, evoked): def test_error_raising(raw, epochs): """Tests input checking.""" - with pytest.raises(IndexError, match=r"empty list"): + with pytest.raises(IndexError, match=r"list index"): unify_bad_channels([]) with pytest.raises(TypeError, match=r"must be an instance of"): unify_bad_channels(["bad_instance"]) @@ -42,7 +42,7 @@ def test_bads_compilation(raw): chns = raw.info["ch_names"][0:3] no_bad = raw.copy() one_bad = raw.copy() - one_bad.info["bads"] = chns[1] + one_bad.info["bads"] = [chns[1]] three_bad = raw.copy() three_bad.info["bads"] = chns # scenario 1: single instance passed with actual bads From dc8a71a174e91c55c9d591f3d4c4f2af3b8abedb Mon Sep 17 00:00:00 2001 From: nordme Date: Wed, 27 Sep 2023 10:23:19 -0700 Subject: [PATCH 06/10] reconcile with Ana --- mne/preprocessing/tests/test_unify_bads.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/mne/preprocessing/tests/test_unify_bads.py b/mne/preprocessing/tests/test_unify_bads.py index 6ca9d60fa72..d5fe4f2b849 100644 --- a/mne/preprocessing/tests/test_unify_bads.py +++ b/mne/preprocessing/tests/test_unify_bads.py @@ -18,15 +18,15 @@ def test_instance_support(instance, request, evoked): def test_error_raising(raw, epochs): """Tests input checking.""" - with pytest.raises(IndexError, match=r"list index"): + with pytest.raises(ValueError, match=r"empty list"): unify_bad_channels([]) with pytest.raises(TypeError, match=r"must be an instance of"): unify_bad_channels(["bad_instance"]) with pytest.raises(ValueError, match=r"same type"): unify_bad_channels([raw, epochs]) - with pytest.raises(AssertionError): + with pytest.raises(ValueError): raw_alt = raw.copy() - raw_alt.info["ch_names"] = raw.info["ch_names"][0] + raw_alt.drop_channels(raw.info["ch_names"][0]) unify_bad_channels([raw, raw_alt]) From 83407f6c918cb6e651760be062730e503681bda9 Mon Sep 17 00:00:00 2001 From: nordme Date: Wed, 27 Sep 2023 14:19:05 -0700 Subject: [PATCH 07/10] fixes for Ana fixes --- mne/preprocessing/tests/test_unify_bads.py | 40 ++++++++++------------ 1 file changed, 18 insertions(+), 22 deletions(-) diff --git a/mne/preprocessing/tests/test_unify_bads.py b/mne/preprocessing/tests/test_unify_bads.py index d5fe4f2b849..1788d863849 100644 --- a/mne/preprocessing/tests/test_unify_bads.py +++ b/mne/preprocessing/tests/test_unify_bads.py @@ -1,33 +1,26 @@ -import numpy as np import pytest - -from mne.preprocessing import unify_bad_channels -from mne.time_frequency.tests.test_spectrum import _get_inst - - -@pytest.mark.parametrize( - "instance", ("raw", "epochs", "evoked", "raw_spectrum", "epochs_spectrum") -) -def test_instance_support(instance, request, evoked): - """Tests support of different classes.""" - # test unify_bads function on instance (single input, no bads scenario) - inst = _get_inst(instance, request, evoked) - inst_out = unify_bad_channels([inst]) - assert inst_out == [inst] +from mne.channels import unify_bad_channels def test_error_raising(raw, epochs): """Tests input checking.""" + with pytest.raises(TypeError, match=r"must be an instance of list"): + unify_bad_channels("bad input") with pytest.raises(ValueError, match=r"empty list"): unify_bad_channels([]) with pytest.raises(TypeError, match=r"must be an instance of"): unify_bad_channels(["bad_instance"]) with pytest.raises(ValueError, match=r"same type"): unify_bad_channels([raw, epochs]) - with pytest.raises(ValueError): - raw_alt = raw.copy() - raw_alt.drop_channels(raw.info["ch_names"][0]) - unify_bad_channels([raw, raw_alt]) + with pytest.raises(ValueError, match=r"sorted differently"): + raw_alt1 = raw.copy() + raw_alt1.drop_channels(raw.info["ch_names"][-1]) + unify_bad_channels([raw, raw_alt1]) # ch diff preserving order + with pytest.raises(ValueError, match=r"not consistent"): + raw_alt2 = raw.copy() + new_order = [raw.info["ch_names"][-1]] + raw.info["ch_names"][:-1] + raw_alt2.reorder_channels(new_order) + unify_bad_channels([raw, raw_alt2]) def test_bads_compilation(raw): @@ -37,6 +30,9 @@ def test_bads_compilation(raw): bad, and b) multiple instances passed to function with varying compilation scenarios including empty bads, unique bads, and partially duplicated bads listed out-of-order. + + Only the Raw instance type is tested, since bad channel implementation is + controlled across instance types with a MixIn class. """ assert raw.info["bads"] == [] chns = raw.info["ch_names"][0:3] @@ -47,11 +43,11 @@ def test_bads_compilation(raw): three_bad.info["bads"] = chns # scenario 1: single instance passed with actual bads s_out = unify_bad_channels([one_bad]) - assert len(s_out) == 1 + assert len(s_out) == 1, len(s_out) assert s_out[0].info["bads"] == [chns[1]], (s_out[0].info["bads"], chns[1]) # scenario 2: multiple instances passed m_out = unify_bad_channels([one_bad, no_bad, three_bad]) - assert len(m_out) == 3 + assert len(m_out) == 3, len(m_out) correct_bads = [chns[1], chns[0], chns[2]] - for i in np.arange(len(m_out)): + for i in range(len(m_out)): assert m_out[i].info["bads"] == correct_bads From df45b8640d21c0978740bcf67e823e4392b039dc Mon Sep 17 00:00:00 2001 From: nordme Date: Wed, 27 Sep 2023 14:24:23 -0700 Subject: [PATCH 08/10] move tests file --- mne/{preprocessing => channels}/tests/test_unify_bads.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename mne/{preprocessing => channels}/tests/test_unify_bads.py (100%) diff --git a/mne/preprocessing/tests/test_unify_bads.py b/mne/channels/tests/test_unify_bads.py similarity index 100% rename from mne/preprocessing/tests/test_unify_bads.py rename to mne/channels/tests/test_unify_bads.py From 0309925780066f87edc055596e689b34cec26452 Mon Sep 17 00:00:00 2001 From: nordme <38704848+nordme@users.noreply.github.com> Date: Wed, 27 Sep 2023 14:58:06 -0700 Subject: [PATCH 09/10] Apply suggestions from code review Co-authored-by: Daniel McCloy --- mne/channels/tests/test_unify_bads.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/mne/channels/tests/test_unify_bads.py b/mne/channels/tests/test_unify_bads.py index 1788d863849..771a52af51c 100644 --- a/mne/channels/tests/test_unify_bads.py +++ b/mne/channels/tests/test_unify_bads.py @@ -8,17 +8,17 @@ def test_error_raising(raw, epochs): unify_bad_channels("bad input") with pytest.raises(ValueError, match=r"empty list"): unify_bad_channels([]) - with pytest.raises(TypeError, match=r"must be an instance of"): + with pytest.raises(TypeError, match=r"each object in insts must be an instance of"): unify_bad_channels(["bad_instance"]) with pytest.raises(ValueError, match=r"same type"): unify_bad_channels([raw, epochs]) - with pytest.raises(ValueError, match=r"sorted differently"): + with pytest.raises(ValueError, match=r"Channels do not match across"): raw_alt1 = raw.copy() raw_alt1.drop_channels(raw.info["ch_names"][-1]) unify_bad_channels([raw, raw_alt1]) # ch diff preserving order - with pytest.raises(ValueError, match=r"not consistent"): + with pytest.raises(ValueError, match=r"sorted differently"): raw_alt2 = raw.copy() - new_order = [raw.info["ch_names"][-1]] + raw.info["ch_names"][:-1] + new_order = [raw.ch_names[-1]] + raw.ch_names[:-1] raw_alt2.reorder_channels(new_order) unify_bad_channels([raw, raw_alt2]) @@ -35,7 +35,7 @@ def test_bads_compilation(raw): controlled across instance types with a MixIn class. """ assert raw.info["bads"] == [] - chns = raw.info["ch_names"][0:3] + chns = raw.ch_names[:3] no_bad = raw.copy() one_bad = raw.copy() one_bad.info["bads"] = [chns[1]] @@ -48,6 +48,6 @@ def test_bads_compilation(raw): # scenario 2: multiple instances passed m_out = unify_bad_channels([one_bad, no_bad, three_bad]) assert len(m_out) == 3, len(m_out) - correct_bads = [chns[1], chns[0], chns[2]] - for i in range(len(m_out)): - assert m_out[i].info["bads"] == correct_bads + expected_order = [chns[1], chns[0], chns[2]] + for inst in m_out: + assert inst.info["bads"] == expected_order From 6c610d1b341abd0ba89b24b3ab46d3503e85c2ea Mon Sep 17 00:00:00 2001 From: nordme Date: Wed, 27 Sep 2023 15:01:58 -0700 Subject: [PATCH 10/10] pytest fix --- mne/channels/tests/test_unify_bads.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/mne/channels/tests/test_unify_bads.py b/mne/channels/tests/test_unify_bads.py index 771a52af51c..ac04983802b 100644 --- a/mne/channels/tests/test_unify_bads.py +++ b/mne/channels/tests/test_unify_bads.py @@ -6,7 +6,7 @@ def test_error_raising(raw, epochs): """Tests input checking.""" with pytest.raises(TypeError, match=r"must be an instance of list"): unify_bad_channels("bad input") - with pytest.raises(ValueError, match=r"empty list"): + with pytest.raises(ValueError, match=r"insts must not be empty"): unify_bad_channels([]) with pytest.raises(TypeError, match=r"each object in insts must be an instance of"): unify_bad_channels(["bad_instance"])