aquarium_control/thermal/

heating.rs

/* Copyright 2024 Uwe Martin

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

use log::error;

#[cfg(not(test))]
use log::warn;

use spin_sleep::SpinSleeper;
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};

#[cfg(all(target_os = "linux", not(test)))]
use nix::unistd::gettid;

use crate::database::sql_interface_error::SqlInterfaceError;
use crate::database::sql_interface_heating_stats::{HeatingStatsEntry, SqlInterfaceHeatingStats};
use crate::database::thermal_set_value_updater_trait::ThermalSetValueUpdaterTrait;
use crate::sensors::sensor_manager::SensorManagerSignals;
use crate::sensors::tank_level_switch::TankLevelSwitchSignals;
use crate::thermal::heating_channels::HeatingChannels;
use crate::thermal::heating_config::HeatingConfig;
use crate::utilities::acknowledge_signal_handler::AcknowledgeSignalHandlerTrait;
use crate::utilities::channel_content::{ActuatorState, AquariumDevice, InternalCommand};
use crate::utilities::check_mutex_access_duration::CheckMutexAccessDurationTrait;
use crate::utilities::common::check_if_mutex_is_blocked;
use crate::utilities::database_ping_trait::DatabasePingTrait;
use crate::utilities::logger::log_error_chain;
use crate::utilities::proc_ext_req::ProcessExternalRequestTrait;
use crate::utilities::sawtooth_profile::SawToothProfile;
use crate::utilities::wait_for_termination::WaitForTerminationTrait;
use crate::{manage_cycle_time_thermal, perform_schedule_check, update_thermal_set_values};
#[cfg(not(test))]
use log::info;

const CYCLE_TIME_HEATING_MILLIS: u64 = 500;

const TIME_INCREMENT_HEATING_SECS: f32 = CYCLE_TIME_HEATING_MILLIS as f32 / 1000.0;

/// allow max. 10 milliseconds for mutex to be blocked by any other thread
const MAX_MUTEX_ACCESS_DURATION_MILLIS: u64 = 10;

/// Trait for the execution of data transfer to SQL database after midnight has arrived.
/// This trait allows running the main control with a mock implementation for testing.
pub trait HeatingStatsDataTransferTrait {
    /// Transfers a completed daily heating statistics entry to the database.
    ///
    /// This function is called once per day, typically just after midnight, to persist
    /// the aggregated heating statistics (energy usage, average temperatures) for the
    /// previous day.
    ///
    /// # Arguments
    /// * `data` - The `HeatingStatsEntry` struct containing the statistics for the day.
    /// * `sql_interface_heating` - A mutable reference to the `SqlInterfaceHeatingStats` instance,
    ///   used for database interaction.
    ///
    /// # Returns
    /// An empty `Result` (`Ok(())`) on a successful database transaction.
    ///
    /// # Errors
    /// Returns an `SqlInterfaceError` if the database operation fails (e.g., connection
    /// issue, SQL error during insertion/update).
    fn transfer_heating_stats(
        &mut self,
        data: HeatingStatsEntry,
        sql_interface_heating: &mut SqlInterfaceHeatingStats,
    ) -> Result<(), SqlInterfaceError>;
}

/// Sends a command to the relay manager to actuate the heater and waits for a response.
///
/// This private helper function encapsulates the logic for sending a command
/// (either `SwitchOn` or `SwitchOff`) to the relay manager. It handles channel
/// communication, error logging, and updates the shared actuation mutex.
///
/// # Arguments
/// * `command` - The `InternalCommand` to send (`SwitchOn` or `SwitchOff`).
/// * `mutex_device_scheduler_heating` - A reference to the shared actuation mutex.
/// * `mutex_blocked_during_actuation` - A mutable flag to track if the actuation mutex was blocked.
/// * `heating_channels` - A mutable reference to the struct containing the channels.
fn actuate_heater(
    command: InternalCommand,
    mutex_device_scheduler_heating: &Arc<Mutex<i32>>,
    mutex_blocked_during_actuation: &mut bool,
    heating_channels: &mut HeatingChannels,
) {
    // reduce the probability of wrong warning
    *mutex_blocked_during_actuation |= check_if_mutex_is_blocked(mutex_device_scheduler_heating);

    // avoid electrical overloads through parallel device actuation
    let mut mutex_data = mutex_device_scheduler_heating.lock().unwrap();

    // Use map_err for more concise error handling on the send operation.
    if let Err(e) = heating_channels.send_to_relay_manager(command.clone()) {
        let error_message = format!("Channel communication to relay manager for {command} failed.");
        log_error_chain(module_path!(), &error_message, e);
    } else {
        // If send was successful, wait for the response.
        if let Err(e) = heating_channels.receive_from_relay_manager() {
            let error_message =
                format!("Receiving answer from relay manager for {command} failed.");
            log_error_chain(module_path!(), &error_message, e);
        }
    }
    *mutex_data = mutex_data.saturating_add(1);
}

/// Commands the relay manager to switch on the heater.
///
/// This function is a specific wrapper around `actuate_heater` that sends the `SwitchOn` command.
///
/// # Arguments
/// * `mutex_device_scheduler_heating` - A reference to the shared actuation mutex.
/// * `mutex_blocked_during_actuation` - A mutable flag to track if the actuation mutex was blocked.
/// * `heating_channels` - A mutable reference to the struct containing the channels.
fn switch_on_heater(
    mutex_device_scheduler_heating: &Arc<Mutex<i32>>,
    mutex_blocked_during_actuation: &mut bool,
    heating_channels: &mut HeatingChannels,
) {
    actuate_heater(
        InternalCommand::SwitchOn(AquariumDevice::Heater),
        mutex_device_scheduler_heating,
        mutex_blocked_during_actuation,
        heating_channels,
    );
}

/// Commands the relay manager to switch off the heater.
///
/// This function is a specific wrapper around `actuate_heater` that sends the `SwitchOff` command.
///
/// # Arguments
/// * `mutex_device_scheduler_heating` - A reference to the shared actuation mutex.
/// * `mutex_blocked_during_actuation` - A mutable flag to track if the actuation mutex was blocked.
/// * `heating_channels` - A mutable reference to the struct containing the channels.
fn switch_off_heater(
    mutex_device_scheduler_heating: &Arc<Mutex<i32>>,
    mutex_blocked_during_actuation: &mut bool,
    heating_channels: &mut HeatingChannels,
) {
    actuate_heater(
        InternalCommand::SwitchOff(AquariumDevice::Heater),
        mutex_device_scheduler_heating,
        mutex_blocked_during_actuation,
        heating_channels,
    );
}

/// Contains `Arc<Mutex>`-wrapped shared data points accessed by the heating control.
///
/// These mutexes provide thread-safe access to various sensor readings and
/// device states that are used by the heating control.
pub struct HeatingMutexes {
    /// Mutex for signals from sensor manager
    pub(crate) mutex_sensor_manager_signals: Arc<Mutex<SensorManagerSignals>>,

    /// Mutex for the tank level switch signals
    pub(crate) mutex_tank_level_switch_signals: Arc<Mutex<TankLevelSwitchSignals>>,

    /// Mutex for the heater status
    pub(crate) mutex_heating_status: Arc<Mutex<bool>>,
}

#[cfg_attr(doc, aquamarine::aquamarine)]
/// Contains the configuration and the implementation for the heating control.
/// Thread communication is as follows:
/// ```mermaid
/// graph LR
///     ambient[Ambient] -.-> heating
///     tank_level_switch[Tank Level Switch] -.-> heating
///     heating --> relay_manager[Relay Manager]
///     relay_manager --> heating
///     heating --> signal_handler[Signal Handler]
///     signal_handler --> heating
///     heating --> data_logger[Data Logger]
///     data_logger --> heating
///     heating --> schedule_check[Schedule Check]
///     schedule_check --> heating
///     messaging[Messaging] --> heating
/// ```
pub struct Heating {
    /// configuration data for heating control
    config: HeatingConfig,

    /// inhibition flag to avoid flooding the log file with repeated messages about failure to receive information from schedule check
    lock_error_channel_receive_schedule_check: bool,

    /// inhibition flag to avoid flooding the log file with repeated messages about failure to send information to schedule check
    lock_error_channel_send_schedule_check: bool,

    /// recording when the last database ping happened
    pub last_ping_instant: Instant,

    /// database ping interval
    pub database_ping_interval: Duration,

    /// inhibition flag to avoid flooding the log file with repeated messages about excessive access time to mutex
    pub lock_warn_max_mutex_access_duration: bool,

    /// Flag to avoid flooding the log with warnings when the heating set values could not be read from the database
    lock_error_heating_set_value_read_failure: bool,

    // for testing purposes: record when mutex access time is exceeded without resetting it
    #[cfg(test)]
    pub mutex_access_duration_exceeded: bool,

    /// Inhibition flag to avoid flooding the log with warning about having received inapplicable command from the signal handler
    pub lock_warn_inapplicable_command_signal_handler: bool,

    /// Inhibition flag to avoid flooding the log with errors about the channel communication not working
    pub lock_error_channel_receive_termination: bool,

    /// Maximum permissible access duration for Mutex
    pub max_mutex_access_duration: Duration,
}

impl ProcessExternalRequestTrait for Heating {}

impl Heating {
    /// Creates a new `Heating` control instance.
    ///
    /// This constructor initializes the heating control module with its specific
    /// configuration and a dedicated SQL interface. It also sets up all internal
    /// "lock" flags to `false` by default; these flags are crucial during operation
    /// to prevent log files from being flooded with repeated error or warning messages
    /// stemming from channel communication or invalid requests.
    ///
    /// # Arguments
    /// * `config` - **Configuration data** for the heating control, loaded from a TOML file.
    ///   This includes parameters such as target temperatures, safety features, and
    ///   behavioral strategies.
    /// * `sql_interface_heating` - The **specific SQL interface** for heating-related database operations.
    ///   This instance is moved into the `Heating` struct.
    /// * `database_ping_interval` - A `Duration` instance, providing the interval to ping the database.
    ///
    /// # Returns
    /// A new **`Heating` struct**, ready to manage the aquarium's heating system.
    pub fn new(config: HeatingConfig, database_ping_interval: Duration) -> Heating {
        Self {
            config,
            lock_error_channel_send_schedule_check: false,
            lock_error_channel_receive_schedule_check: false,
            last_ping_instant: Instant::now(),
            database_ping_interval,
            lock_warn_max_mutex_access_duration: false,
            lock_error_heating_set_value_read_failure: false,
            #[cfg(test)]
            mutex_access_duration_exceeded: false,
            lock_warn_inapplicable_command_signal_handler: false,
            lock_error_channel_receive_termination: false,
            max_mutex_access_duration: Duration::from_millis(MAX_MUTEX_ACCESS_DURATION_MILLIS),
        }
    }

    /// Calculates a **normalized control deviation** based on the measured temperature and configured heating thresholds.
    ///
    /// This private helper function determines how far the `measured_value` deviates
    /// from the `switch_on_temperature` relative to the total temperature control range
    /// (`switch_on_temperature` to `switch_off_temperature`). The result is a float
    /// between `0.0` and `1.0`. A value of `0.0` means the temperature is at or below
    /// `switch_on_temperature` (full heating needed), and `1.0` means it's at or above
    /// `switch_off_temperature` (no heating needed).
    ///
    /// # Arguments
    /// * `measured_value` - The current measured temperature (`f32`).
    ///
    /// # Returns
    /// An `f32` representing the normalized control deviation, ranging from `0.0` to `1.0`.
    /// Returns `0.0` if `switch_off_temperature` is not greater than `switch_on_temperature`
    /// (i.e., `target_value_delta` is not positive), indicating an invalid configuration.
    fn calc_normalized_control_deviation(&self, measured_value: f32) -> f32 {
        let target_value_delta: f32 =
            self.config.switch_off_temperature - self.config.switch_on_temperature;
        let measured_value_delta: f32 = measured_value - self.config.switch_on_temperature;
        if target_value_delta > 0.0 {
            measured_value_delta / target_value_delta
        } else {
            0.0 // default value when target values are not properly set up.
        }
    }

    /// Retrieves the duration in seconds until the next midnight from the database.
    ///
    /// This private helper function acts as a robust wrapper around the SQL interface's
    /// `get_duration_until_midnight` method.
    ///
    /// # Returns
    /// An `i64` representing the number of seconds remaining until the next midnight.
    ///
    /// # Errors
    /// This function handles errors internally. If the database call fails, it logs
    /// the error and returns a default fallback value of 24 hours (86.400 seconds).
    /// This prevents a crash and suspends statistics recording until the next day.
    fn get_duration_until_midnight(
        &mut self,
        sql_interface_heating: &mut SqlInterfaceHeatingStats,
    ) -> i64 {
        sql_interface_heating
            .get_duration_until_midnight()
            .unwrap_or_else(|e| {
                log_error_chain(module_path!(), "Could not get duration until midnight.", e);
                24 * 3600 // default value for time in seconds until midnight
            })
    }

    /// Executes the **main control loop for the heating module**.
    ///
    /// This function runs continuously, managing the aquarium's heating system until a termination
    /// signal is received. It adjusts heater operation based on **water temperature** and
    /// **tank level switch signals** adhering to the limitations imposed by a **schedule**.
    /// The **ambient temperature** signal is considered for logging daily statistical data.
    /// It also processes external `Start`/`Stop` commands, applies a
    /// **sawtooth profile for proportional control**, and **logs daily heating statistics**.
    ///
    /// **Key Operations:**
    /// - **Sensor Data Acquisition**: Reads current water temperature, ambient temperature, and tank level switch states from shared mutexes.
    /// - **Safety Interlocks**: Implements a critical safety feature to turn off the heater if the water level is too low for a configured duration, preventing damage.
    /// - **Schedule & External Control**: Checks with the `ScheduleCheck` module and responds to `Start`/`Stop` commands to inhibit or enable heating.
    /// - **Proportional Control**: When within the active temperature range, uses a `SawToothProfile` to achieve a "PWM-like" heating effect.
    /// - **Energy Logging**: Periodically updates and transfers daily heating statistics (energy consumption, average temperatures) to the SQL database.
    /// - **Cycle Management**: Maintains a fixed cycle time, sleeping as necessary, and warning if execution duration exceeds the cycle limit.
    /// - **Graceful Shutdown**: Responds to `Quit` and `Terminate` commands from the signal handler, ensuring a safe shutdown of the heater and final data logging.
    ///
    /// # Arguments
    /// * `mutex_device_scheduler_heating` - A clone of the `Arc<Mutex<i32>>` used to coordinate device
    ///   actuation across the application, preventing conflicts and tracking activity counts.
    /// * `heating_channels` - A struct containing all sender and receiver channels for communication
    ///   with modules like `RelayManager`, `SignalHandler`, `DataLogger`, `ScheduleCheck`, and `Messaging`.
    /// * `heating_stats_transfer` - A mutable reference to an object implementing `HeatingStatsDataTransferTrait`,
    ///   responsible for persisting daily heating statistics to the database.
    /// * `heating_stats_transfer` - A mutable reference to an object implementing `HeatingSetValueUpdaterTrait`,
    ///   responsible for updating the set values dynamically by communicating with SQL database.
    /// * `heating_mutexes` - Struct containing the mutexes to access data from different threads.
    ///
    /// # Returns
    /// This function does not return a value in the traditional sense, as it is designed
    /// to loop indefinitely. It will only break out of its loop and terminate when a `Quit`
    /// command is received from the signal handler, after which it performs final cleanup
    /// (switching off the heater, logging final stats) and confirms shutdown.
    pub fn execute(
        &mut self,
        mutex_device_scheduler_heating: Arc<Mutex<i32>>,
        heating_channels: &mut HeatingChannels,
        heating_stats_transfer: &mut impl HeatingStatsDataTransferTrait,
        heating_set_val_updater: &mut impl ThermalSetValueUpdaterTrait,
        heating_mutexes: HeatingMutexes,
        mut sql_interface_heating: SqlInterfaceHeatingStats,
    ) {
        #[cfg(all(target_os = "linux", not(test)))]
        info!(target: module_path!(), "Thread started with TID: {}", gettid());

        let _refill_error = false;
        let spin_sleeper = SpinSleeper::default();
        let sleep_duration_hundred_millis = Duration::from_millis(100);
        let mut saw_tooth_profile = SawToothProfile::new(&self.config.saw_tooth_profile_config);
        let mut measured_water_temperature = 0.0;
        let mut measurement_error: bool;
        let mut measured_ambient_temperature = 0.0;
        let mut measured_tank_level_switch_position = true;
        let mut measured_tank_level_switch_invalid = false;
        let mut loop_counter = 0;
        let mut heater_state: ActuatorState = ActuatorState::Undefined;
        let mut schedule_check_result: bool;
        let mut duration_until_midnight =
            self.get_duration_until_midnight(&mut sql_interface_heating);
        let mut tank_level_low_counter = 0;
        let mut energy_increment: f64 = 0.0;
        let mut heating_inhibited: bool = false; // state of heating control determined by if the start/stop command has been received
        let mut lock_warn_cycle_time_exceeded: bool = false;
        let mut actuation_mutex_was_blocked_during_actuation: bool = false;
        let cycle_time_duration = Duration::from_millis(CYCLE_TIME_HEATING_MILLIS);
        let midnight_check_interval = Duration::from_secs(1);
        let mut instant_midnight_check = Instant::now() - midnight_check_interval;

        let mut heating_stats_opt = match sql_interface_heating
            .get_single_heating_stats_from_database()
        {
            Ok(c) => Some(c),
            Err(_) => {
                #[cfg(test)]
                println!(
                    "{}: could not get existing heating stats entry for today from database - creating new one for today",
                    module_path!()
                );

                Some(HeatingStatsEntry::new(&mut sql_interface_heating.conn))
            }
        };

        let mut start_time = Instant::now();
        loop {
            let (
                quit_command_received,  // the request to end the application has been received
                start_command_received, // the request to (re-)start heating has been received
                stop_command_received, // the request to (temporarily) stop heating has been received
            ) = self.process_external_request(
                &mut heating_channels.rx_heating_from_signal_handler,
                heating_channels.rx_heating_from_messaging_opt.as_mut(),
            );
            if quit_command_received {
                break;
            }
            if stop_command_received {
                #[cfg(not(test))]
                info!(
                    target: module_path!(),
                    "received Stop command. inhibiting heating."
                );

                heating_inhibited = true;
            }
            if start_command_received {
                #[cfg(not(test))]
                info!(
                    target: module_path!(),
                    "received Start command. restarting heating."
                );

                heating_inhibited = false;
            }

            if self.config.active {
                // read signals from sensor manager
                {
                    match heating_mutexes.mutex_sensor_manager_signals.lock() {
                        Ok(c) => {
                            measured_water_temperature = c.water_temperature;
                            measured_ambient_temperature = c.ambient_temperature;
                            measurement_error = false;
                        }
                        Err(_) => {
                            measurement_error = true;
                        }
                    };
                }

                // read tank level switch position and invalid bit from mutex
                {
                    (
                        measured_tank_level_switch_position,
                        measured_tank_level_switch_invalid,
                    ) = match heating_mutexes.mutex_tank_level_switch_signals.lock() {
                        Ok(c) => (c.tank_level_switch_position, c.tank_level_switch_invalid),
                        Err(_) => {
                            (
                                measured_tank_level_switch_position,
                                measured_tank_level_switch_invalid,
                            ) // use previous values
                        }
                    }
                }

                // check if the tank-level switch hints to potentially low water level
                if (measured_tank_level_switch_invalid) || (!measured_tank_level_switch_position) {
                    tank_level_low_counter += 1;
                } else {
                    tank_level_low_counter = 0;
                }

                // schedule check to see if actuation is allowed
                perform_schedule_check!(
                    heating_channels,
                    schedule_check_result,
                    self.lock_error_channel_send_schedule_check,
                    self.lock_error_channel_receive_schedule_check,
                    module_path!()
                );

                // check if set values need to be updated
                update_thermal_set_values!(
                    heating_set_val_updater,
                    self.config.switch_off_temperature,
                    self.config.switch_on_temperature,
                    self.lock_error_heating_set_value_read_failure,
                    module_path!()
                );

                if self.config.stop_on_refill_error
                    && (tank_level_low_counter > self.config.stop_on_refill_error_delay)
                {
                    // tank level switch position has not been available or indicating low water level for too long time
                    // switch off the heater if not already off to protect against overheating of the device
                    if heater_state != ActuatorState::Off {
                        switch_off_heater(
                            &mutex_device_scheduler_heating,
                            &mut actuation_mutex_was_blocked_during_actuation,
                            heating_channels,
                        );
                        heater_state = ActuatorState::Off;
                    }
                } else {
                    // component protection allows operation of the heater
                    if schedule_check_result && !heating_inhibited {
                        // Schedule check said that actuation is allowed.
                        // Also, there is no inhibition from external request.
                        // The main control happens here (comparison measured/target, actuation).
                        if (measured_water_temperature >= self.config.switch_on_temperature)
                            && (measured_water_temperature <= self.config.switch_off_temperature)
                        {
                            // temperature is inside (dynamic) control window
                            if (self.calc_normalized_control_deviation(measured_water_temperature)
                                < saw_tooth_profile.level_normalized)
                                && !measurement_error
                            {
                                // switch on the heater if not already on
                                if heater_state != ActuatorState::On {
                                    switch_on_heater(
                                        &mutex_device_scheduler_heating,
                                        &mut actuation_mutex_was_blocked_during_actuation,
                                        heating_channels,
                                    );
                                    heater_state = ActuatorState::On;
                                }
                            } else {
                                // switch off the heater if not already off
                                if heater_state != ActuatorState::Off {
                                    switch_off_heater(
                                        &mutex_device_scheduler_heating,
                                        &mut actuation_mutex_was_blocked_during_actuation,
                                        heating_channels,
                                    );
                                    heater_state = ActuatorState::Off;
                                }
                            }
                        } else {
                            // the temperature is either above or below (dynamic) control window
                            if measured_water_temperature > self.config.switch_off_temperature {
                                // switch off the heater if not already off
                                if heater_state != ActuatorState::Off {
                                    switch_off_heater(
                                        &mutex_device_scheduler_heating,
                                        &mut actuation_mutex_was_blocked_during_actuation,
                                        heating_channels,
                                    );
                                    heater_state = ActuatorState::Off;
                                }
                            }
                            if measured_water_temperature < self.config.switch_on_temperature {
                                // switch on the heater if not already on
                                if heater_state != ActuatorState::On {
                                    switch_on_heater(
                                        &mutex_device_scheduler_heating,
                                        &mut actuation_mutex_was_blocked_during_actuation,
                                        heating_channels,
                                    );
                                    heater_state = ActuatorState::On;
                                }
                            }
                        }
                    } else if heating_inhibited {
                        // the external request to stop heating control has been received
                        match self.config.switch_on_when_external_stop {
                            true => {
                                // switch on the heater if not already on
                                if heater_state != ActuatorState::On {
                                    switch_on_heater(
                                        &mutex_device_scheduler_heating,
                                        &mut actuation_mutex_was_blocked_during_actuation,
                                        heating_channels,
                                    );
                                    heater_state = ActuatorState::On;
                                }
                            }
                            false => {
                                // switch off the heater if not already off
                                if heater_state != ActuatorState::Off {
                                    switch_off_heater(
                                        &mutex_device_scheduler_heating,
                                        &mut actuation_mutex_was_blocked_during_actuation,
                                        heating_channels,
                                    );
                                    heater_state = ActuatorState::Off;
                                }
                            }
                        }
                    } else {
                        // schedule check said that we are not allowed to actuate
                        match self.config.switch_on_when_out_of_schedule {
                            true => {
                                // switch on the heater if not already on
                                if heater_state != ActuatorState::On {
                                    switch_on_heater(
                                        &mutex_device_scheduler_heating,
                                        &mut actuation_mutex_was_blocked_during_actuation,
                                        heating_channels,
                                    );
                                    heater_state = ActuatorState::On;
                                }
                            }
                            false => {
                                // switch off the heater if not already off
                                if heater_state != ActuatorState::Off {
                                    switch_off_heater(
                                        &mutex_device_scheduler_heating,
                                        &mut actuation_mutex_was_blocked_during_actuation,
                                        heating_channels,
                                    );
                                    heater_state = ActuatorState::Off;
                                }
                            }
                        }
                    }
                }

                saw_tooth_profile.execute_with(TIME_INCREMENT_HEATING_SECS);

                // the update of midnight counter only runs every second
                if instant_midnight_check.elapsed() >= midnight_check_interval {
                    // one second closer to midnight
                    instant_midnight_check = Instant::now();
                    duration_until_midnight = duration_until_midnight.saturating_sub(1);
                    match heating_stats_opt {
                        Some(ref mut heating_stats) => {
                            // wrap temperatures depending on the status bits
                            let water_temperature_opt = match measurement_error {
                                true => None,
                                false => Some(measured_water_temperature as f64),
                            };
                            let ambient_temperature_opt = match measurement_error {
                                true => None,
                                false => Some(measured_ambient_temperature as f64),
                            };
                            // update the heating statistics with recently acquired data
                            if heater_state == ActuatorState::On {
                                energy_increment = (self.config.heater_power / 3600.0) as f64;
                            }
                            heating_stats.update(
                                water_temperature_opt,
                                ambient_temperature_opt,
                                energy_increment,
                            );
                        }
                        None => {
                            // do nothing, heating stats or not mandatory to run heating control
                        }
                    }

                    // check if midnight has arrived
                    if duration_until_midnight <= 0 {
                        // Use take() to move the value out of the Option without cloning.
                        if let Some(stats) = heating_stats_opt.take() {
                            if let Err(e) = heating_stats_transfer
                                .transfer_heating_stats(stats, &mut sql_interface_heating)
                            {
                                error!("Error occurred when trying to store heating stats data in database: {e:?}");
                            }
                            // Reset heating stats
                            heating_stats_opt =
                                Some(HeatingStatsEntry::new(&mut sql_interface_heating.conn));
                            duration_until_midnight =
                                self.get_duration_until_midnight(&mut sql_interface_heating);
                        }
                    }
                }
            }

            let instant_before_locking_mutex = Instant::now();
            let mut instant_after_locking_mutex = Instant::now(); // initialization is overwritten

            // Write signal to mutex
            {
                match heating_mutexes.mutex_heating_status.lock() {
                    Ok(mut c) => {
                        instant_after_locking_mutex = Instant::now();
                        *c = match heater_state {
                            ActuatorState::On => true,
                            ActuatorState::Off => false,
                            _ => false,
                        }
                    }
                    Err(_) => {
                        // Do nothing
                    }
                }
            }

            // check if access to mutex took too long
            self.check_mutex_access_duration(
                None,
                instant_after_locking_mutex,
                instant_before_locking_mutex,
            );

            loop_counter += 1;

            // avoid overflow
            if loop_counter == 1_000_000 {
                loop_counter = 0;
            }

            // Manage the loop's cycle time, sleeping or logging a warning as needed.
            manage_cycle_time_thermal!(
                start_time,
                cycle_time_duration,
                CYCLE_TIME_HEATING_MILLIS,
                spin_sleeper,
                lock_warn_cycle_time_exceeded,
                actuation_mutex_was_blocked_during_actuation,
                module_path!()
            );

            self.check_timing_and_ping_database(&mut sql_interface_heating);
        }

        // switch off the heater if not already off
        if heater_state != ActuatorState::Off {
            switch_off_heater(
                &mutex_device_scheduler_heating,
                &mut actuation_mutex_was_blocked_during_actuation,
                heating_channels,
            );
        }

        // update the database with the heating stats data recorded
        // so far for this date
        if let Some(stats) = heating_stats_opt.take() {
            if let Err(e) =
                heating_stats_transfer.transfer_heating_stats(stats, &mut sql_interface_heating)
            {
                error!("Error occurred when trying to store heating stats data in database (during termination): {e:?}");
            }
        }

        heating_channels.acknowledge_signal_handler();

        // This thread has channel connections to underlying threads.
        // Those threads have to stop receiving commands from this thread.
        // The shutdown sequence is handled by the signal_handler module.
        self.wait_for_termination(
            &mut heating_channels.rx_heating_from_signal_handler,
            sleep_duration_hundred_millis,
            module_path!(),
        );
    }
}

#[cfg(test)]
pub mod tests {
    use all_asserts::{assert_ge, assert_le};
    use chrono::Local;
    use mysql::PooledConn;
    use spin_sleep::SpinSleeper;
    use std::sync::{Arc, Mutex};
    use std::thread;
    use std::time::{Duration, Instant};

    use crate::database::sql_interface_heating_stats::{
        HeatingStatsEntry, SqlInterfaceHeatingStats,
    };
    use crate::database::sql_interface_midnight::SqlInterfaceMidnightCalculatorTrait;
    use crate::database::{sql_interface::SqlInterface, sql_interface_error::SqlInterfaceError};
    use crate::launch::channels::Channels;
    use crate::mocks::mock_heating::tests::MockSqlInterfaceHeatingSetVals;
    use crate::mocks::mock_relay_manager::tests::mock_relay_manager;
    use crate::mocks::mock_schedule_check::tests::mock_schedule_check;
    use crate::sensors::sensor_manager::SensorManagerSignals;
    use crate::sensors::tank_level_switch::TankLevelSwitchSignals;
    use crate::thermal::heating::{Heating, HeatingMutexes, HeatingStatsDataTransferTrait};
    use crate::utilities::channel_content::{AquariumDevice, InternalCommand};
    use crate::utilities::common::tests::update_min_max_actuation_duration;
    use crate::utilities::config::{read_config_file_with_test_database, ConfigData};
    use crate::utilities::sawtooth_profile::SawToothProfileConfig;

    pub struct HeatingStatsMockDataTransfer {
        heating_stats_entry_previous: HeatingStatsEntry,
        heating_stats_entry: HeatingStatsEntry,
    }

    impl HeatingStatsMockDataTransfer {
        // Creates a new `HeatingStatsMockDataTransfer` instance.
        //
        // This constructor initializes the mock data transfer object for testing heating statistics.
        // It sets up two `HeatingStatsEntry` instances, both initialized with default (zero) values
        // for the current date, to simulate the previous and current day's statistics.
        //
        // # Returns
        // A new `HeatingStatsMockDataTransfer` struct.
        pub fn new(conn: &mut PooledConn) -> HeatingStatsMockDataTransfer {
            Self {
                heating_stats_entry_previous: HeatingStatsEntry::new(conn),
                heating_stats_entry: HeatingStatsEntry::new(conn),
            }
        }
    }

    impl HeatingStatsDataTransferTrait for HeatingStatsMockDataTransfer {
        // Transfers provides daily heating statistics entry to the SQL database.
        //
        // This implementation updates the `date` of the `heating_stats_entry` to the
        // current database date (ensuring consistency) and then attempts to insert
        // or update this record in the database. Errors during database operations are logged.
        //
        // # Arguments
        // * `heating_stats_entry` - The `HeatingStatsEntry` containing the statistics for the day.
        //   This is passed by value, meaning ownership is transferred to this function.
        // * `sql_interface_heating` - A mutable reference to the `SqlInterfaceHeating` instance,
        //   used for database interaction.
        fn transfer_heating_stats(
            &mut self,
            heating_stats_entry: HeatingStatsEntry,
            _sql_interface_heating: &mut SqlInterfaceHeatingStats,
        ) -> Result<(), SqlInterfaceError> {
            self.heating_stats_entry_previous = self.heating_stats_entry.clone();
            self.heating_stats_entry = heating_stats_entry.clone();
            println!(
                "Heating: Received command to transfer mock data to SQL database: {}",
                heating_stats_entry,
            );
            Ok(())
        }
    }

    pub struct SqlInterfaceHeatingMockMidnightCalculator {
        seconds_to_midnight: i64,
    }

    impl SqlInterfaceHeatingMockMidnightCalculator {
        // Creates a new `SqlInterfaceHeatingMockMidnightCalculator` instance.
        //
        // This constructor initializes the mock calculator, setting the specific
        // number of seconds until midnight that it will consistently return during tests.
        // This allows for predictable simulation of time progression in testing scenarios.
        //
        // # Arguments
        // * `seconds_to_midnight` - The fixed `i64` value representing the number of
        //   seconds until midnight that this mock will provide.
        //
        // # Returns
        // A new `SqlInterfaceHeatingMockMidnightCalculator` struct.
        pub fn new(seconds_to_midnight: i64) -> SqlInterfaceHeatingMockMidnightCalculator {
            Self {
                seconds_to_midnight,
            }
        }
    }

    impl SqlInterfaceMidnightCalculatorTrait for SqlInterfaceHeatingMockMidnightCalculator {
        // Provides a predefined duration until midnight for testing heating statistics transfer.
        //
        // This mock implementation of `get_duration_until_midnight` always returns a
        // fixed `i64` value, `self.seconds_to_midnight`. This allows tests to simulate
        // various durations until midnight without actually waiting for real-world time to pass,
        // enabling deterministic and fast testing of the heating statistics transfer logic.
        //
        // # Returns
        // An `Ok(i64)` containing the predefined number of seconds until midnight.
        // This function will always succeed (`Ok`) as it does not interact with a real database.
        fn get_duration_until_midnight(&mut self) -> Result<i64, SqlInterfaceError> {
            Ok(self.seconds_to_midnight) // seconds to midnight after which heating stats are inserted into the database
                                         // for testing, we do not want to wait until midnight
        }
    }

    // Prepares a `Heating` control instance with a mock midnight calculator and a clean test database.
    //
    // This helper function is designed exclusively for testing the `Heating` module. It sets up
    // a controlled environment by:
    // 1.  Loading a generic test configuration and overriding specific settings (e.g., `stop_on_refill_error_delay`).
    // 2.  Optionally, applying a custom `SawToothProfileConfig` for precise control over heating patterns.
    // 3.  Connecting to and **truncating a dedicated test database** to ensure a clean state for heating statistics.
    // 4.  Injecting a **`SqlInterfaceHeatingMockMidnightCalculator`** to return a predefined `seconds_to_midnight`,
    //     allowing deterministic testing of daily statistic transfers without real-time dependency.
    //
    // # Arguments
    // * `seconds_to_midnight` - The fixed number of seconds (as `i64`) the mock midnight calculator will return.
    //   This directly controls when the `Heating` module attempts to transfer daily statistics.
    // * `test_db_number` - A unique `u32` identifier (e.g., `7`, `8`, `9`) used to select a specific
    //   test database (`aquarium_test_XX`) from the configuration.
    // * `saw_tooth_profile_config_opt` - An `Option<SawToothProfileConfig>`. If `Some`, this custom
    //   sawtooth profile configuration overrides the one loaded from the TOML file for the `Heating` module.
    //
    // # Returns
    // A tuple `(ConfigData, Heating)`:
    // - The `ConfigData` struct, containing the loaded and modified configuration.
    // - The fully initialized `Heating` struct, ready for test execution.
    //
    // # Panics
    // This function will panic if:
    // - `read_config_file_with_test_database` fails (e.g., file not found, invalid DB number).
    // - It fails to connect to the SQL database.
    // - It fails to truncate the `heatingstats` table in the database.
    // - It encounters any issue during the initialization of the `SqlInterfaceHeating` or `Heating` structs.
    pub fn prepare_heating_tests_mock_midnight_calculator(
        seconds_to_midnight: i64,
        test_db_number: u32,
        saw_tooth_profile_config_opt: Option<SawToothProfileConfig>,
    ) -> (ConfigData, Heating, SqlInterface, SqlInterfaceHeatingStats) {
        // prepare struct Heating for further tests
        let mut config: ConfigData = read_config_file_with_test_database(
            "/config/aquarium_control_test_generic.toml".to_string(),
            test_db_number,
        );
        config.heating.stop_on_refill_error_delay = 2;

        match saw_tooth_profile_config_opt {
            Some(saw_tooth_profile_config) => {
                config.heating.saw_tooth_profile_config = saw_tooth_profile_config;
            }
            None => { /* do nothing */ }
        }

        println!("Testing with database {}", config.sql_interface.db_name);
        let mut sql_interface = match SqlInterface::new(config.sql_interface.clone()) {
            Ok(c) => c,
            Err(e) => {
                panic!("Could not connect to SQL database: {e:?}");
            }
        };

        // empty the heating stats table
        match SqlInterface::truncate_table(&mut sql_interface, "heatingstats".to_string()) {
            Ok(_) => {}
            Err(e) => {
                panic!("Could not prepare test case: {e:?}")
            }
        }

        let sql_interface_heating_midnight_calculator = Box::new(
            SqlInterfaceHeatingMockMidnightCalculator::new(seconds_to_midnight),
        );
        let sql_interface_heating_stats = SqlInterfaceHeatingStats::new(
            sql_interface.get_connection().unwrap(),
            config.sql_interface.max_rows_heating_stats,
            sql_interface_heating_midnight_calculator,
        )
        .unwrap();

        println!(
            "prepare_heating_tests_mock_midnight_calculator: SwitchOff temperature = {}, SwitchOn temperature = {}",
            config.heating.switch_on_temperature, config.heating.switch_off_temperature
        );
        let heating_config = config.heating.clone();
        (
            config,
            Heating::new(heating_config, Duration::from_secs(1000)),
            sql_interface,
            sql_interface_heating_stats,
        )
    }

    #[test]
    // Check if the heater remains switched off with a high temperature.
    // Also, implicitly test if the execute function terminates after receiving Quit and Terminate commands.
    // Test case uses test database #11.
    pub fn test_heating_with_measured_temperature_high() {
        let sleep_duration_100_millis = Duration::from_millis(100);
        let spin_sleeper = SpinSleeper::default();

        let (mut config, mut heating, sql_interface, sql_interface_heating_stats) =
            prepare_heating_tests_mock_midnight_calculator(3600, 11, None);

        // replacement values are used to initialize the mutexes
        config.sensor_manager.replacement_value_water_temperature = 30.0;
        config.sensor_manager.replacement_value_ambient_temperature = 24.0;

        let mut channels = Channels::new_for_test();

        // Mutex for tank level switch signals
        let mutex_tank_level_switch_signals =
            Arc::new(Mutex::new(TankLevelSwitchSignals::new(true, true, false)));

        // thread for mock schedule check
        let join_handle_mock_schedule_check = thread::Builder::new()
            .name("mock_schedule_check".to_string())
            .spawn(move || {
                mock_schedule_check(
                    &mut channels.schedule_check.tx_schedule_check_to_heating,
                    &mut channels.schedule_check.rx_schedule_check_from_heating,
                    None,
                    true,
                );
            })
            .unwrap();

        let mutex_device_scheduler_heating = Arc::new(Mutex::new(0));

        // thread for mock relay manager - includes assertions
        let join_handle_mock_relay_manager = thread::Builder::new()
            .name("mock_relay_manager".to_string())
            .spawn(move || {
                let (mut actuation_events, mock_actuator_states) = mock_relay_manager(
                    &mut channels.relay_manager.tx_relay_manager_to_heating,
                    &mut channels.relay_manager.rx_relay_manager_from_heating,
                );
                assert_eq!(actuation_events.len(), 1);
                let actuation_event = actuation_events.pop().unwrap();
                assert_eq!(
                    actuation_event.command,
                    InternalCommand::SwitchOff(AquariumDevice::Heater)
                );
                mock_actuator_states.check_terminal_condition_heating();
            })
            .unwrap();

        // thread for controlling duration of test run
        let join_handle_test_environment = thread::Builder::new()
            .name("test_environment".to_string())
            .spawn(move || {
                let sleep_duration_ten_seconds = Duration::from_secs(10);
                let spin_sleeper = SpinSleeper::default();
                spin_sleeper.sleep(sleep_duration_ten_seconds);
                let _ = channels
                    .signal_handler
                    .send_to_heating(InternalCommand::Quit);
                channels.signal_handler.receive_from_heating().unwrap();
                let _ = channels
                    .signal_handler
                    .send_to_heating(InternalCommand::Terminate);
            })
            .unwrap();

        // make sure all mock threads are running when instantiating the test object
        spin_sleeper.sleep(sleep_duration_100_millis);

        // thread for the test object
        let join_handle_test_object = thread::Builder::new()
            .name("test_object".to_string())
            .spawn(move || {
                // clone sender part of the channels to mock threads so that we can terminate them after execution of the test object
                let mut tx_heating_to_schedule_check_for_test_case_finish =
                    channels.heating.tx_heating_to_schedule_check.clone();
                let mut tx_heating_to_relay_manager_for_test_case_finish =
                    channels.heating.tx_heating_to_relay_manager.clone();

                let mut heating_stats_transfer =
                    HeatingStatsMockDataTransfer::new(&mut sql_interface.get_connection().unwrap());
                let mut heating_set_value_updater =
                    MockSqlInterfaceHeatingSetVals::new(false, None, None, None);

                let heating_mutexes = HeatingMutexes {
                    mutex_sensor_manager_signals: Arc::new(Mutex::new(SensorManagerSignals::new(
                        &config.sensor_manager,
                    ))),
                    mutex_tank_level_switch_signals,
                    mutex_heating_status: Arc::new(Mutex::new(false)),
                };

                heating.execute(
                    mutex_device_scheduler_heating.clone(),
                    &mut channels.heating,
                    &mut heating_stats_transfer,
                    &mut heating_set_value_updater,
                    heating_mutexes,
                    sql_interface_heating_stats,
                );

                // send Quit signal to mock threads because the test object has terminated
                let _ =
                    tx_heating_to_schedule_check_for_test_case_finish.send(InternalCommand::Quit);
                let _ =
                    tx_heating_to_relay_manager_for_test_case_finish.send(InternalCommand::Quit);

                println!("* [Heating] checking reaction to high temperature succeeded.");
            })
            .unwrap();

        join_handle_mock_schedule_check
            .join()
            .expect("Mock schedule check did not finish.");
        join_handle_mock_relay_manager
            .join()
            .expect("Mock relay manager thread did not finish.");
        join_handle_test_environment
            .join()
            .expect("Test environment thread did not finish.");
        join_handle_test_object
            .join()
            .expect("Test object thread did not finish.");
    }

    #[test]
    // Check if the heater is switched on and is not switched off with low temperature.
    // Also, implicitly test if the execute function terminates after receiving Quit and Terminate commands.
    // Check if the heater is switched off after sending Quit command and before sending Terminate command.
    // Test case uses test database #12.
    pub fn test_heating_with_measured_temperature_low_without_mutex_blocked() {
        let sleep_duration_100_millis = Duration::from_millis(100);
        let spin_sleeper = SpinSleeper::default();

        let (mut config, mut heating, sql_interface, sql_interface_heating_stats) =
            prepare_heating_tests_mock_midnight_calculator(3600, 12, None);

        // replacement values are used to initialize the mutexes
        config.sensor_manager.replacement_value_water_temperature = 20.0;
        config.sensor_manager.replacement_value_ambient_temperature = 24.0;

        let mut channels = Channels::new_for_test();

        // Mutex for tank level switch signals
        let mutex_tank_level_switch_signals =
            Arc::new(Mutex::new(TankLevelSwitchSignals::new(true, true, false)));

        // thread for mock schedule check
        let join_handle_mock_schedule_check = thread::Builder::new()
            .name("mock_schedule_check".to_string())
            .spawn(move || {
                mock_schedule_check(
                    &mut channels.schedule_check.tx_schedule_check_to_heating,
                    &mut channels.schedule_check.rx_schedule_check_from_heating,
                    None,
                    true,
                );
            })
            .unwrap();

        let mutex_device_scheduler_heating = Arc::new(Mutex::new(0));

        // thread for mock relay manager - includes assertions
        let join_handle_mock_relay_manager = thread::Builder::new()
            .name("mock_relay_manager".to_string())
            .spawn(move || {
                let (mut actuation_events, mock_actuator_states) = mock_relay_manager(
                    &mut channels.relay_manager.tx_relay_manager_to_heating,
                    &mut channels.relay_manager.rx_relay_manager_from_heating,
                );
                assert_eq!(actuation_events.len(), 2);
                let last_actuation_event = actuation_events.pop().unwrap();
                assert_eq!(
                    last_actuation_event.command,
                    InternalCommand::SwitchOff(AquariumDevice::Heater)
                );
                let first_actuation_event = actuation_events.pop().unwrap();
                assert_eq!(
                    first_actuation_event.command,
                    InternalCommand::SwitchOn(AquariumDevice::Heater)
                );
                mock_actuator_states.check_terminal_condition_heating();
            })
            .unwrap();

        // thread for controlling duration of test run
        let join_handle_test_environment = thread::Builder::new()
            .name("test_environment".to_string())
            .spawn(move || {
                let sleep_duration_ten_seconds = Duration::from_secs(10);
                let spin_sleeper = SpinSleeper::default();
                spin_sleeper.sleep(sleep_duration_ten_seconds);
                let _ = channels
                    .signal_handler
                    .send_to_heating(InternalCommand::Quit);
                channels.signal_handler.receive_from_heating().unwrap();
                let _ = channels
                    .signal_handler
                    .send_to_heating(InternalCommand::Terminate);
            })
            .unwrap();

        // make sure all mock threads are running when instantiating the test object
        spin_sleeper.sleep(sleep_duration_100_millis);

        // thread for the test object
        let join_handle_test_object = thread::Builder::new()
            .name("test_object".to_string())
            .spawn(move || {
                // clone sender part of the channels to mock threads so that we can terminate them after execution of the test object
                let mut tx_heating_to_schedule_check_for_test_case_finish =
                    channels.heating.tx_heating_to_schedule_check.clone();
                let mut tx_heating_to_relay_manager_for_test_case_finish =
                    channels.heating.tx_heating_to_relay_manager.clone();

                let mut heating_stats_transfer =
                    HeatingStatsMockDataTransfer::new(&mut sql_interface.get_connection().unwrap());
                let mut heating_set_value_updater =
                    MockSqlInterfaceHeatingSetVals::new(false, None, None, None);

                let heating_mutexes = HeatingMutexes {
                    mutex_sensor_manager_signals: Arc::new(Mutex::new(SensorManagerSignals::new(
                        &config.sensor_manager,
                    ))),
                    mutex_tank_level_switch_signals,
                    mutex_heating_status: Arc::new(Mutex::new(false)),
                };

                heating.execute(
                    mutex_device_scheduler_heating.clone(),
                    &mut channels.heating,
                    &mut heating_stats_transfer,
                    &mut heating_set_value_updater,
                    heating_mutexes,
                    sql_interface_heating_stats,
                );

                // send Quit signal to mock threads because the test object has terminated
                let _ =
                    tx_heating_to_schedule_check_for_test_case_finish.send(InternalCommand::Quit);
                let _ =
                    tx_heating_to_relay_manager_for_test_case_finish.send(InternalCommand::Quit);

                println!("* [Heating] checking reaction to low temperature succeeded.");
            })
            .unwrap();

        join_handle_mock_schedule_check
            .join()
            .expect("Mock schedule check did not finish.");
        join_handle_mock_relay_manager
            .join()
            .expect("Mock relay manager thread did not finish.");
        join_handle_test_environment
            .join()
            .expect("Test environment thread did not finish.");
        join_handle_test_object
            .join()
            .expect("Test object thread did not finish.");
    }

    #[test]
    // Check if the heater is switched on and off during two cycles of the saw tooth profile.
    // The duration of the heater being switched on shall equal the duration of the heater switched off (1% tolerance).
    // Also, implicitly test if the execute function terminates after receiving Quit and Terminate commands.
    // Test case uses test database #13.
    pub fn test_heating_with_measured_temperature_50_percent() {
        let sleep_duration_100_millis = Duration::from_millis(100);
        let spin_sleeper = SpinSleeper::default();

        let (mut config, mut heating, sql_interface, sql_interface_heating_stats) =
            prepare_heating_tests_mock_midnight_calculator(
                3600,
                13,
                Some(SawToothProfileConfig::new(6, 1, 6, 1)),
            );

        // replacement values are used to initialize the mutexes
        config.sensor_manager.replacement_value_water_temperature = 25.0;
        config.sensor_manager.replacement_value_ambient_temperature = 24.0;

        let mut channels = Channels::new_for_test();

        // Mutex for tank level switch signals
        let mutex_tank_level_switch_signals =
            Arc::new(Mutex::new(TankLevelSwitchSignals::new(true, true, false)));

        // thread for mock schedule check
        let join_handle_mock_schedule_check = thread::Builder::new()
            .name("mock_schedule_check".to_string())
            .spawn(move || {
                mock_schedule_check(
                    &mut channels.schedule_check.tx_schedule_check_to_heating,
                    &mut channels.schedule_check.rx_schedule_check_from_heating,
                    None,
                    true,
                );
            })
            .unwrap();

        let mutex_device_scheduler_heating = Arc::new(Mutex::new(0));

        // thread for mock relay manager - includes assertions
        let join_handle_mock_relay_manager = thread::Builder::new()
            .name("mock_relay_manager".to_string())
            .spawn(move || {
                let (mut actuation_events, mock_actuator_states) = mock_relay_manager(
                    &mut channels.relay_manager.tx_relay_manager_to_heating,
                    &mut channels.relay_manager.rx_relay_manager_from_heating,
                );
                println!(
                    "Mock relay manager received {} commands:",
                    actuation_events.len()
                );
                for actuation_event in actuation_events.clone() {
                    println!("{}", actuation_event);
                }
                // (first and) last actuation events need to be ignored
                let _last_actuation_event = actuation_events.pop().unwrap();
                let second_last_actuation_event = actuation_events.pop().unwrap();
                let third_last_actuation_event = actuation_events.pop().unwrap();
                let fourth_last_actuation_event = actuation_events.pop().unwrap();
                let fifth_last_actuation_event = actuation_events.pop().unwrap();
                let sixth_last_actuation_event = actuation_events.pop().unwrap();
                let seventh_last_actuation_event = actuation_events.pop().unwrap();

                let mut min_actuation_duration: u128 = 100000;
                let mut max_actuation_duration: u128 = 0;

                let second_last_actuation_duration = second_last_actuation_event
                    .time
                    .duration_since(third_last_actuation_event.time)
                    .as_millis();
                (min_actuation_duration, max_actuation_duration) =
                    update_min_max_actuation_duration(
                        min_actuation_duration,
                        max_actuation_duration,
                        second_last_actuation_duration,
                    );
                println!(
                    "second_last_actuation_duration={}",
                    second_last_actuation_duration
                );

                let third_last_actuation_duration = third_last_actuation_event
                    .time
                    .duration_since(fourth_last_actuation_event.time)
                    .as_millis();
                (min_actuation_duration, max_actuation_duration) =
                    update_min_max_actuation_duration(
                        min_actuation_duration,
                        max_actuation_duration,
                        second_last_actuation_duration,
                    );
                println!(
                    "third_last_actuation_duration={}",
                    third_last_actuation_duration
                );

                let fourth_last_actuation_duration = fourth_last_actuation_event
                    .time
                    .duration_since(fifth_last_actuation_event.time)
                    .as_millis();
                (min_actuation_duration, max_actuation_duration) =
                    update_min_max_actuation_duration(
                        min_actuation_duration,
                        max_actuation_duration,
                        second_last_actuation_duration,
                    );
                println!(
                    "fourth_last_actuation_duration={}",
                    fourth_last_actuation_duration
                );

                let fifth_last_actuation_duration = fifth_last_actuation_event
                    .time
                    .duration_since(sixth_last_actuation_event.time)
                    .as_millis();
                (min_actuation_duration, max_actuation_duration) =
                    update_min_max_actuation_duration(
                        min_actuation_duration,
                        max_actuation_duration,
                        second_last_actuation_duration,
                    );
                println!(
                    "fifth_last_actuation_duration={}",
                    fifth_last_actuation_duration
                );

                let sixth_last_actuation_duration = sixth_last_actuation_event
                    .time
                    .duration_since(seventh_last_actuation_event.time)
                    .as_millis();
                (min_actuation_duration, max_actuation_duration) =
                    update_min_max_actuation_duration(
                        min_actuation_duration,
                        max_actuation_duration,
                        second_last_actuation_duration,
                    );
                println!(
                    "sixth_last_actuation_duration={}",
                    sixth_last_actuation_duration
                );

                let delta_min_max_duration = max_actuation_duration - min_actuation_duration;

                // execution timing differs between platforms.
                // hence, platform-specific asserts are necessary
                cfg_if::cfg_if! {
                    if #[cfg(target_os = "linux")] {
                        assert_le!(second_last_actuation_duration, 7100);
                        assert_ge!(second_last_actuation_duration, 6400);
                        assert_le!(third_last_actuation_duration, 7100);
                        assert_ge!(third_last_actuation_duration, 6400);
                        assert_le!(fourth_last_actuation_duration, 7100);
                        assert_ge!(fourth_last_actuation_duration, 6400);
                        assert_le!(fifth_last_actuation_duration, 7100);
                        assert_ge!(fifth_last_actuation_duration, 6400);
                        assert_le!(sixth_last_actuation_duration, 7100);
                        assert_ge!(sixth_last_actuation_duration, 6400);
                }
                    else {
                        assert_le!(second_last_actuation_duration, 7400);
                        assert_ge!(second_last_actuation_duration, 6400);
                        assert_le!(third_last_actuation_duration, 7400);
                        assert_ge!(third_last_actuation_duration, 6400);
                        assert_le!(fourth_last_actuation_duration, 7400);
                        assert_ge!(fourth_last_actuation_duration, 6400);
                        assert_le!(fifth_last_actuation_duration, 7400);
                        assert_ge!(fifth_last_actuation_duration, 6400);
                        assert_le!(sixth_last_actuation_duration, 7400);
                        assert_ge!(sixth_last_actuation_duration, 6400);
                    }
                }
                assert_le!(delta_min_max_duration, 50);
                mock_actuator_states.check_terminal_condition_heating();
            })
            .unwrap();

        // thread for controlling duration of test run
        let join_handle_test_environment = thread::Builder::new()
            .name("test_environment".to_string())
            .spawn(move || {
                let sleep_duration = Duration::from_secs(59);
                let spin_sleeper = SpinSleeper::default();
                spin_sleeper.sleep(sleep_duration);
                let _ = channels
                    .signal_handler
                    .send_to_heating(InternalCommand::Quit);
                channels.signal_handler.receive_from_heating().unwrap();
                let _ = channels
                    .signal_handler
                    .send_to_heating(InternalCommand::Terminate);
            })
            .unwrap();

        // make sure all mock threads are running when instantiating the test object
        spin_sleeper.sleep(sleep_duration_100_millis);

        // thread for the test object
        let join_handle_test_object = thread::Builder::new()
            .name("test_object".to_string())
            .spawn(move || {
                // clone sender part of the channels to mock threads so that we can terminate them after execution of the test object
                let mut tx_heating_to_schedule_check_for_test_case_finish =
                    channels.heating.tx_heating_to_schedule_check.clone();
                let mut tx_heating_to_relay_manager_for_test_case_finish =
                    channels.heating.tx_heating_to_relay_manager.clone();

                let mut heating_stats_transfer =
                    HeatingStatsMockDataTransfer::new(&mut sql_interface.get_connection().unwrap());
                let mut heating_set_value_updater =
                    MockSqlInterfaceHeatingSetVals::new(false, None, None, None);

                let heating_mutexes = HeatingMutexes {
                    mutex_sensor_manager_signals: Arc::new(Mutex::new(SensorManagerSignals::new(
                        &config.sensor_manager,
                    ))),
                    mutex_tank_level_switch_signals,
                    mutex_heating_status: Arc::new(Mutex::new(false)),
                };

                heating.execute(
                    mutex_device_scheduler_heating.clone(),
                    &mut channels.heating,
                    &mut heating_stats_transfer,
                    &mut heating_set_value_updater,
                    heating_mutexes,
                    sql_interface_heating_stats,
                );

                // send Quit signal to mock threads because the test object has terminated
                let _ =
                    tx_heating_to_schedule_check_for_test_case_finish.send(InternalCommand::Quit);
                let _ =
                    tx_heating_to_relay_manager_for_test_case_finish.send(InternalCommand::Quit);

                println!("* [Heating] checking reaction to medium temperature succeeded.");
            })
            .unwrap();

        join_handle_mock_schedule_check
            .join()
            .expect("Mock schedule check did not finish.");
        join_handle_mock_relay_manager
            .join()
            .expect("Mock relay manager thread did not finish.");
        join_handle_test_environment
            .join()
            .expect("Test environment thread did not finish.");
        join_handle_test_object
            .join()
            .expect("Test object thread did not finish.");
    }

    #[test]
    // Test case checks if the Quit command is correctly processed
    // - application shall switch off the heater before exiting
    // The test case uses test database #14.
    pub fn test_heating_with_pending_quit_terminate_command() {
        let sleep_duration_100_millis = Duration::from_millis(100);
        let spin_sleeper = SpinSleeper::default();

        let (mut config, mut heating, sql_interface, sql_interface_heating_stats) =
            prepare_heating_tests_mock_midnight_calculator(3, 14, None);

        // replacement values are used to initialize the mutexes
        config.sensor_manager.replacement_value_water_temperature = 25.0;
        config.sensor_manager.replacement_value_ambient_temperature = 24.0;

        let mut channels = Channels::new_for_test();

        let start_time = Instant::now();

        // Mutex for tank level switch signals
        let mutex_tank_level_switch_signals =
            Arc::new(Mutex::new(TankLevelSwitchSignals::new(true, true, false)));

        // thread for mock schedule check
        let join_handle_mock_schedule_check = thread::Builder::new()
            .name("mock_schedule_check".to_string())
            .spawn(move || {
                mock_schedule_check(
                    &mut channels.schedule_check.tx_schedule_check_to_heating,
                    &mut channels.schedule_check.rx_schedule_check_from_heating,
                    None,
                    true,
                );
            })
            .unwrap();

        let mutex_device_scheduler_heating = Arc::new(Mutex::new(0));

        // thread for mock relay manager
        let join_handle_mock_relay_manager = thread::Builder::new()
            .name("mock_relay_manager".to_string())
            .spawn(move || {
                let (mut actuation_events, mock_actuator_states) = mock_relay_manager(
                    &mut channels.relay_manager.tx_relay_manager_to_heating,
                    &mut channels.relay_manager.rx_relay_manager_from_heating,
                );
                println!(
                    "Mock relay manager received {} commands.",
                    actuation_events.len()
                );
                assert_eq!(actuation_events.len(), 1);
                let actuation_event = actuation_events.pop().unwrap();
                assert_eq!(
                    actuation_event.command,
                    InternalCommand::SwitchOff(AquariumDevice::Heater)
                );
                mock_actuator_states.check_terminal_condition_heating();
            })
            .unwrap();

        // thread for controlling duration of test run
        let join_handle_test_environment = thread::Builder::new()
            .name("test_environment".to_string())
            .spawn(move || {
                let _ = channels
                    .signal_handler
                    .send_to_heating(InternalCommand::Quit);
                channels.signal_handler.receive_from_heating().unwrap();
                let _ = channels
                    .signal_handler
                    .send_to_heating(InternalCommand::Terminate);
            })
            .unwrap();

        spin_sleeper.sleep(sleep_duration_100_millis);

        // thread for the test object
        let join_handle_test_object = thread::Builder::new()
            .name("test_object".to_string())
            .spawn(move || {
                // clone sender part of the channels to mock threads so that we can terminate them after execution of the test object
                let mut tx_heating_to_schedule_check_for_test_case_finish =
                    channels.heating.tx_heating_to_schedule_check.clone();
                let mut tx_heating_to_relay_manager_for_test_case_finish =
                    channels.heating.tx_heating_to_relay_manager.clone();

                let mut heating_stats_transfer =
                    HeatingStatsMockDataTransfer::new(&mut sql_interface.get_connection().unwrap());
                let mut heating_set_value_updater = MockSqlInterfaceHeatingSetVals::new(false, None, None, None);

                let heating_mutexes = HeatingMutexes {
                    mutex_sensor_manager_signals: Arc::new(Mutex::new(SensorManagerSignals::new(&config.sensor_manager))),
                    mutex_tank_level_switch_signals,
                    mutex_heating_status: Arc::new(Mutex::new(false)),
                };

                heating.execute(
                    mutex_device_scheduler_heating.clone(),
                    &mut channels.heating,
                    &mut heating_stats_transfer,
                    &mut heating_set_value_updater,
                    heating_mutexes,
                    sql_interface_heating_stats
                );

                // send Quit signal to mock threads because the test object has terminated
                let _ =
                    tx_heating_to_schedule_check_for_test_case_finish.send(InternalCommand::Quit);
                let _ = tx_heating_to_relay_manager_for_test_case_finish.send(InternalCommand::Quit);

                // check if heater actuation has taken place
                let mutex_data = mutex_device_scheduler_heating.lock().unwrap();
                assert_eq!(*mutex_data, 1);
            let finish_time = Instant::now();
            let execution_duration = finish_time.duration_since(start_time);
            assert_le!(execution_duration.as_millis(), 650);
            println!(
                "* [Heating] checking heating execution with pending quit/terminate command (time limit) succeeded."
            );
        })
        .unwrap();

        join_handle_mock_schedule_check
            .join()
            .expect("Mock schedule check did not finish.");
        join_handle_mock_relay_manager
            .join()
            .expect("Mock relay manager thread did not finish.");
        join_handle_test_environment
            .join()
            .expect("Test environment thread did not finish.");
        join_handle_test_object
            .join()
            .expect("Test object thread did not finish.");
    }

    #[test]
    // Test case checks if waiting for midnight and statistical calculations are computed correctly.
    // Test case uses test database #15.
    pub fn test_heating_wait_for_midnight_calc_stats_heater_on() {
        let sleep_duration_100_millis = Duration::from_millis(100);
        let spin_sleeper = SpinSleeper::default();

        let (mut config, mut heating, sql_interface, mut sql_interface_heating_stats) =
            prepare_heating_tests_mock_midnight_calculator(3, 15, None);

        // replacement values are used to initialize the mutexes
        config.sensor_manager.replacement_value_water_temperature = 20.0;
        config.sensor_manager.replacement_value_ambient_temperature = 24.0;

        let mut channels = Channels::new_for_test();

        // Mutex for tank level switch signals
        let mutex_tank_level_switch_signals =
            Arc::new(Mutex::new(TankLevelSwitchSignals::new(true, true, false)));

        // get initial data for calculation of reference value
        let initial_heating_stats_entry = sql_interface_heating_stats
            .get_single_heating_stats_from_database()
            .unwrap_or_else(|_| {
                // database responded with an empty response - let's create an empty entry
                HeatingStatsEntry {
                    date: Local::now().date_naive(),
                    energy: 0.0,
                    ambient_temperature_average_value: 0.0,
                    ambient_temperature_average_counter: 0,
                    water_temperature_average_value: 0.0,
                    water_temperature_average_counter: 0,
                    heating_control_runtime: 0,
                }
            });

        // thread for mock schedule check
        let join_handle_mock_schedule_check = thread::Builder::new()
            .name("mock_schedule_check".to_string())
            .spawn(move || {
                mock_schedule_check(
                    &mut channels.schedule_check.tx_schedule_check_to_heating,
                    &mut channels.schedule_check.rx_schedule_check_from_heating,
                    None,
                    true,
                );
            })
            .unwrap();

        let mutex_device_scheduler_heating = Arc::new(Mutex::new(0));

        // thread for mock relay manager
        let join_handle_mock_relay_manager = thread::Builder::new()
            .name("mock_relay_manager".to_string())
            .spawn(move || {
                mock_relay_manager(
                    &mut channels.relay_manager.tx_relay_manager_to_heating,
                    &mut channels.relay_manager.rx_relay_manager_from_heating,
                );
            })
            .unwrap();

        // thread for controlling duration of test run
        let join_handle_test_environment = thread::Builder::new()
            .name("test_environment".to_string())
            .spawn(move || {
                let sleep_duration = Duration::from_secs(4);
                let spin_sleeper = SpinSleeper::default();
                spin_sleeper.sleep(sleep_duration);
                let _ = channels
                    .signal_handler
                    .send_to_heating(InternalCommand::Quit);
                channels.signal_handler.receive_from_heating().unwrap();
                let _ = channels
                    .signal_handler
                    .send_to_heating(InternalCommand::Terminate);
            })
            .unwrap();

        spin_sleeper.sleep(sleep_duration_100_millis);

        // thread for the test object
        let join_handle_test_object = thread::Builder::new()
            .name("test_object".to_string())
            .spawn(move || {
                // clone sender part of the channels to mock threads so that we can terminate them after execution of the test object
                let mut tx_heating_to_schedule_check_for_test_case_finish =
                    channels.heating.tx_heating_to_schedule_check.clone();
                let mut tx_heating_to_relay_manager_for_test_case_finish =
                    channels.heating.tx_heating_to_relay_manager.clone();

                let mut heating_stats_transfer =
                    HeatingStatsMockDataTransfer::new(&mut sql_interface.get_connection().unwrap());
                let mut heating_set_value_updater = MockSqlInterfaceHeatingSetVals::new(false, None, None, None);

                let heating_mutexes = HeatingMutexes {
                    mutex_sensor_manager_signals: Arc::new(Mutex::new(SensorManagerSignals::new(&config.sensor_manager))),
                    mutex_tank_level_switch_signals,
                    mutex_heating_status: Arc::new(Mutex::new(false)),
                };

                heating.execute(
                    mutex_device_scheduler_heating.clone(),
                    &mut channels.heating,
                    &mut heating_stats_transfer,
                    &mut heating_set_value_updater,
                    heating_mutexes,
                    sql_interface_heating_stats
                );

                // send Quit signal to mock threads because the test object has terminated
                let _ =
                    tx_heating_to_schedule_check_for_test_case_finish.send(InternalCommand::Quit);
                let _ = tx_heating_to_relay_manager_for_test_case_finish.send(InternalCommand::Quit);

                println!(
                    "test_heating_wait_for_midnight_calc_stats_heater_on (previous): {}",
                    heating_stats_transfer.heating_stats_entry_previous,
                );
                assert_eq!(
                    heating_stats_transfer
                        .heating_stats_entry_previous
                        .heating_control_runtime
                        - initial_heating_stats_entry.heating_control_runtime,
                    3
                );
                assert_le!(
                    0.16666666,
                    heating_stats_transfer.heating_stats_entry_previous.energy
                );
                assert_ge!(
                    0.16666667,
                    heating_stats_transfer.heating_stats_entry_previous.energy
                );
                assert_le!(
                    23.999,
                    heating_stats_transfer
                        .heating_stats_entry_previous
                        .ambient_temperature_average_value
                );
                assert_ge!(
                    24.001,
                    heating_stats_transfer
                        .heating_stats_entry_previous
                        .ambient_temperature_average_value
                );
                assert_le!(
                    19.999,
                    heating_stats_transfer
                        .heating_stats_entry_previous
                        .water_temperature_average_value
                );
                assert_ge!(
                    20.001,
                    heating_stats_transfer
                        .heating_stats_entry_previous
                        .water_temperature_average_value
                );
                assert_eq!(
                    heating_stats_transfer
                        .heating_stats_entry_previous
                        .ambient_temperature_average_counter
                        - initial_heating_stats_entry.ambient_temperature_average_counter,
                    3
                );
                assert_eq!(
                    heating_stats_transfer
                        .heating_stats_entry_previous
                        .water_temperature_average_counter
                        - initial_heating_stats_entry.water_temperature_average_counter,
                    3
                );
                println!(
                    "test_heating_wait_for_midnight_calc_stats_heater_on (current): {}",
                    heating_stats_transfer.heating_stats_entry,
                );
                assert_eq!(
                    heating_stats_transfer
                        .heating_stats_entry
                        .heating_control_runtime
                        - initial_heating_stats_entry.heating_control_runtime,
                    1
                );
                assert_le!(0.0555, heating_stats_transfer.heating_stats_entry.energy);
                assert_ge!(0.0556, heating_stats_transfer.heating_stats_entry.energy);
                assert_le!(
                    23.999,
                    heating_stats_transfer
                        .heating_stats_entry
                        .ambient_temperature_average_value
                );
                assert_ge!(
                    24.001,
                    heating_stats_transfer
                        .heating_stats_entry
                        .ambient_temperature_average_value
                );
                assert_le!(
                    19.999,
                    heating_stats_transfer
                        .heating_stats_entry
                        .water_temperature_average_value
                );
                assert_ge!(
                    20.001,
                    heating_stats_transfer
                        .heating_stats_entry
                        .water_temperature_average_value
                );
                assert_eq!(
                    heating_stats_transfer
                        .heating_stats_entry
                        .ambient_temperature_average_counter
                        - initial_heating_stats_entry.ambient_temperature_average_counter,
                    1
                );
                assert_eq!(
                    heating_stats_transfer
                        .heating_stats_entry
                        .water_temperature_average_counter
                        - initial_heating_stats_entry.water_temperature_average_counter,
                    1
                );
                println!("* [Heating] checking heating waiting for midnight and stats calculation with heater on succeeded.");
            })
            .unwrap();

        join_handle_mock_schedule_check
            .join()
            .expect("Mock schedule check did not finish.");
        join_handle_mock_relay_manager
            .join()
            .expect("Mock relay manager thread did not finish.");
        join_handle_test_environment
            .join()
            .expect("Test environment thread did not finish.");
        join_handle_test_object
            .join()
            .expect("Test object thread did not finish.");
    }

    #[test]
    // Test case checks if waiting for midnight and statistical calculations are computed correctly.
    // Test case uses test database #16.
    pub fn test_heating_wait_for_midnight_calc_stats_heater_off() {
        let sleep_duration_100_millis = Duration::from_millis(100);
        let spin_sleeper = SpinSleeper::default();

        let (mut config, mut heating, sql_interface, mut sql_interface_heating_stats) =
            prepare_heating_tests_mock_midnight_calculator(3, 16, None);

        // replacement values are used to initialize the mutexes
        config.sensor_manager.replacement_value_water_temperature = 30.0;
        config.sensor_manager.replacement_value_ambient_temperature = 24.0;

        let mut channels = Channels::new_for_test();

        // get initial data for calculation of reference value
        let initial_heating_stats_entry = sql_interface_heating_stats
            .get_single_heating_stats_from_database()
            .unwrap_or_else(|_| {
                // database responded with an empty response - let's create an empty entry
                HeatingStatsEntry {
                    date: Local::now().date_naive(),
                    energy: 0.0,
                    ambient_temperature_average_value: 0.0,
                    ambient_temperature_average_counter: 0,
                    water_temperature_average_value: 0.0,
                    water_temperature_average_counter: 0,
                    heating_control_runtime: 0,
                }
            });

        // thread for mock schedule check
        let join_handle_mock_schedule_check = thread::Builder::new()
            .name("mock_schedule_check".to_string())
            .spawn(move || {
                mock_schedule_check(
                    &mut channels.schedule_check.tx_schedule_check_to_heating,
                    &mut channels.schedule_check.rx_schedule_check_from_heating,
                    None,
                    true,
                );
            })
            .unwrap();

        // Mutex for tank level switch signals
        let mutex_tank_level_switch_signals =
            Arc::new(Mutex::new(TankLevelSwitchSignals::new(true, true, false)));

        let mutex_device_scheduler_heating = Arc::new(Mutex::new(0));

        // thread for mock relay manager
        let join_handle_mock_relay_manager = thread::Builder::new()
            .name("mock_relay_manager".to_string())
            .spawn(move || {
                mock_relay_manager(
                    &mut channels.relay_manager.tx_relay_manager_to_heating,
                    &mut channels.relay_manager.rx_relay_manager_from_heating,
                );
            })
            .unwrap();

        // thread for controlling duration of test run
        let join_handle_test_environment = thread::Builder::new()
            .name("test_environment".to_string())
            .spawn(move || {
                let sleep_duration = Duration::from_secs(4);
                let spin_sleeper = SpinSleeper::default();
                spin_sleeper.sleep(sleep_duration);
                let _ = channels
                    .signal_handler
                    .send_to_heating(InternalCommand::Quit);
                channels.signal_handler.receive_from_heating().unwrap();
                let _ = channels
                    .signal_handler
                    .send_to_heating(InternalCommand::Terminate);
            })
            .unwrap();

        spin_sleeper.sleep(sleep_duration_100_millis);

        // thread for the test object
        let join_handle_test_object = thread::Builder::new()
            .name("test_object".to_string())
            .spawn(move || {
                // clone sender part of the channels to mock threads so that we can terminate them after execution of the test object
                let mut tx_heating_to_schedule_check_for_test_case_finish =
                    channels.heating.tx_heating_to_schedule_check.clone();
                let mut tx_heating_to_relay_manager_for_test_case_finish =
                    channels.heating.tx_heating_to_relay_manager.clone();

                let mut heating_stats_transfer =
                    HeatingStatsMockDataTransfer::new(&mut sql_interface.get_connection().unwrap());
                let mut heating_set_value_updater = MockSqlInterfaceHeatingSetVals::new(false, None, None, None);

                let heating_mutexes = HeatingMutexes {
                    mutex_sensor_manager_signals: Arc::new(Mutex::new(SensorManagerSignals::new(&config.sensor_manager))),
                    mutex_tank_level_switch_signals,
                    mutex_heating_status: Arc::new(Mutex::new(false)),
                };

                heating.execute(
                    mutex_device_scheduler_heating.clone(),
                    &mut channels.heating,
                    &mut heating_stats_transfer,
                    &mut heating_set_value_updater,
                    heating_mutexes,
                    sql_interface_heating_stats
                );

                // send Quit signal to mock threads because the test object has terminated
                let _ =
                    tx_heating_to_schedule_check_for_test_case_finish.send(InternalCommand::Quit);
                let _ = tx_heating_to_relay_manager_for_test_case_finish.send(InternalCommand::Quit);

                println!(
                    "test_heating_wait_for_midnight_calc_stats_heater_on (previous): {}",
                    heating_stats_transfer.heating_stats_entry_previous,
                );
                assert_eq!(
                    heating_stats_transfer
                        .heating_stats_entry_previous
                        .heating_control_runtime
                        - initial_heating_stats_entry.heating_control_runtime,
                    3
                );
                assert_le!(
                    -0.001,
                    heating_stats_transfer.heating_stats_entry_previous.energy
                );
                assert_ge!(
                    0.001,
                    heating_stats_transfer.heating_stats_entry_previous.energy
                );
                assert_le!(
                    23.999,
                    heating_stats_transfer
                        .heating_stats_entry_previous
                        .ambient_temperature_average_value
                );
                assert_ge!(
                    24.001,
                    heating_stats_transfer
                        .heating_stats_entry_previous
                        .ambient_temperature_average_value
                );
                assert_le!(
                    29.999,
                    heating_stats_transfer
                        .heating_stats_entry_previous
                        .water_temperature_average_value
                );
                assert_ge!(
                    30.001,
                    heating_stats_transfer
                        .heating_stats_entry_previous
                        .water_temperature_average_value
                );
                assert_eq!(
                    heating_stats_transfer
                        .heating_stats_entry_previous
                        .ambient_temperature_average_counter
                        - initial_heating_stats_entry.ambient_temperature_average_counter,
                    3
                );
                assert_eq!(
                    heating_stats_transfer
                        .heating_stats_entry_previous
                        .water_temperature_average_counter
                        - initial_heating_stats_entry.water_temperature_average_counter,
                    3
                );
                println!(
                    "test_heating_wait_for_midnight_calc_stats_heater_on (current): {}",
                    heating_stats_transfer.heating_stats_entry,
                );
                assert_eq!(
                    heating_stats_transfer
                        .heating_stats_entry
                        .heating_control_runtime
                        - initial_heating_stats_entry.heating_control_runtime,
                    1
                );
                assert_le!(-0.001, heating_stats_transfer.heating_stats_entry.energy);
                assert_ge!(0.001, heating_stats_transfer.heating_stats_entry.energy);
                assert_le!(
                    23.999,
                    heating_stats_transfer
                        .heating_stats_entry
                        .ambient_temperature_average_value
                );
                assert_ge!(
                    24.001,
                    heating_stats_transfer
                        .heating_stats_entry
                        .ambient_temperature_average_value
                );
                assert_le!(
                    29.999,
                    heating_stats_transfer
                        .heating_stats_entry
                        .water_temperature_average_value
                );
                assert_ge!(
                    30.001,
                    heating_stats_transfer
                        .heating_stats_entry
                        .water_temperature_average_value
                );
                assert_eq!(
                    heating_stats_transfer
                        .heating_stats_entry
                        .ambient_temperature_average_counter
                        - initial_heating_stats_entry.ambient_temperature_average_counter,
                    1
                );
                assert_eq!(
                    heating_stats_transfer
                        .heating_stats_entry
                        .water_temperature_average_counter
                        - initial_heating_stats_entry.water_temperature_average_counter,
                    1
                );
                println!("* [Heating] checking heating waiting for midnight and stats calculation with heater on succeeded.");
            })
            .unwrap();

        join_handle_mock_schedule_check
            .join()
            .expect("Mock schedule check did not finish.");
        join_handle_mock_relay_manager
            .join()
            .expect("Mock relay manager thread did not finish.");
        join_handle_test_environment
            .join()
            .expect("Test environment thread did not finish.");
        join_handle_test_object
            .join()
            .expect("Test object thread did not finish.");
    }

    #[test]
    // Test case checks if a negative schedule checker result is processed correctly.
    // Test case uses test database #17.
    pub fn test_heating_blocked_by_schedule() {
        let sleep_duration_100_millis = Duration::from_millis(100);
        let spin_sleeper = SpinSleeper::default();

        let (mut config, mut heating, sql_interface, sql_interface_heating_stats) =
            prepare_heating_tests_mock_midnight_calculator(3600, 17, None);

        // replacement values are used to initialize the mutexes
        config.sensor_manager.replacement_value_water_temperature = 20.0;
        config.sensor_manager.replacement_value_ambient_temperature = 24.0;

        let mut channels = Channels::new_for_test();

        // Mutex for tank level switch signals
        let mutex_tank_level_switch_signals =
            Arc::new(Mutex::new(TankLevelSwitchSignals::new(true, true, false)));

        // thread for mock schedule check
        let join_handle_mock_schedule_check = thread::Builder::new()
            .name("mock_schedule_check".to_string())
            .spawn(move || {
                mock_schedule_check(
                    &mut channels.schedule_check.tx_schedule_check_to_heating,
                    &mut channels.schedule_check.rx_schedule_check_from_heating,
                    None,
                    false,
                );
            })
            .unwrap();

        let mutex_device_scheduler_heating = Arc::new(Mutex::new(0));

        // thread for mock relay manager - includes assertions
        let join_handle_mock_relay_manager = thread::Builder::new()
            .name("mock_relay_manager".to_string())
            .spawn(move || {
                let (mut actuation_events, mock_actuator_states) = mock_relay_manager(
                    &mut channels.relay_manager.tx_relay_manager_to_heating,
                    &mut channels.relay_manager.rx_relay_manager_from_heating,
                );
                assert_eq!(actuation_events.len(), 1);
                let actuation_event = actuation_events.pop().unwrap();
                assert_eq!(
                    actuation_event.command,
                    InternalCommand::SwitchOff(AquariumDevice::Heater)
                );
                mock_actuator_states.check_terminal_condition_heating();
            })
            .unwrap();

        // thread for controlling duration of test run
        let join_handle_test_environment = thread::Builder::new()
            .name("test_environment".to_string())
            .spawn(move || {
                let sleep_duration_ten_seconds = Duration::from_secs(10);
                let spin_sleeper = SpinSleeper::default();
                spin_sleeper.sleep(sleep_duration_ten_seconds);
                let _ = channels
                    .signal_handler
                    .send_to_heating(InternalCommand::Quit);
                channels.signal_handler.receive_from_heating().unwrap();
                let _ = channels
                    .signal_handler
                    .send_to_heating(InternalCommand::Terminate);
            })
            .unwrap();

        // make sure all mock threads are running when instantiating the test object
        spin_sleeper.sleep(sleep_duration_100_millis);

        // thread for the test object
        let join_handle_test_object = thread::Builder::new()
            .name("test_object".to_string())
            .spawn(move || {
                // clone sender part of the channels to mock threads so that we can terminate them after execution of the test object
                let mut tx_heating_to_schedule_check_for_test_case_finish =
                    channels.heating.tx_heating_to_schedule_check.clone();
                let mut tx_heating_to_relay_manager_for_test_case_finish =
                    channels.heating.tx_heating_to_relay_manager.clone();

                let mut heating_stats_transfer =
                    HeatingStatsMockDataTransfer::new(&mut sql_interface.get_connection().unwrap());
                let mut heating_set_value_updater =
                    MockSqlInterfaceHeatingSetVals::new(false, None, None, None);

                let heating_mutexes = HeatingMutexes {
                    mutex_sensor_manager_signals: Arc::new(Mutex::new(SensorManagerSignals::new(
                        &config.sensor_manager,
                    ))),
                    mutex_tank_level_switch_signals,
                    mutex_heating_status: Arc::new(Mutex::new(false)),
                };

                heating.execute(
                    mutex_device_scheduler_heating.clone(),
                    &mut channels.heating,
                    &mut heating_stats_transfer,
                    &mut heating_set_value_updater,
                    heating_mutexes,
                    sql_interface_heating_stats,
                );

                // send Quit signal to mock threads because the test object has terminated
                let _ =
                    tx_heating_to_schedule_check_for_test_case_finish.send(InternalCommand::Quit);
                let _ =
                    tx_heating_to_relay_manager_for_test_case_finish.send(InternalCommand::Quit);
                println!("* [Heating] checking if schedule checker can block actuation.");
            })
            .unwrap();

        join_handle_mock_schedule_check
            .join()
            .expect("Mock schedule check did not finish.");
        join_handle_mock_relay_manager
            .join()
            .expect("Mock relay manager thread did not finish.");
        join_handle_test_environment
            .join()
            .expect("Test environment thread did not finish.");
        join_handle_test_object
            .join()
            .expect("Test object thread did not finish.");
    }

    #[test]
    // Test case checks if component protection is executed.
    // Test case uses test database #18.
    pub fn test_heating_component_protection_when_tank_level_low() {
        let sleep_duration_100_millis = Duration::from_millis(100);
        let spin_sleeper = SpinSleeper::default();

        let (mut config, mut heating, sql_interface, sql_interface_heating_stats) =
            prepare_heating_tests_mock_midnight_calculator(3, 18, None);
        // replacement values are used to initialize the mutexes
        config.sensor_manager.replacement_value_water_temperature = 20.0;
        config.sensor_manager.replacement_value_ambient_temperature = 24.0;

        let mut channels = Channels::new_for_test();

        // thread for mock schedule check
        let join_handle_mock_schedule_check = thread::Builder::new()
            .name("mock_schedule_check".to_string())
            .spawn(move || {
                mock_schedule_check(
                    &mut channels.schedule_check.tx_schedule_check_to_heating,
                    &mut channels.schedule_check.rx_schedule_check_from_heating,
                    None,
                    true,
                );
            })
            .unwrap();

        // Mutex for tank level switch signals
        let mutex_tank_level_switch_signals =
            Arc::new(Mutex::new(TankLevelSwitchSignals::new(false, false, false)));

        let mutex_device_scheduler_heating = Arc::new(Mutex::new(0));

        // thread for mock relay manager - includes assertions
        let join_handle_mock_relay_manager = thread::Builder::new()
            .name("mock_relay_manager".to_string())
            .spawn(move || {
                let (mut actuation_events, mock_actuator_states) = mock_relay_manager(
                    &mut channels.relay_manager.tx_relay_manager_to_heating,
                    &mut channels.relay_manager.rx_relay_manager_from_heating,
                );
                assert_eq!(actuation_events.len(), 2);
                let actuation_event = actuation_events.pop().unwrap();
                assert_eq!(
                    actuation_event.command,
                    InternalCommand::SwitchOff(AquariumDevice::Heater)
                );
                let actuation_event = actuation_events.pop().unwrap();
                assert_eq!(
                    actuation_event.command,
                    InternalCommand::SwitchOn(AquariumDevice::Heater)
                );
                mock_actuator_states.check_terminal_condition_heating();
            })
            .unwrap();

        // thread for controlling duration of test run
        let join_handle_test_environment = thread::Builder::new()
            .name("test_environment".to_string())
            .spawn(move || {
                let sleep_duration_ten_seconds = Duration::from_secs(10);
                let spin_sleeper = SpinSleeper::default();
                spin_sleeper.sleep(sleep_duration_ten_seconds);
                let _ = channels
                    .signal_handler
                    .send_to_heating(InternalCommand::Quit);
                channels.signal_handler.receive_from_heating().unwrap();
                let _ = channels
                    .signal_handler
                    .send_to_heating(InternalCommand::Terminate);
            })
            .unwrap();

        // make sure all mock threads are running when instantiating the test object
        spin_sleeper.sleep(sleep_duration_100_millis);

        // thread for the test object
        let join_handle_test_object = thread::Builder::new()
            .name("test_object".to_string())
            .spawn(move || {
                // clone sender part of the channels to mock threads so that we can terminate them after execution of the test object
                let mut tx_heating_to_schedule_check_for_test_case_finish =
                    channels.heating.tx_heating_to_schedule_check.clone();
                let mut tx_heating_to_relay_manager_for_test_case_finish =
                    channels.heating.tx_heating_to_relay_manager.clone();

                let mut heating_stats_transfer =
                    HeatingStatsMockDataTransfer::new(&mut sql_interface.get_connection().unwrap());
                let mut heating_set_value_updater =
                    MockSqlInterfaceHeatingSetVals::new(false, None, None, None);

                let heating_mutexes = HeatingMutexes {
                    mutex_sensor_manager_signals: Arc::new(Mutex::new(SensorManagerSignals::new(
                        &config.sensor_manager,
                    ))),
                    mutex_tank_level_switch_signals,
                    mutex_heating_status: Arc::new(Mutex::new(false)),
                };

                heating.execute(
                    mutex_device_scheduler_heating.clone(),
                    &mut channels.heating,
                    &mut heating_stats_transfer,
                    &mut heating_set_value_updater,
                    heating_mutexes,
                    sql_interface_heating_stats,
                );

                // send Quit signal to mock threads because the test object has terminated
                let _ =
                    tx_heating_to_schedule_check_for_test_case_finish.send(InternalCommand::Quit);
                let _ =
                    tx_heating_to_relay_manager_for_test_case_finish.send(InternalCommand::Quit);

                println!("* [Heating] checking if schedule checker can block actuation.");
            })
            .unwrap();

        join_handle_mock_schedule_check
            .join()
            .expect("Mock schedule check did not finish.");
        join_handle_mock_relay_manager
            .join()
            .expect("Mock relay manager thread did not finish.");
        join_handle_test_environment
            .join()
            .expect("Test environment thread did not finish.");
        join_handle_test_object
            .join()
            .expect("Test object thread did not finish.");
    }

    #[test]
    // Test case runs heating control and triggers inhibition by sending a stop message via the channel.
    // After verification that heating is stopped,
    // The test case sends the start message via the channel and verifies if heating control
    // resumes operation.
    // Test case uses test database #19.
    pub fn test_messaging_stops_starts_heating() {
        let (mut config, mut heating, sql_interface, sql_interface_heating_stats) =
            prepare_heating_tests_mock_midnight_calculator(3600, 19, None);

        // replacement values are used to initialize the mutexes
        config.sensor_manager.replacement_value_water_temperature = 20.0;
        config.sensor_manager.replacement_value_ambient_temperature = 24.0;

        let mut channels = Channels::new_for_test();

        let mutex_device_scheduler_heating = Arc::new(Mutex::new(0));
        let mutex_device_scheduler_test_environment = mutex_device_scheduler_heating.clone();

        // thread for mock schedule check
        let join_handle_mock_schedule_check = thread::Builder::new()
            .name("mock_schedule_check".to_string())
            .spawn(move || {
                mock_schedule_check(
                    &mut channels.schedule_check.tx_schedule_check_to_heating,
                    &mut channels.schedule_check.rx_schedule_check_from_heating,
                    None,
                    true,
                );
            })
            .unwrap();

        // Mutex for tank level switch signals
        let mutex_tank_level_switch_signals =
            Arc::new(Mutex::new(TankLevelSwitchSignals::new(true, true, false)));

        // thread for mock relay manager - includes assertions
        let join_handle_mock_relay_manager = thread::Builder::new()
            .name("mock_relay_manager".to_string())
            .spawn(move || {
                let (mut actuation_events, mock_actuator_states) = mock_relay_manager(
                    &mut channels.relay_manager.tx_relay_manager_to_heating,
                    &mut channels.relay_manager.rx_relay_manager_from_heating,
                );
                println!("actuation_events:");
                for actuation_event in &actuation_events {
                    println!("{}", actuation_event);
                }
                assert_eq!(actuation_events.len(), 4);
                let actuation_event = actuation_events.pop().unwrap();
                assert_eq!(
                    actuation_event.command,
                    InternalCommand::SwitchOff(AquariumDevice::Heater)
                );
                let actuation_event = actuation_events.pop().unwrap();
                assert_eq!(
                    actuation_event.command,
                    InternalCommand::SwitchOn(AquariumDevice::Heater)
                );
                let actuation_event = actuation_events.pop().unwrap();
                assert_eq!(
                    actuation_event.command,
                    InternalCommand::SwitchOff(AquariumDevice::Heater)
                );
                let actuation_event = actuation_events.pop().unwrap();
                assert_eq!(
                    actuation_event.command,
                    InternalCommand::SwitchOn(AquariumDevice::Heater)
                );
                mock_actuator_states.check_terminal_condition_heating();
            })
            .unwrap();

        // thread for test environment
        let join_handle_test_environment = thread::Builder::new()
            .name("test_environment".to_string())
            .spawn(move || {
                let sleep_duration_100_millis = Duration::from_millis(100);
                let spin_sleeper = SpinSleeper::default();

                // initial wait so that heating control can switch on
                for _ in 0..10 {
                    spin_sleeper.sleep(sleep_duration_100_millis);
                }
                // check the initial state of mutex: should be already switched on
                assert_eq!(*mutex_device_scheduler_test_environment.lock().unwrap(), 1);

                // sending a message requesting stop of heating control
                match channels
                    .messaging
                    .tx_messaging_to_heating
                    .send(InternalCommand::Stop)
                {
                    Ok(()) => { /* do nothing */ }
                    Err(e) => {
                        panic!(
                            "{}: error when sending stop command to test object ({e:?})",
                            module_path!()
                        );
                    }
                }

                // wait for 1 second: heating control will switch off
                for _ in 0..10 {
                    spin_sleeper.sleep(sleep_duration_100_millis);
                }
                // check if heating is actuated
                assert_eq!(*mutex_device_scheduler_test_environment.lock().unwrap(), 2);

                // sending a message requesting restart of heating control
                match channels
                    .messaging
                    .tx_messaging_to_heating
                    .send(InternalCommand::Start)
                {
                    Ok(()) => { /* do nothing */ }
                    Err(e) => {
                        panic!(
                            "{}: error when sending start command to test object ({e:?})",
                            module_path!()
                        );
                    }
                }

                // Wait for 1 second. Heating control will switch on
                for _ in 0..10 {
                    spin_sleeper.sleep(sleep_duration_100_millis);
                }
                // check if heating is actuated
                assert_eq!(*mutex_device_scheduler_test_environment.lock().unwrap(), 3);

                // sending a message requesting stop of heating control
                match channels
                    .messaging
                    .tx_messaging_to_heating
                    .send(InternalCommand::Stop)
                {
                    Ok(()) => { /* do nothing */ }
                    Err(e) => {
                        panic!(
                            "{}: error when sending stop command to test object ({e:?})",
                            module_path!()
                        );
                    }
                }

                // wait for 1 second: Heating control will switch off
                for _ in 0..10 {
                    spin_sleeper.sleep(sleep_duration_100_millis);
                }
                // check if heating is actuated
                assert_eq!(*mutex_device_scheduler_test_environment.lock().unwrap(), 4);

                // requesting heating control to quit
                let _ = channels
                    .signal_handler
                    .send_to_heating(InternalCommand::Quit);
                channels.signal_handler.receive_from_heating().unwrap();

                // check if heating is not actuated
                assert_eq!(*mutex_device_scheduler_test_environment.lock().unwrap(), 4);
                let _ = channels
                    .signal_handler
                    .send_to_heating(InternalCommand::Terminate);
            })
            .unwrap();

        // thread for the test object
        let join_handle_test_object = thread::Builder::new()
            .name("test_object".to_string())
            .spawn(move || {
                // clone sender part of the channels to mock threads so that we can terminate them after execution of the test object
                let mut tx_heating_to_schedule_check_for_test_case_finish =
                    channels.heating.tx_heating_to_schedule_check.clone();
                let mut tx_heating_to_relay_manager_for_test_case_finish =
                    channels.heating.tx_heating_to_relay_manager.clone();

                let mut heating_stats_transfer =
                    HeatingStatsMockDataTransfer::new(&mut sql_interface.get_connection().unwrap());
                let mut heating_set_value_updater =
                    MockSqlInterfaceHeatingSetVals::new(false, None, None, None);

                let heating_mutexes = HeatingMutexes {
                    mutex_sensor_manager_signals: Arc::new(Mutex::new(SensorManagerSignals::new(
                        &config.sensor_manager,
                    ))),
                    mutex_tank_level_switch_signals,
                    mutex_heating_status: Arc::new(Mutex::new(false)),
                };

                heating.execute(
                    mutex_device_scheduler_heating.clone(),
                    &mut channels.heating,
                    &mut heating_stats_transfer,
                    &mut heating_set_value_updater,
                    heating_mutexes,
                    sql_interface_heating_stats,
                );

                // send Quit signal to mock threads because the test object has terminated
                let _ =
                    tx_heating_to_schedule_check_for_test_case_finish.send(InternalCommand::Quit);
                let _ =
                    tx_heating_to_relay_manager_for_test_case_finish.send(InternalCommand::Quit);

                println!("* [Heating] checking if messaging can block and restart actuation.");
            })
            .unwrap();

        join_handle_mock_schedule_check
            .join()
            .expect("Mock schedule check did not finish.");
        join_handle_mock_relay_manager
            .join()
            .expect("Mock relay manager thread did not finish.");
        join_handle_test_environment
            .join()
            .expect("Test environment thread did not finish.");
        join_handle_test_object
            .join()
            .expect("Test object thread did not finish.");
    }

    #[test]
    // Check if the heater remains switched off with a high temperature initially.
    // After a limited time period, increase the set values and observe if the heater is switched on.
    // Also, implicitly test if the execute function terminates after receiving Quit and Terminate commands.
    // Test case uses test database #50.
    pub fn test_heating_with_increased_set_values() {
        let sleep_duration_100_millis = Duration::from_millis(100);
        let spin_sleeper = SpinSleeper::default();

        let (mut config, mut heating, sql_interface, sql_interface_heating_stats) =
            prepare_heating_tests_mock_midnight_calculator(3600, 50, None);
        // replacement values are used to initialize the mutexes
        config.sensor_manager.replacement_value_water_temperature = 30.0;
        config.sensor_manager.replacement_value_ambient_temperature = 24.0;

        let mut channels = Channels::new_for_test();

        // Mutex for tank level switch signals
        let mutex_tank_level_switch_signals =
            Arc::new(Mutex::new(TankLevelSwitchSignals::new(true, true, false)));

        // thread for mock schedule check
        let join_handle_mock_schedule_check = thread::Builder::new()
            .name("mock_schedule_check".to_string())
            .spawn(move || {
                mock_schedule_check(
                    &mut channels.schedule_check.tx_schedule_check_to_heating,
                    &mut channels.schedule_check.rx_schedule_check_from_heating,
                    None,
                    true,
                );
            })
            .unwrap();

        // thread for mock TankLevelSwitch
        let mutex_device_scheduler_heating = Arc::new(Mutex::new(0));

        // thread for mock relay manager - includes assertions
        let join_handle_mock_relay_manager = thread::Builder::new()
            .name("mock_relay_manager".to_string())
            .spawn(move || {
                let (mut actuation_events, mock_actuator_states) = mock_relay_manager(
                    &mut channels.relay_manager.tx_relay_manager_to_heating,
                    &mut channels.relay_manager.rx_relay_manager_from_heating,
                );
                assert_eq!(actuation_events.len(), 3);
                let actuation_event_3 = actuation_events.pop().unwrap();
                let actuation_event_2 = actuation_events.pop().unwrap();
                let actuation_event_1 = actuation_events.pop().unwrap();
                assert_eq!(
                    actuation_event_1.command,
                    InternalCommand::SwitchOff(AquariumDevice::Heater)
                );
                assert_eq!(
                    actuation_event_2.command,
                    InternalCommand::SwitchOn(AquariumDevice::Heater)
                );
                assert_eq!(
                    actuation_event_3.command,
                    InternalCommand::SwitchOff(AquariumDevice::Heater)
                );
                mock_actuator_states.check_terminal_condition_heating();
            })
            .unwrap();

        // thread for controlling duration of test run
        let join_handle_test_environment = thread::Builder::new()
            .name("test_environment".to_string())
            .spawn(move || {
                let sleep_duration_twelve_seconds = Duration::from_secs(12);
                let spin_sleeper = SpinSleeper::default();
                spin_sleeper.sleep(sleep_duration_twelve_seconds);
                let _ = channels
                    .signal_handler
                    .send_to_heating(InternalCommand::Quit);
                channels.signal_handler.receive_from_heating().unwrap();
                let _ = channels
                    .signal_handler
                    .send_to_heating(InternalCommand::Terminate);
            })
            .unwrap();

        // make sure all mock threads are running when instantiating the test object
        spin_sleeper.sleep(sleep_duration_100_millis);

        // thread for the test object
        let join_handle_test_object = thread::Builder::new()
            .name("test_object".to_string())
            .spawn(move || {
                // clone sender part of the channels to mock threads so that we can terminate them after execution of the test object
                let mut tx_heating_to_schedule_check_for_test_case_finish =
                    channels.heating.tx_heating_to_schedule_check.clone();
                let mut tx_heating_to_relay_manager_for_test_case_finish =
                    channels.heating.tx_heating_to_relay_manager.clone();

                let mut heating_stats_transfer =
                    HeatingStatsMockDataTransfer::new(&mut sql_interface.get_connection().unwrap());

                // set up the set value updater to actively manipulate the set values
                let mut heating_set_value_updater = MockSqlInterfaceHeatingSetVals::new(
                    true,
                    Some(50.0),
                    Some(40.0),
                    Some(Duration::from_secs(10)),
                );

                let heating_mutexes = HeatingMutexes {
                    mutex_sensor_manager_signals: Arc::new(Mutex::new(SensorManagerSignals::new(
                        &config.sensor_manager,
                    ))),
                    mutex_tank_level_switch_signals,
                    mutex_heating_status: Arc::new(Mutex::new(false)),
                };

                heating.execute(
                    mutex_device_scheduler_heating.clone(),
                    &mut channels.heating,
                    &mut heating_stats_transfer,
                    &mut heating_set_value_updater,
                    heating_mutexes,
                    sql_interface_heating_stats,
                );

                // send Quit signal to mock threads because the test object has terminated
                let _ =
                    tx_heating_to_schedule_check_for_test_case_finish.send(InternalCommand::Quit);
                let _ =
                    tx_heating_to_relay_manager_for_test_case_finish.send(InternalCommand::Quit);

                println!("* [Heating] checking reaction to high temperature succeeded.");
            })
            .unwrap();

        join_handle_mock_schedule_check
            .join()
            .expect("Mock schedule check did not finish.");
        join_handle_mock_relay_manager
            .join()
            .expect("Mock relay manager thread did not finish.");
        join_handle_test_environment
            .join()
            .expect("Test environment thread did not finish.");
        join_handle_test_object
            .join()
            .expect("Test object thread did not finish.");
    }

    #[test]
    // Check if the heater is switched on and is not switched off with low temperature.
    // Also, implicitly test if the execute function terminates after receiving Quit and Terminate commands.
    // Check if the heater is switched off after sending Quit command and before sending Terminate command.
    // Test case uses test database #12.
    // Additionally, mutex for heater status is blocked by test environment
    pub fn test_heating_with_measured_temperature_low_with_mutex_blocked() {
        let sleep_duration_100_millis = Duration::from_millis(100);
        let spin_sleeper = SpinSleeper::default();

        let (mut config, mut heating, sql_interface, sql_interface_heating_stats) =
            prepare_heating_tests_mock_midnight_calculator(3600, 12, None);

        // replacement values are used to initialize the mutexes
        config.sensor_manager.replacement_value_water_temperature = 20.0;
        config.sensor_manager.replacement_value_ambient_temperature = 24.0;

        let mut channels = Channels::new_for_test();

        // Mutex for tank level switch signals
        let mutex_tank_level_switch_signals =
            Arc::new(Mutex::new(TankLevelSwitchSignals::new(true, true, false)));

        // thread for mock schedule check
        let join_handle_mock_schedule_check = thread::Builder::new()
            .name("mock_schedule_check".to_string())
            .spawn(move || {
                mock_schedule_check(
                    &mut channels.schedule_check.tx_schedule_check_to_heating,
                    &mut channels.schedule_check.rx_schedule_check_from_heating,
                    None,
                    true,
                );
            })
            .unwrap();

        let mutex_device_scheduler_heating = Arc::new(Mutex::new(0));
        let mutex_heating_status = Arc::new(Mutex::new(false));
        let mutex_heating_status_clone_for_test_environment = mutex_heating_status.clone();

        // thread for mock relay manager - includes assertions
        let join_handle_mock_relay_manager = thread::Builder::new()
            .name("mock_relay_manager".to_string())
            .spawn(move || {
                let (mut actuation_events, mock_actuator_states) = mock_relay_manager(
                    &mut channels.relay_manager.tx_relay_manager_to_heating,
                    &mut channels.relay_manager.rx_relay_manager_from_heating,
                );
                assert_eq!(actuation_events.len(), 2);
                let last_actuation_event = actuation_events.pop().unwrap();
                assert_eq!(
                    last_actuation_event.command,
                    InternalCommand::SwitchOff(AquariumDevice::Heater)
                );
                let first_actuation_event = actuation_events.pop().unwrap();
                assert_eq!(
                    first_actuation_event.command,
                    InternalCommand::SwitchOn(AquariumDevice::Heater)
                );
                mock_actuator_states.check_terminal_condition_heating();
            })
            .unwrap();

        // thread for controlling duration of test run
        let join_handle_test_environment = thread::Builder::new()
            .name("test_environment".to_string())
            .spawn(move || {
                let sleep_duration_one_second = Duration::from_secs(1);
                let spin_sleeper = SpinSleeper::default();
                for i in 0..10 {
                    if i % 2 == 0 {
                        spin_sleeper.sleep(sleep_duration_one_second);
                    } else {
                        // block mutex on purpose
                        {
                            match mutex_heating_status_clone_for_test_environment.lock() {
                                Ok(_) => {
                                    spin_sleeper.sleep(sleep_duration_one_second);
                                }
                                Err(_) => {
                                    // Do nothing
                                }
                            }
                        }
                    }
                }
                let _ = channels
                    .signal_handler
                    .send_to_heating(InternalCommand::Quit);
                channels.signal_handler.receive_from_heating().unwrap();
                let _ = channels
                    .signal_handler
                    .send_to_heating(InternalCommand::Terminate);
            })
            .unwrap();

        // make sure all mock threads are running when instantiating the test object
        spin_sleeper.sleep(sleep_duration_100_millis);

        // thread for the test object
        let join_handle_test_object = thread::Builder::new()
            .name("test_object".to_string())
            .spawn(move || {
                // clone sender part of the channels to mock threads so that we can terminate them after execution of the test object
                let mut tx_heating_to_schedule_check_for_test_case_finish =
                    channels.heating.tx_heating_to_schedule_check.clone();
                let mut tx_heating_to_relay_manager_for_test_case_finish =
                    channels.heating.tx_heating_to_relay_manager.clone();

                let mut heating_stats_transfer =
                    HeatingStatsMockDataTransfer::new(&mut sql_interface.get_connection().unwrap());
                let mut heating_set_value_updater =
                    MockSqlInterfaceHeatingSetVals::new(false, None, None, None);

                let heating_mutexes = HeatingMutexes {
                    mutex_sensor_manager_signals: Arc::new(Mutex::new(SensorManagerSignals::new(
                        &config.sensor_manager,
                    ))),
                    mutex_tank_level_switch_signals,
                    mutex_heating_status
                };

                heating.execute(
                    mutex_device_scheduler_heating.clone(),
                    &mut channels.heating,
                    &mut heating_stats_transfer,
                    &mut heating_set_value_updater,
                    heating_mutexes,
                    sql_interface_heating_stats
                );

                // send Quit signal to mock threads because the test object has terminated
                let _ =
                    tx_heating_to_schedule_check_for_test_case_finish.send(InternalCommand::Quit);
                let _ =
                    tx_heating_to_relay_manager_for_test_case_finish.send(InternalCommand::Quit);

                assert_eq!(heating.mutex_access_duration_exceeded, true);

                println!("* [Heating] checking reaction to low temperature with mutex blocked succeeded.");
            })
            .unwrap();

        join_handle_mock_schedule_check
            .join()
            .expect("Mock schedule check did not finish.");
        join_handle_mock_relay_manager
            .join()
            .expect("Mock relay manager thread did not finish.");
        join_handle_test_environment
            .join()
            .expect("Test environment thread did not finish.");
        join_handle_test_object
            .join()
            .expect("Test object thread did not finish.");
    }
}