From a2affc44477fb9cc394c699a1f7f9757bfa81c21 Mon Sep 17 00:00:00 2001
From: Antti Soininen <antti.soininen@vtt.fi>
Date: Mon, 19 Aug 2024 08:51:51 +0300
Subject: [PATCH 1/3] Improve pasting data from Excel

Toolbox is now able to handle Excel's clipboard data properly.
The data is not treated as plain CSV text anymore but instead
we use the full type information which enables pasting date, times,
booleans and such from Excel.

Re #1204
---
 CHANGELOG.md                                  |   1 +
 spinetoolbox/mvcmodels/array_model.py         |  15 +-
 .../mvcmodels/indexed_value_table_model.py    |   4 +
 spinetoolbox/mvcmodels/time_pattern_model.py  |   8 +
 .../time_series_model_fixed_resolution.py     |   6 +
 .../time_series_model_variable_resolution.py  |  18 +-
 spinetoolbox/ui/datetime_editor.py            |   4 +-
 spinetoolbox/ui/datetime_editor.ui            |   3 +-
 spinetoolbox/widgets/custom_qtableview.py     | 413 +++++++++---------
 spinetoolbox/widgets/datetime_editor.py       |  14 +-
 spinetoolbox/widgets/duration_editor.py       |   2 +-
 .../widgets/parameter_value_editor_base.py    |  44 +-
 spinetoolbox/widgets/paste_excel.py           |  96 ++++
 .../widgets/plain_parameter_value_editor.py   |   6 +-
 tests/mock_helpers.py                         |  17 +-
 .../widgets/test_add_items_dialog.py          |  13 +-
 .../widgets/test_custom_qtableview.py         |  14 +-
 .../test_edit_or_remove_items_dialogs.py      |  21 +-
 tests/widgets/test_ArrayTableView.py          | 151 +++----
 tests/widgets/test_CopyPasteTableView.py      |  11 +-
 tests/widgets/test_IndexedValueTableView.py   |  36 +-
 tests/widgets/test_MapTableView.py            |  25 +-
 ...test_TimeSeriesFixedResolutionTableView.py |  60 ++-
 tests/widgets/test_paste_excel.py             | 297 +++++++++++++
 24 files changed, 880 insertions(+), 399 deletions(-)
 create mode 100644 spinetoolbox/widgets/paste_excel.py
 create mode 100644 tests/widgets/test_paste_excel.py

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5c757d07d..547330a21 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -22,6 +22,7 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 - Database editor's hamburger menu has been converted into a menubar beneath the tab bar. The URL toolbar has also
   been replaced with a toolbar that houses different buttons.
 - One dimensional entities can now also be added through *Parameter value* and *Entity alternative* tables.
+- Special data types like dates, times and booleans are now properly pasted from Excel. 
 
 ### Deprecated
 
diff --git a/spinetoolbox/mvcmodels/array_model.py b/spinetoolbox/mvcmodels/array_model.py
index 73b33bea2..7326cba4f 100644
--- a/spinetoolbox/mvcmodels/array_model.py
+++ b/spinetoolbox/mvcmodels/array_model.py
@@ -13,6 +13,7 @@
 """Contains model for the Array editor widget."""
 import locale
 from numbers import Number
+from typing import Type
 import numpy
 from PySide6.QtCore import QAbstractTableModel, QModelIndex, Qt
 from spinedb_api import Array, ParameterValueFormatError, SpineDBAPIError, from_database
@@ -38,6 +39,10 @@ def __init__(self, parent):
         self._data_type = float
         self._index_name = Array.DEFAULT_INDEX_NAME
 
+    @property
+    def data_type(self) -> Type:
+        return self._data_type
+
     def array(self):
         """Returns the array modeled by this model."""
         return Array(self._data, self._data_type, self._index_name)
@@ -53,7 +58,7 @@ def batch_set_data(self, indexes, values):
             return
         top_row = indexes[0].row()
         bottom_row = top_row
-        indexes, values = self._convert_to_data_type(indexes, values)
+        # indexes, values = self._convert_to_data_type(indexes, values)
         if not indexes:
             return
         for index, value in zip(indexes, values):
@@ -63,8 +68,8 @@ def batch_set_data(self, indexes, values):
             if row == len(self._data):
                 self.insertRow(len(self._data))
             self._data[row] = value
-        top_left = self.index(top_row, 0)
-        bottom_right = self.index(bottom_row, 0)
+        top_left = self.index(top_row, 1)
+        bottom_right = self.index(bottom_row, 1)
         self.dataChanged.emit(
             top_left,
             bottom_right,
@@ -86,6 +91,8 @@ def _convert_to_data_type(self, indexes, values):
         Returns:
             tuple: indexes and converted values
         """
+        if all(isinstance(v, self._data_type) for v in values):
+            return indexes, values
         filtered = []
         converted = []
         if self._data_type == float:
@@ -113,6 +120,8 @@ def _convert_to_data_type(self, indexes, values):
                     continue
                 except SpineDBAPIError:
                     pass
+                if not isinstance(value, str):
+                    continue
                 try:
                     data = from_database(value, self._data_type.type_())
                     if isinstance(data, self._data_type):
diff --git a/spinetoolbox/mvcmodels/indexed_value_table_model.py b/spinetoolbox/mvcmodels/indexed_value_table_model.py
index d7e7f6931..5c2292efb 100644
--- a/spinetoolbox/mvcmodels/indexed_value_table_model.py
+++ b/spinetoolbox/mvcmodels/indexed_value_table_model.py
@@ -33,6 +33,10 @@ def columnCount(self, parent=QModelIndex()):
         """Returns the number of columns which is two."""
         return 2
 
+    def column_type(self, column):
+        """Returns column's type."""
+        raise NotImplementedError()
+
     def data(self, index, role=Qt.ItemDataRole.DisplayRole):
         """Returns the data at index for given role."""
         if role in (Qt.ItemDataRole.DisplayRole, Qt.ItemDataRole.EditRole):
diff --git a/spinetoolbox/mvcmodels/time_pattern_model.py b/spinetoolbox/mvcmodels/time_pattern_model.py
index b389609fd..7ccb08781 100644
--- a/spinetoolbox/mvcmodels/time_pattern_model.py
+++ b/spinetoolbox/mvcmodels/time_pattern_model.py
@@ -21,6 +21,14 @@
 class TimePatternModel(IndexedValueTableModel):
     """A model for time pattern type parameter values."""
 
+    def column_type(self, column):
+        """Returns column's type."""
+        if column == 0:
+            return str
+        if column == 1:
+            return float
+        raise RuntimeError("Logic error: column out of bounds")
+
     def flags(self, index):
         """Returns flags at index."""
         if not index.isValid():
diff --git a/spinetoolbox/mvcmodels/time_series_model_fixed_resolution.py b/spinetoolbox/mvcmodels/time_series_model_fixed_resolution.py
index db53a34a9..adbd1b2e0 100644
--- a/spinetoolbox/mvcmodels/time_series_model_fixed_resolution.py
+++ b/spinetoolbox/mvcmodels/time_series_model_fixed_resolution.py
@@ -29,6 +29,12 @@ def __init__(self, series, parent):
         super().__init__(series, parent)
         self.locale = QLocale()
 
+    def column_type(self, column):
+        """Returns column's type."""
+        if column == 1:
+            return float
+        raise RuntimeError("Logic error: column out of bounds")
+
     def flags(self, index):
         """Returns flags at index."""
         if not index.isValid():
diff --git a/spinetoolbox/mvcmodels/time_series_model_variable_resolution.py b/spinetoolbox/mvcmodels/time_series_model_variable_resolution.py
index 57b54cbbe..42950bc16 100644
--- a/spinetoolbox/mvcmodels/time_series_model_variable_resolution.py
+++ b/spinetoolbox/mvcmodels/time_series_model_variable_resolution.py
@@ -20,6 +20,14 @@
 class TimeSeriesModelVariableResolution(IndexedValueTableModel):
     """A model for variable resolution time series type parameter values."""
 
+    def column_type(self, column):
+        """Returns column's type."""
+        if column == 0:
+            return np.datetime64
+        if column == 1:
+            return float
+        raise RuntimeError("Logic error: column out of bounds")
+
     def flags(self, index):
         """Returns the flags for given model index."""
         if not index.isValid():
@@ -164,20 +172,20 @@ def batch_set_data(self, indexes, values):
             indexes (Sequence): a sequence of model indexes
             values (Sequence): a sequence of datetimes/floats corresponding to the indexes
         """
-        modified_rows = []
-        modified_columns = []
+        modified_rows = set()
+        modified_columns = set()
         for index, value in zip(indexes, values):
             row = index.row()
-            modified_rows.append(row)
+            modified_rows.add(row)
             column = index.column()
-            modified_columns.append(column)
+            modified_columns.add(column)
             if column == 0:
                 self._value.indexes[row] = value
             else:
                 self._value.values[row] = value
         left_top = self.index(min(modified_rows), min(modified_columns))
         right_bottom = self.index(max(modified_rows), max(modified_columns))
-        self.dataChanged.emit(left_top, right_bottom, [Qt.ItemDataRole.EditRole])
+        self.dataChanged.emit(left_top, right_bottom, [Qt.ItemDataRole.DisplayRole, Qt.ItemDataRole.EditRole])
 
     @Slot(bool, name="set_ignore_year")
     def set_ignore_year(self, ignore_year):
diff --git a/spinetoolbox/ui/datetime_editor.py b/spinetoolbox/ui/datetime_editor.py
index beebea59a..8724c1000 100644
--- a/spinetoolbox/ui/datetime_editor.py
+++ b/spinetoolbox/ui/datetime_editor.py
@@ -14,7 +14,7 @@
 ################################################################################
 ## Form generated from reading UI file 'datetime_editor.ui'
 ##
-## Created by: Qt User Interface Compiler version 6.5.2
+## Created by: Qt User Interface Compiler version 6.6.3
 ##
 ## WARNING! All changes made in this file will be lost when recompiling UI file!
 ################################################################################
@@ -72,6 +72,6 @@ def retranslateUi(self, DatetimeEditor):
         DatetimeEditor.setWindowTitle(QCoreApplication.translate("DatetimeEditor", u"Form", None))
         self.datetime_edit_label.setText(QCoreApplication.translate("DatetimeEditor", u"Datetime", None))
         self.datetime_edit.setDisplayFormat(QCoreApplication.translate("DatetimeEditor", u"yyyy-MM-ddTHH:mm:ss", None))
-        self.format_label.setText(QCoreApplication.translate("DatetimeEditor", u"Format: YYYY--MM-DDThh:mm:ss", None))
+        self.format_label.setText(QCoreApplication.translate("DatetimeEditor", u"Format: YYYY-MM-DDThh:mm:ss", None))
     # retranslateUi
 
diff --git a/spinetoolbox/ui/datetime_editor.ui b/spinetoolbox/ui/datetime_editor.ui
index 0036ae7e2..4639f8a31 100644
--- a/spinetoolbox/ui/datetime_editor.ui
+++ b/spinetoolbox/ui/datetime_editor.ui
@@ -2,6 +2,7 @@
 <!--
 ######################################################################################################################
 # Copyright (C) 2017-2022 Spine project consortium
+# Copyright Spine Toolbox contributors
 # This file is part of Spine Toolbox.
 # Spine Toolbox is free software: you can redistribute it and\/or modify it under the terms of the GNU Lesser General
 # Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
@@ -50,7 +51,7 @@
        <item>
         <widget class="QLabel" name="format_label">
          <property name="text">
-          <string>Format: YYYY--MM-DDThh:mm:ss</string>
+          <string>Format: YYYY-MM-DDThh:mm:ss</string>
          </property>
         </widget>
        </item>
diff --git a/spinetoolbox/widgets/custom_qtableview.py b/spinetoolbox/widgets/custom_qtableview.py
index c300e16e8..40f29e23a 100644
--- a/spinetoolbox/widgets/custom_qtableview.py
+++ b/spinetoolbox/widgets/custom_qtableview.py
@@ -11,10 +11,11 @@
 ######################################################################################################################
 
 """Custom QTableView classes that support copy-paste and the like."""
-from contextlib import contextmanager
+from contextlib import contextmanager, suppress
 import csv
 import ctypes
 import io
+from itertools import cycle
 import locale
 from numbers import Number
 from operator import methodcaller
@@ -31,8 +32,9 @@
     from_database,
     to_database,
 )
-from spinedb_api.parameter_value import join_value_and_type, split_value_and_type
+from spinedb_api.parameter_value import FLOAT_VALUE_TYPE, join_value_and_type, split_value_and_type
 from ..helpers import busy_effect
+from .paste_excel import EXCEL_CLIPBOARD_MIME_TYPE, clipboard_excel_as_table
 
 _ = csv.field_size_limit(int(ctypes.c_ulong(-1).value // 2))
 
@@ -171,11 +173,9 @@ def _read_pasted_text(text):
 
         def _process_value(value):
             """Delocalizes value, except when it's one of our 'complex' value types.
+
             We need this exception because our complex values are json strings, so they have commas,
             and ``locale.delocalize`` might remove those commas.
-
-            We identify our complex values by checking if the word "type" is in them.
-            See ``spinedb_api.helpers.join_value_and_type`` for the reason why this works.
             """
             new_value = locale.delocalize(value)
             try:
@@ -191,13 +191,30 @@ def _process_value(value):
             with system_lc_numeric():
                 return [[_process_value(element) for element in row] for row in reader]
 
+    def _get_data_from_clipboard(self):
+        """Gets data from clipboard converting it to Python table.
+
+        Returns:
+            list of list: data table
+        """
+        clipboard = QApplication.clipboard()
+        mime_data = clipboard.mimeData()
+        data = None
+        data_formats = mime_data.formats()
+        if EXCEL_CLIPBOARD_MIME_TYPE in data_formats:
+            with suppress(Exception):
+                data = clipboard_excel_as_table(bytes(mime_data.data(EXCEL_CLIPBOARD_MIME_TYPE)))
+        if data is None and "text/plain" in data_formats:
+            text = clipboard.text().strip()
+            if text:
+                with suppress(ValueError):
+                    data = self._read_pasted_text(text)
+        return data
+
     def paste_on_selection(self):
         """Pastes clipboard data on selection, but not beyond.
         If data is smaller than selection, repeat data to fit selection."""
-        text = QApplication.clipboard().text()
-        if not text:
-            return False
-        data = self._read_pasted_text(text)
+        data = self._get_data_from_clipboard()
         if not data:
             return False
         selection = self.selectionModel().selection()
@@ -234,10 +251,7 @@ def paste_normal(self):
         def is_visual_column_hidden(x):
             return h.isSectionHidden(h.logicalIndex(x))
 
-        text = QApplication.clipboard().text().strip()
-        if not text:
-            return False
-        data = self._read_pasted_text(text)
+        data = self._get_data_from_clipboard()
         if not data:
             return False
         current = self.currentIndex()
@@ -412,11 +426,6 @@ def copy(self, _=False):
             QApplication.clipboard().setText(output.getvalue())
         return True
 
-    @staticmethod
-    def _read_pasted_text(text):
-        """Reads CSV formatted table."""
-        raise NotImplementedError()
-
     @Slot(bool)
     def paste(self, _=False):
         """Pastes data from clipboard to selection."""
@@ -432,21 +441,18 @@ def paste(self, _=True):
         selection_model = self.selectionModel()
         if not selection_model.hasSelection():
             return False
-        clipboard = QApplication.clipboard()
-        mime_data = clipboard.mimeData()
-        data_formats = mime_data.formats()
-        if "text/plain" not in data_formats:
-            return False
-        try:
-            pasted_table = self._read_pasted_text(clipboard.text())
-        except ValueError:
+        data = self._get_data_from_clipboard()
+        if not data:
             return False
-        if isinstance(pasted_table, tuple):
-            # Always use the first column
-            pasted_table = pasted_table[0]
-        paste_length = len(pasted_table)
+        pasted_table = [row[0] for row in data]
         first_row, last_row, _, _ = _range(selection_model.selection())
         selection_length = last_row - first_row + 1
+        indexes_to_set, values_to_set = self._convert_pasted_data(
+            pasted_table, first_row, selection_length if selection_length > 1 else len(pasted_table)
+        )
+        if not indexes_to_set:
+            return False
+        paste_length = len(indexes_to_set)
         model = self.model()
         model_row_count = model.rowCount() - 1
         if selection_length == 1:
@@ -456,31 +462,17 @@ def paste(self, _=True):
         elif paste_length > selection_length:
             # If multiple row are selected, we paste what fits the selection.
             paste_length = selection_length
-            pasted_table = pasted_table[0:selection_length]
-        indexes_to_set, values_to_set = self._paste_to_values_column(pasted_table, first_row, paste_length)
-        model.batch_set_data(indexes_to_set, values_to_set)
+            indexes_to_set = indexes_to_set[:selection_length]
+            values_to_set = values_to_set[:selection_length]
+        create_index = model.index
+        model.batch_set_data([create_index(*i) for i in indexes_to_set], values_to_set)
         pasted_selection = QItemSelection(model.index(first_row, 1), model.index(first_row + paste_length - 1, 1))
         self.selectionModel().select(pasted_selection, QItemSelectionModel.ClearAndSelect)
         return True
 
     @staticmethod
-    def _read_pasted_text(text):
-        """Parses the given CSV table.
-        Parsing is locale aware.
-
-        Args:
-            text (str): a CSV table containing numbers
-
-        Returns:
-            list of float: A list of floats
-        """
-        with io.StringIO(text) as input_stream:
-            reader = csv.reader(input_stream, delimiter="\t")
-            with system_lc_numeric():
-                return [locale.atof(row[0]) for row in reader if row]
-
-    def _paste_to_values_column(self, values, first_row, paste_length):
-        """Pastes data to the Values column.
+    def _convert_pasted_data(values, first_row, paste_length):
+        """Converts pasted data.
 
         Args:
             values (list): a list of float values to paste
@@ -488,15 +480,28 @@ def _paste_to_values_column(self, values, first_row, paste_length):
             paste_length (int): length of the paste selection (can be different from len(values))
 
         Returns:
-            tuple: A tuple (list(pasted indexes), list(pasted values))
+            tuple: A tuple (list((row, column)), list(pasted values))
         """
         values_to_set = []
         indexes_to_set = []
-        create_model_index = self.model().index
         # Always paste to the Values column.
-        for row in range(first_row, first_row + paste_length):
-            values_to_set.append(values[row - first_row])
-            indexes_to_set.append(create_model_index(row, 1))
+        with system_lc_numeric():
+            for row, value in enumerate(cycle(values)):
+                if row == paste_length:
+                    break
+                if isinstance(value, bytes):
+                    try:
+                        value = from_database(value, FLOAT_VALUE_TYPE)
+                    except ParameterValueFormatError:
+                        continue
+                elif isinstance(value, str):
+                    try:
+                        value = locale.atof(value)
+                    except ValueError:
+                        continue
+                if isinstance(value, float):
+                    values_to_set.append(value)
+                    indexes_to_set.append((first_row + len(values_to_set) - 1, 1))
         return indexes_to_set, values_to_set
 
 
@@ -509,21 +514,45 @@ def paste(self, _=False):
         selection_model = self.selectionModel()
         if not selection_model.hasSelection():
             return False
-        clipboard = QApplication.clipboard()
-        mime_data = clipboard.mimeData()
-        data_formats = mime_data.formats()
-        if "text/plain" not in data_formats:
-            return False
-        try:
-            pasted_table = self._read_pasted_text(clipboard.text())
-        except ValueError:
+        data = self._get_data_from_clipboard()
+        if not data:
             return False
-        paste_single_column = isinstance(pasted_table, list)
-        paste_length = len(pasted_table) if paste_single_column else len(pasted_table[0])
+        paste_single_column = True
+        pasted_table = []
+        for row in data:
+            if len(row) > 1:
+                paste_single_column = False
+                break
+            pasted_table.append(row[0])
+        if not paste_single_column:
+            index_column = []
+            value_column = []
+            for row in data:
+                index_column.append(row[0])
+                value_column.append(row[1])
+            pasted_table = [index_column, value_column]
         first_row, last_row, first_column, _ = _range(selection_model.selection())
         selection_length = last_row - first_row + 1
         model = self.model()
         model_row_count = model.rowCount() - 1
+        if paste_single_column:
+            indexes_to_set, values_to_set = self._paste_single_column(
+                pasted_table, first_row, first_column, selection_length if selection_length > 1 else len(pasted_table)
+            )
+            paste_length = len(indexes_to_set)
+            paste_selection = QItemSelection(
+                model.index(first_row, first_column), model.index(first_row + paste_length - 1, first_column)
+            )
+        else:
+            indexes_to_set, values_to_set = self._paste_two_columns(
+                pasted_table[0],
+                pasted_table[1],
+                first_row,
+                selection_length if selection_length > 1 else len(pasted_table),
+            )
+            paste_length = len(indexes_to_set) // 2
+            paste_selection = QItemSelection(model.index(first_row, 0), model.index(first_row + paste_length - 1, 1))
+        paste_length = len(pasted_table) if paste_single_column else len(pasted_table[0])
         if selection_length == 1 or model.is_expanse_row(last_row):
             # If a single row or the expanse row is selected, we paste everything.
             if model_row_count <= first_row + paste_length:
@@ -535,22 +564,7 @@ def paste(self, _=False):
                 pasted_table = pasted_table[0:selection_length]
             else:
                 pasted_table = pasted_table[0][0:selection_length], pasted_table[1][0:selection_length]
-        if paste_single_column:
-            indexes_to_set, values_to_set = self._paste_single_column(
-                pasted_table, first_row, first_column, paste_length
-            )
-            paste_selection = QItemSelection(
-                model.index(first_row, first_column), model.index(first_row + paste_length - 1, first_column)
-            )
-        else:
-            indexes_to_set, values_to_set = self._paste_two_columns(
-                pasted_table[0], pasted_table[1], first_row, paste_length
-            )
-            paste_selection = QItemSelection(model.index(first_row, 0), model.index(first_row + paste_length - 1, 1))
-        try:
-            model.batch_set_data(indexes_to_set, values_to_set)
-        except ValueError:
-            return False
+        model.batch_set_data(indexes_to_set, values_to_set)
         self.selectionModel().select(paste_selection, QItemSelectionModel.ClearAndSelect)
         return True
 
@@ -568,13 +582,26 @@ def _paste_two_columns(self, data_indexes, data_values, first_row, paste_length)
         """
         values_to_set = []
         indexes_to_set = []
+        index_type = self.model().column_type(0)
         create_model_index = self.model().index
-        for row in range(first_row, first_row + paste_length):
-            i = row - first_row
-            values_to_set.append(data_indexes[i])
-            indexes_to_set.append(create_model_index(row, 0))
-            values_to_set.append(data_values[i])
-            indexes_to_set.append(create_model_index(row, 1))
+        with system_lc_numeric():
+            for i, (stamp, value) in enumerate(cycle(zip(data_indexes, data_values))):
+                if i == paste_length:
+                    break
+                try:
+                    stamp = index_type(stamp)
+                except ValueError:
+                    continue
+                if isinstance(value, str):
+                    try:
+                        value = locale.atof(value)
+                    except ValueError:
+                        continue
+                row = first_row + i
+                values_to_set.append(stamp)
+                indexes_to_set.append(create_model_index(row, 0))
+                values_to_set.append(value)
+                indexes_to_set.append(create_model_index(row, 1))
         return indexes_to_set, values_to_set
 
     def _paste_single_column(self, values, first_row, first_column, paste_length):
@@ -593,45 +620,20 @@ def _paste_single_column(self, values, first_row, first_column, paste_length):
         create_model_index = self.model().index
         # Always paste numbers to the Values column.
         target_column = first_column if not isinstance(values[0], float) else 1
-        for row in range(first_row, first_row + paste_length):
-            values_to_set.append(values[row - first_row])
-            indexes_to_set.append(create_model_index(row, target_column))
+        column_type = self.model().column_type(target_column)
+        with system_lc_numeric():
+            for i, value in enumerate(cycle(values)):
+                if i == paste_length:
+                    break
+                try:
+                    value = column_type(value)
+                except ValueError:
+                    continue
+                row = first_row + i
+                values_to_set.append(value)
+                indexes_to_set.append(create_model_index(row, target_column))
         return indexes_to_set, values_to_set
 
-    @staticmethod
-    def _read_pasted_text(text):
-        """Parses a given CSV table.
-
-        Args:
-            text (str): a CSV table
-
-        Returns:
-            tuple: a tuple (data indexes, data values)
-        """
-        with io.StringIO(text) as input_stream:
-            reader = csv.reader(input_stream, delimiter="\t")
-            single_column = []
-            data_indexes = []
-            data_values = []
-            with system_lc_numeric():
-                for row in reader:
-                    column_count = len(row)
-                    if column_count == 1:
-                        try:
-                            number = locale.atof(row[0])
-                            single_column.append(number)
-                        except ValueError:
-                            single_column.append(row[0])
-                    elif column_count > 1:
-                        data_indexes.append(row[0])
-                        data_values.append(locale.atof(row[1]))
-        if single_column:
-            if data_indexes:
-                # Don't know how to handle a mixture of single and multiple columns.
-                raise ValueError()
-            return single_column
-        return data_indexes, data_values
-
 
 class ArrayTableView(IndexedParameterValueTableViewBase):
     """Custom QTableView with copy and paste methods for single column tables."""
@@ -681,22 +683,17 @@ def paste(self, _=False):
         selection_model = self.selectionModel()
         if not selection_model.hasSelection():
             return False
-        clipboard = QApplication.clipboard()
-        mime_data = clipboard.mimeData()
-        data_formats = mime_data.formats()
-        if "text/plain" not in data_formats:
-            return False
-        try:
-            pasted_table = self._read_pasted_text(clipboard.text())
-        except ValueError:
-            return False
-        if isinstance(pasted_table, tuple):
-            # Always use the first column
-            pasted_table = pasted_table[0]
-        paste_length = len(pasted_table)
+        data = self._get_data_from_clipboard()
+        pasted_table = [row[0] for row in data]
         first_row, last_row, _, _ = _range(selection_model.selection())
         selection_length = last_row - first_row + 1
         model = self.model()
+        indexes_to_set, values_to_set = self._convert_pasted_data(
+            pasted_table, first_row, selection_length if selection_length > 1 else len(pasted_table)
+        )
+        paste_length = len(values_to_set)
+        if paste_length == 0:
+            return False
         model_row_count = model.rowCount() - 1
         if selection_length == 1:
             # If a single row is selected, we paste everything.
@@ -705,33 +702,46 @@ def paste(self, _=False):
         elif paste_length > selection_length:
             # If multiple row are selected, we paste what fits the selection.
             paste_length = selection_length
-            pasted_table = pasted_table[0:selection_length]
-        values_to_set = []
-        indexes_to_set = []
+            values_to_set = values_to_set[:selection_length]
+            indexes_to_set = indexes_to_set[:selection_length]
         create_model_index = self.model().index
-        for row in range(first_row, first_row + paste_length):
-            values_to_set.append(pasted_table[row - first_row])
-            indexes_to_set.append(create_model_index(row, 0))
-        with system_lc_numeric():
-            model.batch_set_data(indexes_to_set, values_to_set)
-        paste_selection = QItemSelection(model.index(first_row, 0), model.index(first_row + paste_length - 1, 0))
+        model.batch_set_data([create_model_index(*i) for i in indexes_to_set], values_to_set)
+        paste_selection = QItemSelection(model.index(first_row, 1), model.index(first_row + paste_length - 1, 1))
         self.selectionModel().select(paste_selection, QItemSelectionModel.ClearAndSelect)
         return True
 
-    @staticmethod
-    def _read_pasted_text(text):
-        """Reads the first column of given CSV table.
+    def _convert_pasted_data(self, values, first_row, paste_length):
+        """Converts pasted data.
 
         Args:
-            text (str): a CSV table
+            values (list): a list of float values to paste
+            first_row (int): index of the first row where to paste
+            paste_length (int): length of the paste selection (can be different from len(values))
 
         Returns:
-            list of str: data column
+            tuple: A tuple (list((row, column)), list(pasted values))
         """
-        with io.StringIO(text) as input_stream:
-            reader = csv.reader(input_stream, delimiter="\t")
-            column = [row[0] for row in reader if row]
-        return column
+        values_to_set = []
+        indexes_to_set = []
+        model = self.model()
+        with system_lc_numeric():
+            for row, value in enumerate(cycle(values)):
+                if row == paste_length:
+                    break
+                if isinstance(value, bytes):
+                    try:
+                        value = from_database(value, FLOAT_VALUE_TYPE)
+                    except ParameterValueFormatError:
+                        continue
+                elif isinstance(value, str) and model.data_type == float:
+                    try:
+                        value = locale.atof(value)
+                    except ValueError:
+                        continue
+                if isinstance(value, model.data_type):
+                    values_to_set.append(value)
+                    indexes_to_set.append((first_row + len(values_to_set) - 1, 1))
+        return indexes_to_set, values_to_set
 
 
 class MapTableView(CopyPasteTableView):
@@ -801,16 +811,16 @@ def paste(self, _=False):
         selection_model = self.selectionModel()
         if not selection_model.hasSelection():
             return False
-        clipboard = QApplication.clipboard()
-        mime_data = clipboard.mimeData()
-        data_formats = mime_data.formats()
-        if "text/plain" not in data_formats:
+        data = self._get_data_from_clipboard()
+        if not data:
             return False
-        pasted_table = self._read_pasted_text(clipboard.text())
-        paste_length = len(pasted_table)
-        paste_width = len(pasted_table[0]) if pasted_table else 0
         first_row, last_row, first_column, last_column = _range(selection_model.selection())
         selection_length = last_row - first_row + 1
+        pasted_table = self._convert_pasted_data(data, selection_length if selection_length > 1 else len(data))
+        if not pasted_table:
+            return False
+        paste_length = len(pasted_table)
+        paste_width = len(pasted_table[0])
         selection_width = last_column - first_column + 1
         model = self.model()
         if (
@@ -838,52 +848,57 @@ def paste(self, _=False):
         return True
 
     @staticmethod
-    def _read_pasted_text(text):
-        """Parses a given CSV table.
+    def _convert_pasted_data(data, length):
+        """Convert pasted data to what the model expects.
 
         Args:
-            text (str): a CSV table
+            data (list of list): pasted data
+            length (int): paste length
 
         Returns:
-            list of list: a list of table rows
+            list of list: converted data
         """
-        data = []
-        with io.StringIO(text) as input_stream:
-            reader = csv.reader(input_stream, delimiter="\t")
-            with system_lc_numeric():
-                for row in reader:
-                    data_row = []
-                    for cell in row:
-                        try:
-                            number = locale.atof(cell)
-                            data_row.append(number)
-                            continue
-                        except ValueError:
-                            pass
+        pasted_table = []
+        with system_lc_numeric():
+            for i, row in enumerate(cycle(data)):
+                if i == length:
+                    break
+                table_row = []
+                for cell in row:
+                    if isinstance(cell, bytes):
+                        cell = str(cell, encoding="utf-8")
+                    elif isinstance(cell, (float, bool)):
+                        table_row.append(cell)
+                        continue
+                    try:
+                        table_row.append(locale.atof(cell))
+                        continue
+                    except ValueError:
+                        pass
+                    try:
+                        # Try parsing Duration before DateTime
+                        # because DateTime will happily accept strings like '1h'
+                        value = Duration(cell)
+                        table_row.append(value)
+                        continue
+                    except SpineDBAPIError:
+                        pass
+                    if _could_be_time_stamp(cell):
                         try:
-                            # Try parsing Duration before DateTime
-                            # because DateTime will happily accept strings like '1h'
-                            value = Duration(cell)
-                            data_row.append(value)
+                            value = DateTime(cell)
+                            table_row.append(value)
                             continue
                         except SpineDBAPIError:
                             pass
-                        if _could_be_time_stamp(cell):
-                            try:
-                                value = DateTime(cell)
-                                data_row.append(value)
-                                continue
-                            except SpineDBAPIError:
-                                pass
-                        try:
-                            value = from_database(*split_value_and_type(cell))
-                            data_row.append(value)
-                            continue
-                        except ParameterValueFormatError:
-                            pass
-                        data_row.append(cell)
-                    data.append(data_row)
-        return data
+                    try:
+                        value = from_database(*split_value_and_type(cell))
+                        table_row.append(value)
+                        continue
+                    except ParameterValueFormatError:
+                        pass
+                    table_row.append(cell)
+                pasted_table.append(table_row)
+        return pasted_table
 
 
 def _range(selection):
diff --git a/spinetoolbox/widgets/datetime_editor.py b/spinetoolbox/widgets/datetime_editor.py
index 9118b80f5..82aedf168 100644
--- a/spinetoolbox/widgets/datetime_editor.py
+++ b/spinetoolbox/widgets/datetime_editor.py
@@ -39,18 +39,18 @@ def _datetime_to_QDateTime(dt):
 
 
 class DatetimeEditor(QWidget):
-    """
-    An editor widget for DateTime type parameter values.
-
-    Attributes:
-        parent (QWidget): a parent widget
-    """
+    """An editor widget for DateTime type parameter values."""
 
     def __init__(self, parent=None):
+        """
+        Args:
+
+        parent (QWidget, optional): a parent widget
+        """
         from ..ui.datetime_editor import Ui_DatetimeEditor  # pylint: disable=import-outside-toplevel
 
         super().__init__(parent)
-        self._value = DateTime("2000-01-01")
+        self._value = DateTime()
         self._ui = Ui_DatetimeEditor()
         self._ui.setupUi(self)
         self._ui.datetime_edit.setMinimumDate(QDate(1, 1, 1))
diff --git a/spinetoolbox/widgets/duration_editor.py b/spinetoolbox/widgets/duration_editor.py
index f4950e2a9..96202359d 100644
--- a/spinetoolbox/widgets/duration_editor.py
+++ b/spinetoolbox/widgets/duration_editor.py
@@ -28,7 +28,7 @@ def __init__(self, parent=None):
         from ..ui.duration_editor import Ui_DurationEditor  # pylint: disable=import-outside-toplevel
 
         super().__init__(parent)
-        self._value = Duration(duration_to_relativedelta("1 hour"))
+        self._value = Duration()
         self._ui = Ui_DurationEditor()
         self._ui.setupUi(self)
         self._ui.duration_edit.editingFinished.connect(self._change_duration)
diff --git a/spinetoolbox/widgets/parameter_value_editor_base.py b/spinetoolbox/widgets/parameter_value_editor_base.py
index 5238574ce..fd4036ec3 100644
--- a/spinetoolbox/widgets/parameter_value_editor_base.py
+++ b/spinetoolbox/widgets/parameter_value_editor_base.py
@@ -109,8 +109,9 @@ def _change_parameter_type(self, selector_index):
         """
         Handles switching between value types.
 
-        Does a rude conversion between fixed and variable resolution time series.
-        In other cases, a default 'empty' value is used.
+        Does some rude conversions between previous and new values
+        if it makes sense.
+        Otherwise, the new value is set to a default 'empty' value.
 
         Args:
             selector_index (int): an index to the selector combo box
@@ -144,9 +145,44 @@ def _change_parameter_type(self, selector_index):
                 variable_resolution_value.repeat,
             )
             self._editors[ValueType.TIME_SERIES_FIXED_RESOLUTION].set_value(fixed_resolution_value)
+        elif selector_index == self._editor_indexes[ValueType.PLAIN_VALUE]:
+            value = self._editors[ValueType.PLAIN_VALUE].value()
+            if value == "":  # Try to override empty string only, not False, 0 or None.
+                if old_index == self._editor_indexes[ValueType.DATETIME]:
+                    date_time_value = self._editors[ValueType.DATETIME].value()
+                    if date_time_value != DateTime():
+                        value = str(date_time_value)
+                elif old_index == self._editor_indexes[ValueType.DURATION]:
+                    duration_value = self._editors[ValueType.DURATION].value()
+                    if duration_value != Duration():
+                        value = str(duration_value)
+            self._editors[ValueType.PLAIN_VALUE].set_value(value)
+        elif old_index == self._editor_indexes[ValueType.PLAIN_VALUE]:
+            if (
+                selector_index == self._editor_indexes[ValueType.DATETIME]
+                and self._editors[ValueType.DATETIME].value() == DateTime()
+            ):
+                plain_value = self._editors[ValueType.PLAIN_VALUE]
+                if isinstance(plain_value, str):
+                    try:
+                        date_time_value = DateTime(plain_value)
+                    except ParameterValueFormatError:
+                        pass
+                    else:
+                        self._editors[ValueType.DATETIME].set_value(date_time_value)
+            if (
+                selector_index == self._editor_indexes[ValueType.DURATION]
+                and self._editors[ValueType.DURATION].value() == Duration()
+            ):
+                plain_value = self._editors[ValueType.PLAIN_VALUE].value()
+                if isinstance(plain_value, str):
+                    try:
+                        duration_value = Duration(plain_value)
+                    except ParameterValueFormatError:
+                        pass
+                    else:
+                        self._editors[ValueType.DURATION].set_value(duration_value)
         self._ui.editor_stack.setCurrentIndex(selector_index)
-        if selector_index == self._editor_indexes[ValueType.PLAIN_VALUE]:
-            self._editors[ValueType.PLAIN_VALUE].set_value("")
 
     def _select_editor(self, value):
         """Shows the editor widget corresponding to the given value type on the editor stack."""
diff --git a/spinetoolbox/widgets/paste_excel.py b/spinetoolbox/widgets/paste_excel.py
new file mode 100644
index 000000000..c8f7defae
--- /dev/null
+++ b/spinetoolbox/widgets/paste_excel.py
@@ -0,0 +1,96 @@
+######################################################################################################################
+# Copyright (C) 2017-2022 Spine project consortium
+# Copyright Spine Toolbox contributors
+# This file is part of Spine Toolbox.
+# Spine Toolbox is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General
+# Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
+# any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+# without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
+# Public License for more details. You should have received a copy of the GNU Lesser General Public License along with
+# this program. If not, see <http://www.gnu.org/licenses/>.
+######################################################################################################################
+"""This module contains utilities for pasting data from Excel."""
+from xml.etree import ElementTree
+from spinedb_api import DateTime, to_database
+from spinedb_api.parameter_value import join_value_and_type
+
+# Ideally, we would use openpyxl to deal with Excel data.
+# However, openpyxl is geared towards handling data from file,
+# not from clipboard, and it seems to be very tedious to get it to work with the
+# clipboard's XML blobs.
+
+EXCEL_CLIPBOARD_MIME_TYPE = 'application/x-qt-windows-mime;value="XML Spreadsheet"'
+URN_PREFIX = "{urn:schemas-microsoft-com:office:spreadsheet}"
+
+
+def _convert_from_excel(data):
+    """Converts cell data to Python.
+
+    Args:
+        data (Element): cell element
+
+    Returns:
+        Any: cell's data
+    """
+
+    def date_time_to_database(x):
+        return bytes(join_value_and_type(*to_database(DateTime(x))), encoding="utf-8")
+
+    def bool_to_database(x):
+        return bytes(join_value_and_type(*to_database(bool(x))), encoding="utf-8")
+
+    convert_function = {
+        "Boolean": bool_to_database,
+        "DateTime": date_time_to_database,
+        "Number": float,
+        "String": str,
+    }[data.attrib[URN_PREFIX + "Type"]]
+    return convert_function(data.text)
+
+
+def clipboard_excel_as_table(clipboard_data):
+    """Converts Excel XML blob to Python table.
+
+    Args:
+        clipboard_data (bytes): XML blob
+
+    Returns:
+        list of list: table
+    """
+    if clipboard_data.endswith(b"\00"):
+        clipboard_data = clipboard_data[:-1]
+    root = ElementTree.fromstring(clipboard_data)
+    worksheet = root.find(URN_PREFIX + "Worksheet")
+    if worksheet is None:
+        raise ValueError("no worksheet")
+    table = worksheet.find(URN_PREFIX + "Table")
+    if table is None:
+        raise ValueError("no table")
+    converted_data = {}
+    all_column_indexes = set()
+    row_i = 0
+    for row in table.findall(URN_PREFIX + "Row"):
+        row_index = row.attrib.get(URN_PREFIX + "Index")
+        if row_index is not None:
+            row_i = int(row_index) - 1
+        column_i = 0
+        for cell in row.findall(URN_PREFIX + "Cell"):
+            cell_index = cell.attrib.get(URN_PREFIX + "Index")
+            if cell_index is not None:
+                column_i = int(cell_index) - 1
+            data = cell.find(URN_PREFIX + "Data")
+            converted_data[(row_i, column_i)] = _convert_from_excel(data)
+            all_column_indexes.add(column_i)
+            column_i += 1
+        row_i += 1
+    if not converted_data:
+        return []
+    result_table = []
+    row_count = row_i
+    column_count = max(all_column_indexes) + 1
+    for row_i in range(row_count):
+        result_row = []
+        result_table.append(result_row)
+        for column_i in range(column_count):
+            result_row.append(converted_data.get((row_i, column_i)))
+    return result_table
diff --git a/spinetoolbox/widgets/plain_parameter_value_editor.py b/spinetoolbox/widgets/plain_parameter_value_editor.py
index 2bb2353da..27486adf2 100644
--- a/spinetoolbox/widgets/plain_parameter_value_editor.py
+++ b/spinetoolbox/widgets/plain_parameter_value_editor.py
@@ -48,12 +48,12 @@ def _set_string_enabled(self, on):
 
     def set_value(self, value):
         """Sets the value to be edited in this widget."""
+        self._ui.string_value_edit.clear()
+        self._ui.value_edit.clear()
         if value is None:
             self._ui.radioButton_null.setChecked(True)
-        elif value is True:
+        elif isinstance(value, bool):
             self._ui.radioButton_true.setChecked(True)
-        elif value is False:
-            self._ui.radioButton_false.setChecked(True)
         elif isinstance(value, str) and value:
             self._ui.string_value_edit.setText(str(value))
             self._ui.radioButton_string.setChecked(True)
diff --git a/tests/mock_helpers.py b/tests/mock_helpers.py
index 622b08766..0bb60dc60 100644
--- a/tests/mock_helpers.py
+++ b/tests/mock_helpers.py
@@ -13,7 +13,7 @@
 """Classes and functions that can be shared among unit test modules."""
 from contextlib import contextmanager
 from unittest import mock
-from PySide6.QtCore import QModelIndex, Qt
+from PySide6.QtCore import QMimeData, QModelIndex, Qt
 from PySide6.QtWidgets import QApplication
 import spinetoolbox.resources_icons_rc  # pylint: disable=unused-import
 from spinetoolbox.spine_db_manager import SpineDBManager
@@ -383,3 +383,18 @@ def is_url_validated(self):
 
     def tear_down(self):
         return True
+
+
+@contextmanager
+def mock_clipboard_patch(text, clipboard_module):
+    with mock.patch(clipboard_module) as clipboard_getter:
+        clipboard = mock.MagicMock()
+        mime_data = QMimeData()
+        mime_data.setText(text)
+        clipboard.mimeData.return_value = mime_data
+        clipboard.text.return_value = text
+        clipboard_getter.return_value = clipboard
+        try:
+            yield clipboard
+        finally:
+            mime_data.deleteLater()
diff --git a/tests/spine_db_editor/widgets/test_add_items_dialog.py b/tests/spine_db_editor/widgets/test_add_items_dialog.py
index 3dc154c08..7c6da145f 100644
--- a/tests/spine_db_editor/widgets/test_add_items_dialog.py
+++ b/tests/spine_db_editor/widgets/test_add_items_dialog.py
@@ -14,7 +14,7 @@
 from tempfile import TemporaryDirectory
 import unittest
 from unittest import mock
-from PySide6.QtCore import QItemSelection, QItemSelectionModel, QModelIndex
+from PySide6.QtCore import QItemSelection, QItemSelectionModel, QMimeData, QModelIndex
 from PySide6.QtWidgets import QApplication
 from spinetoolbox.spine_db_editor.widgets.add_items_dialogs import (
     AddEntitiesDialog,
@@ -23,6 +23,7 @@
 )
 from spinetoolbox.spine_db_editor.widgets.spine_db_editor import SpineDBEditor
 from spinetoolbox.spine_db_manager import SpineDBManager
+from tests.mock_helpers import mock_clipboard_patch
 from tests.spine_db_editor.helpers import TestBase
 
 
@@ -251,13 +252,9 @@ def test_add_entities_dialog_autofill(self):
         result = [model.index(0, column).data() for column in range(model.columnCount())]
         self.assertEqual(expected, result)
 
-    @staticmethod
-    def _paste_to_table_view(text, dialog):
-        mock_clipboard = mock.MagicMock()
-        mock_clipboard.text.return_value = text
-        with mock.patch("spinetoolbox.widgets.custom_qtableview.QApplication.clipboard") as clipboard:
-            clipboard.return_value = mock_clipboard
-            dialog.table_view.paste()
+    def _paste_to_table_view(self, text, dialog):
+        with mock_clipboard_patch(text, "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
+            self.assertTrue(dialog.table_view.paste())
 
     def _commit_changes_to_database(self, commit_message):
         with mock.patch.object(self._db_editor, "_get_commit_msg") as commit_msg:
diff --git a/tests/spine_db_editor/widgets/test_custom_qtableview.py b/tests/spine_db_editor/widgets/test_custom_qtableview.py
index c4fc90503..d39ba3813 100644
--- a/tests/spine_db_editor/widgets/test_custom_qtableview.py
+++ b/tests/spine_db_editor/widgets/test_custom_qtableview.py
@@ -19,7 +19,7 @@
 from PySide6.QtCore import QItemSelectionModel, QModelIndex
 from PySide6.QtWidgets import QApplication, QMessageBox
 from spinedb_api import Array, DatabaseMapping, import_functions, to_database
-from tests.mock_helpers import fetch_model
+from tests.mock_helpers import fetch_model, mock_clipboard_patch
 from tests.spine_db_editor.helpers import TestBase
 from tests.spine_db_editor.widgets.helpers import EditorDelegateMocking, add_entity, add_zero_dimension_entity_class
 
@@ -66,10 +66,7 @@ def test_paste_empty_string_to_entity_byname_column(self):
         table_view.selectionModel().setCurrentIndex(
             model.index(0, byname_column), QItemSelectionModel.SelectionFlag.ClearAndSelect
         )
-        mock_clipboard = mock.MagicMock()
-        mock_clipboard.text.return_value = "''"
-        with mock.patch("spinetoolbox.widgets.custom_qtableview.QApplication.clipboard") as clipboard:
-            clipboard.return_value = mock_clipboard
+        with mock_clipboard_patch("''", "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
             self.assertTrue(table_view.paste())
         self.assertEqual(model.rowCount(), 1)
         self.assertEqual(model.columnCount(), 6)
@@ -513,10 +510,9 @@ def test_pasting_gibberish_to_the_active_column_converts_to_false(self):
         table_view = self._db_editor.ui.tableView_entity_alternative
         model = table_view.model()
         table_view.selectionModel().setCurrentIndex(model.index(0, 0), QItemSelectionModel.SelectionFlag.ClearAndSelect)
-        mock_clipboard = mock.MagicMock()
-        mock_clipboard.text.return_value = "Object\tspoon\tBase\tGIBBERISH"
-        with mock.patch("spinetoolbox.widgets.custom_qtableview.QApplication.clipboard") as clipboard:
-            clipboard.return_value = mock_clipboard
+        with mock_clipboard_patch(
+            "Object\tspoon\tBase\tGIBBERISH", "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"
+        ):
             self.assertTrue(table_view.paste())
         self.assertEqual(model.rowCount(), 2)
         self.assertEqual(model.columnCount(), 5)
diff --git a/tests/spine_db_editor/widgets/test_edit_or_remove_items_dialogs.py b/tests/spine_db_editor/widgets/test_edit_or_remove_items_dialogs.py
index cfbb7e277..17f3cb3f2 100644
--- a/tests/spine_db_editor/widgets/test_edit_or_remove_items_dialogs.py
+++ b/tests/spine_db_editor/widgets/test_edit_or_remove_items_dialogs.py
@@ -16,6 +16,7 @@
 from PySide6.QtCore import QItemSelectionModel
 from PySide6.QtWidgets import QApplication
 from spinetoolbox.spine_db_editor.widgets.edit_or_remove_items_dialogs import EditEntityClassesDialog
+from tests.mock_helpers import mock_clipboard_patch
 from tests.spine_db_editor.helpers import TestBase
 
 
@@ -34,16 +35,10 @@ def test_pasting_gibberish_to_active_by_default_column_gives_false(self):
         dialog.table_view.selectionModel().setCurrentIndex(
             model.index(0, 3), QItemSelectionModel.SelectionFlag.ClearAndSelect
         )
-        mock_clipboard = mock.MagicMock()
-        mock_clipboard.text.return_value = "true"
-        with mock.patch("spinetoolbox.widgets.custom_qtableview.QApplication.clipboard") as clipboard:
-            clipboard.return_value = mock_clipboard
+        with mock_clipboard_patch("true", "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
             self.assertTrue(dialog.table_view.paste())
         self._assert_table_contents(model, [["Object", None, None, True, "TestEditEntityClassesDialog_db"]])
-        mock_clipboard = mock.MagicMock()
-        mock_clipboard.text.return_value = "GIBBERISH"
-        with mock.patch("spinetoolbox.widgets.custom_qtableview.QApplication.clipboard") as clipboard:
-            clipboard.return_value = mock_clipboard
+        with mock_clipboard_patch("GIBBERISH", "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
             self.assertTrue(dialog.table_view.paste())
         self._assert_table_contents(model, [["Object", None, None, False, "TestEditEntityClassesDialog_db"]])
 
@@ -61,16 +56,10 @@ def test_pasting_gibberish_to_display_icon_column_gives_none(self):
         dialog.table_view.selectionModel().setCurrentIndex(
             model.index(0, 2), QItemSelectionModel.SelectionFlag.ClearAndSelect
         )
-        mock_clipboard = mock.MagicMock()
-        mock_clipboard.text.return_value = "23"
-        with mock.patch("spinetoolbox.widgets.custom_qtableview.QApplication.clipboard") as clipboard:
-            clipboard.return_value = mock_clipboard
+        with mock_clipboard_patch("23", "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
             self.assertTrue(dialog.table_view.paste())
         self._assert_table_contents(model, [["Object", None, 23, True, "TestEditEntityClassesDialog_db"]])
-        mock_clipboard = mock.MagicMock()
-        mock_clipboard.text.return_value = "GIBBERISH"
-        with mock.patch("spinetoolbox.widgets.custom_qtableview.QApplication.clipboard") as clipboard:
-            clipboard.return_value = mock_clipboard
+        with mock_clipboard_patch("GIBBERISH", "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
             self.assertTrue(dialog.table_view.paste())
         self._assert_table_contents(model, [["Object", None, None, True, "TestEditEntityClassesDialog_db"]])
 
diff --git a/tests/widgets/test_ArrayTableView.py b/tests/widgets/test_ArrayTableView.py
index 18a7db8ba..eb3ea167e 100644
--- a/tests/widgets/test_ArrayTableView.py
+++ b/tests/widgets/test_ArrayTableView.py
@@ -15,11 +15,12 @@
 from io import StringIO
 import locale
 import unittest
-from PySide6.QtCore import QItemSelectionModel, QObject
+from PySide6.QtCore import QItemSelectionModel
 from PySide6.QtWidgets import QApplication
 from spinedb_api import Array
 from spinetoolbox.mvcmodels.array_model import ArrayModel
 from spinetoolbox.widgets.custom_qtableview import ArrayTableView, system_lc_numeric
+from tests.mock_helpers import mock_clipboard_patch
 
 
 class TestArrayTableView(unittest.TestCase):
@@ -29,120 +30,110 @@ def setUpClass(cls):
             QApplication()
 
     def setUp(self):
-        self._parent = QObject()
-        self._original_clip = QApplication.clipboard().text()
+        self._table_view = ArrayTableView()
+        self._model = ArrayModel(self._table_view)
+        self._table_view.setModel(self._model)
 
     def tearDown(self):
-        self._parent.deleteLater()
-        QApplication.clipboard().setText(self._original_clip)
+        self._table_view.deleteLater()
 
     def test_copy_without_selection_returns_false(self):
-        model = ArrayModel(self._parent)
-        table_view = ArrayTableView()
-        table_view.setModel(model)
-        self.assertFalse(table_view.copy())
-        table_view.deleteLater()
+        self.assertFalse(self._table_view.copy())
 
     def test_copy_single_non_numeric_cell(self):
-        model = ArrayModel(self._parent)
-        table_view = ArrayTableView()
-        table_view.setModel(model)
-        model.reset(Array(["a"]))
-        index = model.index(0, 1)
-        table_view.selectionModel().select(index, QItemSelectionModel.Select)
-        self.assertTrue(table_view.copy())
+        self._model.reset(Array(["a"]))
+        index = self._model.index(0, 1)
+        self._table_view.selectionModel().select(index, QItemSelectionModel.Select)
+        self.assertTrue(self._table_view.copy())
         clip = StringIO(QApplication.clipboard().text())
         array = list(csv.reader(clip))
         self.assertEqual(array, [["a"]])
-        table_view.deleteLater()
 
     def test_copy_single_numeric_cell(self):
-        model = ArrayModel(self._parent)
-        table_view = ArrayTableView()
-        table_view.setModel(model)
-        model.reset(Array([5.5]))
-        index = model.index(0, 1)
-        table_view.selectionModel().select(index, QItemSelectionModel.Select)
-        self.assertTrue(table_view.copy())
+        self._model.reset(Array([5.5]))
+        index = self._model.index(0, 1)
+        self._table_view.selectionModel().select(index, QItemSelectionModel.Select)
+        self.assertTrue(self._table_view.copy())
         clip = StringIO(QApplication.clipboard().text())
         array = list(csv.reader(clip, delimiter="\t"))
         with system_lc_numeric():
             self.assertEqual(array, [[locale.str(5.5)]])
-        table_view.deleteLater()
 
     def test_copy_does_not_copy_expansion_row(self):
-        model = ArrayModel(self._parent)
-        table_view = ArrayTableView()
-        table_view.setModel(model)
-        model.reset(Array([5.5]))
-        for column in range(model.columnCount()):
-            for row in range(model.rowCount()):
-                table_view.selectionModel().select(model.index(row, column), QItemSelectionModel.Select)
-        self.assertTrue(table_view.copy())
+        self._model.reset(Array([5.5]))
+        for column in range(self._model.columnCount()):
+            for row in range(self._model.rowCount()):
+                self._table_view.selectionModel().select(self._model.index(row, column), QItemSelectionModel.Select)
+        self.assertTrue(self._table_view.copy())
         clip = StringIO(QApplication.clipboard().text())
         array = list(csv.reader(clip, delimiter="\t"))
         with system_lc_numeric():
             self.assertEqual(array, [["0", locale.str(5.5)]])
-        table_view.deleteLater()
 
     def test_paste_non_numeric_to_empty_table(self):
-        model = ArrayModel(self._parent)
-        model.set_array_type(str)
-        table_view = ArrayTableView()
-        table_view.setModel(model)
-        index = model.index(0, 0)
-        table_view.selectionModel().select(index, QItemSelectionModel.Select)
-        self._write_to_clipboard([["a"]])
-        self.assertTrue(table_view.paste())
-        self.assertEqual(model.rowCount(), 2)
-        self.assertEqual(model.array(), Array(["a"]))
-        table_view.deleteLater()
+        self._model.set_array_type(str)
+        index = self._model.index(0, 0)
+        self._table_view.selectionModel().select(index, QItemSelectionModel.Select)
+        data = self._write_clipboard([["a"]])
+        with mock_clipboard_patch(data, "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
+            self.assertTrue(self._table_view.paste())
+        self.assertEqual(self._model.rowCount(), 2)
+        self.assertEqual(self._model.array(), Array(["a"]))
 
     def test_paste_numeric_to_empty_table(self):
-        model = ArrayModel(self._parent)
-        table_view = ArrayTableView()
-        table_view.setModel(model)
-        index = model.index(0, 0)
-        table_view.selectionModel().select(index, QItemSelectionModel.Select)
-        self._write_to_clipboard([[2.3]])
-        self.assertTrue(table_view.paste())
-        self.assertEqual(model.rowCount(), 2)
-        self.assertEqual(model.array(), Array([2.3]))
-        table_view.deleteLater()
+        index = self._model.index(0, 0)
+        self._table_view.selectionModel().select(index, QItemSelectionModel.Select)
+        data = self._write_clipboard([[2.3]])
+        with mock_clipboard_patch(data, "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
+            self.assertTrue(self._table_view.paste())
+        self.assertEqual(self._model.rowCount(), 2)
+        self.assertEqual(self._model.array(), Array([2.3]))
 
     def test_paste_multiple_rows_to_single_row_selection(self):
-        model = ArrayModel(self._parent)
-        model.reset(Array([5.5]))
-        table_view = ArrayTableView()
-        table_view.setModel(model)
-        index = model.index(0, 0)
-        table_view.selectionModel().select(index, QItemSelectionModel.Select)
-        self._write_to_clipboard([[2.3], [-2.3]])
-        self.assertTrue(table_view.paste())
-        self.assertEqual(model.rowCount(), 3)
-        self.assertEqual(model.array(), Array([2.3, -2.3]))
-        table_view.deleteLater()
+        self._model.reset(Array([5.5]))
+        index = self._model.index(0, 0)
+        self._table_view.selectionModel().select(index, QItemSelectionModel.Select)
+        data = self._write_clipboard([[2.3], [-2.3]])
+        with mock_clipboard_patch(data, "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
+            self.assertTrue(self._table_view.paste())
+        self.assertEqual(self._model.rowCount(), 3)
+        self.assertEqual(self._model.array(), Array([2.3, -2.3]))
 
     def test_paste_only_what_fits_selection(self):
-        model = ArrayModel(self._parent)
-        model.reset(Array([5.5, -5.5]))
-        table_view = ArrayTableView()
-        table_view.setModel(model)
+        self._model.reset(Array([5.5, -5.5]))
         for row in (0, 1):
-            table_view.selectionModel().select(model.index(row, 0), QItemSelectionModel.Select)
-        self._write_to_clipboard([[2.3], [-2.3], [23.0]])
-        self.assertTrue(table_view.paste())
-        self.assertEqual(model.rowCount(), 3)
-        self.assertEqual(model.array(), Array([2.3, -2.3]))
-        table_view.deleteLater()
+            self._table_view.selectionModel().select(self._model.index(row, 0), QItemSelectionModel.Select)
+        data = self._write_clipboard([[2.3], [-2.3], [23.0]])
+        with mock_clipboard_patch(data, "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
+            self.assertTrue(self._table_view.paste())
+        self.assertEqual(self._model.rowCount(), 3)
+        self.assertEqual(self._model.array(), Array([2.3, -2.3]))
+
+    def test_pasting_incompatible_data_type_does_not_expand_model(self):
+        self._model.reset(Array([5.5]))
+        for row in (0, 1):
+            self._table_view.selectionModel().select(self._model.index(row, 0), QItemSelectionModel.Select)
+        data = self._write_clipboard([["Ilmarinen"], ["Väinämöinen"], ["Joukahainen"]])
+        with mock_clipboard_patch(data, "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
+            self.assertFalse(self._table_view.paste())
+        self.assertEqual(self._model.rowCount(), 2)
+        self.assertEqual(self._model.array(), Array([5.5]))
+
+    def test_pasting_incompatible_data_type_in_the_middle_expands_model_properly(self):
+        self._model.reset(Array([5.5]))
+        self._table_view.selectionModel().select(self._model.index(0, 0), QItemSelectionModel.Select)
+        data = self._write_clipboard([[-2.3], ["Väinämöinen"], [-23.0]])
+        with mock_clipboard_patch(data, "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
+            self.assertTrue(self._table_view.paste())
+        self.assertEqual(self._model.rowCount(), 3)
+        self.assertEqual(self._model.array(), Array([-2.3, -23.0]))
 
     @staticmethod
-    def _write_to_clipboard(data):
+    def _write_clipboard(data):
         with StringIO() as out_string:
             writer = csv.writer(out_string)
             writer.writerows(data)
-            clip = out_string.getvalue()
-        QApplication.clipboard().setText(clip)
+            return out_string.getvalue()
 
 
 if __name__ == "__main__":
diff --git a/tests/widgets/test_CopyPasteTableView.py b/tests/widgets/test_CopyPasteTableView.py
index 185b01b3c..ccf6e5bf1 100644
--- a/tests/widgets/test_CopyPasteTableView.py
+++ b/tests/widgets/test_CopyPasteTableView.py
@@ -17,6 +17,7 @@
 from PySide6.QtCore import QAbstractTableModel, QItemSelection, QItemSelectionModel, QModelIndex, Qt
 from PySide6.QtWidgets import QApplication
 from spinetoolbox.widgets.custom_qtableview import CopyPasteTableView
+from tests.mock_helpers import mock_clipboard_patch
 
 
 class _MockModel(QAbstractTableModel):
@@ -162,10 +163,7 @@ def test_pasting_normal_with_column_converter(self):
         view.setModel(model)
         selection_model = view.selectionModel()
         selection_model.setCurrentIndex(model.index(0, 2), QItemSelectionModel.ClearAndSelect)
-        mock_clipboard = MagicMock()
-        mock_clipboard.text.return_value = "3.14"
-        with patch("spinetoolbox.widgets.custom_qtableview.QApplication.clipboard") as clipboard:
-            clipboard.return_value = mock_clipboard
+        with mock_clipboard_patch("3.14", "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
             self.assertTrue(view.paste())
         data = model.index(0, 2).data()
         self.assertIsInstance(data, float)
@@ -179,10 +177,7 @@ def test_pasting_selection_with_column_converter(self):
         selection = QItemSelection(model.index(1, 0), model.index(1, 2))
         selection_model = view.selectionModel()
         selection_model.select(selection, QItemSelectionModel.ClearAndSelect)
-        mock_clipboard = MagicMock()
-        mock_clipboard.text.return_value = "G\tH\t3.14"
-        with patch("spinetoolbox.widgets.custom_qtableview.QApplication.clipboard") as clipboard:
-            clipboard.return_value = mock_clipboard
+        with mock_clipboard_patch("G\tH\t3.14", "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
             self.assertTrue(view.paste())
         data = [model.index(1, column).data() for column in range(3)]
         self.assertEqual(data, ["G", "H", 3.14])
diff --git a/tests/widgets/test_IndexedValueTableView.py b/tests/widgets/test_IndexedValueTableView.py
index 8750924dc..a0c676847 100644
--- a/tests/widgets/test_IndexedValueTableView.py
+++ b/tests/widgets/test_IndexedValueTableView.py
@@ -18,6 +18,7 @@
 from spinedb_api import TimeSeriesVariableResolution
 from spinetoolbox.mvcmodels.time_series_model_variable_resolution import TimeSeriesModelVariableResolution
 from spinetoolbox.widgets.custom_qtableview import IndexedValueTableView, system_lc_numeric
+from tests.mock_helpers import mock_clipboard_patch
 
 
 class TestIndexedValueTableView(unittest.TestCase):
@@ -27,7 +28,6 @@ def setUpClass(cls):
             QApplication()
 
     def setUp(self):
-        QApplication.clipboard().clear()
         self._table_view = IndexedValueTableView(parent=None)
         series = TimeSeriesVariableResolution(
             ["2019-08-08T12:00", "2019-08-08T13:00", "2019-08-08T14:00", "2019-08-08T15:00"],
@@ -73,8 +73,8 @@ def test_paste_single_value(self):
         model = self._table_view.model()
         selection_model.select(model.index(0, 1), QItemSelectionModel.Select)
         copied_data = locale.str(-1.1)
-        QApplication.clipboard().setText(copied_data)
-        self._table_view.paste()
+        with mock_clipboard_patch(copied_data, "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
+            self.assertTrue(self._table_view.paste())
         series = TimeSeriesVariableResolution(
             ["2019-08-08T12:00", "2019-08-08T13:00", "2019-08-08T14:00", "2019-08-08T15:00"],
             [-1.1, 2.2, 3.3, 4.4],
@@ -88,8 +88,8 @@ def test_paste_single_index(self):
         model = self._table_view.model()
         selection_model.select(model.index(0, 0), QItemSelectionModel.Select)
         copied_data = "2019-08-08T00:00"
-        QApplication.clipboard().setText(copied_data)
-        self._table_view.paste()
+        with mock_clipboard_patch(copied_data, "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
+            self.assertTrue(self._table_view.paste())
         series = TimeSeriesVariableResolution(
             ["2019-08-08T00:00", "2019-08-08T13:00", "2019-08-08T14:00", "2019-08-08T15:00"],
             [1.1, 2.2, 3.3, 4.4],
@@ -103,8 +103,8 @@ def test_pasting_multiple_columns_to_last_row_expands_model(self):
         model = self._table_view.model()
         selection_model.select(model.index(3, 1), QItemSelectionModel.Select)
         copied_data = f"2019-08-08T17:00\t{-4.4}\n2019-08-08T18:00\t{-5.5}"
-        QApplication.clipboard().setText(copied_data)
-        self._table_view.paste()
+        with mock_clipboard_patch(copied_data, "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
+            self.assertTrue(self._table_view.paste())
         series = TimeSeriesVariableResolution(
             ["2019-08-08T12:00", "2019-08-08T13:00", "2019-08-08T14:00", "2019-08-08T17:00", "2019-08-08T18:00"],
             [1.1, 2.2, 3.3, -4.4, -5.5],
@@ -118,8 +118,8 @@ def test_pasting_single_column_to_last_row_expands_model(self):
         model = self._table_view.model()
         selection_model.select(model.index(3, 0), QItemSelectionModel.Select)
         copied_data = "2019-08-08T17:00\n2019-08-08T18:00"
-        QApplication.clipboard().setText(copied_data)
-        self._table_view.paste()
+        with mock_clipboard_patch(copied_data, "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
+            self.assertTrue(self._table_view.paste())
         series = TimeSeriesVariableResolution(
             ["2019-08-08T12:00", "2019-08-08T13:00", "2019-08-08T14:00", "2019-08-08T17:00", "2019-08-08T18:00"],
             [1.1, 2.2, 3.3, 4.4, 0.0],
@@ -136,8 +136,8 @@ def test_paste_to_multirow_selection_limits_pasted_data(self):
         selection_model.select(model.index(2, 0), QItemSelectionModel.Select)
         selection_model.select(model.index(2, 1), QItemSelectionModel.Select)
         copied_data = f"2019-08-08T12:30\t{-2.2}\n2019-08-08T13:30\t{-3.3}\n2019-08-08T14:30\t{-4.4}"
-        QApplication.clipboard().setText(copied_data)
-        self._table_view.paste()
+        with mock_clipboard_patch(copied_data, "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
+            self.assertTrue(self._table_view.paste())
         series = TimeSeriesVariableResolution(
             ["2019-08-08T12:00", "2019-08-08T12:30", "2019-08-08T13:30", "2019-08-08T15:00"],
             [1.1, -2.2, -3.3, 4.4],
@@ -146,7 +146,7 @@ def test_paste_to_multirow_selection_limits_pasted_data(self):
         )
         self.assertEqual(model.value, series)
 
-    def test_paste_to_larger_selection_overrides_first_rows_only(self):
+    def test_paste_to_larger_selection_cycles_data(self):
         selection_model = self._table_view.selectionModel()
         model = self._table_view.model()
         selection_model.select(model.index(0, 0), QItemSelectionModel.Select)
@@ -156,11 +156,11 @@ def test_paste_to_larger_selection_overrides_first_rows_only(self):
         selection_model.select(model.index(2, 0), QItemSelectionModel.Select)
         selection_model.select(model.index(2, 1), QItemSelectionModel.Select)
         copied_data = f"2019-08-08T12:30\t{-1.1}\n2019-08-08T13:30\t{-2.2}"
-        QApplication.clipboard().setText(copied_data)
-        self._table_view.paste()
+        with mock_clipboard_patch(copied_data, "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
+            self.assertTrue(self._table_view.paste())
         series = TimeSeriesVariableResolution(
-            ["2019-08-08T12:30", "2019-08-08T13:30", "2019-08-08T14:00", "2019-08-08T15:00"],
-            [-1.1, -2.2, 3.3, 4.4],
+            ["2019-08-08T12:30", "2019-08-08T13:30", "2019-08-08T12:30", "2019-08-08T15:00"],
+            [-1.1, -2.2, -1.1, 4.4],
             False,
             False,
         )
@@ -171,8 +171,8 @@ def test_pasted_cells_are_selected(self):
         model = self._table_view.model()
         selection_model.select(model.index(0, 1), QItemSelectionModel.Select)
         copied_data = locale.str(-1.1) + "\n" + locale.str(-2.2)
-        QApplication.clipboard().setText(copied_data)
-        self._table_view.paste()
+        with mock_clipboard_patch(copied_data, "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
+            self.assertTrue(self._table_view.paste())
         selected_indexes = selection_model.selectedIndexes()
         self.assertEqual(len(selected_indexes), 2)
         self.assertTrue(model.index(0, 1) in selected_indexes)
diff --git a/tests/widgets/test_MapTableView.py b/tests/widgets/test_MapTableView.py
index 21f40fb0e..e58f396c7 100644
--- a/tests/widgets/test_MapTableView.py
+++ b/tests/widgets/test_MapTableView.py
@@ -20,6 +20,7 @@
 from spinedb_api import Map
 from spinetoolbox.mvcmodels.map_model import MapModel
 from spinetoolbox.widgets.custom_qtableview import MapTableView, system_lc_numeric
+from tests.mock_helpers import mock_clipboard_patch
 
 
 class TestMapTableView(unittest.TestCase):
@@ -28,12 +29,6 @@ def setUpClass(cls):
         if not QApplication.instance():
             QApplication()
 
-    def setUp(self):
-        self._original_clip = QApplication.clipboard().text()
-
-    def tearDown(self):
-        QApplication.clipboard().setText(self._original_clip)
-
     def test_copy_without_selection_returns_false(self):
         table_view = MapTableView()
         model = MapModel(Map([], [], float), table_view)
@@ -72,7 +67,8 @@ def test_paste_without_selection_returns_false(self):
         table_view = MapTableView()
         model = MapModel(Map(["A"], [2.3]), table_view)
         table_view.setModel(model)
-        self.assertFalse(table_view.paste())
+        with mock_clipboard_patch("won't be pasted", "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
+            self.assertFalse(table_view.paste())
         table_view.deleteLater()
 
     def test_paste_to_empty_table(self):
@@ -80,8 +76,7 @@ def test_paste_to_empty_table(self):
         model = MapModel(Map([], [], str), table_view)
         table_view.setModel(model)
         table_view.selectionModel().select(model.index(0, 0), QItemSelectionModel.Select)
-        self._write_to_clipboard([["A", 2.3]])
-        self.assertTrue(table_view.paste())
+        self._paste_from_clipboard([["A", 2.3]], table_view)
         self.assertEqual(model.rowCount(), 2)
         self.assertEqual(model.columnCount(), 3)
         self.assertEqual(model.value(), Map(["A"], [2.3]))
@@ -92,8 +87,7 @@ def test_paste_to_single_cell_pastes_everything(self):
         model = MapModel(Map(["A"], [2.3]), table_view)
         table_view.setModel(model)
         table_view.selectionModel().select(model.index(0, 0), QItemSelectionModel.Select)
-        self._write_to_clipboard([["V", -5.5], ["W", -6.6]])
-        self.assertTrue(table_view.paste())
+        self._paste_from_clipboard([["V", -5.5], ["W", -6.6]], table_view)
         self.assertEqual(model.rowCount(), 3)
         self.assertEqual(model.columnCount(), 3)
         self.assertEqual(model.value(), Map(["V", "W"], [-5.5, -6.6]))
@@ -105,20 +99,19 @@ def test_paste_large_data_to_small_selection_cuts_data(self):
         table_view.setModel(model)
         for row in (0, 1):
             table_view.selectionModel().select(model.index(row, 0), QItemSelectionModel.Select)
-        self._write_to_clipboard([["Q", -4.4], ["V", -5.5], ["W", -6.6]])
-        self.assertTrue(table_view.paste())
+        self._paste_from_clipboard([["Q", -4.4], ["V", -5.5], ["W", -6.6]], table_view)
         self.assertEqual(model.rowCount(), 4)
         self.assertEqual(model.columnCount(), 3)
         self.assertEqual(model.value(), Map(["Q", "V", "C"], [2.3, 3.2, 4.3]))
         table_view.deleteLater()
 
-    @staticmethod
-    def _write_to_clipboard(data):
+    def _paste_from_clipboard(self, data, table_view):
         with StringIO() as out_string:
             writer = csv.writer(out_string, delimiter="\t")
             writer.writerows(data)
             clip = out_string.getvalue()
-        QApplication.clipboard().setText(clip)
+        with mock_clipboard_patch(clip, "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
+            self.assertTrue(table_view.paste())
 
 
 if __name__ == "__main__":
diff --git a/tests/widgets/test_TimeSeriesFixedResolutionTableView.py b/tests/widgets/test_TimeSeriesFixedResolutionTableView.py
index 1f58f477a..d3ebc6132 100644
--- a/tests/widgets/test_TimeSeriesFixedResolutionTableView.py
+++ b/tests/widgets/test_TimeSeriesFixedResolutionTableView.py
@@ -12,12 +12,15 @@
 
 """Unit tests for TimeSeriesFixedResolutionTableView class."""
 import locale
+import os
 import unittest
+from unittest import mock
 from PySide6.QtCore import QItemSelectionModel
 from PySide6.QtWidgets import QApplication
 from spinedb_api import TimeSeriesFixedResolution
 from spinetoolbox.mvcmodels.time_series_model_fixed_resolution import TimeSeriesModelFixedResolution
 from spinetoolbox.widgets.custom_qtableview import TimeSeriesFixedResolutionTableView
+from tests.mock_helpers import mock_clipboard_patch
 
 
 class TestTimeSeriesFixedResolutionTableView(unittest.TestCase):
@@ -27,7 +30,6 @@ def setUpClass(cls):
             QApplication()
 
     def setUp(self):
-        QApplication.clipboard().clear()
         self._table_view = TimeSeriesFixedResolutionTableView(parent=None)
         series = TimeSeriesFixedResolution("2019-08-08T15:00", "1h", [1.1, 2.2, 3.3, 4.4], False, False)
         model = TimeSeriesModelFixedResolution(series, self._table_view)
@@ -40,17 +42,19 @@ def test_copy_single_cell(self):
         selection_model = self._table_view.selectionModel()
         model = self._table_view.model()
         selection_model.select(model.index(0, 0), QItemSelectionModel.Select)
-        self._table_view.copy()
-        copied = QApplication.clipboard().text()
-        self.assertEqual(copied.strip(), "2019-08-08T15:00:00")
+        with mock.patch("spinetoolbox.widgets.custom_qtableview.QApplication.clipboard") as clipboard_getter:
+            mock_clipboard = mock.MagicMock()
+            clipboard_getter.return_value = mock_clipboard
+            self._table_view.copy()
+            mock_clipboard.setText.assert_called_once_with("2019-08-08T15:00:00" + os.linesep)
 
     def test_paste_single_value(self):
         selection_model = self._table_view.selectionModel()
         model = self._table_view.model()
         selection_model.select(model.index(0, 1), QItemSelectionModel.Select)
         copied_data = locale.str(-1.1)
-        QApplication.clipboard().setText(copied_data)
-        self._table_view.paste()
+        with mock_clipboard_patch(copied_data, "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
+            self.assertTrue(self._table_view.paste())
         series = TimeSeriesFixedResolution("2019-08-08T15:00", "1h", [-1.1, 2.2, 3.3, 4.4], False, False)
         self.assertEqual(model.value, series)
 
@@ -59,8 +63,8 @@ def test_paste_value_when_time_stamp_is_selected(self):
         model = self._table_view.model()
         selection_model.select(model.index(0, 0), QItemSelectionModel.Select)
         copied_data = locale.str(-1.1)
-        QApplication.clipboard().setText(copied_data)
-        self._table_view.paste()
+        with mock_clipboard_patch(copied_data, "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
+            self.assertTrue(self._table_view.paste())
         series = TimeSeriesFixedResolution("2019-08-08T15:00", "1h", [-1.1, 2.2, 3.3, 4.4], False, False)
         self.assertEqual(model.value, series)
 
@@ -69,8 +73,8 @@ def test_pasting_to_last_row_expands_model(self):
         model = self._table_view.model()
         selection_model.select(model.index(3, 1), QItemSelectionModel.Select)
         copied_data = locale.str(-4.4) + "\n" + locale.str(-5.5)
-        QApplication.clipboard().setText(copied_data)
-        self._table_view.paste()
+        with mock_clipboard_patch(copied_data, "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
+            self.assertTrue(self._table_view.paste())
         series = TimeSeriesFixedResolution("2019-08-08T15:00", "1h", [1.1, 2.2, 3.3, -4.4, -5.5], False, False)
         self.assertEqual(model.value, series)
 
@@ -80,20 +84,40 @@ def test_paste_to_multirow_selection_limits_pasted_data(self):
         selection_model.select(model.index(0, 1), QItemSelectionModel.Select)
         selection_model.select(model.index(1, 1), QItemSelectionModel.Select)
         copied_data = locale.str(-1.1) + "\n" + locale.str(-2.2) + "\n" + locale.str(-3.3)
-        QApplication.clipboard().setText(copied_data)
-        self._table_view.paste()
+        with mock_clipboard_patch(copied_data, "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
+            self.assertTrue(self._table_view.paste())
         series = TimeSeriesFixedResolution("2019-08-08T15:00", "1h", [-1.1, -2.2, 3.3, 4.4], False, False)
         self.assertEqual(model.value, series)
 
-    def test_paste_to_larger_selection_overrides_first_rows_only(self):
+    def test_paste_to_larger_selection_cycles_data(self):
         selection_model = self._table_view.selectionModel()
         model = self._table_view.model()
         selection_model.select(model.index(0, 1), QItemSelectionModel.Select)
         selection_model.select(model.index(1, 1), QItemSelectionModel.Select)
         copied_data = locale.str(-1.1)
-        QApplication.clipboard().setText(copied_data)
-        self._table_view.paste()
-        series = TimeSeriesFixedResolution("2019-08-08T15:00", "1h", [-1.1, 2.2, 3.3, 4.4], False, False)
+        with mock_clipboard_patch(copied_data, "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
+            self.assertTrue(self._table_view.paste())
+        series = TimeSeriesFixedResolution("2019-08-08T15:00", "1h", [-1.1, -1.1, 3.3, 4.4], False, False)
+        self.assertEqual(model.value, series)
+
+    def test_pasted_gibberish_is_rejected(self):
+        selection_model = self._table_view.selectionModel()
+        model = self._table_view.model()
+        selection_model.select(model.index(0, 1), QItemSelectionModel.Select)
+        copied_data = "Totoro"
+        with mock_clipboard_patch(copied_data, "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
+            self.assertFalse(self._table_view.paste())
+        series = TimeSeriesFixedResolution("2019-08-08T15:00", "1h", [1.1, 2.2, 3.3, 4.4], False, False)
+        self.assertEqual(model.value, series)
+
+    def test_pasted_gibberish_in_the_middle_gets_rejected(self):
+        selection_model = self._table_view.selectionModel()
+        model = self._table_view.model()
+        selection_model.select(model.index(0, 1), QItemSelectionModel.Select)
+        copied_data = "-1.1\nTotoro\n-2.2\n-3.3\n-4.4\n-5.5\n"
+        with mock_clipboard_patch(copied_data, "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
+            self.assertTrue(self._table_view.paste())
+        series = TimeSeriesFixedResolution("2019-08-08T15:00", "1h", [-1.1, -2.2, -3.3, -4.4, -5.5], False, False)
         self.assertEqual(model.value, series)
 
     def test_pasted_cells_are_selected(self):
@@ -101,8 +125,8 @@ def test_pasted_cells_are_selected(self):
         model = self._table_view.model()
         selection_model.select(model.index(0, 1), QItemSelectionModel.Select)
         copied_data = locale.str(-1.1) + "\n" + locale.str(-2.2)
-        QApplication.clipboard().setText(copied_data)
-        self._table_view.paste()
+        with mock_clipboard_patch(copied_data, "spinetoolbox.widgets.custom_qtableview.QApplication.clipboard"):
+            self.assertTrue(self._table_view.paste())
         selected_indexes = selection_model.selectedIndexes()
         self.assertEqual(len(selected_indexes), 2)
         self.assertTrue(model.index(0, 1) in selected_indexes)
diff --git a/tests/widgets/test_paste_excel.py b/tests/widgets/test_paste_excel.py
new file mode 100644
index 000000000..9b44cf431
--- /dev/null
+++ b/tests/widgets/test_paste_excel.py
@@ -0,0 +1,297 @@
+######################################################################################################################
+# Copyright (C) 2017-2022 Spine project consortium
+# Copyright Spine Toolbox contributors
+# This file is part of Spine Toolbox.
+# Spine Toolbox is free software: you can redistribute it and/or modify it under the terms of the GNU Lesser General
+# Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option)
+# any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+# without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
+# Public License for more details. You should have received a copy of the GNU Lesser General Public License along with
+# this program. If not, see <http://www.gnu.org/licenses/>.
+######################################################################################################################
+import unittest
+from spinedb_api import DateTime, to_database
+from spinedb_api.parameter_value import join_value_and_type
+from spinetoolbox.widgets.paste_excel import clipboard_excel_as_table
+
+
+class Test(unittest.TestCase):
+    def test_single_empty_cell_gives_empty_table(self):
+        data = b'<?xml version="1.0"?>\r\n\
+<?mso-application progid="Excel.Sheet"?>\r\n\
+<Workbook xmlns="urn:schemas-microsoft-com:office:spreadsheet"\r\n\
+ xmlns:o="urn:schemas-microsoft-com:office:office"\r\n\
+ xmlns:x="urn:schemas-microsoft-com:office:excel"\r\n\
+ xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet"\r\n\
+ xmlns:html="http://www.w3.org/TR/REC-html40">\r\n\
+ <Styles>\r\n\
+  <Style ss:ID="Default" ss:Name="Normal">\r\n\
+   <Alignment ss:Vertical="Bottom"/>\r\n\
+   <Borders/>\r\n\
+   <Font ss:FontName="Calibri" x:Family="Swiss" ss:Size="11" ss:Color="#000000"/>\r\n\
+   <Interior/>\r\n\
+   <NumberFormat/>\r\n\
+   <Protection/>\r\n\
+  </Style>\r\n\
+ </Styles>\r\n\
+ <Worksheet ss:Name="Sheet1">\r\n\
+  <Table ss:ExpandedColumnCount="1" ss:ExpandedRowCount="1"\r\n\
+   ss:DefaultRowHeight="15">\r\n\
+  </Table>\r\n\
+ </Worksheet>\r\n\
+</Workbook>\r\n\
+\x00'
+        self.assertEqual(clipboard_excel_as_table(data), [])
+
+    def test_convert_single_boolean_cell(self):
+        data = b'<?xml version="1.0"?>\r\n\
+<?mso-application progid="Excel.Sheet"?>\r\n\
+<Workbook xmlns="urn:schemas-microsoft-com:office:spreadsheet"\r\n\
+ xmlns:o="urn:schemas-microsoft-com:office:office"\r\n\
+ xmlns:x="urn:schemas-microsoft-com:office:excel"\r\n\
+ xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet"\r\n\
+ xmlns:html="http://www.w3.org/TR/REC-html40">\r\n\
+ <Styles>\r\n\
+  <Style ss:ID="Default" ss:Name="Normal">\r\n\
+   <Alignment ss:Vertical="Bottom"/>\r\n\
+   <Borders/>\r\n\
+   <Font ss:FontName="Calibri" x:Family="Swiss" ss:Size="11" ss:Color="#000000"/>\r\n\
+   <Interior/>\r\n\
+   <NumberFormat/>\r\n\
+   <Protection/>\r\n\
+  </Style>\r\n\
+ </Styles>\r\n\
+ <Worksheet ss:Name="Sheet1">\r\n\
+  <Table ss:ExpandedColumnCount="1" ss:ExpandedRowCount="1"\r\n\
+   ss:DefaultRowHeight="15">\r\n\
+   <Row>\r\n\
+    <Cell><Data ss:Type="Boolean">1</Data></Cell>\r\n\
+   </Row>\r\n\
+  </Table>\r\n\
+ </Worksheet>\r\n\
+</Workbook>\r\n\
+\x00'
+        value, _ = to_database(True)
+        self.assertEqual(clipboard_excel_as_table(data), [[value]])
+
+    def test_convert_single_number_cell(self):
+        data = b'<?xml version="1.0"?>\r\n\
+<?mso-application progid="Excel.Sheet"?>\r\n\
+<Workbook xmlns="urn:schemas-microsoft-com:office:spreadsheet"\r\n\
+ xmlns:o="urn:schemas-microsoft-com:office:office"\r\n\
+ xmlns:x="urn:schemas-microsoft-com:office:excel"\r\n\
+ xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet"\r\n\
+ xmlns:html="http://www.w3.org/TR/REC-html40">\r\n\
+ <Styles>\r\n\
+  <Style ss:ID="Default" ss:Name="Normal">\r\n\
+   <Alignment ss:Vertical="Bottom"/>\r\n\
+   <Borders/>\r\n\
+   <Font ss:FontName="Calibri" x:Family="Swiss" ss:Size="11" ss:Color="#000000"/>\r\n\
+   <Interior/>\r\n\
+   <NumberFormat/>\r\n\
+   <Protection/>\r\n\
+  </Style>\r\n\
+  <Style ss:ID="s63">\r\n\
+   <NumberFormat/>\r\n\
+  </Style>\r\n\
+ </Styles>\r\n\
+ <Worksheet ss:Name="Sheet1">\r\n\
+  <Table ss:ExpandedColumnCount="1" ss:ExpandedRowCount="1"\r\n\
+   ss:DefaultRowHeight="15">\r\n\
+   <Row>\r\n\
+    <Cell ss:StyleID="s63"><Data ss:Type="Number">2.2999999999999998</Data></Cell>\r\n\
+   </Row>\r\n\
+  </Table>\r\n\
+ </Worksheet>\r\n\
+</Workbook>\r\n\
+\x00'
+        self.assertEqual(clipboard_excel_as_table(data), [[2.3]])
+
+    def test_convert_single_string_cell(self):
+        data = b'<?xml version="1.0"?>\r\n\
+<?mso-application progid="Excel.Sheet"?>\r\n\
+<Workbook xmlns="urn:schemas-microsoft-com:office:spreadsheet"\r\n\
+ xmlns:o="urn:schemas-microsoft-com:office:office"\r\n\
+ xmlns:x="urn:schemas-microsoft-com:office:excel"\r\n\
+ xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet"\r\n\
+ xmlns:html="http://www.w3.org/TR/REC-html40">\r\n\
+ <Styles>\r\n\
+  <Style ss:ID="Default" ss:Name="Normal">\r\n\
+   <Alignment ss:Vertical="Bottom"/>\r\n\
+   <Borders/>\r\n\
+   <Font ss:FontName="Calibri" x:Family="Swiss" ss:Size="11" ss:Color="#000000"/>\r\n\
+   <Interior/>\r\n\
+   <NumberFormat/>\r\n\
+   <Protection/>\r\n\
+  </Style>\r\n\
+ </Styles>\r\n\
+ <Worksheet ss:Name="Sheet1">\r\n\
+  <Table ss:ExpandedColumnCount="1" ss:ExpandedRowCount="1"\r\n\
+   ss:DefaultRowHeight="15">\r\n\
+   <Row>\r\n\
+    <Cell><Data ss:Type="String">this is text</Data></Cell>\r\n\
+   </Row>\r\n\
+  </Table>\r\n\
+ </Worksheet>\r\n\
+</Workbook>\r\n\
+\x00'
+        self.assertEqual(clipboard_excel_as_table(data), [["this is text"]])
+
+    def test_convert_single_date_time_cell(self):
+        data = b'<?xml version="1.0"?>\r\n\
+<?mso-application progid="Excel.Sheet"?>\r\n\
+<Workbook xmlns="urn:schemas-microsoft-com:office:spreadsheet"\r\n\
+ xmlns:o="urn:schemas-microsoft-com:office:office"\r\n\
+ xmlns:x="urn:schemas-microsoft-com:office:excel"\r\n\
+ xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet"\r\n\
+ xmlns:html="http://www.w3.org/TR/REC-html40">\r\n\
+ <Styles>\r\n\
+  <Style ss:ID="Default" ss:Name="Normal">\r\n\
+   <Alignment ss:Vertical="Bottom"/>\r\n\
+   <Borders/>\r\n\
+   <Font ss:FontName="Calibri" x:Family="Swiss" ss:Size="11" ss:Color="#000000"/>\r\n\
+   <Interior/>\r\n\
+   <NumberFormat/>\r\n\
+   <Protection/>\r\n\
+  </Style>\r\n\
+  <Style ss:ID="s64">\r\n\
+   <NumberFormat ss:Format="General Date"/>\r\n\
+  </Style>\r\n\
+ </Styles>\r\n\
+ <Worksheet ss:Name="Sheet1">\r\n\
+  <Table ss:ExpandedColumnCount="1" ss:ExpandedRowCount="1"\r\n\
+   ss:DefaultRowHeight="15">\r\n\
+   <Column ss:AutoFitWidth="0" ss:Width="109.5"/>\r\n\
+   <Row>\r\n\
+    <Cell ss:StyleID="s64"><Data ss:Type="DateTime">2024-08-14T14:41:44.000</Data></Cell>\r\n\
+   </Row>\r\n\
+  </Table>\r\n\
+ </Worksheet>\r\n\
+</Workbook>\r\n\
+\x00'
+        value = bytes(join_value_and_type(*to_database(DateTime("2024-08-14T14:41:44"))), encoding="utf-8")
+        self.assertEqual(clipboard_excel_as_table(data), [[value]])
+
+    def test_small_table(self):
+        data = b'<?xml version="1.0"?>\r\n\
+<?mso-application progid="Excel.Sheet"?>\r\n\
+<Workbook xmlns="urn:schemas-microsoft-com:office:spreadsheet"\r\n\
+ xmlns:o="urn:schemas-microsoft-com:office:office"\r\n\
+ xmlns:x="urn:schemas-microsoft-com:office:excel"\r\n\
+ xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet"\r\n\
+ xmlns:html="http://www.w3.org/TR/REC-html40">\r\n\
+ <Styles>\r\n\
+  <Style ss:ID="Default" ss:Name="Normal">\r\n\
+   <Alignment ss:Vertical="Bottom"/>\r\n\
+   <Borders/>\r\n\
+   <Font ss:FontName="Calibri" x:Family="Swiss" ss:Size="11" ss:Color="#000000"/>\r\n\
+   <Interior/>\r\n\
+   <NumberFormat/>\r\n\
+   <Protection/>\r\n\
+  </Style>\r\n\
+  <Style ss:ID="s63">\r\n\
+   <NumberFormat/>\r\n\
+  </Style>\r\n\
+  <Style ss:ID="s64">\r\n\
+   <NumberFormat ss:Format="General Date"/>\r\n\
+  </Style>\r\n\
+ </Styles>\r\n\
+ <Worksheet ss:Name="Sheet1">\r\n\
+  <Table ss:ExpandedColumnCount="3" ss:ExpandedRowCount="2"\r\n\
+   ss:DefaultRowHeight="15">\r\n\
+   <Column ss:Index="3" ss:AutoFitWidth="0" ss:Width="109.5"/>\r\n\
+   <Row>\r\n\
+    <Cell ss:StyleID="s63"><Data ss:Type="Number">2.2999999999999998</Data></Cell>\r\n\
+    <Cell><Data ss:Type="Boolean">1</Data></Cell>\r\n\
+    <Cell ss:StyleID="s64"><Data ss:Type="DateTime">2024-08-14T14:41:44.000</Data></Cell>\r\n\
+   </Row>\r\n\
+   <Row>\r\n\
+    <Cell><Data ss:Type="String">this is text</Data></Cell>\r\n\
+   </Row>\r\n\
+  </Table>\r\n\
+ </Worksheet>\r\n\
+</Workbook>\r\n\
+\x00'
+        bool_value, _ = to_database(True)
+        date_time_value = bytes(join_value_and_type(*to_database(DateTime("2024-08-14T14:41:44"))), encoding="utf-8")
+        self.assertEqual(
+            clipboard_excel_as_table(data), [[2.3, bool_value, date_time_value], ["this is text", None, None]]
+        )
+
+    def test_table_with_holes_in_columns(self):
+        data = b'<?xml version="1.0"?>\r\n\
+<?mso-application progid="Excel.Sheet"?>\r\n\
+<Workbook xmlns="urn:schemas-microsoft-com:office:spreadsheet"\r\n\
+ xmlns:o="urn:schemas-microsoft-com:office:office"\r\n\
+ xmlns:x="urn:schemas-microsoft-com:office:excel"\r\n\
+ xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet"\r\n\
+ xmlns:html="http://www.w3.org/TR/REC-html40">\r\n\
+ <Styles>\r\n\
+  <Style ss:ID="Default" ss:Name="Normal">\r\n\
+   <Alignment ss:Vertical="Bottom"/>\r\n\
+   <Borders/>\r\n\
+   <Font ss:FontName="Calibri" x:Family="Swiss" ss:Size="11" ss:Color="#000000"/>\r\n\
+   <Interior/>\r\n\
+   <NumberFormat/>\r\n\
+   <Protection/>\r\n\
+  </Style>\r\n\
+ </Styles>\r\n\
+ <Worksheet ss:Name="Sheet1">\r\n\
+  <Table ss:ExpandedColumnCount="3" ss:ExpandedRowCount="3"\r\n\
+  ss:DefaultRowHeight="15">\r\n\
+  <Row>\r\n\
+   <Cell><Data ss:Type="Number">2.2999999999999998</Data></Cell>\r\n\
+   <Cell><Data ss:Type="Number">2.4</Data></Cell>\r\n\
+  </Row>\r\n\
+  <Row>\r\n\
+   <Cell><Data ss:Type="Number">2.5</Data></Cell>\r\n\
+   <Cell ss:Index="3"><Data ss:Type="Number">2.6</Data></Cell>\r\n\
+  </Row>\r\n\
+  <Row>\r\n\
+   <Cell ss:Index="2"><Data ss:Type="Number">2.7</Data></Cell>\r\n\
+   <Cell><Data ss:Type="Number">2.8</Data></Cell>\r\n\
+  </Row>\r\n\
+  </Table>\r\n\
+ </Worksheet>\r\n\
+</Workbook>\r\n\
+\x00'
+        self.assertEqual(clipboard_excel_as_table(data), [[2.3, 2.4, None], [2.5, None, 2.6], [None, 2.7, 2.8]])
+
+    def test_table_with_holes_in_rows(self):
+        data = b'<?xml version="1.0"?>\r\n\
+<?mso-application progid="Excel.Sheet"?>\r\n\
+<Workbook xmlns="urn:schemas-microsoft-com:office:spreadsheet"\r\n\
+ xmlns:o="urn:schemas-microsoft-com:office:office"\r\n\
+ xmlns:x="urn:schemas-microsoft-com:office:excel"\r\n\
+ xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet"\r\n\
+ xmlns:html="http://www.w3.org/TR/REC-html40">\r\n\
+ <Styles>\r\n\
+  <Style ss:ID="Default" ss:Name="Normal">\r\n\
+   <Alignment ss:Vertical="Bottom"/>\r\n\
+   <Borders/>\r\n\
+   <Font ss:FontName="Calibri" x:Family="Swiss" ss:Size="11" ss:Color="#000000"/>\r\n\
+   <Interior/>\r\n\
+   <NumberFormat/>\r\n\
+   <Protection/>\r\n\
+  </Style>\r\n\
+ </Styles>\r\n\
+ <Worksheet ss:Name="Sheet1">\r\n\
+  <Table ss:ExpandedColumnCount="2" ss:ExpandedRowCount="3"\r\n\
+   ss:DefaultRowHeight="15">\r\n\
+   <Row>\r\n\
+    <Cell><Data ss:Type="Number">2.2999999999999998</Data></Cell>\r\n\
+    <Cell><Data ss:Type="Number">2.4</Data></Cell>\r\n\
+   </Row>\r\n\
+   <Row ss:Index="3">\r\n\
+    <Cell><Data ss:Type="Number">2.5</Data></Cell>\r\n\
+    <Cell><Data ss:Type="Number">2.6</Data></Cell>\r\n\
+   </Row>\r\n\
+  </Table>\r\n\
+ </Worksheet>\r\n\
+</Workbook>\r\n\
+\x00'
+        self.assertEqual(clipboard_excel_as_table(data), [[2.3, 2.4], [None, None], [2.5, 2.6]])
+
+
+if __name__ == "__main__":
+    unittest.main()

From 7c7c6f1d867044a1c24447ada309c74bcd6d0c3f Mon Sep 17 00:00:00 2001
From: Antti Soininen <antti.soininen@vtt.fi>
Date: Mon, 19 Aug 2024 14:30:50 +0300
Subject: [PATCH 2/3] Make sure deterred object deletion takes place in unit
 tests

This makes unit tests eat up considerably less memory and resources.
---
 spinetoolbox/execution_managers.py            |  7 +--
 tests/mock_helpers.py                         | 16 +++++-
 tests/mvcmodels/test_ArrayModel.py            |  3 +-
 tests/mvcmodels/test_FileListModel.py         | 10 +---
 tests/mvcmodels/test_FilterCheckboxList.py    |  9 +--
 .../mvcmodels/test_IndexedValueTableModel.py  |  9 +--
 tests/mvcmodels/test_MapModel.py              |  3 +-
 tests/mvcmodels/test_MinimalTableModel.py     |  9 +--
 tests/mvcmodels/test_TimePatternModel.py      |  9 +--
 .../test_TimeSeriesModelFixedResolution.py    |  9 +--
 .../test_TimeSeriesModelVariableResolution.py |  9 +--
 tests/mvcmodels/test_resource_filter_model.py |  9 +--
 tests/project_item/test_ProjectItem.py        | 10 +---
 tests/project_item/test_logging_connection.py | 17 +-----
 .../test_specification_editor_window.py       | 17 +-----
 tests/server/test_EngineClient.py             | 11 +---
 tests/spine_db_editor/helpers.py              |  8 +--
 .../mvcmodels/test_alternative_model.py       | 16 +-----
 .../mvcmodels/test_emptyParameterModels.py    | 11 +---
 .../mvcmodels/test_frozen_table_model.py      |  9 +--
 .../test_item_metadata_table_model.py         |  9 +--
 .../mvcmodels/test_metadata_table_model.py    |  9 +--
 .../mvcmodels/test_scenario_model.py          |  8 +--
 .../mvcmodels/test_single_parameter_models.py | 17 +-----
 tests/spine_db_editor/mvcmodels/test_utils.py |  9 +--
 tests/spine_db_editor/test_graphics_items.py  | 10 +---
 .../widgets/spine_db_editor_test_base.py      | 10 +---
 .../widgets/test_SpineDBEditor.py             |  9 +--
 .../widgets/test_SpineDBEditorBase.py         | 10 +---
 .../widgets/test_SpineDBEditorFilter.py       |  3 +-
 .../test_SpineDBEditorWithDBMapping.py        | 20 +------
 .../widgets/test_add_items_dialog.py          | 11 +---
 .../widgets/test_commit_viewer.py             |  9 +--
 .../widgets/test_custom_delegates.py          |  9 +--
 .../widgets/test_custom_editors.py            | 12 ++--
 .../widgets/test_custom_menus.py              | 10 +---
 .../widgets/test_custom_qgraphicsviews.py     | 10 +---
 .../widgets/test_mass_select_items_dialogs.py |  8 +--
 tests/spine_db_editor/widgets/test_toolbar.py |  6 --
 tests/test_ProjectUpgrader.py                 | 20 ++-----
 tests/test_SpineDBManager.py                  | 55 ++++---------------
 tests/test_SpineToolboxProject.py             |  9 +--
 tests/test_ToolboxUI.py                       | 23 ++------
 tests/test_helpers.py                         |  9 +--
 tests/test_load_project_items.py              |  9 +--
 tests/test_parameter_type_validation.py       | 11 ++--
 tests/test_plotting.py                        |  8 +--
 tests/test_project_item_icon.py               | 38 ++++---------
 tests/test_spine_db_fetcher.py                | 10 +---
 tests/test_spine_engine_worker.py             |  8 +--
 tests/widgets/test_AboutWidget.py             | 29 +++++-----
 tests/widgets/test_AddProjectItemWidget.py    | 18 ++----
 tests/widgets/test_AddUpSpineOptWizard.py     | 12 +---
 tests/widgets/test_ArrayTableView.py          |  9 +--
 tests/widgets/test_CopyPasteTableView.py      | 11 +---
 tests/widgets/test_DatetimeEditor.py          |  9 +--
 tests/widgets/test_DurationEditor.py          |  9 +--
 tests/widgets/test_IndexedValueTableView.py   |  9 +--
 tests/widgets/test_InstallJuliaWizard.py      | 12 +---
 tests/widgets/test_JupyterConsoleWidget.py    | 10 +---
 tests/widgets/test_KernelFetcher.py           | 11 +---
 tests/widgets/test_MapEditor.py               |  9 +--
 tests/widgets/test_MapTableView.py            |  9 +--
 tests/widgets/test_ParameterValueEditor.py    |  9 +--
 .../widgets/test_PlainParameterValueEditor.py |  9 +--
 tests/widgets/test_TimePatternEditor.py       |  9 +--
 .../test_TimeSeriesFixedResolutionEditor.py   |  9 +--
 ...test_TimeSeriesFixedResolutionTableView.py | 10 +---
 ...test_TimeSeriesVariableResolutionEditor.py |  8 +--
 tests/widgets/test_custom_combobox.py         | 10 +---
 tests/widgets/test_custom_qgraphicsscene.py   | 26 +--------
 tests/widgets/test_custom_qlineedits.py       | 11 +---
 tests/widgets/test_custom_qtextbrowser.py     | 20 +------
 tests/widgets/test_custom_qwidgets.py         | 17 ++----
 .../test_indexed_value_table_context_menu.py  | 22 ++------
 tests/widgets/test_jump_properties_widget.py  | 10 +---
 tests/widgets/test_kernel_editor.py           |  9 +--
 tests/widgets/test_notification.py            |  8 +--
 tests/widgets/test_open_project_dialog.py     | 11 +---
 tests/widgets/test_plot_widget.py             |  9 +--
 tests/widgets/test_plugin_manager_widgets.py  | 11 +---
 tests/widgets/test_select_database_items.py   |  9 +--
 tests/widgets/test_settings_widget.py         | 10 +---
 83 files changed, 240 insertions(+), 744 deletions(-)

diff --git a/spinetoolbox/execution_managers.py b/spinetoolbox/execution_managers.py
index 7d9df5abc..d2dcce41a 100644
--- a/spinetoolbox/execution_managers.py
+++ b/spinetoolbox/execution_managers.py
@@ -47,8 +47,7 @@ class QProcessExecutionManager(ExecutionManager):
     """Class to manage tool instance execution using a PySide6 QProcess."""
 
     def __init__(self, logger, program="", args=None, silent=False, semisilent=False):
-        """Class constructor.
-
+        """
         Args:
             logger (LoggerInterface): a logger instance
             program (str): Path to program to run in the subprocess (e.g. julia.exe)
@@ -180,9 +179,7 @@ def on_process_error(self, process_error):
     def teardown_process(self):
         """Tears down the QProcess in case a QProcess.ProcessError occurred.
         Emits execution_finished signal."""
-        if not self._process:
-            pass
-        else:
+        if self._process:
             out = str(self._process.readAllStandardOutput().data(), "utf-8", errors="replace")
             errout = str(self._process.readAllStandardError().data(), "utf-8", errors="replace")
             if out is not None:
diff --git a/tests/mock_helpers.py b/tests/mock_helpers.py
index 0bb60dc60..6430abeb5 100644
--- a/tests/mock_helpers.py
+++ b/tests/mock_helpers.py
@@ -12,14 +12,28 @@
 
 """Classes and functions that can be shared among unit test modules."""
 from contextlib import contextmanager
+import unittest
 from unittest import mock
-from PySide6.QtCore import QMimeData, QModelIndex, Qt
+from PySide6.QtCore import QMimeData, QModelIndex, Qt, QTimer
 from PySide6.QtWidgets import QApplication
 import spinetoolbox.resources_icons_rc  # pylint: disable=unused-import
 from spinetoolbox.spine_db_manager import SpineDBManager
 from spinetoolbox.ui_main import ToolboxUI
 
 
+class TestCaseWithQApplication(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        if not QApplication.instance():
+            QApplication()
+        cls._q_app = QApplication.instance()
+
+    @classmethod
+    def tearDownClass(cls):
+        QTimer.singleShot(0, lambda: cls._q_app.quit())
+        cls._q_app.exec()
+
+
 def create_toolboxui():
     """Returns ToolboxUI, where QSettings among others has been mocked."""
     with mock.patch("spinetoolbox.ui_main.QSettings.value") as mock_qsettings_value, mock.patch(
diff --git a/tests/mvcmodels/test_ArrayModel.py b/tests/mvcmodels/test_ArrayModel.py
index ef22bdb17..6fa0c0892 100644
--- a/tests/mvcmodels/test_ArrayModel.py
+++ b/tests/mvcmodels/test_ArrayModel.py
@@ -15,9 +15,10 @@
 from PySide6.QtCore import QObject, Qt
 from spinedb_api import Array
 from spinetoolbox.mvcmodels.array_model import ArrayModel
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestArrayModel(unittest.TestCase):
+class TestArrayModel(TestCaseWithQApplication):
     def setUp(self):
         self._parent = QObject()
 
diff --git a/tests/mvcmodels/test_FileListModel.py b/tests/mvcmodels/test_FileListModel.py
index 0f49fd08f..242de3025 100644
--- a/tests/mvcmodels/test_FileListModel.py
+++ b/tests/mvcmodels/test_FileListModel.py
@@ -12,18 +12,12 @@
 
 """Unit tests for FileListModel class."""
 from pathlib import Path
-import unittest
-from PySide6.QtWidgets import QApplication
 from spine_engine.project_item.project_item_resource import file_resource, file_resource_in_pack
 from spinetoolbox.mvcmodels.file_list_models import FileListModel
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestFileListModel(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestFileListModel(TestCaseWithQApplication):
     def setUp(self):
         self._model = FileListModel()
 
diff --git a/tests/mvcmodels/test_FilterCheckboxList.py b/tests/mvcmodels/test_FilterCheckboxList.py
index 6eb043b15..3c1e835c7 100644
--- a/tests/mvcmodels/test_FilterCheckboxList.py
+++ b/tests/mvcmodels/test_FilterCheckboxList.py
@@ -14,16 +14,11 @@
 import unittest
 from unittest import mock
 from PySide6.QtCore import Qt
-from PySide6.QtWidgets import QApplication
 from spinetoolbox.mvcmodels.filter_checkbox_list_model import SimpleFilterCheckboxListModel
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestFilterCheckboxListModel(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestFilterCheckboxListModel(TestCaseWithQApplication):
     def setUp(self):
         self.model = SimpleFilterCheckboxListModel(None)
         self.data = ["a", "aa", "aaa", "b", "bb", "bbb"]
diff --git a/tests/mvcmodels/test_IndexedValueTableModel.py b/tests/mvcmodels/test_IndexedValueTableModel.py
index 069221a65..aeefc53aa 100644
--- a/tests/mvcmodels/test_IndexedValueTableModel.py
+++ b/tests/mvcmodels/test_IndexedValueTableModel.py
@@ -13,8 +13,8 @@
 """Unit tests for the IndexedValueTableModel class."""
 import unittest
 from PySide6.QtCore import Qt
-from PySide6.QtWidgets import QApplication
 from spinetoolbox.mvcmodels.indexed_value_table_model import IndexedValueTableModel
+from tests.mock_helpers import TestCaseWithQApplication
 
 
 class MockValue:
@@ -32,12 +32,7 @@ def __len__(self):
         return len(self.indexes)
 
 
-class TestIndexedValueTableModel(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestIndexedValueTableModel(TestCaseWithQApplication):
     def setUp(self):
         self._value = MockValue(["a", "b", "c"], [7, 5, 3])
         self._model = IndexedValueTableModel(self._value, None)
diff --git a/tests/mvcmodels/test_MapModel.py b/tests/mvcmodels/test_MapModel.py
index 833a47e54..95327c3c7 100644
--- a/tests/mvcmodels/test_MapModel.py
+++ b/tests/mvcmodels/test_MapModel.py
@@ -16,9 +16,10 @@
 from PySide6.QtGui import QColor
 from spinedb_api import Array, DateTime, Duration, Map, ParameterValueFormatError
 from spinetoolbox.mvcmodels.map_model import MapModel
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestMapModel(unittest.TestCase):
+class TestMapModel(TestCaseWithQApplication):
     def setUp(self):
         self._parent = QObject()
 
diff --git a/tests/mvcmodels/test_MinimalTableModel.py b/tests/mvcmodels/test_MinimalTableModel.py
index d84dcdec7..ee0cd40c0 100644
--- a/tests/mvcmodels/test_MinimalTableModel.py
+++ b/tests/mvcmodels/test_MinimalTableModel.py
@@ -13,16 +13,11 @@
 """Unit tests for the MinimalTableModel class."""
 import unittest
 from PySide6.QtCore import Qt
-from PySide6.QtWidgets import QApplication
 from spinetoolbox.mvcmodels.minimal_table_model import MinimalTableModel
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestMinimalTableModel(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestMinimalTableModel(TestCaseWithQApplication):
     def test_clear(self):
         """Test the clear() method of MinimalTableModel."""
         model = MinimalTableModel()
diff --git a/tests/mvcmodels/test_TimePatternModel.py b/tests/mvcmodels/test_TimePatternModel.py
index 1fbdfb995..444b6e18a 100644
--- a/tests/mvcmodels/test_TimePatternModel.py
+++ b/tests/mvcmodels/test_TimePatternModel.py
@@ -15,17 +15,12 @@
 import numpy as np
 import numpy.testing
 from PySide6.QtCore import Qt
-from PySide6.QtWidgets import QApplication
 from spinedb_api import TimePattern
 from spinetoolbox.mvcmodels.time_pattern_model import TimePatternModel
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestTimePatternModel(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestTimePatternModel(TestCaseWithQApplication):
     def test_flags(self):
         model = TimePatternModel(TimePattern(["", ""], [0.0, 0.0]), None)
         for row in range(len(model.value)):
diff --git a/tests/mvcmodels/test_TimeSeriesModelFixedResolution.py b/tests/mvcmodels/test_TimeSeriesModelFixedResolution.py
index 7936c1fac..d49bfe977 100644
--- a/tests/mvcmodels/test_TimeSeriesModelFixedResolution.py
+++ b/tests/mvcmodels/test_TimeSeriesModelFixedResolution.py
@@ -17,17 +17,12 @@
 import numpy as np
 import numpy.testing
 from PySide6.QtCore import Qt
-from PySide6.QtWidgets import QApplication
 from spinedb_api import TimeSeriesFixedResolution
 from spinetoolbox.mvcmodels.time_series_model_fixed_resolution import TimeSeriesModelFixedResolution
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestTimeSeriesModelFixedStep(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestTimeSeriesModelFixedStep(TestCaseWithQApplication):
     def test_data(self):
         model = TimeSeriesModelFixedResolution(
             TimeSeriesFixedResolution("2019-07-05T12:00", "2 hours", [-5.0, 7.0], True, False), None
diff --git a/tests/mvcmodels/test_TimeSeriesModelVariableResolution.py b/tests/mvcmodels/test_TimeSeriesModelVariableResolution.py
index 00f1324cc..60e12ba30 100644
--- a/tests/mvcmodels/test_TimeSeriesModelVariableResolution.py
+++ b/tests/mvcmodels/test_TimeSeriesModelVariableResolution.py
@@ -14,17 +14,12 @@
 import unittest
 import numpy
 from PySide6.QtCore import QObject, Qt
-from PySide6.QtWidgets import QApplication
 from spinedb_api import TimeSeriesVariableResolution
 from spinetoolbox.mvcmodels.time_series_model_variable_resolution import TimeSeriesModelVariableResolution
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestTimeSeriesModelFixedStep(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestTimeSeriesModelFixedStep(TestCaseWithQApplication):
     def setUp(self):
         self._parent = QObject()
 
diff --git a/tests/mvcmodels/test_resource_filter_model.py b/tests/mvcmodels/test_resource_filter_model.py
index e9e55948e..e4b59a3c2 100644
--- a/tests/mvcmodels/test_resource_filter_model.py
+++ b/tests/mvcmodels/test_resource_filter_model.py
@@ -15,19 +15,14 @@
 from unittest import mock
 from PySide6.QtCore import QObject, Qt
 from PySide6.QtGui import QUndoStack
-from PySide6.QtWidgets import QApplication
 from spine_engine.project_item.project_item_resource import database_resource
 from spinedb_api.filters.alternative_filter import ALTERNATIVE_FILTER_TYPE
 from spinedb_api.filters.scenario_filter import SCENARIO_FILTER_TYPE
 from spinetoolbox.mvcmodels.resource_filter_model import ResourceFilterModel
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestResourceFilterModel(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestResourceFilterModel(TestCaseWithQApplication):
     def setUp(self):
         self._logger = mock.MagicMock()
         self._parent = QObject()
diff --git a/tests/project_item/test_ProjectItem.py b/tests/project_item/test_ProjectItem.py
index ec495922f..0387201b8 100644
--- a/tests/project_item/test_ProjectItem.py
+++ b/tests/project_item/test_ProjectItem.py
@@ -14,17 +14,11 @@
 from tempfile import TemporaryDirectory
 import unittest
 from unittest.mock import MagicMock, NonCallableMagicMock
-from PySide6.QtWidgets import QApplication
 from spinetoolbox.project_item.project_item import ProjectItem
-from ..mock_helpers import clean_up_toolbox, create_toolboxui_with_project
+from ..mock_helpers import TestCaseWithQApplication, clean_up_toolbox, create_toolboxui_with_project
 
 
-class TestProjectItem(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestProjectItem(TestCaseWithQApplication):
     def setUp(self):
         """Set up."""
         self._temp_dir = TemporaryDirectory()
diff --git a/tests/project_item/test_logging_connection.py b/tests/project_item/test_logging_connection.py
index 099af4db3..0afa3c13e 100644
--- a/tests/project_item/test_logging_connection.py
+++ b/tests/project_item/test_logging_connection.py
@@ -16,7 +16,6 @@
 import unittest
 from unittest.mock import MagicMock
 from PySide6.QtGui import QColor
-from PySide6.QtWidgets import QApplication
 from spine_engine.project_item.connection import FilterSettings
 from spine_engine.project_item.project_item_resource import database_resource
 from spinedb_api.filters.scenario_filter import SCENARIO_FILTER_TYPE
@@ -26,7 +25,7 @@
 from spinetoolbox.project_item.project_item_factory import ProjectItemFactory
 from spinetoolbox.project_item_icon import ProjectItemIcon
 from spinetoolbox.widgets.properties_widget import PropertiesWidgetBase
-from tests.mock_helpers import clean_up_toolbox, create_toolboxui_with_project
+from tests.mock_helpers import TestCaseWithQApplication, clean_up_toolbox, create_toolboxui_with_project
 
 
 class TestLoggingConnection(unittest.TestCase):
@@ -64,12 +63,7 @@ def test_set_filter_default_online_status(self):
         connection.tear_down()
 
 
-class TestLoggingConnectionWithToolbox(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestLoggingConnectionWithToolbox(TestCaseWithQApplication):
     def setUp(self):
         self._temp_dir = TemporaryDirectory()
         self._toolbox = create_toolboxui_with_project(self._temp_dir.name)
@@ -96,12 +90,7 @@ def test_removing_connection_that_has_None_db_map_does_not_raise(self):
         connection.tear_down()
 
 
-class TestLoggingConnectionWithDatabaseManager(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestLoggingConnectionWithDatabaseManager(TestCaseWithQApplication):
     def setUp(self):
         self._temp_dir = TemporaryDirectory()
         self._toolbox = create_toolboxui_with_project(self._temp_dir.name)
diff --git a/tests/project_item/test_specification_editor_window.py b/tests/project_item/test_specification_editor_window.py
index 2b37cfaef..d8b6edf34 100644
--- a/tests/project_item/test_specification_editor_window.py
+++ b/tests/project_item/test_specification_editor_window.py
@@ -15,7 +15,6 @@
 import unittest
 from unittest.mock import MagicMock, PropertyMock, call, patch
 from PySide6.QtGui import QColor, QUndoStack
-from PySide6.QtWidgets import QApplication
 from spine_engine.project_item.project_item_specification import ProjectItemSpecification
 from spinetoolbox.project_item.project_item import ProjectItem
 from spinetoolbox.project_item.project_item_factory import ProjectItemFactory
@@ -24,15 +23,10 @@
     SpecificationEditorWindowBase,
 )
 from spinetoolbox.project_item_icon import ProjectItemIcon
-from tests.mock_helpers import clean_up_toolbox, create_toolboxui_with_project
+from tests.mock_helpers import TestCaseWithQApplication, clean_up_toolbox, create_toolboxui_with_project
 
 
-class TestChangeSpecPropertyCommand(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestChangeSpecPropertyCommand(TestCaseWithQApplication):
     def test_init(self):
         undo_stack = QUndoStack()
         callback = MagicMock()
@@ -52,12 +46,7 @@ def test_undo(self):
         undo_stack.deleteLater()
 
 
-class TestSpecificationEditorWindowBase(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestSpecificationEditorWindowBase(TestCaseWithQApplication):
     def setUp(self):
         self._temp_dir = TemporaryDirectory()
         self._toolbox = create_toolboxui_with_project(self._temp_dir.name)
diff --git a/tests/server/test_EngineClient.py b/tests/server/test_EngineClient.py
index 5f8d77036..09446a3c8 100644
--- a/tests/server/test_EngineClient.py
+++ b/tests/server/test_EngineClient.py
@@ -16,13 +16,12 @@
 from tempfile import TemporaryDirectory
 import unittest
 from unittest import mock
-from PySide6.QtWidgets import QApplication
 import zmq
 from spine_engine.exception import RemoteEngineInitFailed
 from spine_engine.execution_managers.persistent_execution_manager import PythonPersistentExecutionManager
 from spine_engine.server.engine_server import EngineServer, ServerSecurityModel
 from spinetoolbox.server.engine_client import ClientSecurityModel, EngineClient
-from tests.mock_helpers import clean_up_toolbox, create_toolboxui_with_project
+from tests.mock_helpers import TestCaseWithQApplication, clean_up_toolbox, create_toolboxui_with_project
 
 client_sec_dir = os.path.join(str(Path(__file__).parent), "client_secfolder")
 server_sec_dir = os.path.join(str(Path(__file__).parent), "server_secfolder")
@@ -33,13 +32,7 @@ def _security_folder_exists():
     return os.path.exists(client_sec_dir) and os.path.exists(server_sec_dir)
 
 
-class TestEngineClient(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        """Runs once before any tests in this class."""
-        if not QApplication.instance():
-            QApplication()
-
+class TestEngineClient(TestCaseWithQApplication):
     def setUp(self):
         self._temp_dir = TemporaryDirectory()
         self.toolbox = create_toolboxui_with_project(self._temp_dir.name)
diff --git a/tests/spine_db_editor/helpers.py b/tests/spine_db_editor/helpers.py
index a17ae66cf..116b001f7 100644
--- a/tests/spine_db_editor/helpers.py
+++ b/tests/spine_db_editor/helpers.py
@@ -11,21 +11,19 @@
 ######################################################################################################################
 
 """Helper utilities for Database editor's tests."""
-import unittest
 from unittest import mock
 from PySide6.QtWidgets import QApplication
 from spinetoolbox.spine_db_editor.widgets.spine_db_editor import SpineDBEditor
-from tests.mock_helpers import TestSpineDBManager
+from tests.mock_helpers import TestCaseWithQApplication, TestSpineDBManager
 
 
-class TestBase(unittest.TestCase):
+class TestBase(TestCaseWithQApplication):
     """Base class for Database editor's table and tree view tests."""
 
     @classmethod
     def setUpClass(cls):
+        super().setUpClass()
         cls.db_codename = cls.__name__ + "_db"
-        if not QApplication.instance():
-            QApplication()
 
     def setUp(self):
         self._common_setup("sqlite://", create=True)
diff --git a/tests/spine_db_editor/mvcmodels/test_alternative_model.py b/tests/spine_db_editor/mvcmodels/test_alternative_model.py
index 8b214fce6..84853733f 100644
--- a/tests/spine_db_editor/mvcmodels/test_alternative_model.py
+++ b/tests/spine_db_editor/mvcmodels/test_alternative_model.py
@@ -20,17 +20,12 @@
 from spinetoolbox.spine_db_editor.mvcmodels import mime_types
 from spinetoolbox.spine_db_editor.mvcmodels.alternative_model import AlternativeModel
 from spinetoolbox.spine_db_editor.widgets.spine_db_editor import SpineDBEditor
-from tests.mock_helpers import TestSpineDBManager, model_data_to_dict
+from tests.mock_helpers import TestCaseWithQApplication, TestSpineDBManager, model_data_to_dict
 
 
-class TestAlternativeModel(unittest.TestCase):
+class TestAlternativeModel(TestCaseWithQApplication):
     db_codename = "alternative_model_test_db"
 
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
     def setUp(self):
         app_settings = MagicMock()
         logger = MagicMock()
@@ -125,14 +120,9 @@ def test_mimeData(self):
         self.assertEqual(alternative_data, {self._db_mngr.db_map_key(self._db_map): ["Base"]})
 
 
-class TestAlternativeModelWithTwoDatabases(unittest.TestCase):
+class TestAlternativeModelWithTwoDatabases(TestCaseWithQApplication):
     db_codename = "alternative_model_with_two_databases_test_db"
 
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
     def setUp(self):
         self._temp_dir = TemporaryDirectory()
         app_settings = MagicMock()
diff --git a/tests/spine_db_editor/mvcmodels/test_emptyParameterModels.py b/tests/spine_db_editor/mvcmodels/test_emptyParameterModels.py
index 26c461796..8ac64dc3e 100644
--- a/tests/spine_db_editor/mvcmodels/test_emptyParameterModels.py
+++ b/tests/spine_db_editor/mvcmodels/test_emptyParameterModels.py
@@ -11,9 +11,7 @@
 ######################################################################################################################
 
 """Unit tests for the EmptyParameterModel subclasses."""
-import unittest
 from unittest import mock
-from PySide6.QtWidgets import QApplication
 from spinedb_api import (
     import_object_classes,
     import_object_parameters,
@@ -29,7 +27,7 @@
     CompoundParameterValueModel,
 )
 from spinetoolbox.spine_db_editor.mvcmodels.empty_models import EmptyParameterDefinitionModel, EmptyParameterValueModel
-from tests.mock_helpers import TestSpineDBManager, fetch_model
+from tests.mock_helpers import TestCaseWithQApplication, TestSpineDBManager, fetch_model
 
 
 class TestEmptyParameterDefinitionModel(EmptyParameterDefinitionModel):
@@ -46,12 +44,7 @@ def _empty_indexes(model):
     return [model.index(0, model.header.index(field)) for field in model.header]
 
 
-class TestEmptyParameterModel(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestEmptyParameterModel(TestCaseWithQApplication):
     def setUp(self):
         """Overridden method. Runs before each test."""
         app_settings = mock.MagicMock()
diff --git a/tests/spine_db_editor/mvcmodels/test_frozen_table_model.py b/tests/spine_db_editor/mvcmodels/test_frozen_table_model.py
index e1658306b..3da5f0d33 100644
--- a/tests/spine_db_editor/mvcmodels/test_frozen_table_model.py
+++ b/tests/spine_db_editor/mvcmodels/test_frozen_table_model.py
@@ -16,17 +16,12 @@
 from PySide6.QtCore import QModelIndex, QObject, Qt
 from PySide6.QtWidgets import QApplication
 from spinetoolbox.spine_db_editor.mvcmodels.frozen_table_model import FrozenTableModel
-from tests.mock_helpers import TestSpineDBManager, model_data_to_table
+from tests.mock_helpers import TestCaseWithQApplication, TestSpineDBManager, model_data_to_table
 
 
-class TestFrozenTableModel(unittest.TestCase):
+class TestFrozenTableModel(TestCaseWithQApplication):
     db_codename = "frozen_table_model_test_db"
 
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
     def setUp(self):
         app_settings = MagicMock()
         logger = MagicMock()
diff --git a/tests/spine_db_editor/mvcmodels/test_item_metadata_table_model.py b/tests/spine_db_editor/mvcmodels/test_item_metadata_table_model.py
index 121d15888..7e8ebeae3 100644
--- a/tests/spine_db_editor/mvcmodels/test_item_metadata_table_model.py
+++ b/tests/spine_db_editor/mvcmodels/test_item_metadata_table_model.py
@@ -34,15 +34,10 @@
 )
 from spinetoolbox.spine_db_editor.mvcmodels.item_metadata_table_model import ItemMetadataTableModel
 from spinetoolbox.spine_db_editor.mvcmodels.metadata_table_model_base import Column
-from tests.mock_helpers import TestSpineDBManager, fetch_model
+from tests.mock_helpers import TestCaseWithQApplication, TestSpineDBManager, fetch_model
 
 
-class TestItemMetadataTableModelWithExistingData(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestItemMetadataTableModelWithExistingData(TestCaseWithQApplication):
     def setUp(self):
         self._temp_dir = TemporaryDirectory()
         self._url = "sqlite:///" + self._temp_dir.name + "/db.sqlite"
diff --git a/tests/spine_db_editor/mvcmodels/test_metadata_table_model.py b/tests/spine_db_editor/mvcmodels/test_metadata_table_model.py
index 9e967fba0..e49447bf6 100644
--- a/tests/spine_db_editor/mvcmodels/test_metadata_table_model.py
+++ b/tests/spine_db_editor/mvcmodels/test_metadata_table_model.py
@@ -20,15 +20,10 @@
 from PySide6.QtWidgets import QApplication
 from spinetoolbox.spine_db_editor.mvcmodels.metadata_table_model import MetadataTableModel
 from spinetoolbox.spine_db_editor.mvcmodels.metadata_table_model_base import Column
-from tests.mock_helpers import TestSpineDBManager, fetch_model
+from tests.mock_helpers import TestCaseWithQApplication, TestSpineDBManager, fetch_model
 
 
-class TestMetadataTableModel(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestMetadataTableModel(TestCaseWithQApplication):
     def setUp(self):
         mock_settings = mock.Mock()
         mock_settings.value.side_effect = lambda *args, **kwargs: 0
diff --git a/tests/spine_db_editor/mvcmodels/test_scenario_model.py b/tests/spine_db_editor/mvcmodels/test_scenario_model.py
index aeb1ad5da..79fa1ab6c 100644
--- a/tests/spine_db_editor/mvcmodels/test_scenario_model.py
+++ b/tests/spine_db_editor/mvcmodels/test_scenario_model.py
@@ -22,14 +22,10 @@
 from spinetoolbox.spine_db_editor.mvcmodels import mime_types
 from spinetoolbox.spine_db_editor.mvcmodels.scenario_model import ScenarioModel
 from spinetoolbox.spine_db_editor.widgets.spine_db_editor import SpineDBEditor
-from tests.mock_helpers import TestSpineDBManager, model_data_to_dict
+from tests.mock_helpers import TestCaseWithQApplication, TestSpineDBManager, model_data_to_dict
 
 
-class _TestBase(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
+class _TestBase(TestCaseWithQApplication):
 
     @staticmethod
     def _fetch_recursively(model):
diff --git a/tests/spine_db_editor/mvcmodels/test_single_parameter_models.py b/tests/spine_db_editor/mvcmodels/test_single_parameter_models.py
index ff1c7f3c5..152d88a8c 100644
--- a/tests/spine_db_editor/mvcmodels/test_single_parameter_models.py
+++ b/tests/spine_db_editor/mvcmodels/test_single_parameter_models.py
@@ -13,7 +13,6 @@
 """Unit tests for the ``single_parameter_model`` module."""
 import unittest
 from unittest.mock import MagicMock
-from PySide6.QtWidgets import QApplication
 from spinedb_api import to_database
 from spinetoolbox.mvcmodels.shared import DB_MAP_ROLE
 from spinetoolbox.spine_db_editor.mvcmodels.compound_models import (
@@ -24,7 +23,7 @@
     SingleParameterDefinitionModel,
     SingleParameterValueModel,
 )
-from tests.mock_helpers import TestSpineDBManager, fetch_model, q_object
+from tests.mock_helpers import TestCaseWithQApplication, TestSpineDBManager, fetch_model, q_object
 
 ENTITY_PARAMETER_VALUE_HEADER = [
     "entity_class_name",
@@ -46,7 +45,7 @@ def __init__(self, db_mngr, db_map, entity_class_id, committed):
         super().__init__(CompoundParameterValueModel(None, db_mngr), db_map, entity_class_id, committed)
 
 
-class TestEmptySingleParameterDefinitionModel(unittest.TestCase):
+class TestEmptySingleParameterDefinitionModel(TestCaseWithQApplication):
     HEADER = [
         "entity_class_name",
         "parameter_name",
@@ -57,11 +56,6 @@ class TestEmptySingleParameterDefinitionModel(unittest.TestCase):
         "database",
     ]
 
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
     def test_rowCount_is_zero(self):
         with q_object(TestSingleParameterDefinitionModel(None, None, 1, False)) as model:
             self.assertEqual(model.rowCount(), 0)
@@ -71,7 +65,7 @@ def test_columnCount_is_header_length(self):
             self.assertEqual(model.columnCount(), len(self.HEADER))
 
 
-class TestSingleObjectParameterValueModel(unittest.TestCase):
+class TestSingleObjectParameterValueModel(TestCaseWithQApplication):
     OBJECT_PARAMETER_VALUE_HEADER = [
         "entity_class_name",
         "object_name",
@@ -81,11 +75,6 @@ class TestSingleObjectParameterValueModel(unittest.TestCase):
         "database",
     ]
 
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
     def setUp(self):
         self._db_mngr = TestSpineDBManager(None, None)
         self._logger = MagicMock()
diff --git a/tests/spine_db_editor/mvcmodels/test_utils.py b/tests/spine_db_editor/mvcmodels/test_utils.py
index 46a7fc2eb..3993c5f25 100644
--- a/tests/spine_db_editor/mvcmodels/test_utils.py
+++ b/tests/spine_db_editor/mvcmodels/test_utils.py
@@ -14,16 +14,11 @@
 import unittest
 from PySide6.QtCore import QObject
 from PySide6.QtGui import QStandardItem, QStandardItemModel
-from PySide6.QtWidgets import QApplication
 from spinetoolbox.spine_db_editor.mvcmodels.utils import two_column_as_csv
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestTwoColumnAsCsv(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestTwoColumnAsCsv(TestCaseWithQApplication):
     def setUp(self):
         self._parent = QObject()
 
diff --git a/tests/spine_db_editor/test_graphics_items.py b/tests/spine_db_editor/test_graphics_items.py
index ac8b1c087..7d0af6977 100644
--- a/tests/spine_db_editor/test_graphics_items.py
+++ b/tests/spine_db_editor/test_graphics_items.py
@@ -17,17 +17,12 @@
 from PySide6.QtWidgets import QApplication
 from spinetoolbox.spine_db_editor.graphics_items import EntityItem
 from spinetoolbox.spine_db_editor.widgets.spine_db_editor import SpineDBEditor
-from tests.mock_helpers import TestSpineDBManager
+from tests.mock_helpers import TestCaseWithQApplication, TestSpineDBManager
 
 
-class TestEntityItem(unittest.TestCase):
+class TestEntityItem(TestCaseWithQApplication):
     _db_mngr = None
 
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
     def setUp(self):
         with mock.patch("spinetoolbox.spine_db_editor.widgets.spine_db_editor.SpineDBEditor.restore_ui"), mock.patch(
             "spinetoolbox.spine_db_editor.widgets.spine_db_editor.SpineDBEditor.show"
@@ -60,6 +55,7 @@ def setUp(self):
 
     @classmethod
     def tearDownClass(cls):
+        super().tearDownClass()
         QApplication.removePostedEvents(None)  # Clean up unfinished fetcher signals
 
     def tearDown(self):
diff --git a/tests/spine_db_editor/widgets/spine_db_editor_test_base.py b/tests/spine_db_editor/widgets/spine_db_editor_test_base.py
index 4ade6c89e..ca6735ab5 100644
--- a/tests/spine_db_editor/widgets/spine_db_editor_test_base.py
+++ b/tests/spine_db_editor/widgets/spine_db_editor_test_base.py
@@ -11,20 +11,14 @@
 ######################################################################################################################
 
 """Base classes and helpers for database editor tests."""
-import unittest
 from unittest import mock
 from PySide6.QtWidgets import QApplication
 from spinedb_api import to_database
 from spinetoolbox.spine_db_editor.widgets.spine_db_editor import SpineDBEditor
-from tests.mock_helpers import TestSpineDBManager
+from tests.mock_helpers import TestCaseWithQApplication, TestSpineDBManager
 
 
-class DBEditorTestBase(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class DBEditorTestBase(TestCaseWithQApplication):
     db_codename = "database"
 
     def setUp(self):
diff --git a/tests/spine_db_editor/widgets/test_SpineDBEditor.py b/tests/spine_db_editor/widgets/test_SpineDBEditor.py
index eebdc8be8..60a717eac 100644
--- a/tests/spine_db_editor/widgets/test_SpineDBEditor.py
+++ b/tests/spine_db_editor/widgets/test_SpineDBEditor.py
@@ -20,7 +20,7 @@
 from spinedb_api.helpers import name_from_elements
 from spinetoolbox.helpers import signal_waiter
 from spinetoolbox.spine_db_editor.widgets.spine_db_editor import SpineDBEditor
-from tests.mock_helpers import TestSpineDBManager
+from tests.mock_helpers import TestCaseWithQApplication, TestSpineDBManager
 from tests.spine_db_editor.widgets.spine_db_editor_test_base import DBEditorTestBase
 
 
@@ -252,12 +252,7 @@ def test_stacked_table_empty_row_defaults_are_updated_on_entity_rename(self):
                 self.assertEqual(empty_row, expected_empty_row)
 
 
-class TestClosingDBEditors(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestClosingDBEditors(TestCaseWithQApplication):
     def setUp(self):
         self._editors = []
         with mock.patch("spinetoolbox.spine_db_editor.widgets.spine_db_editor.SpineDBEditor.restore_ui"), mock.patch(
diff --git a/tests/spine_db_editor/widgets/test_SpineDBEditorBase.py b/tests/spine_db_editor/widgets/test_SpineDBEditorBase.py
index 21c075489..f8d790d23 100644
--- a/tests/spine_db_editor/widgets/test_SpineDBEditorBase.py
+++ b/tests/spine_db_editor/widgets/test_SpineDBEditorBase.py
@@ -13,17 +13,11 @@
 """Contains unit tests for the SpineDBEditorBase class."""
 import unittest
 from unittest import mock
-from PySide6.QtWidgets import QApplication
 from spinetoolbox.spine_db_editor.widgets.spine_db_editor import SpineDBEditorBase
-from tests.mock_helpers import TestSpineDBManager
+from tests.mock_helpers import TestCaseWithQApplication, TestSpineDBManager
 
 
-class TestSpineDBEditorBase(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestSpineDBEditorBase(TestCaseWithQApplication):
     def setUp(self):
         """Builds a SpineDBEditorBase object."""
         with mock.patch("spinetoolbox.spine_db_worker.DatabaseMapping") as mock_DiffDBMapping, mock.patch(
diff --git a/tests/spine_db_editor/widgets/test_SpineDBEditorFilter.py b/tests/spine_db_editor/widgets/test_SpineDBEditorFilter.py
index 680cae6de..0d7841a10 100644
--- a/tests/spine_db_editor/widgets/test_SpineDBEditorFilter.py
+++ b/tests/spine_db_editor/widgets/test_SpineDBEditorFilter.py
@@ -155,8 +155,7 @@ class TestSpineDBEditorGraphFilter(DBEditorTestBase):
 
     @classmethod
     def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
+        super().setUpClass()
         cls.data = {}
         cls._add_test_data()
         cls._create_highlights()
diff --git a/tests/spine_db_editor/widgets/test_SpineDBEditorWithDBMapping.py b/tests/spine_db_editor/widgets/test_SpineDBEditorWithDBMapping.py
index dc348a55c..38553246d 100644
--- a/tests/spine_db_editor/widgets/test_SpineDBEditorWithDBMapping.py
+++ b/tests/spine_db_editor/widgets/test_SpineDBEditorWithDBMapping.py
@@ -11,33 +11,17 @@
 ######################################################################################################################
 
 """Unit tests for SpineDBEditor classes."""
-import logging
 import os.path
-import sys
 from tempfile import TemporaryDirectory
 import unittest
 from unittest import mock
 from PySide6.QtCore import QItemSelectionModel
 from PySide6.QtWidgets import QApplication
 from spinetoolbox.spine_db_editor.widgets.spine_db_editor import SpineDBEditor
-from tests.mock_helpers import TestSpineDBManager
+from tests.mock_helpers import TestCaseWithQApplication, TestSpineDBManager
 
 
-class TestSpineDBEditorWithDBMapping(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        """Overridden method. Runs once before all tests in this class."""
-        try:
-            cls.app = QApplication().processEvents()
-        except RuntimeError:
-            pass
-        logging.basicConfig(
-            stream=sys.stderr,
-            level=logging.DEBUG,
-            format="%(asctime)s %(levelname)s: %(message)s",
-            datefmt="%Y-%m-%d %H:%M:%S",
-        )
-
+class TestSpineDBEditorWithDBMapping(TestCaseWithQApplication):
     def setUp(self):
         """Overridden method. Runs before each test. Makes instances of SpineDBEditor classes."""
         self._temp_dir = TemporaryDirectory()
diff --git a/tests/spine_db_editor/widgets/test_add_items_dialog.py b/tests/spine_db_editor/widgets/test_add_items_dialog.py
index 7c6da145f..dd021f2b5 100644
--- a/tests/spine_db_editor/widgets/test_add_items_dialog.py
+++ b/tests/spine_db_editor/widgets/test_add_items_dialog.py
@@ -14,7 +14,7 @@
 from tempfile import TemporaryDirectory
 import unittest
 from unittest import mock
-from PySide6.QtCore import QItemSelection, QItemSelectionModel, QMimeData, QModelIndex
+from PySide6.QtCore import QItemSelection, QItemSelectionModel, QModelIndex
 from PySide6.QtWidgets import QApplication
 from spinetoolbox.spine_db_editor.widgets.add_items_dialogs import (
     AddEntitiesDialog,
@@ -23,16 +23,11 @@
 )
 from spinetoolbox.spine_db_editor.widgets.spine_db_editor import SpineDBEditor
 from spinetoolbox.spine_db_manager import SpineDBManager
-from tests.mock_helpers import mock_clipboard_patch
+from tests.mock_helpers import TestCaseWithQApplication, mock_clipboard_patch
 from tests.spine_db_editor.helpers import TestBase
 
 
-class TestAddItemsDialog(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestAddItemsDialog(TestCaseWithQApplication):
     def setUp(self):
         """Overridden method. Runs before each test. Makes instance of SpineDBEditor class."""
         with mock.patch("spinetoolbox.spine_db_editor.widgets.spine_db_editor.SpineDBEditor.restore_ui"):
diff --git a/tests/spine_db_editor/widgets/test_commit_viewer.py b/tests/spine_db_editor/widgets/test_commit_viewer.py
index d67d0a024..51a4b4f2f 100644
--- a/tests/spine_db_editor/widgets/test_commit_viewer.py
+++ b/tests/spine_db_editor/widgets/test_commit_viewer.py
@@ -19,15 +19,10 @@
 import spinetoolbox.resources_icons_rc  # pylint: disable=unused-import
 from spinetoolbox.spine_db_editor.widgets.commit_viewer import CommitViewer, QSplitter
 from spinetoolbox.spine_db_manager import SpineDBManager
-from tests.mock_helpers import q_object
+from tests.mock_helpers import TestCaseWithQApplication, q_object
 
 
-class TestCommitViewer(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestCommitViewer(TestCaseWithQApplication):
     def setUp(self):
         with mock.patch("spinetoolbox.spine_db_editor.widgets.spine_db_editor.SpineDBEditor.restore_ui"):
             mock_settings = mock.Mock()
diff --git a/tests/spine_db_editor/widgets/test_custom_delegates.py b/tests/spine_db_editor/widgets/test_custom_delegates.py
index 1f0d20ddd..d54a6e0c9 100644
--- a/tests/spine_db_editor/widgets/test_custom_delegates.py
+++ b/tests/spine_db_editor/widgets/test_custom_delegates.py
@@ -14,17 +14,12 @@
 import unittest
 from unittest import mock
 from PySide6.QtGui import QStandardItem, QStandardItemModel
-from PySide6.QtWidgets import QApplication
 from spinetoolbox.helpers import signal_waiter
 from spinetoolbox.spine_db_editor.widgets.custom_delegates import BooleanValueDelegate
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestBooleanValueDelegate(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestBooleanValueDelegate(TestCaseWithQApplication):
     def setUp(self):
         self._model = QStandardItemModel()
         row = [QStandardItem()]
diff --git a/tests/spine_db_editor/widgets/test_custom_editors.py b/tests/spine_db_editor/widgets/test_custom_editors.py
index ef6c44b9f..eea1b3676 100644
--- a/tests/spine_db_editor/widgets/test_custom_editors.py
+++ b/tests/spine_db_editor/widgets/test_custom_editors.py
@@ -29,15 +29,14 @@
     SearchBarEditor,
     _CustomLineEditDelegate,
 )
-from tests.mock_helpers import q_object
+from tests.mock_helpers import TestCaseWithQApplication, q_object
 
 
-class TestEditors(unittest.TestCase):
+class TestEditors(TestCaseWithQApplication):
     @classmethod
     def setUpClass(cls):
+        super().setUpClass()
         qInitResources()
-        if not QApplication.instance():
-            QApplication()
 
     def test_searchbar_editor_set_data_sorts_items_case_insensitively(self):
         with q_object(QWidget()) as parent:
@@ -141,12 +140,11 @@ def test_boolean_searchbar_editor(self):
             self.assertEqual(True, retval)
 
 
-class TestParameterTypeEditor(unittest.TestCase):
+class TestParameterTypeEditor(TestCaseWithQApplication):
     @classmethod
     def setUpClass(cls):
+        super().setUpClass()
         qInitResources()
-        if not QApplication.instance():
-            QApplication()
 
     def setUp(self):
         self._editor = ParameterTypeEditor(None)
diff --git a/tests/spine_db_editor/widgets/test_custom_menus.py b/tests/spine_db_editor/widgets/test_custom_menus.py
index 42afc212a..dc9b0d2cd 100644
--- a/tests/spine_db_editor/widgets/test_custom_menus.py
+++ b/tests/spine_db_editor/widgets/test_custom_menus.py
@@ -13,17 +13,13 @@
 """Unit tests for ``custom_menus`` module."""
 import unittest
 from unittest import mock
-from PySide6.QtWidgets import QApplication, QWidget
+from PySide6.QtWidgets import QWidget
 from spinetoolbox.helpers import signal_waiter
 from spinetoolbox.spine_db_editor.widgets.custom_menus import TabularViewCodenameFilterMenu
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestTabularViewCodenameFilterMenu(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestTabularViewCodenameFilterMenu(TestCaseWithQApplication):
     def setUp(self):
         self._parent = QWidget()
 
diff --git a/tests/spine_db_editor/widgets/test_custom_qgraphicsviews.py b/tests/spine_db_editor/widgets/test_custom_qgraphicsviews.py
index 9ba365a91..643bd2e58 100644
--- a/tests/spine_db_editor/widgets/test_custom_qgraphicsviews.py
+++ b/tests/spine_db_editor/widgets/test_custom_qgraphicsviews.py
@@ -13,18 +13,14 @@
 """Unit tests for ``custom_qgraphicsviews`` module."""
 import unittest
 from unittest import mock
-from PySide6.QtWidgets import QApplication, QWidget
+from PySide6.QtWidgets import QWidget
 from spinetoolbox.spine_db_editor.widgets.custom_qgraphicsviews import EntityQGraphicsView
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestGraphOptionsOverlay(unittest.TestCase):
+class TestGraphOptionsOverlay(TestCaseWithQApplication):
     """Tests for the class GraphOptionsOverlay"""
 
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
     def setUp(self):
         self._parent = QWidget()
         self.graph = EntityQGraphicsView(self._parent)
diff --git a/tests/spine_db_editor/widgets/test_mass_select_items_dialogs.py b/tests/spine_db_editor/widgets/test_mass_select_items_dialogs.py
index cbf3fc533..df8a49c9e 100644
--- a/tests/spine_db_editor/widgets/test_mass_select_items_dialogs.py
+++ b/tests/spine_db_editor/widgets/test_mass_select_items_dialogs.py
@@ -16,14 +16,10 @@
 from PySide6.QtWidgets import QApplication, QDialogButtonBox
 from spinetoolbox.spine_db_editor.widgets.mass_select_items_dialogs import MassRemoveItemsDialog
 from spinetoolbox.spine_db_manager import SpineDBManager
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestMassRemoveItemsDialog(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestMassRemoveItemsDialog(TestCaseWithQApplication):
     def setUp(self):
         url = "sqlite:///"
         with mock.patch("spinetoolbox.spine_db_editor.widgets.spine_db_editor.SpineDBEditor.restore_ui"), mock.patch(
diff --git a/tests/spine_db_editor/widgets/test_toolbar.py b/tests/spine_db_editor/widgets/test_toolbar.py
index 4cf448715..1fb920468 100644
--- a/tests/spine_db_editor/widgets/test_toolbar.py
+++ b/tests/spine_db_editor/widgets/test_toolbar.py
@@ -13,18 +13,12 @@
 """Unit tests for the ``toolbar`` module."""
 from tempfile import TemporaryDirectory
 from unittest import mock
-from PySide6.QtWidgets import QApplication
 from spinetoolbox.spine_db_editor.widgets.toolbar import DBEditorToolBar
 from tests.mock_helpers import clean_up_toolbox, create_toolboxui_with_project
 from tests.spine_db_editor.widgets.spine_db_editor_test_base import DBEditorTestBase
 
 
 class TestDBEditorToolBar(DBEditorTestBase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
     def setUp(self):
         super().setUp()
         self._temp_dir = TemporaryDirectory()
diff --git a/tests/test_ProjectUpgrader.py b/tests/test_ProjectUpgrader.py
index a2cdfda9f..563f53e16 100644
--- a/tests/test_ProjectUpgrader.py
+++ b/tests/test_ProjectUpgrader.py
@@ -12,36 +12,24 @@
 
 """Unit tests for ProjectUpgrader class."""
 import json
-import logging
 import os
 from pathlib import Path
-import sys
 from tempfile import TemporaryDirectory
-import unittest
 from unittest import mock
-from PySide6.QtWidgets import QApplication, QMessageBox
+from PySide6.QtWidgets import QMessageBox
 from spinetoolbox.config import LATEST_PROJECT_VERSION
 from spinetoolbox.project_settings import ProjectSettings
 from spinetoolbox.project_upgrader import ProjectUpgrader
 from spinetoolbox.resources_icons_rc import qInitResources
-from .mock_helpers import clean_up_toolbox, create_toolboxui
+from .mock_helpers import TestCaseWithQApplication, clean_up_toolbox, create_toolboxui
 
 
-class TestProjectUpgrader(unittest.TestCase):
+class TestProjectUpgrader(TestCaseWithQApplication):
     @classmethod
     def setUpClass(cls):
         """Overridden method. Runs once before all tests in this class."""
+        super().setUpClass()
         qInitResources()
-        try:
-            cls.app = QApplication().processEvents()
-        except RuntimeError:
-            pass
-        logging.basicConfig(
-            stream=sys.stderr,
-            level=logging.DEBUG,
-            format="%(asctime)s %(levelname)s: %(message)s",
-            datefmt="%Y-%m-%d %H:%M:%S",
-        )
 
     def setUp(self):
         """Makes an instance of ToolboxUI class without a project."""
diff --git a/tests/test_SpineDBManager.py b/tests/test_SpineDBManager.py
index dcbafce5b..34c44635f 100644
--- a/tests/test_SpineDBManager.py
+++ b/tests/test_SpineDBManager.py
@@ -32,9 +32,10 @@
 from spinetoolbox.fetch_parent import FlexibleFetchParent
 from spinetoolbox.helpers import signal_waiter
 from spinetoolbox.spine_db_manager import SpineDBManager
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestParameterValueFormatting(unittest.TestCase):
+class TestParameterValueFormatting(TestCaseWithQApplication):
     """Tests for parameter_value formatting in SpineDBManager."""
 
     @staticmethod
@@ -50,11 +51,6 @@ def _get_item(db_map, item_type, id_, only_visible=True):
 
         return _get_item
 
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
     def setUp(self):
         app_settings = MagicMock()
         self.db_mngr = SpineDBManager(app_settings, None, synchronous=True)
@@ -234,12 +230,7 @@ def test_broken_value_in_tool_tip_role(self):
         self.assertTrue(formatted.startswith("<qt>Could not decode the value"))
 
 
-class TestAddItems(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestAddItems(TestCaseWithQApplication):
     def setUp(self):
         self._temp_dir = TemporaryDirectory()
         db_path = Path(self._temp_dir.name, "db.sqlite")
@@ -284,12 +275,7 @@ def test_add_object_metadata(self):
         )
 
 
-class TestDoRestoreItems(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestDoRestoreItems(TestCaseWithQApplication):
     def setUp(self):
         self._temp_dir = TemporaryDirectory()
         db_path = Path(self._temp_dir.name, "db.sqlite")
@@ -323,12 +309,7 @@ def test_restore_entity_class(self):
         self.assertTrue(class_item.is_valid())
 
 
-class TestImportExportData(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestImportExportData(TestCaseWithQApplication):
     def setUp(self):
         mock_settings = MagicMock()
         mock_settings.value.side_effect = lambda *args, **kwargs: 0
@@ -421,12 +402,7 @@ def test_import_parameter_value_lists(self):
         )
 
 
-class TestOpenDBEditor(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestOpenDBEditor(TestCaseWithQApplication):
     def setUp(self):
         self._temp_dir = TemporaryDirectory()
         db_path = Path(self._temp_dir.name, "db.sqlite")
@@ -471,12 +447,11 @@ def tearDown(self):
                 running = False
 
 
-class TestDuplicateEntity(unittest.TestCase):
+class TestDuplicateEntity(TestCaseWithQApplication):
     @classmethod
     def setUpClass(cls):
+        super().setUpClass()
         cls.db_codename = cls.__name__ + "_db"
-        if not QApplication.instance():
-            QApplication()
 
     def setUp(self):
         self._db_mngr = SpineDBManager(QSettings(), None)
@@ -544,12 +519,7 @@ def test_duplicates_parameter_values_and_entity_alternatives(self):
         self.assertEqual({v["alternative_name"] for v in values}, {"low highs"})
 
 
-class TestUpdateExpandedParameterValues(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestUpdateExpandedParameterValues(TestCaseWithQApplication):
     def setUp(self):
         mock_settings = MagicMock()
         mock_settings.value.side_effect = lambda *args, **kwargs: 0
@@ -594,12 +564,7 @@ def test_updating_indexed_value_changes_the_unparsed_value_in_database(self):
         self.assertEqual(update_value, Map(["a"], ["c"]))
 
 
-class TestRemoveScenarioAlternative(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestRemoveScenarioAlternative(TestCaseWithQApplication):
     def setUp(self):
         mock_settings = MagicMock()
         mock_settings.value.side_effect = lambda *args, **kwargs: 0
diff --git a/tests/test_SpineToolboxProject.py b/tests/test_SpineToolboxProject.py
index 87ef630a5..3384896e3 100644
--- a/tests/test_SpineToolboxProject.py
+++ b/tests/test_SpineToolboxProject.py
@@ -32,6 +32,7 @@
 from spinetoolbox.project_item.project_item import ProjectItem
 from spinetoolbox.project_item.project_item_factory import ProjectItemFactory
 from tests.mock_helpers import (
+    TestCaseWithQApplication,
     add_data_transformer,
     add_dc,
     add_ds,
@@ -47,13 +48,7 @@
 
 
 # noinspection PyUnusedLocal
-class TestSpineToolboxProject(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        """Runs once before any tests in this class."""
-        if not QApplication.instance():
-            QApplication()
-
+class TestSpineToolboxProject(TestCaseWithQApplication):
     def setUp(self):
         """Makes a ToolboxUI instance and opens a project before each test."""
         self._temp_dir = TemporaryDirectory()
diff --git a/tests/test_ToolboxUI.py b/tests/test_ToolboxUI.py
index 57c1c5b1b..9c7f86703 100644
--- a/tests/test_ToolboxUI.py
+++ b/tests/test_ToolboxUI.py
@@ -13,11 +13,9 @@
 """Unit tests for ToolboxUI class."""
 from contextlib import contextmanager
 import json
-import logging
 import os
 import pathlib
 from pathlib import Path
-import sys
 from tempfile import TemporaryDirectory
 import unittest
 from unittest import mock
@@ -33,6 +31,7 @@
 from spinetoolbox.widgets.persistent_console_widget import PersistentConsoleWidget
 from spinetoolbox.widgets.project_item_drag import NiceButton, ProjectItemDragMixin
 from .mock_helpers import (
+    TestCaseWithQApplication,
     add_dc,
     add_dc_trough_undo_stack,
     add_tool,
@@ -44,21 +43,12 @@
 
 
 # noinspection PyUnusedLocal,DuplicatedCode
-class TestToolboxUI(unittest.TestCase):
+class TestToolboxUI(TestCaseWithQApplication):
     @classmethod
     def setUpClass(cls):
         """Overridden method. Runs once before all tests in this class."""
+        super().setUpClass()
         qInitResources()
-        try:
-            cls.app = QApplication().processEvents()
-        except RuntimeError:
-            pass
-        logging.basicConfig(
-            stream=sys.stderr,
-            level=logging.DEBUG,
-            format="%(asctime)s %(levelname)s: %(message)s",
-            datefmt="%Y-%m-%d %H:%M:%S",
-        )
 
     def setUp(self):
         """Overridden method. Runs before each test. Makes an instance of ToolboxUI class
@@ -835,12 +825,7 @@ class MockDraggableButton(ProjectItemDragMixin, NiceButton):
     """Mocked draggable button"""
 
 
-class TestToolboxUIWithTestSettings(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestToolboxUIWithTestSettings(TestCaseWithQApplication):
     def test_legacy_settings_keys_get_renamed(self):
         settings_dict = {"appSettings/useEmbeddedJulia": "julia value", "appSettings/useEmbeddedPython": "python value"}
         with toolbox_with_settings(settings_dict) as toolbox:
diff --git a/tests/test_helpers.py b/tests/test_helpers.py
index 7c4157a26..201f7aa98 100644
--- a/tests/test_helpers.py
+++ b/tests/test_helpers.py
@@ -19,7 +19,7 @@
 import unittest
 from unittest.mock import MagicMock, patch
 from PySide6.QtCore import QSettings
-from PySide6.QtWidgets import QApplication, QLineEdit, QWidget
+from PySide6.QtWidgets import QLineEdit, QWidget
 from spine_engine.load_project_items import load_item_specification_factories
 from spinetoolbox.config import PROJECT_FILENAME, PROJECT_LOCAL_DATA_DIR_NAME, PROJECT_LOCAL_DATA_FILENAME
 from spinetoolbox.helpers import (
@@ -54,13 +54,10 @@
     tuple_itemgetter,
     unique_name,
 )
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestHelpers(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
+class TestHelpers(TestCaseWithQApplication):
 
     def test_format_log_message(self):
         stamp_pattern = re.compile(r"\[\d\d-\d\d-\d\d\d\d \d\d:\d\d:\d\d]")
diff --git a/tests/test_load_project_items.py b/tests/test_load_project_items.py
index 1830af44c..7ee8026e1 100644
--- a/tests/test_load_project_items.py
+++ b/tests/test_load_project_items.py
@@ -12,17 +12,12 @@
 
 """Unit tests for the :module:`spinetoolbox.load_project_items` module."""
 import unittest
-from PySide6.QtWidgets import QApplication
 from spinetoolbox.load_project_items import load_project_items
 from spinetoolbox.project_item.project_item_factory import ProjectItemFactory
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestLoadProjectItems(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestLoadProjectItems(TestCaseWithQApplication):
     def test_load_project_items_finds_all_default_items(self):
         factories = load_project_items("spine_items")
         for factory in factories.values():
diff --git a/tests/test_parameter_type_validation.py b/tests/test_parameter_type_validation.py
index 104cb20b3..5aca06561 100644
--- a/tests/test_parameter_type_validation.py
+++ b/tests/test_parameter_type_validation.py
@@ -15,15 +15,14 @@
 from spinedb_api import to_database
 from spinetoolbox.helpers import signal_waiter
 from spinetoolbox.parameter_type_validation import ValidationKey
-from tests.mock_helpers import TestSpineDBManager
+from tests.mock_helpers import TestCaseWithQApplication, TestSpineDBManager
 
 
-class TestTypeValidator(unittest.TestCase):
+class TestTypeValidator(TestCaseWithQApplication):
     @classmethod
     def setUpClass(cls):
+        super().setUpClass()
         cls.db_codename = cls.__name__ + "_db"
-        if not QApplication.instance():
-            QApplication()
 
     def setUp(self):
         mock_settings = mock.MagicMock()
@@ -53,7 +52,7 @@ def test_valid_parameter_default_value(self):
             )
         )
         self._db_map.commit_session("Add test data.")
-        with signal_waiter(self._db_mngr.parameter_type_validator.validated, timeout=2) as waiter:
+        with signal_waiter(self._db_mngr.parameter_type_validator.validated, timeout=5.0) as waiter:
             self._db_mngr.parameter_type_validator.start_validating(self._db_mngr, self._db_map, [price["id"]])
             waiter.wait()
             self.assertEqual(
@@ -96,7 +95,7 @@ def test_valid_parameter_value(self):
                 type=value_type,
             )
         )
-        with signal_waiter(self._db_mngr.parameter_type_validator.validated, timeout=2) as waiter:
+        with signal_waiter(self._db_mngr.parameter_type_validator.validated, timeout=5.0) as waiter:
             self._db_mngr.parameter_type_validator.start_validating(
                 self._db_mngr, self._db_map, [fish_n_chips_price["id"]]
             )
diff --git a/tests/test_plotting.py b/tests/test_plotting.py
index be984b5d0..d8a2184cf 100644
--- a/tests/test_plotting.py
+++ b/tests/test_plotting.py
@@ -42,6 +42,7 @@
     reduce_indexes,
     turn_node_to_xy_data,
 )
+from tests.mock_helpers import TestCaseWithQApplication
 from tests.spine_db_editor.helpers import TestBase
 
 
@@ -762,12 +763,7 @@ def test_all_same_indexes_combined(self):
         self.assertEqual(combined, expected)
 
 
-class TestPlotData(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestPlotData(TestCaseWithQApplication):
     def test_nothing_to_plot(self):
         plot_widget = plot_data([])
         self.assertEqual(len(plot_widget.canvas.axes.lines), 0)
diff --git a/tests/test_project_item_icon.py b/tests/test_project_item_icon.py
index 2339d3010..ea5c40e07 100644
--- a/tests/test_project_item_icon.py
+++ b/tests/test_project_item_icon.py
@@ -17,22 +17,23 @@
 from unittest.mock import MagicMock, patch
 from PySide6.QtCore import QEvent, QPoint, Qt
 from PySide6.QtGui import QColor
-from PySide6.QtWidgets import QApplication, QGraphicsSceneMouseEvent
+from PySide6.QtWidgets import QGraphicsSceneMouseEvent
 from spine_engine.project_item.project_item_resource import database_resource
 from spinedb_api import DatabaseMapping, import_scenarios
 from spinetoolbox.link import Link
 from spinetoolbox.project_commands import MoveIconCommand
 from spinetoolbox.project_item.logging_connection import LoggingConnection
 from spinetoolbox.project_item_icon import ExclamationIcon, ProjectItemIcon, RankIcon
-from tests.mock_helpers import TestSpineDBManager, add_view, clean_up_toolbox, create_toolboxui_with_project
+from tests.mock_helpers import (
+    TestCaseWithQApplication,
+    TestSpineDBManager,
+    add_view,
+    clean_up_toolbox,
+    create_toolboxui_with_project,
+)
 
 
-class TestProjectItemIcon(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestProjectItemIcon(TestCaseWithQApplication):
     def setUp(self):
         self._temp_dir = TemporaryDirectory()
         self._toolbox = create_toolboxui_with_project(self._temp_dir.name)
@@ -100,12 +101,7 @@ def test_context_menu_event(self):
             mock_show_menu.assert_called()
 
 
-class TestExclamationIcon(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestExclamationIcon(TestCaseWithQApplication):
     def test_no_notifications(self):
         with patch("PySide6.QtWidgets.QToolTip.showText") as show_text:
             icon = ExclamationIcon(None)
@@ -128,12 +124,7 @@ def test_clear_notifications(self):
             show_text.assert_not_called()
 
 
-class TestRankIcon(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestRankIcon(TestCaseWithQApplication):
     def setUp(self):
         self._temp_dir = TemporaryDirectory()
         self._toolbox = create_toolboxui_with_project(self._temp_dir.name)
@@ -150,12 +141,7 @@ def test_set_rank(self):
         self.assertEqual(icon.toPlainText(), "23")
 
 
-class TestLink(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestLink(TestCaseWithQApplication):
     def setUp(self):
         self._temp_dir = TemporaryDirectory()
         self._toolbox = create_toolboxui_with_project(self._temp_dir.name)
diff --git a/tests/test_spine_db_fetcher.py b/tests/test_spine_db_fetcher.py
index 55a928067..4990c6980 100644
--- a/tests/test_spine_db_fetcher.py
+++ b/tests/test_spine_db_fetcher.py
@@ -14,11 +14,10 @@
 import unittest
 from unittest.mock import MagicMock
 from PySide6.QtGui import QIcon
-from PySide6.QtWidgets import QApplication
 from spinedb_api import DatabaseMapping
 from spinedb_api.import_functions import import_data
 from spinetoolbox.fetch_parent import ItemTypeFetchParent
-from tests.mock_helpers import TestSpineDBManager
+from tests.mock_helpers import TestCaseWithQApplication, TestSpineDBManager
 
 
 class TestItemTypeFetchParent(ItemTypeFetchParent):
@@ -27,12 +26,7 @@ def __init__(self, item_type):
         self.handle_items_added = MagicMock()
 
 
-class TestSpineDBFetcher(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestSpineDBFetcher(TestCaseWithQApplication):
     def setUp(self):
         app_settings = MagicMock()
         self._logger = MagicMock()  # Collects error messages therefore handy for debugging.
diff --git a/tests/test_spine_engine_worker.py b/tests/test_spine_engine_worker.py
index ec4f57d5f..1de506906 100644
--- a/tests/test_spine_engine_worker.py
+++ b/tests/test_spine_engine_worker.py
@@ -17,14 +17,10 @@
 from PySide6.QtCore import QObject, Slot
 from PySide6.QtWidgets import QApplication
 from spinetoolbox.spine_engine_worker import SpineEngineWorker
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestSpineEngineWorker(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestSpineEngineWorker(TestCaseWithQApplication):
     def test_empty_project_executes(self):
         logger = MagicMock()
         worker = SpineEngineWorker(
diff --git a/tests/widgets/test_AboutWidget.py b/tests/widgets/test_AboutWidget.py
index ebbf1a392..634dcf5ba 100644
--- a/tests/widgets/test_AboutWidget.py
+++ b/tests/widgets/test_AboutWidget.py
@@ -12,33 +12,32 @@
 
 """Unit tests for the AboutWidget class."""
 import unittest
-from PySide6.QtWidgets import QApplication, QWidget
+from unittest import mock
+from PySide6.QtWidgets import QWidget
 from spinetoolbox.widgets.about_widget import AboutWidget
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestAboutWidget(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestAboutWidget(TestCaseWithQApplication):
     def setUp(self):
-        self._original_clip = QApplication.clipboard().text()
+        self._parent_widget = QWidget()
 
     def tearDown(self):
-        QApplication.clipboard().setText(self._original_clip)
+        self._parent_widget.deleteLater()
 
     def test_constructor(self):
-        w = AboutWidget(QWidget())
+        w = AboutWidget(self._parent_widget)
         self.assertIsInstance(w, AboutWidget)
         w.close()
 
     def test_copy_to_clipboard(self):
-        w = AboutWidget(QWidget())
-        w.copy_to_clipboard(True)
-        cb_contents = QApplication.clipboard().text()
-        # Note: clipboard tests may break if other apps (eg. VMs in Virtual Box) reserve the system clipboard
-        self.assertTrue("Python" in cb_contents)
+        w = AboutWidget(self._parent_widget)
+        with mock.patch("spinetoolbox.widgets.about_widget.QApplication.clipboard") as clipboard_getter:
+            mock_clipboard = mock.MagicMock()
+            clipboard_getter.return_value = mock_clipboard
+            w.copy_to_clipboard(True)
+            clipboard_getter.assert_called_once_with()
+            mock_clipboard.setText.assert_called_once()
         w.close()
 
 
diff --git a/tests/widgets/test_AddProjectItemWidget.py b/tests/widgets/test_AddProjectItemWidget.py
index 3d47d71a7..5473cdbae 100644
--- a/tests/widgets/test_AddProjectItemWidget.py
+++ b/tests/widgets/test_AddProjectItemWidget.py
@@ -15,19 +15,14 @@
 import unittest
 from unittest.mock import MagicMock, patch
 from PySide6.QtGui import QColor
-from PySide6.QtWidgets import QApplication, QWidget
+from PySide6.QtWidgets import QWidget
 from spinetoolbox.project_item.project_item import ProjectItem
 from spinetoolbox.project_item.project_item_factory import ProjectItemFactory
 from spinetoolbox.widgets.add_project_item_widget import AddProjectItemWidget
-from tests.mock_helpers import clean_up_toolbox, create_toolboxui_with_project
+from tests.mock_helpers import TestCaseWithQApplication, clean_up_toolbox, create_toolboxui_with_project
 
 
-class TestAddProjectItemWidget(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestAddProjectItemWidget(TestCaseWithQApplication):
     def setUp(self):
         """Set up toolbox."""
         self._temp_dir = TemporaryDirectory()
@@ -52,12 +47,7 @@ def test_find_item_is_used_to_create_prefix(self):
         self.assertEqual(widget.ui.lineEdit_name.text(), "TestItemType")
 
 
-class TestAddProjectItemWidgetWithSpecifications(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestAddProjectItemWidgetWithSpecifications(TestCaseWithQApplication):
     def setUp(self):
         """Set up toolbox."""
         self._temp_dir = TemporaryDirectory()
diff --git a/tests/widgets/test_AddUpSpineOptWizard.py b/tests/widgets/test_AddUpSpineOptWizard.py
index 595579e84..a73bfb19f 100644
--- a/tests/widgets/test_AddUpSpineOptWizard.py
+++ b/tests/widgets/test_AddUpSpineOptWizard.py
@@ -11,20 +11,14 @@
 ######################################################################################################################
 
 """Unit tests for the Add/Update SpineOpt Wizard."""
-import unittest
 from unittest import mock
-from PySide6.QtWidgets import QApplication, QWizard
+from PySide6.QtWidgets import QWizard
 from spinetoolbox.widgets.add_up_spine_opt_wizard import REQUIRED_SPINE_OPT_VERSION, AddUpSpineOptWizard
 from spinetoolbox.widgets.settings_widget import SettingsWidget
-from tests.mock_helpers import MockInstantQProcess, clean_up_toolbox, create_toolboxui
+from tests.mock_helpers import MockInstantQProcess, TestCaseWithQApplication, clean_up_toolbox, create_toolboxui
 
 
-class TestAddUpSpineOptWizard(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestAddUpSpineOptWizard(TestCaseWithQApplication):
     def setUp(self):
         """Set up toolbox."""
         self.toolbox = create_toolboxui()
diff --git a/tests/widgets/test_ArrayTableView.py b/tests/widgets/test_ArrayTableView.py
index eb3ea167e..0ec97ca95 100644
--- a/tests/widgets/test_ArrayTableView.py
+++ b/tests/widgets/test_ArrayTableView.py
@@ -20,15 +20,10 @@
 from spinedb_api import Array
 from spinetoolbox.mvcmodels.array_model import ArrayModel
 from spinetoolbox.widgets.custom_qtableview import ArrayTableView, system_lc_numeric
-from tests.mock_helpers import mock_clipboard_patch
+from tests.mock_helpers import TestCaseWithQApplication, mock_clipboard_patch
 
 
-class TestArrayTableView(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestArrayTableView(TestCaseWithQApplication):
     def setUp(self):
         self._table_view = ArrayTableView()
         self._model = ArrayModel(self._table_view)
diff --git a/tests/widgets/test_CopyPasteTableView.py b/tests/widgets/test_CopyPasteTableView.py
index ccf6e5bf1..390f0b6c9 100644
--- a/tests/widgets/test_CopyPasteTableView.py
+++ b/tests/widgets/test_CopyPasteTableView.py
@@ -13,11 +13,11 @@
 """Unit tests for CopyPasteTableView class."""
 import locale
 import unittest
-from unittest.mock import MagicMock, patch
+from unittest.mock import patch
 from PySide6.QtCore import QAbstractTableModel, QItemSelection, QItemSelectionModel, QModelIndex, Qt
 from PySide6.QtWidgets import QApplication
 from spinetoolbox.widgets.custom_qtableview import CopyPasteTableView
-from tests.mock_helpers import mock_clipboard_patch
+from tests.mock_helpers import TestCaseWithQApplication, mock_clipboard_patch
 
 
 class _MockModel(QAbstractTableModel):
@@ -86,12 +86,7 @@ def str_with_comma_decimal_separator(x):
     return string.replace(".", ",")
 
 
-class TestCopyPasteTableView(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestCopyPasteTableView(TestCaseWithQApplication):
     @patch("spinetoolbox.widgets.custom_qtableview.locale.str", str_with_comma_decimal_separator)
     def test_copy_single_number(self):
         view = CopyPasteTableView()
diff --git a/tests/widgets/test_DatetimeEditor.py b/tests/widgets/test_DatetimeEditor.py
index 3fb9b36f0..bbc000904 100644
--- a/tests/widgets/test_DatetimeEditor.py
+++ b/tests/widgets/test_DatetimeEditor.py
@@ -12,17 +12,12 @@
 
 """Unit tests for the DatetimeEditor widget."""
 import unittest
-from PySide6.QtWidgets import QApplication
 from spinedb_api import DateTime
 from spinetoolbox.widgets.datetime_editor import DatetimeEditor
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestDatetimeEditor(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestDatetimeEditor(TestCaseWithQApplication):
     def test_initial_value(self):
         editor = DatetimeEditor()
         value = editor.value()
diff --git a/tests/widgets/test_DurationEditor.py b/tests/widgets/test_DurationEditor.py
index b7e77e034..f84d1c8a9 100644
--- a/tests/widgets/test_DurationEditor.py
+++ b/tests/widgets/test_DurationEditor.py
@@ -12,17 +12,12 @@
 
 """Unit tests for the DuratonEditor widget."""
 import unittest
-from PySide6.QtWidgets import QApplication
 from spinedb_api import Duration
 from spinetoolbox.widgets.duration_editor import DurationEditor
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestDurationEditor(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestDurationEditor(TestCaseWithQApplication):
     def test_initial_value(self):
         editor = DurationEditor()
         value = editor.value()
diff --git a/tests/widgets/test_IndexedValueTableView.py b/tests/widgets/test_IndexedValueTableView.py
index a0c676847..f49fe00b6 100644
--- a/tests/widgets/test_IndexedValueTableView.py
+++ b/tests/widgets/test_IndexedValueTableView.py
@@ -18,15 +18,10 @@
 from spinedb_api import TimeSeriesVariableResolution
 from spinetoolbox.mvcmodels.time_series_model_variable_resolution import TimeSeriesModelVariableResolution
 from spinetoolbox.widgets.custom_qtableview import IndexedValueTableView, system_lc_numeric
-from tests.mock_helpers import mock_clipboard_patch
+from tests.mock_helpers import TestCaseWithQApplication, mock_clipboard_patch
 
 
-class TestIndexedValueTableView(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestIndexedValueTableView(TestCaseWithQApplication):
     def setUp(self):
         self._table_view = IndexedValueTableView(parent=None)
         series = TimeSeriesVariableResolution(
diff --git a/tests/widgets/test_InstallJuliaWizard.py b/tests/widgets/test_InstallJuliaWizard.py
index 620fb3b43..6e02dc7bc 100644
--- a/tests/widgets/test_InstallJuliaWizard.py
+++ b/tests/widgets/test_InstallJuliaWizard.py
@@ -11,20 +11,14 @@
 ######################################################################################################################
 
 """Unit tests for the KernelEditor widget."""
-import unittest
 from unittest import mock
-from PySide6.QtWidgets import QApplication, QWizard
+from PySide6.QtWidgets import QWizard
 from spinetoolbox.widgets.install_julia_wizard import InstallJuliaWizard
 from spinetoolbox.widgets.settings_widget import SettingsWidget
-from tests.mock_helpers import MockInstantQProcess, clean_up_toolbox, create_toolboxui
+from tests.mock_helpers import MockInstantQProcess, TestCaseWithQApplication, clean_up_toolbox, create_toolboxui
 
 
-class TestInstallJuliaWizard(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestInstallJuliaWizard(TestCaseWithQApplication):
     def setUp(self):
         """Set up toolbox."""
         self.toolbox = create_toolboxui()
diff --git a/tests/widgets/test_JupyterConsoleWidget.py b/tests/widgets/test_JupyterConsoleWidget.py
index 49dbe1835..602ae3114 100644
--- a/tests/widgets/test_JupyterConsoleWidget.py
+++ b/tests/widgets/test_JupyterConsoleWidget.py
@@ -13,7 +13,6 @@
 """Unit tests for the JupyterConsoleWidget."""
 import queue
 from threading import Event
-import unittest
 from unittest import mock
 from unittest.mock import MagicMock
 from jupyter_client.kernelspec import NATIVE_KERNEL_NAME
@@ -25,7 +24,7 @@
 from traitlets import Type
 from spine_engine.execution_managers.kernel_execution_manager import _kernel_manager_factory
 from spinetoolbox.widgets.jupyter_console_widget import JupyterConsoleWidget
-from tests.mock_helpers import clean_up_toolbox, create_toolboxui
+from tests.mock_helpers import TestCaseWithQApplication, clean_up_toolbox, create_toolboxui
 
 
 class CustomQtZMQSocketChannel(QtZMQSocketChannel):
@@ -68,12 +67,7 @@ class CustomQtKernelClient(QtKernelClientMixin, CustomThreadedKernelClient):
     hb_channel_class = Type(QtHBChannel)
 
 
-class TestJupyterConsoleWidget(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestJupyterConsoleWidget(TestCaseWithQApplication):
     def setUp(self):
         """Set up toolbox."""
         self.toolbox = create_toolboxui()
diff --git a/tests/widgets/test_KernelFetcher.py b/tests/widgets/test_KernelFetcher.py
index c1269ae03..32f00f639 100644
--- a/tests/widgets/test_KernelFetcher.py
+++ b/tests/widgets/test_KernelFetcher.py
@@ -11,19 +11,12 @@
 ######################################################################################################################
 
 """Unit tests for the KernelFetcher class."""
-import unittest
-from PySide6.QtWidgets import QApplication
 from spinetoolbox.helpers import SignalWaiter
 from spinetoolbox.kernel_fetcher import KernelFetcher
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestKernelFetcher(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        """Runs once before any tests in this class."""
-        if not QApplication.instance():
-            QApplication()
-
+class TestKernelFetcher(TestCaseWithQApplication):
     def test_fetch_all_kernels(self):
         waiter = SignalWaiter()
         kf = KernelFetcher(conda_path="")  # 1: All kernels
diff --git a/tests/widgets/test_MapEditor.py b/tests/widgets/test_MapEditor.py
index dc7f2dc74..3c6c08d99 100644
--- a/tests/widgets/test_MapEditor.py
+++ b/tests/widgets/test_MapEditor.py
@@ -12,17 +12,12 @@
 
 """Unit tests for the MapEditor widget."""
 import unittest
-from PySide6.QtWidgets import QApplication
 from spinedb_api import Map
 from spinetoolbox.widgets.map_editor import MapEditor
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestDictionaryEditor(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestDictionaryEditor(TestCaseWithQApplication):
     def test_initial_value(self):
         editor = MapEditor()
         value = editor.value()
diff --git a/tests/widgets/test_MapTableView.py b/tests/widgets/test_MapTableView.py
index e58f396c7..3c27470cf 100644
--- a/tests/widgets/test_MapTableView.py
+++ b/tests/widgets/test_MapTableView.py
@@ -20,15 +20,10 @@
 from spinedb_api import Map
 from spinetoolbox.mvcmodels.map_model import MapModel
 from spinetoolbox.widgets.custom_qtableview import MapTableView, system_lc_numeric
-from tests.mock_helpers import mock_clipboard_patch
+from tests.mock_helpers import TestCaseWithQApplication, mock_clipboard_patch
 
 
-class TestMapTableView(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestMapTableView(TestCaseWithQApplication):
     def test_copy_without_selection_returns_false(self):
         table_view = MapTableView()
         model = MapModel(Map([], [], float), table_view)
diff --git a/tests/widgets/test_ParameterValueEditor.py b/tests/widgets/test_ParameterValueEditor.py
index fa9deb3b9..a9723372e 100644
--- a/tests/widgets/test_ParameterValueEditor.py
+++ b/tests/widgets/test_ParameterValueEditor.py
@@ -15,7 +15,6 @@
 import dateutil.parser
 import numpy as np
 from PySide6.QtCore import QAbstractTableModel, QModelIndex, Qt
-from PySide6.QtWidgets import QApplication
 from spinedb_api import (
     DateTime,
     Duration,
@@ -26,6 +25,7 @@
     to_database,
 )
 from spinetoolbox.widgets.parameter_value_editor import ParameterValueEditor
+from tests.mock_helpers import TestCaseWithQApplication
 
 
 class _MockParentModel(QAbstractTableModel):
@@ -60,12 +60,7 @@ def index_name(index):
         return "index_name"
 
 
-class TestParameterValueEditor(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestParameterValueEditor(TestCaseWithQApplication):
     def _check_parent_model_updated_when_closed(self, value):
         model = _MockParentModel()
         model_index = model.index(1, 1)
diff --git a/tests/widgets/test_PlainParameterValueEditor.py b/tests/widgets/test_PlainParameterValueEditor.py
index ddb642b1f..312c39352 100644
--- a/tests/widgets/test_PlainParameterValueEditor.py
+++ b/tests/widgets/test_PlainParameterValueEditor.py
@@ -12,16 +12,11 @@
 
 """Unit tests for the PlainParameterValueEditor widget."""
 import unittest
-from PySide6.QtWidgets import QApplication
 from spinetoolbox.widgets.plain_parameter_value_editor import PlainParameterValueEditor
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestPlainParameterValueEditor(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestPlainParameterValueEditor(TestCaseWithQApplication):
     def test_initial_value(self):
         editor = PlainParameterValueEditor()
         value = editor.value()
diff --git a/tests/widgets/test_TimePatternEditor.py b/tests/widgets/test_TimePatternEditor.py
index d5085e07d..d653b8e8e 100644
--- a/tests/widgets/test_TimePatternEditor.py
+++ b/tests/widgets/test_TimePatternEditor.py
@@ -12,17 +12,12 @@
 
 """Unit tests for the TimePatternEditor widget."""
 import unittest
-from PySide6.QtWidgets import QApplication
 from spinedb_api import TimePattern
 from spinetoolbox.widgets.time_pattern_editor import TimePatternEditor
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestTimePatternEditor(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestTimePatternEditor(TestCaseWithQApplication):
     def test_initial_value(self):
         editor = TimePatternEditor()
         value = editor.value()
diff --git a/tests/widgets/test_TimeSeriesFixedResolutionEditor.py b/tests/widgets/test_TimeSeriesFixedResolutionEditor.py
index df9c828cd..24447bef7 100644
--- a/tests/widgets/test_TimeSeriesFixedResolutionEditor.py
+++ b/tests/widgets/test_TimeSeriesFixedResolutionEditor.py
@@ -12,17 +12,12 @@
 
 """Unit tests for the TimeSeriesFixedResolutionEditor widget."""
 import unittest
-from PySide6.QtWidgets import QApplication
 from spinedb_api import TimeSeriesFixedResolution
 from spinetoolbox.widgets.time_series_fixed_resolution_editor import TimeSeriesFixedResolutionEditor
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestTimeSeriesFixedResolutionEditor(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestTimeSeriesFixedResolutionEditor(TestCaseWithQApplication):
     def test_initial_value(self):
         editor = TimeSeriesFixedResolutionEditor()
         value = editor.value()
diff --git a/tests/widgets/test_TimeSeriesFixedResolutionTableView.py b/tests/widgets/test_TimeSeriesFixedResolutionTableView.py
index d3ebc6132..1a3204a55 100644
--- a/tests/widgets/test_TimeSeriesFixedResolutionTableView.py
+++ b/tests/widgets/test_TimeSeriesFixedResolutionTableView.py
@@ -16,19 +16,13 @@
 import unittest
 from unittest import mock
 from PySide6.QtCore import QItemSelectionModel
-from PySide6.QtWidgets import QApplication
 from spinedb_api import TimeSeriesFixedResolution
 from spinetoolbox.mvcmodels.time_series_model_fixed_resolution import TimeSeriesModelFixedResolution
 from spinetoolbox.widgets.custom_qtableview import TimeSeriesFixedResolutionTableView
-from tests.mock_helpers import mock_clipboard_patch
+from tests.mock_helpers import TestCaseWithQApplication, mock_clipboard_patch
 
 
-class TestTimeSeriesFixedResolutionTableView(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestTimeSeriesFixedResolutionTableView(TestCaseWithQApplication):
     def setUp(self):
         self._table_view = TimeSeriesFixedResolutionTableView(parent=None)
         series = TimeSeriesFixedResolution("2019-08-08T15:00", "1h", [1.1, 2.2, 3.3, 4.4], False, False)
diff --git a/tests/widgets/test_TimeSeriesVariableResolutionEditor.py b/tests/widgets/test_TimeSeriesVariableResolutionEditor.py
index 5b0a633af..b31a694a2 100644
--- a/tests/widgets/test_TimeSeriesVariableResolutionEditor.py
+++ b/tests/widgets/test_TimeSeriesVariableResolutionEditor.py
@@ -15,14 +15,10 @@
 from PySide6.QtWidgets import QApplication
 from spinedb_api import TimeSeriesVariableResolution
 from spinetoolbox.widgets.time_series_variable_resolution_editor import TimeSeriesVariableResolutionEditor
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestTimeSeriesVariableResolutionEditor(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestTimeSeriesVariableResolutionEditor(TestCaseWithQApplication):
     def test_initial_value(self):
         editor = TimeSeriesVariableResolutionEditor()
         value = editor.value()
diff --git a/tests/widgets/test_custom_combobox.py b/tests/widgets/test_custom_combobox.py
index 8dd83b90d..a3dd29b49 100644
--- a/tests/widgets/test_custom_combobox.py
+++ b/tests/widgets/test_custom_combobox.py
@@ -14,16 +14,12 @@
 OpenProjectDialogComboBox is tested in test_open_project_dialog module."""
 import unittest
 from PySide6.QtGui import QPaintEvent
-from PySide6.QtWidgets import QApplication, QWidget
+from PySide6.QtWidgets import QWidget
 from spinetoolbox.widgets.custom_combobox import CustomQComboBox, ElidedCombobox
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestCustomComboBoxes(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestCustomComboBoxes(TestCaseWithQApplication):
     def test_custom_combobox(self):
         parent = QWidget()
         cb = CustomQComboBox(parent)
diff --git a/tests/widgets/test_custom_qgraphicsscene.py b/tests/widgets/test_custom_qgraphicsscene.py
index b6e3aab68..7ef7c644b 100644
--- a/tests/widgets/test_custom_qgraphicsscene.py
+++ b/tests/widgets/test_custom_qgraphicsscene.py
@@ -13,17 +13,12 @@
 """Unit tests for custom graphics scenes."""
 from tempfile import TemporaryDirectory
 import unittest
-from PySide6.QtWidgets import QApplication, QGraphicsRectItem
+from PySide6.QtWidgets import QGraphicsRectItem
 from spinetoolbox.widgets.custom_qgraphicsscene import CustomGraphicsScene
-from tests.mock_helpers import clean_up_toolbox, create_toolboxui_with_project
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestCustomGraphicsScene(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestCustomGraphicsScene(TestCaseWithQApplication):
     def test_center_items(self):
         scene = CustomGraphicsScene()
         rect = scene.addRect(-120.0, 66.0, 1.0, 1.0)
@@ -33,20 +28,5 @@ def test_center_items(self):
         scene.deleteLater()
 
 
-class TestDesignGraphicsScene(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
-    def setUp(self):
-        self._temp_dir = TemporaryDirectory()
-        self._toolbox = create_toolboxui_with_project(self._temp_dir.name)
-
-    def tearDown(self):
-        clean_up_toolbox(self._toolbox)
-        self._temp_dir.cleanup()
-
-
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/widgets/test_custom_qlineedits.py b/tests/widgets/test_custom_qlineedits.py
index 3ecc09dad..714f0c92e 100644
--- a/tests/widgets/test_custom_qlineedits.py
+++ b/tests/widgets/test_custom_qlineedits.py
@@ -11,17 +11,12 @@
 ######################################################################################################################
 
 """Unit tests for the classes in ``custom_qlineedits`` module."""
-import unittest
-from PySide6.QtWidgets import QApplication, QWidget
+from PySide6.QtWidgets import QWidget
 from spinetoolbox.widgets.custom_qlineedits import PropertyQLineEdit
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestPropertyQLineEdit(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestPropertyQLineEdit(TestCaseWithQApplication):
     def test_property_qlineedit(self):
         parent = QWidget()
         le = PropertyQLineEdit(parent)
diff --git a/tests/widgets/test_custom_qtextbrowser.py b/tests/widgets/test_custom_qtextbrowser.py
index b42dc2d59..e2cd65ab1 100644
--- a/tests/widgets/test_custom_qtextbrowser.py
+++ b/tests/widgets/test_custom_qtextbrowser.py
@@ -11,30 +11,14 @@
 ######################################################################################################################
 
 """Unit tests for the custom QTextBrowser."""
-import logging
-import sys
 import unittest
-from PySide6.QtWidgets import QApplication
 from spinetoolbox.widgets.custom_qtextbrowser import CustomQTextBrowser
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestCustomQTextBrowser(unittest.TestCase):
+class TestCustomQTextBrowser(TestCaseWithQApplication):
     """Tests the CustomQTextBrowser class."""
 
-    @classmethod
-    def setUpClass(cls):
-        """Overridden method. Runs once before all tests in this class."""
-        try:
-            cls.app = QApplication().processEvents()
-        except RuntimeError:
-            pass
-        logging.basicConfig(
-            stream=sys.stderr,
-            level=logging.DEBUG,
-            format="%(asctime)s %(levelname)s: %(message)s",
-            datefmt="%Y-%m-%d %H:%M:%S",
-        )
-
     def test_default_max_blocks(self):
         browser = CustomQTextBrowser(None)
         self.assertEqual(browser.document().maximumBlockCount(), 2000)
diff --git a/tests/widgets/test_custom_qwidgets.py b/tests/widgets/test_custom_qwidgets.py
index 7e9320fcd..46300aa55 100644
--- a/tests/widgets/test_custom_qwidgets.py
+++ b/tests/widgets/test_custom_qwidgets.py
@@ -14,17 +14,13 @@
 from contextlib import contextmanager
 import unittest
 from PySide6.QtCore import Qt
-from PySide6.QtWidgets import QApplication, QDialogButtonBox
+from PySide6.QtWidgets import QDialogButtonBox
 from spinetoolbox.mvcmodels.filter_checkbox_list_model import DataToValueFilterCheckboxListModel
 from spinetoolbox.widgets.custom_qwidgets import FilterWidget, SelectDatabaseItemsDialog
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestFilterWidget(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestFilterWidget(TestCaseWithQApplication):
     def setUp(self):
         self._widget = FilterWidget(None, DataToValueFilterCheckboxListModel, None, str)
         self._widget.set_filter_list(["ei", "bii", "cii"])
@@ -93,12 +89,7 @@ def test_save_state(self):
         self.assertTrue(self._widget._filter_empty_state)
 
 
-class TestSelectDatabaseItemsDialog(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestSelectDatabaseItemsDialog(TestCaseWithQApplication):
     def test_ok_button_text(self):
         text = "Do it!"
         with _select_database_items_dialog(None, text) as dialog:
diff --git a/tests/widgets/test_indexed_value_table_context_menu.py b/tests/widgets/test_indexed_value_table_context_menu.py
index 3ffd974af..18c129dff 100644
--- a/tests/widgets/test_indexed_value_table_context_menu.py
+++ b/tests/widgets/test_indexed_value_table_context_menu.py
@@ -25,14 +25,10 @@
 from spinetoolbox.widgets.time_pattern_editor import TimePatternEditor
 from spinetoolbox.widgets.time_series_fixed_resolution_editor import TimeSeriesFixedResolutionEditor
 from spinetoolbox.widgets.time_series_variable_resolution_editor import TimeSeriesVariableResolutionEditor
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestArrayTableContextMenu(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestArrayTableContextMenu(TestCaseWithQApplication):
     def test_insert_row_after(self):
         editor = ArrayEditor()
         editor.set_value(Array([-1.0]))
@@ -95,12 +91,7 @@ def test_show_value_editor(self):
         editor.deleteLater()
 
 
-class TestIndexedValueTableContextMenu(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestIndexedValueTableContextMenu(TestCaseWithQApplication):
     def test_insert_row_after_with_time_pattern_editor(self):
         editor = TimePatternEditor()
         editor.set_value(TimePattern(["D1-2"], [-1.1]))
@@ -260,12 +251,7 @@ def test_remove_rows_with_time_series_variable_resolution_editor(self):
         editor.deleteLater()
 
 
-class TestMapTableContextMenu(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestMapTableContextMenu(TestCaseWithQApplication):
     def test_insert_column_after(self):
         editor = MapEditor()
         editor.set_value(Map(["a"], [-1.0]))
diff --git a/tests/widgets/test_jump_properties_widget.py b/tests/widgets/test_jump_properties_widget.py
index 590063374..42e170e5d 100644
--- a/tests/widgets/test_jump_properties_widget.py
+++ b/tests/widgets/test_jump_properties_widget.py
@@ -19,16 +19,10 @@
 from spinetoolbox.link import JumpLink
 from spinetoolbox.project_item.logging_connection import LoggingConnection, LoggingJump
 from spinetoolbox.widgets.jump_properties_widget import JumpPropertiesWidget
-from tests.mock_helpers import clean_up_toolbox, create_toolboxui_with_project
+from tests.mock_helpers import TestCaseWithQApplication, clean_up_toolbox, create_toolboxui_with_project
 
 
-class TestJumpPropertiesWidget(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        """Runs once before any tests in this class."""
-        if not QApplication.instance():
-            QApplication()
-
+class TestJumpPropertiesWidget(TestCaseWithQApplication):
     def setUp(self):
         self._temp_dir = TemporaryDirectory()
         self._toolbox = create_toolboxui_with_project(self._temp_dir.name)
diff --git a/tests/widgets/test_kernel_editor.py b/tests/widgets/test_kernel_editor.py
index bf0e8c146..ab53730e1 100644
--- a/tests/widgets/test_kernel_editor.py
+++ b/tests/widgets/test_kernel_editor.py
@@ -16,12 +16,12 @@
 import subprocess
 import sys
 from tempfile import TemporaryDirectory
-import unittest
 from unittest.mock import MagicMock, patch
 import venv
 from PySide6.QtWidgets import QApplication, QMessageBox, QWidget
 from spine_engine.utils.helpers import resolve_default_julia_executable
 from spinetoolbox.widgets.kernel_editor import KernelEditorBase
+from tests.mock_helpers import TestCaseWithQApplication
 
 
 class MockSettingsWidget(QWidget):
@@ -30,12 +30,7 @@ def __init__(self):
         self.qsettings = MagicMock()
 
 
-class TestKernelEditorBase(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestKernelEditorBase(TestCaseWithQApplication):
     def setUp(self):
         self._settings_widget = MockSettingsWidget()
 
diff --git a/tests/widgets/test_notification.py b/tests/widgets/test_notification.py
index 4a0cac0f5..6cc086a15 100644
--- a/tests/widgets/test_notification.py
+++ b/tests/widgets/test_notification.py
@@ -17,15 +17,11 @@
 from PySide6.QtGui import QUndoCommand, QUndoStack
 from PySide6.QtWidgets import QApplication, QWidget
 from spinetoolbox.widgets.notification import ChangeNotifier, Notification
+from tests.mock_helpers import TestCaseWithQApplication
 
 
 @unittest.skip("Test hangs on Windows when running all tests.")
-class TestChangeNotifier(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestChangeNotifier(TestCaseWithQApplication):
     def setUp(self):
         self._parent = QWidget()
         self._undo_stack = QUndoStack(self._parent)
diff --git a/tests/widgets/test_open_project_dialog.py b/tests/widgets/test_open_project_dialog.py
index 8a94ebdcf..277a06110 100644
--- a/tests/widgets/test_open_project_dialog.py
+++ b/tests/widgets/test_open_project_dialog.py
@@ -12,19 +12,14 @@
 
 """Unit tests for the ``open_project_dialog`` module."""
 from tempfile import TemporaryDirectory
-import unittest
 from unittest import mock
 from PySide6.QtCore import QPoint
-from PySide6.QtWidgets import QApplication, QWidget
+from PySide6.QtWidgets import QWidget
 from spinetoolbox.widgets.open_project_dialog import OpenProjectDialog
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestOpenProjectDialog(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestOpenProjectDialog(TestCaseWithQApplication):
     def test_open_project_dialog(self):
         widget = QWidget()
         opw = OpenProjectDialog(DummyToolbox(widget))
diff --git a/tests/widgets/test_plot_widget.py b/tests/widgets/test_plot_widget.py
index 9c7b4dc7a..4d4a54e00 100644
--- a/tests/widgets/test_plot_widget.py
+++ b/tests/widgets/test_plot_widget.py
@@ -15,19 +15,14 @@
 import unittest
 from unittest import mock
 from matplotlib.gridspec import GridSpec
-from PySide6.QtWidgets import QApplication
 from spinedb_api.parameter_value import TimeSeriesFixedResolution
 from spinetoolbox.plotting import TreeNode, convert_indexed_value_to_tree, plot_data, turn_node_to_xy_data
 from spinetoolbox.widgets.plot_canvas import LegendPosition
 from spinetoolbox.widgets.plot_widget import PlotWidget, _PlotDataWidget
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestPlotWidget(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestPlotWidget(TestCaseWithQApplication):
     def setUp(self):
         self._plot_widget = PlotWidget()
 
diff --git a/tests/widgets/test_plugin_manager_widgets.py b/tests/widgets/test_plugin_manager_widgets.py
index 953af925a..9d8989aec 100644
--- a/tests/widgets/test_plugin_manager_widgets.py
+++ b/tests/widgets/test_plugin_manager_widgets.py
@@ -11,17 +11,12 @@
 ######################################################################################################################
 
 """Unit tests for the classes in ``plugin_manager_widgets`` module."""
-import unittest
-from PySide6.QtWidgets import QApplication, QWidget
+from PySide6.QtWidgets import QWidget
 from spinetoolbox.widgets.plugin_manager_widgets import InstallPluginDialog, ManagePluginsDialog
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestPluginManagerWidgets(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestPluginManagerWidgets(TestCaseWithQApplication):
     def test_install_plugins_dialog(self):
         parent = QWidget()
         d = InstallPluginDialog(parent)
diff --git a/tests/widgets/test_select_database_items.py b/tests/widgets/test_select_database_items.py
index b4763de70..24446b6dc 100644
--- a/tests/widgets/test_select_database_items.py
+++ b/tests/widgets/test_select_database_items.py
@@ -12,18 +12,13 @@
 """Unit tests for ``select_database_items`` module."""
 from contextlib import contextmanager
 import unittest
-from PySide6.QtWidgets import QApplication
 from spinedb_api import DatabaseMapping
 from spinedb_api.mapped_items import item_factory
 from spinetoolbox.widgets.select_database_items import SelectDatabaseItems
+from tests.mock_helpers import TestCaseWithQApplication
 
 
-class TestSelectDatabaseItems(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestSelectDatabaseItems(TestCaseWithQApplication):
     ITEMS = tuple(type_ for type_ in DatabaseMapping.item_types() if not item_factory(type_).is_protected)
 
     def test_restore_previously_checked_states(self):
diff --git a/tests/widgets/test_settings_widget.py b/tests/widgets/test_settings_widget.py
index c5066f7f7..91fc0add2 100644
--- a/tests/widgets/test_settings_widget.py
+++ b/tests/widgets/test_settings_widget.py
@@ -13,17 +13,11 @@
 import os
 import unittest
 from PySide6.QtCore import QSettings
-from PySide6.QtWidgets import QApplication
 from spinetoolbox.widgets.settings_widget import SettingsWidget
-from tests.mock_helpers import create_toolboxui
+from tests.mock_helpers import TestCaseWithQApplication, create_toolboxui
 
 
-class TestSettingsWidget(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        if not QApplication.instance():
-            QApplication()
-
+class TestSettingsWidget(TestCaseWithQApplication):
     def setUp(self):
         self._settings = QSettings("SpineProject", "Spine Toolbox tests")
         self._toolbox = create_toolboxui()

From b02b0850254790d7d6370af043f6ec5dbe224fe4 Mon Sep 17 00:00:00 2001
From: Antti Soininen <ajsanttij@Ubuntu.myguest.virtualbox.org>
Date: Mon, 19 Aug 2024 15:13:47 +0300
Subject: [PATCH 3/3] Fix unit test

Re #1204
---
 tests/widgets/test_TimeSeriesFixedResolutionTableView.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/widgets/test_TimeSeriesFixedResolutionTableView.py b/tests/widgets/test_TimeSeriesFixedResolutionTableView.py
index 1a3204a55..77627d249 100644
--- a/tests/widgets/test_TimeSeriesFixedResolutionTableView.py
+++ b/tests/widgets/test_TimeSeriesFixedResolutionTableView.py
@@ -40,7 +40,7 @@ def test_copy_single_cell(self):
             mock_clipboard = mock.MagicMock()
             clipboard_getter.return_value = mock_clipboard
             self._table_view.copy()
-            mock_clipboard.setText.assert_called_once_with("2019-08-08T15:00:00" + os.linesep)
+            mock_clipboard.setText.assert_called_once_with("2019-08-08T15:00:00\r\n")
 
     def test_paste_single_value(self):
         selection_model = self._table_view.selectionModel()