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

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

@@ -0,0 +1,224 @@
+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

@@ -0,0 +1,85 @@
+# 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

@@ -0,0 +1,136 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,226 @@
+# 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(),
+                )