def test_data_can_be_added_correctly_via_keyword_args(self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
self.assertEqual(data.num_items(), 1)
self.assertEqual(data.contains_n(run=1234), 1)
self.assertEqual(data.contains_n(workspace=[1]), 1)
self.assertEqual(data.contains_n(filename="C:\\dir1\\file1.nxs"), 1)
def test_data_can_be_added_correctly_via_keyword_args(self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
self.assertEqual(data.num_items(), 1)
self.assertEqual(data.contains_n(run=1234), 1)
self.assertEqual(data.contains_n(workspace=[1]), 1)
self.assertEqual(data.contains_n(filename="C:\\dir1\\file1.nxs"), 1)
def test_counting_entries_with_keyword_argument_gives_correct_count(self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.add_data(run=1235, workspace=[2], filename="C:\\dir1\\file2.nxs")
data.add_data(run=1234, workspace=[3], filename="C:\\dir1\\file3.nxs")
self.assertEqual(data.contains_n(run=1234), 2)
self.assertEqual(data.contains_n(filename="C:\\dir1\\file1.nxs"), 1)
self.assertEqual(data.contains_n(run=9999), 0)
def test_counting_entries_with_keyword_argument_gives_correct_count(self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.add_data(run=1235, workspace=[2], filename="C:\\dir1\\file2.nxs")
data.add_data(run=1234, workspace=[3], filename="C:\\dir1\\file3.nxs")
self.assertEqual(data.contains_n(run=1234), 2)
self.assertEqual(data.contains_n(filename="C:\\dir1\\file1.nxs"), 1)
self.assertEqual(data.contains_n(run=9999), 0)
def test_that_contains_is_true_when_data_contains_entries_which_match_to_at_least_one_of_multiple_keywords(self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.add_data(run=1235, workspace=[2], filename="C:\\dir1\\file2.nxs")
data.add_data(run=1234, workspace=[3], filename="C:\\dir1\\file3.nxs")
# values from keywords correspond to different entries
self.assertTrue(data.contains(run=1234, filename="C:\\dir1\\file2.nxs"))
self.assertTrue(data.contains(run=1234, workspace=[3]))
def test_that_contains_is_false_when_data_contains_entries_which_match_to_only_one_of_multiple_keywords(self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.add_data(run=1235, workspace=[2], filename="C:\\dir1\\file2.nxs")
data.add_data(run=1234, workspace=[3], filename="C:\\dir1\\file3.nxs")
# values from keywords correspond to different entries
self.assertFalse(data.contains(run=1234, filename="C:\\dir1\\file2.nxs"))
self.assertTrue(data.contains(run=1234, workspace=[3]))
def test_that_remove_method_can_remove_several_entries_at_once(self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.add_data(run=1234, workspace=[2], filename="C:\\dir1\\file2.nxs")
data.add_data(run=1234, workspace=[3], filename="C:\\dir1\\file3.nxs")
self.assertEqual(data.num_items(), 3)
data.remove_data(run=1234)
self.assert_empty(data)
def test_counting_entries_applies_OR_behaviour_to_keyword_arguments(self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.add_data(run=1235, workspace=[2], filename="C:\\dir1\\file2.nxs")
data.add_data(run=1234, workspace=[3], filename="C:\\dir1\\file3.nxs")
data.add_data(run=1236, workspace=[4], filename="C:\\dir1\\file4.nxs")
self.assertEqual(data.contains_n(run=1234, workspace=[1]), 2)
self.assertEqual(data.contains_n(run=1234, workspace=[2]), 3)
self.assertEqual(data.contains_n(run=1234, workspace=[2], filename="C:\\dir1\\file4.nxs"), 4)
def test_counting_entries_applies_AND_behaviour_to_keyword_arguments(self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.add_data(run=1235, workspace=[2], filename="C:\\dir1\\file2.nxs")
data.add_data(run=1234, workspace=[3], filename="C:\\dir1\\file3.nxs")
data.add_data(run=1236, workspace=[4], filename="C:\\dir1\\file4.nxs")
self.assertEqual(data.contains_n(run=1234, workspace=[1]), 1)
self.assertEqual(data.contains_n(run=1234, workspace=[2]), 0)
self.assertEqual(data.contains_n(run=1234, workspace=[2], filename="C:\\dir1\\file4.nxs"), 0)
def test_that_remove_method_can_remove_several_entries_at_once(self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.add_data(run=1234, workspace=[2], filename="C:\\dir1\\file2.nxs")
data.add_data(run=1234, workspace=[3], filename="C:\\dir1\\file3.nxs")
self.assertEqual(data.num_items(), 3)
data.remove_data(run=1234)
self.assert_empty(data)
def test_that_contains_is_true_when_data_contains_entry_which_matches_to_a_single_keyword_and_false_otherwise(self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.add_data(run=1235, workspace=[2], filename="C:\\dir1\\file2.nxs")
data.add_data(run=1234, workspace=[3], filename="C:\\dir1\\file3.nxs")
self.assertTrue(data.contains(run=1234))
self.assertTrue(data.contains(filename="C:\\dir1\\file1.nxs"))
self.assertFalse(data.contains(run=9999))
self.assertFalse(data.contains(filename="C:\\dir1\\file4.nxs"))
def test_that_contains_is_true_when_data_contains_entry_which_matches_to_a_single_keyword_and_false_otherwise(self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.add_data(run=1235, workspace=[2], filename="C:\\dir1\\file2.nxs")
data.add_data(run=1234, workspace=[3], filename="C:\\dir1\\file3.nxs")
self.assertTrue(data.contains(run=1234))
self.assertTrue(data.contains(filename="C:\\dir1\\file1.nxs"))
self.assertFalse(data.contains(run=9999))
self.assertFalse(data.contains(filename="C:\\dir1\\file4.nxs"))
def populate_loaded_data(self):
data = MuonLoadData()
data.add_data(run=1234,
workspace=[1],
filename="C:\\dir1\\file1.nxs",
instrument='EMU')
data.add_data(run=1235,
workspace=[2],
filename="C:\\dir1\\file2.nxs",
instrument='EMU')
data.add_data(run=1236,
workspace=[3],
filename="C:\\dir1\\file3.nxs",
instrument='EMU')
return data
def test_that_adding_then_removing_single_item_leaves_data_empty(self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
self.assertEqual(data.num_items(), 1)
data.remove_data(run=1234)
self.assert_empty(data)
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.remove_data(workspace=[1])
self.assert_empty(data)
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.remove_data(filename="C:\\dir1\\file1.nxs")
self.assert_empty(data)
def test_that_adding_then_removing_single_item_leaves_data_empty(self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
self.assertEqual(data.num_items(), 1)
data.remove_data(run=1234)
self.assert_empty(data)
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.remove_data(workspace=[1])
self.assert_empty(data)
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.remove_data(filename="C:\\dir1\\file1.nxs")
self.assert_empty(data)
class EAGroupContextTest(unittest.TestCase):
def setUp(self):
self.context = EAGroupContext()
self.loadedData = MuonLoadData()
def create_group_workspace_and_load(self):
grpws = WorkspaceGroup()
ws_detector1 = '9999; Detector 1'
grpws.addWorkspace(CreateSampleWorkspace(OutputWorkspace=ws_detector1))
ws_detector2 = '9999; Detector 2'
grpws.addWorkspace(CreateSampleWorkspace(OutputWorkspace=ws_detector2))
run = 9999
self.loadedData.add_data(run=[run], workspace=grpws)
# ------------------------------------------------------------------------------------------------------------------
# TESTS
# ------------------------------------------------------------------------------------------------------------------
def test_add_new_group(self):
self.loadedData.clear()
self.create_group_workspace_and_load()
empty_group = []
new_group = self.context.add_new_group(empty_group, self.loadedData)
self.assertEqual(len(new_group), 2)
def test_remove_group(self):
self.loadedData.clear()
self.create_group_workspace_and_load()
self.context.reset_group_to_default(self.loadedData)
self.assertEqual(len(self.context.groups), 2)
group_name1 = '9999; Detector 1'
self.assertTrue(group_name1 in self.context.group_names)
self.context.remove_group(group_name1)
self.assertFalse(group_name1 in self.context.group_names)
def test_reset_group_to_default(self):
self.loadedData.clear()
self.assertEqual(self.loadedData.num_items(), 0)
self.create_group_workspace_and_load()
self.context.reset_group_to_default(self.loadedData)
self.assertEqual(len(self.context.groups), 2)
def test_clear(self):
self.loadedData.clear()
self.create_group_workspace_and_load()
self.context.reset_group_to_default(self.loadedData)
self.assertEqual(len(self.context.groups), 2)
self.context.clear()
self.assertEqual(len(self.context.groups), 0)
@mock.patch(
"Muon.GUI.ElementalAnalysis2.ea_group.EAGroup.remove_rebinned_workspace"
)
@mock.patch(
"Muon.GUI.ElementalAnalysis2.ea_group.EAGroup.remove_peak_table")
@mock.patch(
"Muon.GUI.ElementalAnalysis2.ea_group.EAGroup.remove_matches_group")
def test_remove_rebinned_workspace_from_group(self, mock_remove_matches,
mock_remove_peak,
mock_remove_rebinned):
mock_group = EAGroup("9999; Detector 1", "detector 1", "9999")
self.context.add_group(mock_group)
self.context.remove_workspace_from_group(
'9999; Detector 1_EA_Rebinned_Fixed')
mock_remove_rebinned.assert_called_once()
mock_remove_peak.assert_not_called()
mock_remove_matches.assert_not_called()
@mock.patch(
"Muon.GUI.ElementalAnalysis2.ea_group.EAGroup.remove_rebinned_workspace"
)
@mock.patch(
"Muon.GUI.ElementalAnalysis2.ea_group.EAGroup.remove_peak_table")
@mock.patch(
"Muon.GUI.ElementalAnalysis2.ea_group.EAGroup.remove_matches_group")
def test_remove_peak_table_from_group(self, mock_remove_matches,
mock_remove_peak,
mock_remove_rebinned):
mock_group = EAGroup("9999; Detector 1", "detector 1", "9999")
self.context.add_group(mock_group)
self.context.remove_workspace_from_group(
'9999; Detector 1_EA_peak_table')
mock_remove_rebinned.assert_not_called()
mock_remove_peak.aassert_called_once()
mock_remove_matches.assert_not_called()
@mock.patch(
"Muon.GUI.ElementalAnalysis2.ea_group.EAGroup.remove_rebinned_workspace"
)
@mock.patch(
"Muon.GUI.ElementalAnalysis2.ea_group.EAGroup.remove_peak_table")
@mock.patch(
"Muon.GUI.ElementalAnalysis2.ea_group.EAGroup.remove_matches_group")
def test_remove_matches_table_from_group(self, mock_remove_matches,
mock_remove_peak,
mock_remove_rebinned):
mock_group = EAGroup("9999; Detector 1", "detector 1", "9999")
self.context.add_group(mock_group)
self.context.remove_workspace_from_group('9999; Detector 1_EA_matches')
mock_remove_rebinned.assert_not_called()
mock_remove_peak.aassert_not_called()
mock_remove_matches.assert_called_once()
@mock.patch(
"Muon.GUI.ElementalAnalysis2.ea_group.EAGroup.remove_rebinned_workspace"
)
@mock.patch(
"Muon.GUI.ElementalAnalysis2.ea_group.EAGroup.remove_peak_table")
@mock.patch(
"Muon.GUI.ElementalAnalysis2.ea_group.EAGroup.remove_matches_group")
def test_remove_workspace_from_group_when_not_in_group(
self, mock_remove_matches, mock_remove_peak, mock_remove_rebinned):
mock_group = EAGroup("9999; Detector 1", "detector 1", "9999")
self.context.add_group(mock_group)
self.context.remove_workspace_from_group('mock_workspace')
mock_remove_rebinned.assert_not_called()
mock_remove_peak.aassert_not_called()
mock_remove_matches.assert_not_called()
@mock.patch("Muon.GUI.ElementalAnalysis2.ea_group.remove_ws_if_present")
def test_error_raised_when_deleting_EAGroup(self, mock_remove_ws):
self.loadedData.clear()
self.create_group_workspace_and_load()
self.context.reset_group_to_default(self.loadedData)
self.assertEqual(len(self.context.groups), 2)
group_name1 = '9999; Detector 1'
self.assertTrue(group_name1 in self.context.group_names)
mock_remove_ws.side_effect = ValueError("mock error")
error_notifier_mock = mock.Mock()
self.context[group_name1].error_notifier = error_notifier_mock
self.context.remove_group(group_name1)
self.assertFalse(group_name1 in self.context.group_names)
mock_remove_ws.assert_called_once_with(group_name1)
error_notifier_mock.notify_subscribers.assert_called_once_with(
f"Unexpected error occurred when"
f" deleting group {group_name1}: mock error")
class MuonLoadDataTest(unittest.TestCase):
def setUp(self):
self.muon_load_data = MuonLoadData()
self.workspace = mock.MagicMock()
self.workspace_last = mock.MagicMock()
self.muon_load_data.add_data(run=1, workspace=mock.MagicMock(), filename='path to file')
self.muon_load_data.add_data(run=2, workspace=self.workspace, filename='path to file')
self.muon_load_data.add_data(run=3, workspace=mock.MagicMock(), filename='matching path')
self.muon_load_data.add_data()
self.muon_load_data.add_data(run=4, workspace=self.workspace_last, filename='path to file')
def assert_empty(self, load_data):
self.assertEqual(load_data.get_parameter("run"), [])
self.assertEqual(load_data.get_parameter("workspace"), [])
self.assertEqual(load_data.get_parameter("filename"), [])
self.assertEqual(load_data.num_items(), 0)
def populate_loaded_data(self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.add_data(run=1235, workspace=[2], filename="C:\\dir1\\file2.nxs")
data.add_data(run=1236, workspace=[3], filename="C:\\dir1\\file3.nxs")
return data
# ------------------------------------------------------------------------------------------------------------------
# TESTS
# ------------------------------------------------------------------------------------------------------------------
def test_load_data_initialized_as_empty(self):
data = MuonLoadData()
self.assert_empty(data)
def test_data_can_be_added_correctly_via_keyword_args(self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
self.assertEqual(data.num_items(), 1)
self.assertEqual(data.contains_n(run=1234), 1)
self.assertEqual(data.contains_n(workspace=[1]), 1)
self.assertEqual(data.contains_n(filename="C:\\dir1\\file1.nxs"), 1)
def test_that_clear_empties_the_data_of_all_entries(self):
data = self.populate_loaded_data()
self.assertEqual(data.num_items(), 3)
data.clear()
self.assert_empty(data)
def test_that_adding_then_removing_single_item_leaves_data_empty(self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
self.assertEqual(data.num_items(), 1)
data.remove_data(run=1234)
self.assert_empty(data)
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.remove_data(workspace=[1])
self.assert_empty(data)
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.remove_data(filename="C:\\dir1\\file1.nxs")
self.assert_empty(data)
def test_that_remove_method_can_remove_several_entries_at_once(self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.add_data(run=1234, workspace=[2], filename="C:\\dir1\\file2.nxs")
data.add_data(run=1234, workspace=[3], filename="C:\\dir1\\file3.nxs")
self.assertEqual(data.num_items(), 3)
data.remove_data(run=1234)
self.assert_empty(data)
def test_that_remove_method_applies_OR_to_multiple_keyword_arguments(self):
data = self.populate_loaded_data()
self.assertEqual(data.num_items(), 3)
data.remove_data(run=1234, workspace=[2], filename="C:\\dir1\\file3.nxs")
self.assert_empty(data)
def test_that_contains_is_true_when_data_contains_entry_which_matches_to_a_single_keyword_and_false_otherwise(self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.add_data(run=1235, workspace=[2], filename="C:\\dir1\\file2.nxs")
data.add_data(run=1234, workspace=[3], filename="C:\\dir1\\file3.nxs")
self.assertTrue(data.contains(run=1234))
self.assertTrue(data.contains(filename="C:\\dir1\\file1.nxs"))
self.assertFalse(data.contains(run=9999))
self.assertFalse(data.contains(filename="C:\\dir1\\file4.nxs"))
def test_that_contains_is_true_when_data_contains_entries_which_match_to_at_least_one_of_multiple_keywords(self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.add_data(run=1235, workspace=[2], filename="C:\\dir1\\file2.nxs")
data.add_data(run=1234, workspace=[3], filename="C:\\dir1\\file3.nxs")
# values from keywords correspond to different entries
self.assertTrue(data.contains(run=1234, filename="C:\\dir1\\file2.nxs"))
self.assertTrue(data.contains(run=1234, workspace=[3]))
def test_counting_entries_with_keyword_argument_gives_correct_count(self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.add_data(run=1235, workspace=[2], filename="C:\\dir1\\file2.nxs")
data.add_data(run=1234, workspace=[3], filename="C:\\dir1\\file3.nxs")
self.assertEqual(data.contains_n(run=1234), 2)
self.assertEqual(data.contains_n(filename="C:\\dir1\\file1.nxs"), 1)
self.assertEqual(data.contains_n(run=9999), 0)
def test_counting_entries_applies_OR_behaviour_to_keyword_arguments(self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.add_data(run=1235, workspace=[2], filename="C:\\dir1\\file2.nxs")
data.add_data(run=1234, workspace=[3], filename="C:\\dir1\\file3.nxs")
data.add_data(run=1236, workspace=[4], filename="C:\\dir1\\file4.nxs")
self.assertEqual(data.contains_n(run=1234, workspace=[1]), 2)
self.assertEqual(data.contains_n(run=1234, workspace=[2]), 3)
self.assertEqual(data.contains_n(run=1234, workspace=[2], filename="C:\\dir1\\file4.nxs"), 4)
def test_iterator_behaviour_of_data(self):
data = self.populate_loaded_data()
check = [{"run": 1234, "workspace": [1], "filename": "C:\\dir1\\file1.nxs"},
{"run": 1235, "workspace": [2], "filename": "C:\\dir1\\file2.nxs"},
{"run": 1236, "workspace": [3], "filename": "C:\\dir1\\file3.nxs"}]
for data_item in iter(data):
self.assertEqual(data_item, check.pop(0))
def test_that_remove_current_data_removes_the_most_recently_added_data(self):
data = self.populate_loaded_data()
data.remove_current_data()
check = [{"run": 1234, "workspace": [1], "filename": "C:\\dir1\\file1.nxs"},
{"run": 1235, "workspace": [2], "filename": "C:\\dir1\\file2.nxs"}]
for data_item in iter(data):
self.assertEqual(data_item, check.pop(0))
def test_that_remove_last_added_data_removes_the_previous_data_item_before_the_most_recent(self):
data = self.populate_loaded_data()
data.remove_last_added_data()
check = [{"run": 1234, "workspace": [1], "filename": "C:\\dir1\\file1.nxs"},
{"run": 1236, "workspace": [3], "filename": "C:\\dir1\\file3.nxs"}]
for data_item in iter(data):
self.assertEqual(data_item, check.pop(0))
def test_that_can_add_data_to_struct(self):
self.assertEqual(self.muon_load_data.num_items(), 5)
self.assertEqual(self.muon_load_data.get_parameter('run')[2], 3)
self.assertEqual(self.muon_load_data.get_parameter('workspace')[1], self.workspace)
self.assertEqual(self.muon_load_data.get_parameter('filename')[0], 'path to file')
def test_that_matches_returns_true_for_all_entries_with_one_match(self):
match_list = self.muon_load_data._matches(run=1, workspace=self.workspace, filename='matching path')
self.assertEqual(match_list, [True, True, True, False, False])
def test_that_matches_with_no_params_matches_none(self):
match_list = self.muon_load_data._matches()
self.assertEqual(match_list, [False, False, False, False, False])
def test_that_matches_with_unused_parameters_match_none(self):
match_list = self.muon_load_data._matches(new_info='new info')
self.assertEqual(match_list, [False, False, False, False, False])
def test_that_matches_correctly_with_only_one_parameter_given(self):
match_list = self.muon_load_data._matches(filename='path to file')
self.assertEqual(match_list, [True, True, False, False, True])
def test_that_get_data_returns_correct_dict(self):
data_dict = self.muon_load_data.get_data(run=2)
self.assertEqual(data_dict, {'workspace': self.workspace, 'filename': 'path to file', 'run': 2})
def test_that_get_latest_data_returns_correct_dict(self):
data_dict = self.muon_load_data.get_latest_data()
self.assertEqual(data_dict, {'workspace': self.workspace_last, 'filename': 'path to file', 'run': 4})
class MuonLoadDataTest(unittest.TestCase):
def setUp(self):
self.muon_load_data = MuonLoadData()
self.workspace = mock.MagicMock()
self.workspace_last = mock.MagicMock()
self.muon_load_data.add_data(run=1,
workspace=mock.MagicMock(),
filename='path to file')
self.muon_load_data.add_data(run=2,
workspace=self.workspace,
filename='path to file')
self.muon_load_data.add_data(run=3,
workspace=mock.MagicMock(),
filename='matching path')
self.muon_load_data.add_data()
self.muon_load_data.add_data(run=4,
workspace=self.workspace_last,
filename='path to file')
def assert_empty(self, load_data):
self.assertEqual(load_data.get_parameter("run"), [])
self.assertEqual(load_data.get_parameter("workspace"), [])
self.assertEqual(load_data.get_parameter("filename"), [])
self.assertEqual(load_data.num_items(), 0)
def assert_unchanged(self, load_data):
self.assertEqual(load_data.get_parameter("run"), [1234, 1235, 1236])
self.assertEqual(load_data.get_parameter("workspace"), [[1], [2], [3]])
self.assertEqual(load_data.get_parameter("filename"), [
"C:\\dir1\\file1.nxs", "C:\\dir1\\file2.nxs", "C:\\dir1\\file3.nxs"
])
self.assertEqual(load_data.num_items(), 3)
def populate_loaded_data(self):
data = MuonLoadData()
data.add_data(run=1234,
workspace=[1],
filename="C:\\dir1\\file1.nxs",
instrument='EMU')
data.add_data(run=1235,
workspace=[2],
filename="C:\\dir1\\file2.nxs",
instrument='EMU')
data.add_data(run=1236,
workspace=[3],
filename="C:\\dir1\\file3.nxs",
instrument='EMU')
return data
# ------------------------------------------------------------------------------------------------------------------
# TESTS
# ------------------------------------------------------------------------------------------------------------------
def test_load_data_initialized_as_empty(self):
data = MuonLoadData()
self.assert_empty(data)
def test_data_can_be_added_correctly_via_keyword_args(self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
self.assertEqual(data.num_items(), 1)
self.assertEqual(data.contains_n(run=1234), 1)
self.assertEqual(data.contains_n(workspace=[1]), 1)
self.assertEqual(data.contains_n(filename="C:\\dir1\\file1.nxs"), 1)
def test_that_clear_empties_the_data_of_all_entries(self):
data = self.populate_loaded_data()
self.assertEqual(data.num_items(), 3)
data.clear()
self.assert_empty(data)
def test_that_adding_then_removing_single_item_leaves_data_empty(self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
self.assertEqual(data.num_items(), 1)
data.remove_data(run=1234)
self.assert_empty(data)
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.remove_data(workspace=[1])
self.assert_empty(data)
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.remove_data(filename="C:\\dir1\\file1.nxs")
self.assert_empty(data)
def test_that_remove_method_can_remove_several_entries_at_once(self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.add_data(run=1234, workspace=[2], filename="C:\\dir1\\file2.nxs")
data.add_data(run=1234, workspace=[3], filename="C:\\dir1\\file3.nxs")
self.assertEqual(data.num_items(), 3)
data.remove_data(run=1234)
self.assert_empty(data)
def test_that_remove_method_applies_AND_to_multiple_keyword_arguments(
self):
data = self.populate_loaded_data()
self.assertEqual(data.num_items(), 3)
data.remove_data(run=1234,
workspace=[2],
filename="C:\\dir1\\file3.nxs")
self.assert_unchanged(data)
def test_that_contains_is_true_when_data_contains_entry_which_matches_to_a_single_keyword_and_false_otherwise(
self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.add_data(run=1235, workspace=[2], filename="C:\\dir1\\file2.nxs")
data.add_data(run=1234, workspace=[3], filename="C:\\dir1\\file3.nxs")
self.assertTrue(data.contains(run=1234))
self.assertTrue(data.contains(filename="C:\\dir1\\file1.nxs"))
self.assertFalse(data.contains(run=9999))
self.assertFalse(data.contains(filename="C:\\dir1\\file4.nxs"))
def test_that_contains_is_false_when_data_contains_entries_which_match_to_only_one_of_multiple_keywords(
self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.add_data(run=1235, workspace=[2], filename="C:\\dir1\\file2.nxs")
data.add_data(run=1234, workspace=[3], filename="C:\\dir1\\file3.nxs")
# values from keywords correspond to different entries
self.assertFalse(
data.contains(run=1234, filename="C:\\dir1\\file2.nxs"))
self.assertTrue(data.contains(run=1234, workspace=[3]))
def test_counting_entries_with_keyword_argument_gives_correct_count(self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.add_data(run=1235, workspace=[2], filename="C:\\dir1\\file2.nxs")
data.add_data(run=1234, workspace=[3], filename="C:\\dir1\\file3.nxs")
self.assertEqual(data.contains_n(run=1234), 2)
self.assertEqual(data.contains_n(filename="C:\\dir1\\file1.nxs"), 1)
self.assertEqual(data.contains_n(run=9999), 0)
def test_counting_entries_applies_AND_behaviour_to_keyword_arguments(self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.add_data(run=1235, workspace=[2], filename="C:\\dir1\\file2.nxs")
data.add_data(run=1234, workspace=[3], filename="C:\\dir1\\file3.nxs")
data.add_data(run=1236, workspace=[4], filename="C:\\dir1\\file4.nxs")
self.assertEqual(data.contains_n(run=1234, workspace=[1]), 1)
self.assertEqual(data.contains_n(run=1234, workspace=[2]), 0)
self.assertEqual(
data.contains_n(run=1234,
workspace=[2],
filename="C:\\dir1\\file4.nxs"), 0)
def test_iterator_behaviour_of_data(self):
data = self.populate_loaded_data()
check = [{
"run": 1234,
"workspace": [1],
"filename": "C:\\dir1\\file1.nxs",
'instrument': 'EMU'
}, {
"run": 1235,
"workspace": [2],
"filename": "C:\\dir1\\file2.nxs",
'instrument': 'EMU'
}, {
"run": 1236,
"workspace": [3],
"filename": "C:\\dir1\\file3.nxs",
'instrument': 'EMU'
}]
for data_item in iter(data):
self.assertEqual(data_item, check.pop(0))
def test_that_remove_current_data_removes_the_most_recently_added_data(
self):
data = self.populate_loaded_data()
data.remove_current_data()
check = [{
"run": 1234,
"workspace": [1],
"filename": "C:\\dir1\\file1.nxs",
'instrument': 'EMU'
}, {
"run": 1235,
"workspace": [2],
"filename": "C:\\dir1\\file2.nxs",
'instrument': 'EMU'
}]
for data_item in iter(data):
self.assertEqual(data_item, check.pop(0))
def test_that_remove_last_added_data_removes_the_previous_data_item_before_the_most_recent(
self):
data = self.populate_loaded_data()
data.remove_last_added_data()
check = [{
"run": 1234,
"workspace": [1],
"filename": "C:\\dir1\\file1.nxs",
'instrument': 'EMU'
}, {
"run": 1236,
"workspace": [3],
"filename": "C:\\dir1\\file3.nxs",
'instrument': 'EMU'
}]
for data_item in iter(data):
self.assertEqual(data_item, check.pop(0))
def test_that_can_add_data_to_struct(self):
self.assertEqual(self.muon_load_data.num_items(), 5)
self.assertEqual(self.muon_load_data.get_parameter('run')[2], 3)
self.assertEqual(
self.muon_load_data.get_parameter('workspace')[1], self.workspace)
self.assertEqual(
self.muon_load_data.get_parameter('filename')[0], 'path to file')
def test_that_matches_returns_false_for_all_entries_with_only_one_match(
self):
match_list = self.muon_load_data._matches(run=1,
workspace=self.workspace,
filename='matching path')
self.assertEqual(match_list, [False, False, False, False, False])
def test_that_matches_with_no_params_matches_all(self):
match_list = self.muon_load_data._matches()
self.assertEqual(match_list, [True, True, True, True, True])
def test_that_matches_with_unused_parameters_match_none(self):
match_list = self.muon_load_data._matches(new_info='new info')
self.assertEqual(match_list, [False, False, False, False, False])
def test_that_matches_correctly_with_only_one_parameter_given(self):
match_list = self.muon_load_data._matches(filename='path to file')
self.assertEqual(match_list, [True, True, False, False, True])
def test_that_get_data_returns_correct_dict(self):
data_dict = self.muon_load_data.get_data(run=2)
self.assertEqual(
data_dict, {
'workspace': self.workspace,
'filename': 'path to file',
'run': 2,
'instrument': ''
})
def test_that_get_latest_data_returns_correct_dict(self):
data_dict = self.muon_load_data.get_latest_data()
self.assertEqual(
data_dict, {
'workspace': self.workspace_last,
'filename': 'path to file',
'run': 4,
'instrument': ''
})
def populate_loaded_data(self):
data = MuonLoadData()
data.add_data(run=1234, workspace=[1], filename="C:\\dir1\\file1.nxs")
data.add_data(run=1235, workspace=[2], filename="C:\\dir1\\file2.nxs")
data.add_data(run=1236, workspace=[3], filename="C:\\dir1\\file3.nxs")
return data
class MuonContextTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
pass
def setUp(self):
AnalysisDataService.clear()
self.filepath = FileFinder.findRuns('EMU00019489.nxs')[0]
self.load_result, self.run_number, self.filename = load_workspace_from_filename(
self.filepath)
self.loaded_data = MuonLoadData()
self.data_context = MuonDataContext(self.loaded_data)
self.gui_context = MuonGuiContext()
self.group_pair_context = MuonGroupPairContext()
self.gui_context.update({'RebinType': 'None'})
self.context = MuonContext(muon_data_context=self.data_context,
muon_gui_context=self.gui_context,
muon_group_context=self.group_pair_context)
self.data_context.instrument = 'EMU'
self.loaded_data.add_data(workspace=self.load_result,
run=[self.run_number],
filename=self.filename,
instrument='EMU')
self.data_context.current_runs = [[self.run_number]]
self.data_context.update_current_data()
self.group_pair_context.reset_group_and_pairs_to_default(
self.load_result['OutputWorkspace'][0]._workspace, 'EMU', '')
def populate_ADS(self):
self.context.calculate_all_groups()
self.context.show_all_groups()
self.context.calculate_all_pairs()
self.context.show_all_pairs()
workspace = CreateWorkspace([0], [0], StoreInADS=False)
self.context.phase_context.add_phase_quad(
MuonWorkspaceWrapper(workspace,
'EMU19489; PhaseQuad; PhaseTable EMU19489'))
def test_reset_groups_and_pairs_to_default(self):
self.assertEquals(self.group_pair_context.group_names, ['fwd', 'bwd'])
self.assertEquals(self.group_pair_context.pair_names, ['long'])
def test_calculate_group_calculates_group_for_given_run(self):
counts_workspace, asymmetry_workspace = self.context.calculate_group(
'fwd', run=[19489])
self.assertEquals(type(counts_workspace), Workspace2D)
self.assertEquals(type(counts_workspace), Workspace2D)
def test_calculate_pair_calculates_pair_for_given_run(self):
pair_asymmetry = self.context.calculate_pair('long', run=[19489])
self.assertEquals(type(pair_asymmetry), Workspace2D)
def test_show_all_groups_calculates_and_shows_all_groups(self):
self.context.show_all_groups()
self.assertEquals(AnalysisDataService.getObjectNames(), [
'EMU19489', 'EMU19489 Groups',
'EMU19489; Group; bwd; Asymmetry; #1',
'EMU19489; Group; bwd; Counts; #1',
'EMU19489; Group; fwd; Asymmetry; #1',
'EMU19489; Group; fwd; Counts; #1', 'Muon Data'
])
def test_that_show_all_calculates_and_shows_all_groups_with_rebin(self):
self.gui_context['RebinType'] = 'Fixed'
self.gui_context['RebinFixed'] = 2
self.context.show_all_groups()
self.assertEquals(AnalysisDataService.getObjectNames(), [
'EMU19489', 'EMU19489 Groups',
'EMU19489; Group; bwd; Asymmetry; #1',
'EMU19489; Group; bwd; Asymmetry; Rebin; #1',
'EMU19489; Group; bwd; Counts; #1',
'EMU19489; Group; bwd; Counts; Rebin; #1',
'EMU19489; Group; fwd; Asymmetry; #1',
'EMU19489; Group; fwd; Asymmetry; Rebin; #1',
'EMU19489; Group; fwd; Counts; #1',
'EMU19489; Group; fwd; Counts; Rebin; #1', 'Muon Data'
])
def test_show_all_pairs_calculates_and_shows_all_pairs(self):
self.context.show_all_pairs()
self.assertEquals(AnalysisDataService.getObjectNames(), [
'EMU19489', 'EMU19489 Pairs', 'EMU19489; Pair Asym; long; #1',
'Muon Data'
])
def test_that_show_all_calculates_and_shows_all_pairs_with_rebin(self):
self.gui_context['RebinType'] = 'Fixed'
self.gui_context['RebinFixed'] = 2
self.context.show_all_pairs()
self.assertEquals(AnalysisDataService.getObjectNames(), [
'EMU19489', 'EMU19489 Pairs', 'EMU19489; Pair Asym; long; #1',
'EMU19489; Pair Asym; long; Rebin; #1', 'Muon Data'
])
def test_update_current_data_sets_current_run_in_data_context(self):
self.context.update_current_data()
self.assertEquals(self.data_context.current_data, self.load_result)
def test_update_current_data_sets_groups_and_pairs(self):
self.context.update_current_data()
self.assertEquals(self.group_pair_context.pair_names, ['long'])
self.assertEquals(self.group_pair_context.group_names, ['fwd', 'bwd'])
def test_show_raw_data_puts_raw_data_into_the_ADS(self):
self.context.show_raw_data()
self.assertEquals(AnalysisDataService.getObjectNames(), [
'EMU19489', 'EMU19489 Raw Data', 'EMU19489_raw_data', 'Muon Data'
])
def test_that_first_good_data_returns_correctly_when_from_file_chosen_option(
self):
self.gui_context.update({'FirstGoodDataFromFile': True})
first_good_data = self.context.first_good_data([19489])
self.assertEquals(first_good_data, 0.11)
def test_first_good_data_returns_correctly_when_manually_specified_used(
self):
self.gui_context.update({
'FirstGoodDataFromFile': False,
'FirstGoodData': 5
})
first_good_data = self.context.first_good_data([19489])
self.assertEquals(first_good_data, 5)
def test_that_last_good_data_returns_correctly_when_from_file_chosen_option(
self):
self.gui_context.update({'LastGoodDataFromFile': True})
last_good_data = self.context.last_good_data([19489])
self.assertEquals(last_good_data, 31.76)
def test_last_good_data_returns_correctly_when_manually_specified_used(
self):
self.gui_context.update({
'LastGoodDataFromFile': False,
'LastGoodData': 5
})
last_good_data = self.context.last_good_data([19489])
self.assertEquals(last_good_data, 5)
def test_that_dead_time_table_from_ADS_returns_table_name(self):
self.gui_context.update({
'DeadTimeSource': 'FromADS',
'DeadTimeTable': 'deadtime_table_name'
})
deadtime_table = self.context.dead_time_table([19489])
self.assertEquals(deadtime_table, 'deadtime_table_name')
def test_get_workspace_names_returns_all_stored_workspaces_if_all_selected(
self):
self.populate_ADS()
workspace_list = self.context.get_names_of_workspaces_to_fit(
'19489', 'fwd, bwd, long', True)
self.assertEqual(workspace_list, [
'EMU19489; Group; fwd; Asymmetry; #1',
'EMU19489; Group; bwd; Asymmetry; #1',
'EMU19489; Pair Asym; long; #1',
'EMU19489; PhaseQuad; PhaseTable EMU19489'
])
def test_get_workspace_names_returns_nothing_if_no_parameters_passed(self):
self.populate_ADS()
workspace_list = self.context.get_names_of_workspaces_to_fit()
self.assertEqual(workspace_list, [])
def test_get_workspaces_names_copes_with_bad_groups(self):
self.populate_ADS()
workspace_list = self.context.get_names_of_workspaces_to_fit(
'19489', 'fwd, bwd, long, random, wrong', True)
self.assertEqual(workspace_list, [
'EMU19489; Group; fwd; Asymmetry; #1',
'EMU19489; Group; bwd; Asymmetry; #1',
'EMU19489; Pair Asym; long; #1',
'EMU19489; PhaseQuad; PhaseTable EMU19489'
])
def test_get_workspaces_names_copes_with_non_existent_runs(self):
self.populate_ADS()
workspace_list = self.context.get_names_of_workspaces_to_fit(
'19489, 22222', 'fwd, bwd, long', True)
self.assertEqual(workspace_list, [
'EMU19489; Group; fwd; Asymmetry; #1',
'EMU19489; Group; bwd; Asymmetry; #1',
'EMU19489; Pair Asym; long; #1',
'EMU19489; PhaseQuad; PhaseTable EMU19489'
])
def test_that_run_ranged_correctly_parsed(self):
self.populate_ADS()
workspace_list = self.context.get_names_of_workspaces_to_fit(
'19489-95', 'fwd, bwd, long', True)
self.assertEqual(workspace_list, [
'EMU19489; Group; fwd; Asymmetry; #1',
'EMU19489; Group; bwd; Asymmetry; #1',
'EMU19489; Pair Asym; long; #1',
'EMU19489; PhaseQuad; PhaseTable EMU19489'
])
class MuonDataContextTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
super(MuonDataContextTest, cls).setUpClass()
cls.filepath = FileFinder.findRuns('EMU00019489.nxs')[0]
cls.load_result, cls.run_number, cls.filename, _ = load_workspace_from_filename(
cls.filepath)
def setUp(self):
self.loaded_data = MuonLoadData()
self.context = MuonDataContext(load_data=self.loaded_data)
self.context.instrument = 'EMU'
self.loaded_data.add_data(workspace=self.load_result,
run=[self.run_number],
filename=self.filename,
instrument='EMU')
self.context.current_runs = [[self.run_number]]
self.context.update_current_data()
def tearDown(self):
AnalysisDataService.clear()
def test_setting_current_data_with_a_different_field_sends_message_signal(
self):
self.context.current_data['MainFieldDirection'] = 'transverse'
self.context.message_notifier.notify_subscribers = mock.MagicMock()
self.context.update_current_data()
self.context.message_notifier.notify_subscribers.assert_called_once_with(
'MainFieldDirection has changed between'
' data sets, click default to reset grouping if required')
self.context.current_data['MainFieldDirection'] = 'longitudinal'
def test_that_setting_current_runs_with_mixture_of_transverse_and_longitudanal_runs_raises_warning(
self):
loaded_data = copy.copy(self.context.current_data)
self.context.message_notifier.notify_subscribers = mock.MagicMock()
loaded_data['MainFieldDirection'] = 'transverse'
self.loaded_data.add_data(workspace=loaded_data,
run=[1],
filename='filename',
instrument='EMU')
self.context.current_runs = [[19489], [1]]
self.context.message_notifier.notify_subscribers.assert_called_once_with(
'MainFieldDirection changes within current run set:\ntransverse field runs 1\nlongitudinal field runs 19489\n'
)
def test_is_data_loaded_returns_true_if_data_loaded(self):
self.assertTrue(self.context.is_data_loaded())
def test_is_data_loaded_returns_false_if_no_data_loaded(self):
self.context._loaded_data.clear()
self.assertFalse(self.context.is_data_loaded())
def test_current_filenames_returns_path_to_current_file(self):
self.assertEqual(self.context.current_filenames, [self.filepath])
def test_current_runs_set_correctly(self):
self.assertEqual(self.context.current_runs, [[19489]])
def test_current_workspaces_returns_correctly(self):
self.assertEqual(self.context.current_workspaces, [self.load_result])
def test_get_loaded_data_for_run_returns_correctly(self):
self.assertEqual(self.context.get_loaded_data_for_run([19489]),
self.load_result)
def test_num_detectors_returns_correctly(self):
self.assertEqual(self.context.num_detectors, 96)
def test_num_periods_returns_correctly(self):
self.assertEqual(self.context.num_periods([19489]), 1)
def test_main_field_direction_returns_correctly(self):
self.assertEqual(self.context.main_field_direction, 'Longitudinal')
def test_dead_time_table_returns_correctly(self):
self.assertEqual(self.context.dead_time_table,
self.load_result['DeadTimeTable'])
def test_return_sample_log_returns_correctly(self):
self.assertEqual(self.context.get_sample_log('goodfrm').value, 31369.0)
class MuonDataContextTest(unittest.TestCase):
def setUp(self):
self.loaded_data = MuonLoadData()
self.context = MuonDataContext(self.loaded_data)
self.context.instrument = 'EMU'
filepath = FileFinder.findRuns('EMU00019489.nxs')[0]
load_result, run, filename = load_workspace_from_filename(filepath)
self.loaded_data.add_data(workspace=load_result,
run=[run],
filename=filename,
instrument='EMU')
self.context.current_runs = [[run]]
self.context.update_current_data()
def tearDown(self):
AnalysisDataService.clear()
def test_that_setting_a_fixed_rebin_step_calculates_all_groups_and_pairs_twice(
self):
self.context.gui_variables['RebinType'] = 'Fixed'
self.context.gui_variables['RebinFixed'] = '2'
self.context.show_all_groups()
expected_workspaces = [
'EMU19489', 'EMU19489 Groups',
'EMU19489; Group; bwd; Asymmetry; #1',
'EMU19489; Group; bwd; Asymmetry; Rebin; #1',
'EMU19489; Group; bwd; Counts; #1',
'EMU19489; Group; bwd; Counts; Rebin; #1',
'EMU19489; Group; fwd; Asymmetry; #1',
'EMU19489; Group; fwd; Asymmetry; Rebin; #1',
'EMU19489; Group; fwd; Counts; #1',
'EMU19489; Group; fwd; Counts; Rebin; #1', 'Muon Data'
]
self.assertEqual(AnalysisDataService.getObjectNames(),
expected_workspaces)
def test_that_setting_no_rebinning_calculates_groups_and_pairs_once(self):
self.context.gui_variables['RebinType'] = 'None'
self.context.show_all_groups()
expected_workspaces = [
'EMU19489', 'EMU19489 Groups',
'EMU19489; Group; bwd; Asymmetry; #1',
'EMU19489; Group; bwd; Counts; #1',
'EMU19489; Group; fwd; Asymmetry; #1',
'EMU19489; Group; fwd; Counts; #1', 'Muon Data'
]
self.assertEqual(AnalysisDataService.getObjectNames(),
expected_workspaces)
def test_that_setting_a_variable_rebin_step_calculates_all_groups_and_pairs_twice(
self):
self.context.gui_variables['RebinType'] = 'Variable'
self.context.gui_variables['RebinVariable'] = '1,0.1,2'
self.context.show_all_groups()
expected_workspaces = [
'EMU19489', 'EMU19489 Groups',
'EMU19489; Group; bwd; Asymmetry; #1',
'EMU19489; Group; bwd; Asymmetry; Rebin; #1',
'EMU19489; Group; bwd; Counts; #1',
'EMU19489; Group; bwd; Counts; Rebin; #1',
'EMU19489; Group; fwd; Asymmetry; #1',
'EMU19489; Group; fwd; Asymmetry; Rebin; #1',
'EMU19489; Group; fwd; Counts; #1',
'EMU19489; Group; fwd; Counts; Rebin; #1', 'Muon Data'
]
self.assertEqual(AnalysisDataService.getObjectNames(),
expected_workspaces)
class MuonContextTest(unittest.TestCase):
@classmethod
def setUpClass(cls):
pass
def setUp(self):
AnalysisDataService.clear()
self.filepath = FileFinder.findRuns('EMU00019489.nxs')[0]
self.load_result, self.run_number, self.filename = load_workspace_from_filename(self.filepath)
self.loaded_data = MuonLoadData()
self.data_context = MuonDataContext(self.loaded_data)
self.gui_context = MuonGuiContext()
self.group_pair_context = MuonGroupPairContext()
self.gui_context.update({'RebinType': 'None'})
self.context = MuonContext(muon_data_context=self.data_context, muon_gui_context=self.gui_context, muon_group_context=self.group_pair_context)
self.data_context.instrument = 'EMU'
self.loaded_data.add_data(workspace=self.load_result, run=[self.run_number], filename=self.filename,
instrument='EMU')
self.data_context.current_runs = [[self.run_number]]
self.data_context.update_current_data()
self.group_pair_context.reset_group_and_pairs_to_default(self.load_result['OutputWorkspace'][0]._workspace,
'EMU', '')
def test_reset_groups_and_pairs_to_default(self):
self.assertEquals(self.group_pair_context.group_names, ['fwd', 'bwd'])
self.assertEquals(self.group_pair_context.pair_names, ['long'])
def test_calculate_group_calculates_group_for_given_run(self):
counts_workspace, asymmetry_workspace = self.context.calculate_group('fwd', run=[19489])
self.assertEquals(type(counts_workspace), Workspace2D)
self.assertEquals(type(counts_workspace), Workspace2D)
def test_calculate_pair_calculates_pair_for_given_run(self):
pair_asymmetry = self.context.calculate_pair('long', run=[19489])
self.assertEquals(type(pair_asymmetry), Workspace2D)
def test_show_all_groups_calculates_and_shows_all_groups(self):
self.context.show_all_groups()
self.assertEquals(AnalysisDataService.getObjectNames(), ['EMU19489', 'EMU19489 Groups', 'EMU19489; Group; bwd; Asymmetry; #1',
'EMU19489; Group; bwd; Counts; #1', 'EMU19489; Group; fwd; Asymmetry; #1',
'EMU19489; Group; fwd; Counts; #1', 'Muon Data'])
def test_that_show_all_calculates_and_shows_all_groups_with_rebin(self):
self.gui_context['RebinType'] = 'Fixed'
self.gui_context['RebinFixed'] = 2
self.context.show_all_groups()
self.assertEquals(AnalysisDataService.getObjectNames(),
['EMU19489', 'EMU19489 Groups', 'EMU19489; Group; bwd; Asymmetry; #1', 'EMU19489; Group; bwd; Asymmetry; Rebin; #1',
'EMU19489; Group; bwd; Counts; #1', 'EMU19489; Group; bwd; Counts; Rebin; #1',
'EMU19489; Group; fwd; Asymmetry; #1', 'EMU19489; Group; fwd; Asymmetry; Rebin; #1',
'EMU19489; Group; fwd; Counts; #1', 'EMU19489; Group; fwd; Counts; Rebin; #1', 'Muon Data'])
def test_show_all_pairs_calculates_and_shows_all_pairs(self):
self.context.show_all_pairs()
self.assertEquals(AnalysisDataService.getObjectNames(), ['EMU19489', 'EMU19489 Pairs', 'EMU19489; Pair Asym; long; #1', 'Muon Data'])
def test_that_show_all_calculates_and_shows_all_pairs_with_rebin(self):
self.gui_context['RebinType'] = 'Fixed'
self.gui_context['RebinFixed'] = 2
self.context.show_all_pairs()
self.assertEquals(AnalysisDataService.getObjectNames(),
['EMU19489', 'EMU19489 Pairs', 'EMU19489; Pair Asym; long; #1', 'EMU19489; Pair Asym; long; Rebin; #1', 'Muon Data'])
def test_update_current_data_sets_current_run_in_data_context(self):
self.context.update_current_data()
self.assertEquals(self.data_context.current_data, self.load_result)
def test_update_current_data_sets_groups_and_pairs(self):
self.context.update_current_data()
self.assertEquals(self.group_pair_context.pair_names, ['long'])
self.assertEquals(self.group_pair_context.group_names, ['fwd', 'bwd'])
def test_show_raw_data_puts_raw_data_into_the_ADS(self):
self.context.show_raw_data()
self.assertEquals(AnalysisDataService.getObjectNames(), ['EMU19489', 'EMU19489 Raw Data', 'EMU19489_raw_data', 'Muon Data'])
def test_that_first_good_data_returns_correctly_when_from_file_chosen_option(self):
self.gui_context.update({'FirstGoodDataFromFile': True})
first_good_data = self.context.first_good_data([19489])
self.assertEquals(first_good_data, 0.11)
def test_first_good_data_returns_correctly_when_manually_specified_used(self):
self.gui_context.update({'FirstGoodDataFromFile': False, 'FirstGoodData': 5})
first_good_data = self.context.first_good_data([19489])
self.assertEquals(first_good_data, 5)
def test_that_last_good_data_returns_correctly_when_from_file_chosen_option(self):
self.gui_context.update({'LastGoodDataFromFile': True})
last_good_data = self.context.last_good_data([19489])
self.assertEquals(last_good_data, 31.76)
def test_last_good_data_returns_correctly_when_manually_specified_used(self):
self.gui_context.update({'LastGoodDataFromFile': False, 'LastGoodData': 5})
last_good_data = self.context.last_good_data([19489])
self.assertEquals(last_good_data, 5)
def test_that_dead_time_table_from_ADS_returns_table_name(self):
self.gui_context.update({'DeadTimeSource': 'FromADS', 'DeadTimeTable': 'deadtime_table_name'})
deadtime_table = self.context.dead_time_table([19489])
self.assertEquals(deadtime_table, 'deadtime_table_name')
