def test_data_tooltip_role_masked_bin(self):
if not qtpy.PYQT5:
self.skipTest("QVariant cannot be instantiated in QT4, and the test fails with an error.")
ws, model, row, index = setup_common_for_test_data()
model.ws_spectrum_info.isMasked = Mock(return_value=False)
model.ws_spectrum_info.isMonitor = Mock(return_value=False)
ws.hasMaskedBins = Mock(return_value=True)
ws.maskedBinsIndices = Mock(return_value=[index.column()])
output = model.data(index, Qt.ToolTipRole)
model.ws_spectrum_info.hasDetectors.assert_has_calls([call.do_work(row), call.do_work(row)])
model.ws_spectrum_info.isMasked.assert_called_once_with(row)
model.ws_spectrum_info.isMonitor.assert_called_once_with(row)
self.assertEqual(MatrixWorkspaceTableViewModel.MASKED_BIN_STRING, output)
# Doing the same thing a second time should hit the cache, so no additional calls will have been made
output = model.data(index, Qt.ToolTipRole)
self.assertEqual(4, model.ws_spectrum_info.hasDetectors.call_count)
self.assertEqual(2, model.ws_spectrum_info.isMasked.call_count)
self.assertEqual(2, model.ws_spectrum_info.isMonitor.call_count)
# This was called only once because the monitor was cached
ws.hasMaskedBins.assert_called_once_with(row)
ws.maskedBinsIndices.assert_called_once_with(row)
self.assertEqual(MatrixWorkspaceTableViewModel.MASKED_BIN_STRING, output)
def test_data_tooltip_role_masked_row(self):
if not qtpy.PYQT5:
self.skipTest("QVariant cannot be instantiated in QT4, and the test fails with an error.")
ws, model, row, index = setup_common_for_test_data()
model.ws_spectrum_info.hasDetectors = Mock(return_value=True)
model.ws_spectrum_info.isMasked = Mock(return_value=True)
model.ws_spectrum_info.isMonitor = Mock(return_value=False)
output = model.data(index, Qt.ToolTipRole)
model.ws_spectrum_info.hasDetectors.assert_has_calls([call.do_work(row), call.do_work(row)])
model.ws_spectrum_info.isMasked.assert_called_once_with(row)
model.ws_spectrum_info.isMonitor.assert_called_once_with(row)
self.assertEqual(MatrixWorkspaceTableViewModel.MASKED_ROW_STRING, output)
output = model.data(index, Qt.ToolTipRole)
# The row was masked so it should have been cached
model.ws_spectrum_info.isMasked.assert_called_once_with(row)
# However it is checked if it is a monitor again
self.assertEqual(3, model.ws_spectrum_info.hasDetectors.call_count)
self.assertEqual(2, model.ws_spectrum_info.isMonitor.call_count)
self.assertEqual(MatrixWorkspaceTableViewModel.MASKED_ROW_STRING, output)
def test_data_tooltip_role_monitor_row(self):
if not qtpy.PYQT5:
self.skipTest("QVariant cannot be instantiated in QT4, and the test fails with an error.")
ws, model, row, index = setup_common_for_test_data()
# necessary otherwise it is returned that there is a masked bin, and we get the wrong output
ws.hasMaskedBins = Mock(return_value=False)
model.ws_spectrum_info.isMasked = Mock(return_value=False)
model.ws_spectrum_info.isMonitor = Mock(return_value=True)
output = model.data(index, Qt.ToolTipRole)
model.ws_spectrum_info.hasDetectors.assert_has_calls([call.do_work(row), call.do_work(row)])
model.ws_spectrum_info.isMasked.assert_called_once_with(row)
model.ws_spectrum_info.isMonitor.assert_called_once_with(row)
self.assertEqual(MatrixWorkspaceTableViewModel.MONITOR_ROW_STRING, output)
# Doing the same thing a second time should hit the cache, so no additional calls will have been made
output = model.data(index, Qt.ToolTipRole)
model.ws_spectrum_info.hasDetectors.assert_has_calls([call.do_work(row), call.do_work(row)])
self.assertEqual(2, model.ws_spectrum_info.isMasked.call_count)
# This was called only once because the monitor was cached
model.ws_spectrum_info.isMonitor.assert_called_once_with(row)
self.assertEqual(MatrixWorkspaceTableViewModel.MONITOR_ROW_STRING, output)
def test_data_tooltip_role_masked_bin(self):
if not qtpy.PYQT5:
self.skipTest("QVariant cannot be instantiated in QT4, and the test fails with an error.")
ws, model, row, index = setup_common_for_test_data()
model.ws_spectrum_info.isMasked = Mock(return_value=False)
model.ws_spectrum_info.isMonitor = Mock(return_value=False)
ws.hasMaskedBins = Mock(return_value=True)
ws.maskedBinsIndices = Mock(return_value=[index.column()])
output = model.data(index, Qt.ToolTipRole)
model.ws_spectrum_info.hasDetectors.assert_has_calls([call.do_work(row), call.do_work(row)])
model.ws_spectrum_info.isMasked.assert_called_once_with(row)
model.ws_spectrum_info.isMonitor.assert_called_once_with(row)
self.assertEqual(MatrixWorkspaceTableViewModel.MASKED_BIN_STRING, output)
# Doing the same thing a second time should hit the cache, so no additional calls will have been made
output = model.data(index, Qt.ToolTipRole)
self.assertEqual(4, model.ws_spectrum_info.hasDetectors.call_count)
self.assertEqual(2, model.ws_spectrum_info.isMasked.call_count)
self.assertEqual(2, model.ws_spectrum_info.isMonitor.call_count)
# This was called only once because the monitor was cached
ws.hasMaskedBins.assert_called_once_with(row)
ws.maskedBinsIndices.assert_called_once_with(row)
self.assertEqual(MatrixWorkspaceTableViewModel.MASKED_BIN_STRING, output)
def test_data_background_role_monitor_row(self):
ws, model, row, index = setup_common_for_test_data()
model.ws_spectrum_info.isMasked = Mock(return_value=False)
model.ws_spectrum_info.isMonitor = Mock(return_value=True)
output = model.data(index, Qt.BackgroundRole)
model.ws_spectrum_info.hasDetectors.assert_called_with(row)
model.ws_spectrum_info.isMasked.assert_called_once_with(row)
model.ws_spectrum_info.isMonitor.assert_called_once_with(row)
index.row.assert_called_once_with()
self.assertFalse(index.column.called)
self.assertEqual(model.monitor_color, output)
# Just do it a second time -> This time it's cached and should be read off the cache.
# If it is not read off the cache the assert_called_once below will fail,
# as the functions would be called a 2nd time
output = model.data(index, Qt.BackgroundRole)
model.ws_spectrum_info.hasDetectors.assert_called_with(row)
# assert that it has been called twice with the same parameters
model.ws_spectrum_info.isMasked.assert_has_calls([call.do_work(row), call.do_work(row)])
# only called once, as the 2nd time should have hit the cached monitor
model.ws_spectrum_info.isMonitor.assert_called_once_with(row)
self.assertEqual(model.monitor_color, output)
# assert that the row was called twice with no parameters
self.assertEqual(2, index.row.call_count)
self.assertFalse(index.column.called)
def test_data_tooltip_role_masked_row(self):
if not qtpy.PYQT5:
self.skipTest("QVariant cannot be instantiated in QT4, and the test fails with an error.")
ws, model, row, index = setup_common_for_test_data()
model.ws_spectrum_info.hasDetectors = Mock(return_value=True)
model.ws_spectrum_info.isMasked = Mock(return_value=True)
model.ws_spectrum_info.isMonitor = Mock(return_value=False)
output = model.data(index, Qt.ToolTipRole)
model.ws_spectrum_info.hasDetectors.assert_has_calls([call.do_work(row), call.do_work(row)])
model.ws_spectrum_info.isMasked.assert_called_once_with(row)
model.ws_spectrum_info.isMonitor.assert_called_once_with(row)
self.assertEqual(MatrixWorkspaceTableViewModel.MASKED_ROW_STRING, output)
output = model.data(index, Qt.ToolTipRole)
# The row was masked so it should have been cached
model.ws_spectrum_info.isMasked.assert_called_once_with(row)
# However it is checked if it is a monitor again
self.assertEqual(3, model.ws_spectrum_info.hasDetectors.call_count)
self.assertEqual(2, model.ws_spectrum_info.isMonitor.call_count)
self.assertEqual(MatrixWorkspaceTableViewModel.MASKED_ROW_STRING, output)
def test_data_tooltip_role_monitor_row(self):
if not qtpy.PYQT5:
self.skipTest("QVariant cannot be instantiated in QT4, and the test fails with an error.")
ws, model, row, index = setup_common_for_test_data()
# necessary otherwise it is returned that there is a masked bin, and we get the wrong output
ws.hasMaskedBins = Mock(return_value=False)
model.ws_spectrum_info.isMasked = Mock(return_value=False)
model.ws_spectrum_info.isMonitor = Mock(return_value=True)
output = model.data(index, Qt.ToolTipRole)
model.ws_spectrum_info.hasDetectors.assert_has_calls([call.do_work(row), call.do_work(row)])
model.ws_spectrum_info.isMasked.assert_called_once_with(row)
model.ws_spectrum_info.isMonitor.assert_called_once_with(row)
self.assertEqual(MatrixWorkspaceTableViewModel.MONITOR_ROW_STRING, output)
# Doing the same thing a second time should hit the cache, so no additional calls will have been made
output = model.data(index, Qt.ToolTipRole)
model.ws_spectrum_info.hasDetectors.assert_has_calls([call.do_work(row), call.do_work(row)])
self.assertEqual(2, model.ws_spectrum_info.isMasked.call_count)
# This was called only once because the monitor was cached
model.ws_spectrum_info.isMonitor.assert_called_once_with(row)
self.assertEqual(MatrixWorkspaceTableViewModel.MONITOR_ROW_STRING, output)
def test_data_background_role_monitor_row(self):
ws, model, row, index = setup_common_for_test_data()
model.ws_spectrum_info.isMasked = Mock(return_value=False)
model.ws_spectrum_info.isMonitor = Mock(return_value=True)
output = model.data(index, Qt.BackgroundRole)
model.ws_spectrum_info.hasDetectors.assert_called_with(row)
model.ws_spectrum_info.isMasked.assert_called_once_with(row)
model.ws_spectrum_info.isMonitor.assert_called_once_with(row)
index.row.assert_called_once_with()
self.assertFalse(index.column.called)
self.assertEqual(model.monitor_color, output)
# Just do it a second time -> This time it's cached and should be read off the cache.
# If it is not read off the cache the assert_called_once below will fail,
# as the functions would be called a 2nd time
output = model.data(index, Qt.BackgroundRole)
model.ws_spectrum_info.hasDetectors.assert_called_with(row)
# assert that it has been called twice with the same parameters
model.ws_spectrum_info.isMasked.assert_has_calls([call.do_work(row), call.do_work(row)])
# only called once, as the 2nd time should have hit the cached monitor
model.ws_spectrum_info.isMonitor.assert_called_once_with(row)
self.assertEqual(model.monitor_color, output)
# assert that the row was called twice with no parameters
self.assertEqual(2, index.row.call_count)
self.assertFalse(index.column.called)
def test_data_tooltip_role_masked_monitor_row(self):
if not qtpy.PYQT5:
self.skipTest(
"QVariant cannot be instantiated in QT4, and the test fails with an error."
)
ws, model, row, index = setup_common_for_test_data()
model.ws_spectrum_info.isMasked = Mock(return_value=True)
model.ws_spectrum_info.isMonitor = Mock(return_value=True)
output = model.data(index, Qt.ToolTipRole)
model.ws_spectrum_info.hasDetectors.assert_has_calls(
[call.do_work(row), call.do_work(row)])
model.ws_spectrum_info.isMasked.assert_called_once_with(row)
model.ws_spectrum_info.isMonitor.assert_called_once_with(row)
self.assertEqual(
MatrixWorkspaceTableViewModel.MASKED_MONITOR_ROW_STRING, output)
# Doing the same thing a second time should hit the cache, so no additional calls will have been made
output = model.data(index, Qt.ToolTipRole)
model.ws_spectrum_info.hasDetectors.assert_has_calls(
[call.do_work(row), call.do_work(row)])
model.ws_spectrum_info.isMasked.assert_called_once_with(row)
model.ws_spectrum_info.isMonitor.assert_called_once_with(row)
self.assertEqual(
MatrixWorkspaceTableViewModel.MASKED_MONITOR_ROW_STRING, output)
def test_data_tooltip_role_masked_monitor_row(self):
if not qtpy.PYQT5:
self.skipTest("QVariant cannot be instantiated in QT4, and the test fails with an error.")
ws, model, row, index = setup_common_for_test_data()
model.ws_spectrum_info.isMasked = Mock(return_value=True)
model.ws_spectrum_info.isMonitor = Mock(return_value=True)
output = model.data(index, Qt.ToolTipRole)
model.ws_spectrum_info.hasDetectors.assert_has_calls([call.do_work(row), call.do_work(row)])
model.ws_spectrum_info.isMasked.assert_called_once_with(row)
model.ws_spectrum_info.isMonitor.assert_called_once_with(row)
self.assertEqual(MatrixWorkspaceTableViewModel.MASKED_MONITOR_ROW_STRING, output)
# Doing the same thing a second time should hit the cache, so no additional calls will have been made
output = model.data(index, Qt.ToolTipRole)
model.ws_spectrum_info.hasDetectors.assert_has_calls([call.do_work(row), call.do_work(row)])
model.ws_spectrum_info.isMasked.assert_called_once_with(row)
model.ws_spectrum_info.isMonitor.assert_called_once_with(row)
self.assertEqual(MatrixWorkspaceTableViewModel.MASKED_MONITOR_ROW_STRING, output)
def test_data_background_role_masked_bin(self):
ws, model, row, index = setup_common_for_test_data()
model.ws_spectrum_info.isMasked = Mock(return_value=False)
model.ws_spectrum_info.isMonitor = Mock(return_value=False)
output = model.data(index, Qt.BackgroundRole)
model.ws_spectrum_info.hasDetectors.assert_called_with(row)
model.ws_spectrum_info.isMasked.assert_called_once_with(row)
model.ws_spectrum_info.isMonitor.assert_called_once_with(row)
ws.hasMaskedBins.assert_called_once_with(row)
ws.maskedBinsIndices.assert_called_once_with(row)
index.row.assert_called_once_with()
index.column.assert_called_once_with()
self.assertEqual(model.masked_color, output)
# Just do it a second time -> This time it's cached and should be read off the cache.
# If it is not read off the cache the assert_called_once below will fail,
# as the functions would be called a 2nd time
output = model.data(index, Qt.BackgroundRole)
# masked bins is checked last, so it will call all other functions a second time
model.ws_spectrum_info.hasDetectors.assert_has_calls(
[call.do_work(row), call.do_work(row)])
model.ws_spectrum_info.isMasked.assert_has_calls(
[call.do_work(row), call.do_work(row)])
model.ws_spectrum_info.isMonitor.assert_has_calls(
[call.do_work(row), call.do_work(row)])
# these, however, should remain at 1 call, as the masked bin cache should have been hit
ws.hasMaskedBins.assert_called_once_with(row)
ws.maskedBinsIndices.assert_called_once_with(row)
self.assertEqual(model.masked_color, output)
self.assertEqual(2, index.row.call_count)
self.assertEqual(2, index.column.call_count)
def test_data_background_role_masked_bin(self):
ws, model, row, index = setup_common_for_test_data()
model.ws_spectrum_info.isMasked = Mock(return_value=False)
model.ws_spectrum_info.isMonitor = Mock(return_value=False)
output = model.data(index, Qt.BackgroundRole)
model.ws_spectrum_info.hasDetectors.assert_called_with(row)
model.ws_spectrum_info.isMasked.assert_called_once_with(row)
model.ws_spectrum_info.isMonitor.assert_called_once_with(row)
ws.hasMaskedBins.assert_called_once_with(row)
ws.maskedBinsIndices.assert_called_once_with(row)
index.row.assert_called_once_with()
index.column.assert_called_once_with()
self.assertEqual(model.masked_color, output)
# Just do it a second time -> This time it's cached and should be read off the cache.
# If it is not read off the cache the assert_called_once below will fail,
# as the functions would be called a 2nd time
output = model.data(index, Qt.BackgroundRole)
# masked bins is checked last, so it will call all other functions a second time
model.ws_spectrum_info.hasDetectors.assert_has_calls([call.do_work(row), call.do_work(row)])
model.ws_spectrum_info.isMasked.assert_has_calls([call.do_work(row), call.do_work(row)])
model.ws_spectrum_info.isMonitor.assert_has_calls([call.do_work(row), call.do_work(row)])
# these, however, should remain at 1 call, as the masked bin cache should have been hit
ws.hasMaskedBins.assert_called_once_with(row)
ws.maskedBinsIndices.assert_called_once_with(row)
self.assertEqual(model.masked_color, output)
self.assertEqual(2, index.row.call_count)
self.assertEqual(2, index.column.call_count)