tomwer 1.3.7__py3-none-any.whl → 1.3.8__py3-none-any.whl

orangecontrib/tomwer/widgets/reconstruction/test/test_axis.py

@@ -1,224 +0,0 @@
-import gc
-import pickle
-import shutil
-import tempfile
-import time
-import os
-
-import pytest
-from orangecanvas.scheme.readwrite import literal_dumps
-from silx.gui import qt
-from silx.gui.utils.testutils import TestCaseQt
-
-from orangecontrib.tomwer.widgets.reconstruction.AxisOW import AxisOW
-from tomwer.core.utils.lbsram import mock_low_memory
-from tomwer.core.process.reconstruction.axis.mode import AxisMode
-from tomwer.core.settings import mock_lsbram
-from tomwer.core.utils.scanutils import MockNXtomo, MockEDF
-from tomwer.tests.utils import skip_gui_test
-
-
-@pytest.mark.skipif(skip_gui_test(), reason="skip gui test")
-class TestOWAxis(TestCaseQt):
-    """Test that the axis widget work correctly"""
-
-    def setUp(self):
-        self._window = AxisOW()
-        self.recons_params = self._window.recons_params
-        self.tempdir = tempfile.mkdtemp()
-        self.scan = MockNXtomo(
-            scan_path=os.path.join(self.tempdir, "nx_tomo.nx"),
-            n_proj=10,
-            n_ini_proj=10,
-            scan_range=180,
-            dim=20,
-            energy=12.3,
-        ).scan
-
-        self._window.getAxis().mode = AxisMode.centered
-        self._window.show()
-        self.qWaitForWindowExposed(self._window)
-
-    def tearDown(self):
-        shutil.rmtree(self.tempdir)
-        self._window.setAttribute(qt.Qt.WA_DeleteOnClose)
-        self._window.close()
-        gc.collect()
-
-    def testAxisLock(self):
-        """Test behavior when locking the axis position. Could not be included
-        in the tomwer/gui because the lock action is only available for the OW
-        """
-        assert self._window.getAxis().mode in (AxisMode.centered, AxisMode.global_)
-        radio_axis = self._window._widget._axisWidget._radioAxis
-        main_widget = self._window._widget._axisWidget
-        self.assertFalse(main_widget._controlWidget._lockBut.isLocked())
-        self.assertTrue(radio_axis._controlWidget._mainWidget.isEnabled())
-        self.mouseClick(main_widget._controlWidget._lockBut, qt.Qt.LeftButton)
-        self.qapp.processEvents()
-        self.assertTrue(main_widget._controlWidget._lockBut.isLocked())
-        # when the lock button is activated we should automatically switch to
-        # the manual mode
-        self.assertTrue(self._window.getAxis().mode is AxisMode.manual)
-        self.assertFalse(radio_axis._controlWidget._mainWidget.isEnabled())
-
-    def test_serializing(self):
-        pickle.dumps(self._window.recons_params.to_dict())
-
-    def test_literal_dumps(self):
-        literal_dumps(self._window.recons_params.to_dict())
-
-
-class TestWindowAxisComputation(TestCaseQt):
-    @staticmethod
-    def _long_computation(scan):
-        time.sleep(5)
-        return -1
-
-    """Test that the axis widget work correctly"""
-
-    def setUp(self):
-        TestCaseQt.setUp(self)
-        self.tempdir = tempfile.mkdtemp()
-        self._mainWindow = AxisOW()
-        self.recons_params = self._mainWindow.recons_params
-        self._window = self._mainWindow._widget
-        self.scan = MockNXtomo(
-            scan_path=os.path.join(self.tempdir, "nx_tomo.nx"),
-            n_proj=10,
-            n_ini_proj=10,
-            scan_range=180,
-            dim=20,
-            energy=12.3,
-        ).scan
-        self._mainWindow.show()
-        self.qWaitForWindowExposed(self._mainWindow)
-        self._mainWindow.setMode("manual")
-
-    def tearDown(self):
-        shutil.rmtree(self.tempdir)
-        self._mainWindow.setAttribute(qt.Qt.WA_DeleteOnClose)
-        self._mainWindow.close()
-        self._mainWindow = None
-        self._window = None
-        gc.collect()
-
-    def testFailedComputation(self):
-        """Test gui if the axis position fails"""
-        self.qapp.processEvents()
-        self.recons_params.set_position_frm_par_file("not existing", force=True)
-        radio_axis = self._window._axisWidget._radioAxis
-        radio_axis.setMode("read")
-        self.assertEqual(radio_axis.getMode(), AxisMode.read)
-        self._mainWindow.process(self.scan)
-        self.assertEqual(radio_axis.getMode(), AxisMode.read)
-        self.assertEqual(self.recons_params.value_ref_tomwer, None)
-        self.assertEqual(self.recons_params.mode, AxisMode.read)
-
-    def testComputationSucceed(self):
-        """Test gui if the axis position is correctly computed"""
-        self.recons_params.mode = AxisMode.manual
-        radio_axis = self._window._axisWidget._radioAxis
-        self.assertEqual(radio_axis.getMode(), AxisMode.manual)
-        radio_axis.setXShift(2.345)
-        self._mainWindow.process(self.scan)
-        self.qapp.processEvents()
-        self.assertEqual(radio_axis.getMode(), AxisMode.manual)
-        self.assertEqual(self.recons_params.value_ref_tomwer, 2.345)
-        position_info_widget = self._window._axisWidget._controlWidget._positionInfo
-        self.assertEqual(position_info_widget._relativePositionQLE.text(), "2.345")
-
-
-global _computation_res
-_computation_res = 0
-
-
-@pytest.mark.skipif(skip_gui_test(), reason="skip gui test")
-class TestAxisStack(TestCaseQt):
-    """Test axis computation of a stack of scan"""
-
-    @staticmethod
-    def _test_computation(scan):
-        global _computation_res
-        _computation_res += 1
-        return _computation_res
-
-    def setUp(self):
-        # not working due to OW
-        TestCaseQt.setUp(self)
-        self._scan1 = MockEDF.mockScan(scanID=tempfile.mkdtemp())
-        self._scan2 = MockEDF.mockScan(scanID=tempfile.mkdtemp())
-        self._scan3 = MockEDF.mockScan(scanID=tempfile.mkdtemp())
-        self._mainWindow = AxisOW()
-        self.recons_params = self._mainWindow._axis_params
-        self._mainWindow._skip_exec(True)
-
-        global _computation_res
-        _computation_res = 0
-
-        self._mainWindow.patch_calc_method(
-            AxisMode.centered, TestAxisStack._test_computation
-        )
-        self.recons_params.mode = AxisMode.centered
-
-        self._mainWindow.show()
-        self.qWaitForWindowExposed(self._mainWindow)
-
-    def tearDown(self):
-        mock_low_memory(False)
-        mock_lsbram(False)
-        self._mainWindow.setAttribute(qt.Qt.WA_DeleteOnClose)
-        self._mainWindow.close()
-        self._mainWindow = None
-        self._recons_params = None
-        self.qapp.processEvents()
-        for scan in (self._scan1, self._scan2, self._scan3):
-            shutil.rmtree(scan.path)
-        gc.collect()
-
-    def testLowMemory(self):
-        """Make sure the axis computation will be skip if we are in low memory"""
-        mock_low_memory(True)
-        mock_lsbram(True)
-        for scan in (self._scan1, self._scan2, self._scan3):
-            self.qapp.processEvents()
-            self._mainWindow.new_data_in(scan)
-
-        self.assertEqual(self._scan1.axis_params, None)
-        self.assertEqual(self._scan2.axis_params, None)
-        self.assertEqual(self._scan3.axis_params, None)
-
-    def testUnlockStack(self):
-        """Check that all axis position will be computed properly if we set a
-        stack of scan"""
-        self._mainWindow.recons_params.set_relative_value(1.0)
-        for scan in (self._scan1, self._scan2, self._scan3):
-            self._mainWindow.process(scan)
-
-        for i in range(5):
-            self.qapp.processEvents()
-            time.sleep(0.2)
-            self.qapp.processEvents()
-
-        self.assertNotEqual(self._scan1.axis_params, None)
-        self.assertNotEqual(self._scan2.axis_params, None)
-        self.assertNotEqual(self._scan3.axis_params, None)
-
-    def testLockStack(self):
-        """Check that axis position will be simply copy if we are in a lock
-        stack"""
-        self.recons_params.mode = AxisMode.manual
-        position_value = 0.36
-        self.recons_params.set_relative_value(position_value)
-
-        for scan in (self._scan1, self._scan2, self._scan3):
-            self._mainWindow.process(scan)
-
-        for i in range(5):
-            self.qapp.processEvents()
-            time.sleep(0.2)
-            self.qapp.processEvents()
-
-        self.assertEqual(self._scan1.axis_params.value_ref_tomwer, position_value)
-        self.assertEqual(self._scan2.axis_params.value_ref_tomwer, position_value)
-        self.assertEqual(self._scan3.axis_params.value_ref_tomwer, position_value)

orangecontrib/tomwer/widgets/reconstruction/test/test_cast_volumeow.py

@@ -1,85 +0,0 @@
-# coding: utf-8
-# /*##########################################################################
-#
-# Copyright (c) 2017-2021 European Synchrotron Radiation Facility
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-# ###########################################################################*/
-
-__authors__ = ["H. Payno"]
-__license__ = "MIT"
-__date__ = "16/12/2021"
-
-
-import gc
-import os
-import pickle
-import tempfile
-import time
-
-import numpy
-from orangecanvas.scheme.readwrite import literal_dumps
-from silx.gui import qt
-from silx.gui.utils.testutils import TestCaseQt
-
-from orangecontrib.tomwer.widgets.reconstruction.CastNabuVolumeOW import (
-    CastNabuVolumeOW,
-)
-from tomwer.core.volume.rawvolume import RawVolume
-
-
-class TestCastVolumeOW(TestCaseQt):
-    def setUp(self):
-        super().setUp()
-        self._window = CastNabuVolumeOW()
-
-    def tearDown(self):
-        self._window.setAttribute(qt.Qt.WA_DeleteOnClose)
-        self._window.close()
-        self._window = None
-        gc.collect()
-
-    def test(self):
-        self._window.show()
-        self.qWaitForWindowExposed(self._window)
-
-    def test_serializing(self):
-        pickle.dumps(self._window.getConfiguration())
-
-    def test_literal_dumps(self):
-        literal_dumps(self._window.getConfiguration())
-
-    def test_cast_volume(self):
-        with tempfile.TemporaryDirectory() as tmp_dir:
-            input_dir = os.path.join(tmp_dir, "input")
-            os.makedirs(input_dir)
-
-            volume = RawVolume(
-                file_path=os.path.join(input_dir, "vol_file.vol"),
-                data=numpy.linspace(0, 10, 100 * 100 * 3, dtype=numpy.float32).reshape(
-                    3, 100, 100
-                ),
-            )
-            volume.save()
-
-            self._window.process_volume(volume)
-            while self._window._processingStack.is_computing():
-                time.sleep(0.1)
-                self.qapp.processEvents()

orangecontrib/tomwer/widgets/reconstruction/test/test_dark_refs_widget.py

@@ -1,136 +0,0 @@
-import gc
-import logging
-import os
-import pickle
-import tempfile
-
-import numpy
-from orangecanvas.scheme.readwrite import literal_dumps
-from silx.gui import qt
-from silx.gui.utils.testutils import TestCaseQt
-
-from orangecontrib.tomwer.widgets.reconstruction.DarkRefAndCopyOW import (
-    DarkRefAndCopyOW,
-)
-from tomwer.core.utils.scanutils import MockNXtomo
-
-logging.disable(logging.INFO)
-
-
-class TestDarkRefWidget(TestCaseQt):
-    """class testing the DarkRefWidget"""
-
-    def setUp(self):
-        self._tmp_path = tempfile.mkdtemp()
-        scan_folder_with_raw = os.path.join(self._tmp_path, "test_dir_1")
-        scan_folder_without_raw = os.path.join(self._tmp_path, "test_dir_2")
-        for my_dir in (scan_folder_with_raw, scan_folder_without_raw):
-            os.makedirs(my_dir)
-
-        self._scan_with_raw = MockNXtomo(
-            scan_path=scan_folder_with_raw,
-            create_ini_dark=True,
-            create_ini_flat=True,
-            create_final_flat=False,
-            n_proj=10,
-            n_ini_proj=10,
-            dim=12,
-        ).scan
-        self._scan_without_raw = MockNXtomo(
-            scan_path=scan_folder_without_raw,
-            create_ini_dark=False,
-            create_ini_flat=False,
-            create_final_flat=False,
-            n_proj=10,
-            n_ini_proj=10,
-            dim=12,
-        ).scan
-
-        self.widget = DarkRefAndCopyOW()
-        return super().setUp()
-
-    def tearDown(self):
-        # shutil.rmtree(self._tmp_path)
-        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
-        self.widget.close()
-        gc.collect()
-
-    def test_serializing(self):
-        self.widget._updateSettingsVals()
-        pickle.dumps(self.widget._ewoks_default_inputs)
-
-    def test_literal_dumps(self):
-        self.widget._updateSettingsVals()
-        literal_dumps(self.widget._ewoks_default_inputs)
-
-    def test_copy(self):
-        self.widget.setCopyActive(True)
-        while self.qapp.hasPendingEvents():
-            self.qapp.processEvents()
-        assert len(os.listdir(self.widget._processing_stack._save_dir)) == 0
-
-        self.widget.process(self._scan_with_raw)
-        self.widget._processing_stack.wait_computation_finished()
-        while self.qapp.hasPendingEvents():
-            self.qapp.processEvents()
-        assert self._scan_with_raw.load_reduced_darks() not in (None, {})
-        assert self._scan_with_raw.load_reduced_flats() not in (None, {})
-        assert len(os.listdir(self.widget._processing_stack._save_dir)) == 1
-        assert len(os.listdir(self.widget._processing_stack._save_dir)) == 1
-
-        self.widget.setCopyActive(False)
-        while self.qapp.hasPendingEvents():
-            self.qapp.processEvents()
-        self.widget.process(self._scan_without_raw)
-        self.widget._processing_stack.wait_computation_finished()
-        while self.qapp.hasPendingEvents():
-            self.qapp.processEvents()
-        assert self._scan_without_raw.load_reduced_darks() in (None, {})
-        assert self._scan_without_raw.load_reduced_flats() in (None, {})
-
-        self.widget.setCopyActive(True)
-        while self.qapp.hasPendingEvents():
-            self.qapp.processEvents()
-        self.widget.process(self._scan_without_raw)
-        self.widget._processing_stack.wait_computation_finished()
-        while self.qapp.hasPendingEvents():
-            self.qapp.processEvents()
-        assert self._scan_without_raw.load_reduced_darks() not in (None, {})
-        assert self._scan_without_raw.load_reduced_flats() not in (None, {})
-
-    def test_set_darks_and_flats(self):
-        """
-        Test settings darks and flats.
-        """
-        self.widget.setCopyActive(True)
-
-        assert len(os.listdir(self.widget._processing_stack._save_dir)) == 0
-        self.widget.setReducedFlats(
-            {
-                "0.0r": numpy.linspace(12, 12 + 12 * 12, 12 * 12).reshape(12, 12),
-                "1.0r": numpy.linspace(24, 24 + 12 * 12, 12 * 12).reshape(12, 12),
-            }
-        )
-        self.widget.setReducedDarks(
-            {
-                "0.0r": numpy.linspace(0, 12 * 12, 12 * 12).reshape(12, 12),
-            }
-        )
-        self.widget.process(self._scan_without_raw)
-        self.widget._processing_stack.wait_computation_finished()
-        while self.qapp.hasPendingEvents():
-            self.qapp.processEvents()
-
-        loaded_reduced_darks = self._scan_without_raw.load_reduced_darks()
-        assert tuple(loaded_reduced_darks.keys()) == (0,)
-        numpy.testing.assert_allclose(
-            loaded_reduced_darks[0],
-            numpy.linspace(0, 12 * 12, 12 * 12).reshape(12, 12),
-        )
-
-        loaded_reduced_flats = self._scan_without_raw.load_reduced_flats()
-        assert tuple(loaded_reduced_flats.keys()) == (0, 9)
-        numpy.testing.assert_allclose(
-            loaded_reduced_flats[9],
-            numpy.linspace(24, 24 + 12 * 12, 12 * 12).reshape(12, 12),
-        )

orangecontrib/tomwer/widgets/reconstruction/test/test_delta_beta_selector.py

@@ -1,15 +0,0 @@
-import numpy
-
-from orangecontrib.tomwer.widgets.reconstruction.NabuVolumeOW import (
-    _DeltaBetaSelectorDialog,
-)
-from tomwer.tests.conftest import qtapp  # noqa F401
-
-
-def test_DeltaBetaSelector(
-    qtapp,  # noqa F811
-):
-    """simple test of the _DeltaBetaSelectorDialog"""
-    dialog = _DeltaBetaSelectorDialog(values=(12, 45))
-    dialog.show()
-    assert numpy.isscalar(dialog.getSelectedValue())

orangecontrib/tomwer/widgets/reconstruction/test/test_i_norm.py

@@ -1,226 +0,0 @@
-# coding: utf-8
-# /*##########################################################################
-#
-# Copyright (c) 2016-2017 European Synchrotron Radiation Facility
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in
-# all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# THE SOFTWARE.
-#
-# ###########################################################################*/
-
-__authors__ = ["H. Payno"]
-__license__ = "MIT"
-__date__ = "09/06/2021"
-
-import gc
-import logging
-import os
-import pickle
-import shutil
-import tempfile
-
-from orangecanvas.scheme.readwrite import literal_dumps
-from processview.core.manager import DatasetState, ProcessManager
-from silx.gui import qt
-from silx.gui.utils.testutils import TestCaseQt
-from silx.io.utils import h5py_read_dataset
-
-from orangecontrib.tomwer.widgets.reconstruction.SinoNormOW import (
-    SinoNormOW as _NormIOW,
-)
-from tomwer.core import settings
-from tomwer.core.utils.lbsram import mock_low_memory
-from tomwer.core.process.reconstruction.normalization import SinoNormalizationTask
-from tomwer.core.utils.scanutils import MockNXtomo
-from tomwer.io.utils.h5pyutils import EntryReader
-
-logger = logging.getLogger(__name__)
-
-
-class NormIOW(_NormIOW):
-    def __init__(self, parent=None):
-        self._scans_finished = []
-        super().__init__(parent)
-
-    def processing_finished(self, scan):
-        self._scans_finished.append(scan)
-
-    def wait_processing(self, wait_time):
-        self._window._processing_stack._computationThread.wait(wait_time)
-
-    @property
-    def scans_finished(self):
-        return self._scans_finished
-
-    def compute(self):
-        self._window._processCurrentScan()
-
-    def setROI(self, start_x, end_x, start_y, end_y):
-        self._window.setROI(start_x=start_x, end_x=end_x, start_y=start_y, end_y=end_y)
-
-    def close(self):
-        self._scans_finished = {}
-        super().close()
-
-
-class TestProcessing(TestCaseQt):
-    DIM = 100
-
-    def setUp(self):
-        super().setUp()
-        self._source_dir = tempfile.mkdtemp()
-
-        def create_scan(folder_name):
-            _dir = os.path.join(self._source_dir, folder_name)
-            return MockNXtomo(
-                scan_path=_dir,
-                n_ini_proj=20,
-                n_proj=20,
-                n_alignement_proj=2,
-                create_final_flat=False,
-                create_ini_dark=True,
-                create_ini_flat=True,
-                n_refs=1,
-                dim=self.DIM,
-            ).scan
-
-        # create scans
-        self.scan_1 = create_scan("scan_1")
-        self.scan_2 = create_scan("scan_2")
-        self.scan_3 = create_scan("scan_3")
-        self._process_manager = ProcessManager()
-
-        self.widget = NormIOW()
-        self.widget.show()
-
-    def tearDown(self):
-        mock_low_memory(False)
-        settings.mock_lsbram(False)
-        self.widget.setAttribute(qt.Qt.WA_DeleteOnClose)
-        self.widget.close()
-        self.widget = None
-        self.qapp.processEvents()
-        shutil.rmtree(self._source_dir)
-        gc.collect()
-
-    def test_serializing(self):
-        pickle.dumps(self.widget.getConfiguration())
-
-    def test_literal_dumps(self):
-        self.widget._updateSettings()
-        literal_dumps(self.widget._ewoks_default_inputs)
-
-    def testUnlocked(self):
-        """Test result when used with some interaction"""
-        self.widget.setLocked(False)
-
-        def process_scalar_manually():
-            self.widget.setCurrentMethod("division")
-            self.widget.setCurrentSource("manual ROI")
-
-            self.qapp.processEvents()
-            self.widget.setROI(start_x=0, end_x=10, start_y=0, end_y=10)
-            self.qapp.processEvents()
-            self.widget.compute()
-            self.widget.wait_processing(5000)
-            self.qapp.processEvents()
-
-        self.widget.process(self.scan_1)
-        process_scalar_manually()
-        self.assertEqual(
-            self._process_manager.get_dataset_state(
-                dataset_id=self.scan_1.get_identifier(),
-                process=self.widget,
-            ),
-            DatasetState.WAIT_USER_VALIDATION,
-        )
-
-        self.widget.process(self.scan_2)
-        process_scalar_manually()
-        self.assertEqual(len(self.widget.scans_finished), 0)
-        self.assertEqual(
-            self._process_manager.get_dataset_state(
-                dataset_id=self.scan_1.get_identifier(),
-                process=self.widget,
-            ),
-            DatasetState.SKIPPED,
-        )
-        self.assertEqual(
-            self._process_manager.get_dataset_state(
-                dataset_id=self.scan_2.get_identifier(),
-                process=self.widget,
-            ),
-            DatasetState.WAIT_USER_VALIDATION,
-        )
-
-        self.widget.process(self.scan_3)
-        process_scalar_manually()
-        self.widget.validateCurrentScan()
-        self.assertEqual(
-            self._process_manager.get_dataset_state(
-                dataset_id=self.scan_3.get_identifier(),
-                process=self.widget,
-            ),
-            DatasetState.SUCCEED,
-        )
-
-    def testTestLbsram(self):
-        """Test scan are all validated if 'low memory on lbsram' scenario is
-        activated"""
-        mock_low_memory(True)
-        settings.mock_lsbram(True)
-        for scan in (self.scan_1, self.scan_2, self.scan_3):
-            self.widget.process(scan)
-            self.widget.wait_processing(5000)
-            self.qapp.processEvents()
-
-        for scan in (self.scan_1, self.scan_2, self.scan_3):
-            with self.subTest(scan=str(scan)):
-                self.assertEqual(
-                    self._process_manager.get_dataset_state(
-                        dataset_id=scan.get_identifier(),
-                        process=self.widget,
-                    ),
-                    DatasetState.SKIPPED,
-                )
-
-    def testLocked(self):
-        """Test scan are all validated if the widget is lock"""
-        self.widget.setLocked(True)
-        for scan in (self.scan_1, self.scan_2, self.scan_3):
-            self.widget.process(scan)
-            self.widget.wait_processing(5000)
-            self.qapp.processEvents()
-
-        for scan in (self.scan_1, self.scan_2, self.scan_3):
-            # test status is SUCCEED
-            with self.subTest(scan=str(scan)):
-                self.assertEqual(
-                    self._process_manager.get_dataset_state(
-                        dataset_id=scan.get_identifier(),
-                        process=self.widget,
-                    ),
-                    DatasetState.SUCCEED,
-                )
-            # test process file has been updated
-            with EntryReader(scan.process_file_url) as entry:
-                self.assertTrue("tomwer_process_0" in entry)
-                self.assertEqual(
-                    h5py_read_dataset(entry["tomwer_process_0"]["program"]),
-                    SinoNormalizationTask.program_name(),
-                )