yash_env/

trap.rs

// This file is part of yash, an extended POSIX shell.
// Copyright (C) 2021 WATANABE Yuki
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <https://www.gnu.org/licenses/>.

//! Signal and other event handling settings.
//!
//! The trap is a mechanism of the shell that allows you to configure event
//! handlers for specific situations. A [`TrapSet`] is a mapping from [`Condition`]s to
//! [`Action`]s. When the mapping is modified, it updates the corresponding signal
//! disposition in the underlying system through a [`SignalSystem`] implementor.
//! Methods of `TrapSet` expect they are passed the same system instance in
//! every call to keep it in a correct state.
//!
//! `TrapSet` manages two types of signal handling configurations. One is
//! user-defined traps, which the user explicitly configures with the trap
//! built-in. The other is internal dispositions, which the shell implicitly
//! installs to the system to implement additional actions it needs to perform.
//! `TrapSet` merges the two configurations into a single [`Disposition`] for
//! each signal and sets it to the system.
//!
//! No signal disposition is involved for conditions other than signals, and the
//! trap set serves only as a storage for action settings.

mod cond;
mod state;

pub use self::cond::Condition;
pub use self::state::{Action, Origin, SetActionError, TrapState};
use self::state::{EnterSubshellOption, GrandState};
use crate::Env;
use crate::signal;
use crate::source::Location;
#[cfg(doc)]
use crate::system::Concurrent;
use crate::system::{Disposition, Errno, Signals};
use std::collections::BTreeMap;
use std::collections::btree_map::Entry;
use std::pin::Pin;
use std::rc::Rc;

/// System interface for signal handling configuration
pub trait SignalSystem: Signals {
    /// Returns the current disposition for a signal.
    ///
    /// This function returns the current disposition for the specified signal like
    /// [`set_disposition`](Self::set_disposition) does, but does not change the
    /// disposition.
    fn get_disposition(&self, signal: signal::Number) -> Result<Disposition, Errno>;

    /// Sets how a signal is handled.
    ///
    /// This function updates the signal blocking mask and the disposition for
    /// the specified signal, and returns the previous disposition.
    ///
    /// The return type is a future so that
    /// [virtual systems](crate::system::virtual) can simulate termination or
    /// suspension of the process that may be caused by a signal delivered as a
    /// result of changing the disposition.
    fn set_disposition(
        &self,
        signal: signal::Number,
        disposition: Disposition,
    ) -> impl Future<Output = Result<Disposition, Errno>> + use<Self>;
}

/// Delegates the `SignalSystem` trait to the contained instance of `S`
impl<S: SignalSystem> SignalSystem for Rc<S> {
    #[inline]
    fn get_disposition(&self, signal: signal::Number) -> Result<Disposition, Errno> {
        (self as &S).get_disposition(signal)
    }
    #[inline]
    fn set_disposition(
        &self,
        signal: signal::Number,
        disposition: Disposition,
    ) -> impl Future<Output = Result<Disposition, Errno>> + use<S> {
        (self as &S).set_disposition(signal, disposition)
    }
}

/// Iterator of trap actions configured in a [trap set](TrapSet).
///
/// [`TrapSet::iter`] returns this type of iterator.
#[must_use]
pub struct Iter<'a> {
    inner: std::collections::btree_map::Iter<'a, Condition, GrandState>,
}

impl<'a> Iterator for Iter<'a> {
    /// Type of items yielded by this iterator
    ///
    /// Each item is a tuple of a condition, the currently configured trap state,
    /// and the parent state that was active before entering a subshell.
    type Item = (&'a Condition, &'a TrapState, Option<&'a TrapState>);

    fn next(&mut self) -> Option<(&'a Condition, &'a TrapState, Option<&'a TrapState>)> {
        self.inner
            .next()
            .map(|(cond, state)| (cond, state.current_state(), state.parent_state()))
    }
}

/// Collection of event handling settings.
///
/// See the [module documentation](self) for details.
#[derive(Clone, Debug, Default)]
pub struct TrapSet {
    traps: BTreeMap<Condition, GrandState>,
}

impl TrapSet {
    /// Returns the current and parent states for a condition.
    ///
    /// This function returns a pair of optional trap states. The first is the
    /// currently configured trap action, and the second is the action set
    /// before [`enter_subshell`](Self::enter_subshell) was called.
    ///
    /// The current state (the first return value) is `None` if the state is
    /// unknown (because no trap action or internal disposition has been set for
    /// the signal specified by the condition). To get the current signal
    /// disposition in this case, use [`peek_state`](Self::peek_state).
    ///
    /// The parent state (the second return value) is `None` if the
    /// shell environment has not [entered a subshell](Self::enter_subshell) or
    /// a [trap action has been modified](Self::set_action) after entering the
    /// subshell.
    pub fn get_state<C: Into<Condition>>(
        &self,
        cond: C,
    ) -> (Option<&TrapState>, Option<&TrapState>) {
        self.get_state_impl(cond.into())
    }

    fn get_state_impl(&self, cond: Condition) -> (Option<&TrapState>, Option<&TrapState>) {
        match self.traps.get(&cond) {
            None => (None, None),
            Some(state) => (Some(state.current_state()), state.parent_state()),
        }
    }

    /// Returns the current state for a condition.
    ///
    /// This function returns the trap action for the specified condition that
    /// is to be included in the output of the `trap` built-in.
    ///
    /// If the current state is not yet known (because no trap action or
    /// internal disposition has been set for the signal specified by the
    /// condition), it calls [`SignalSystem::get_disposition`] to get the
    /// current signal disposition and saves it as the current state.
    ///
    /// If the shell environment has [entered a subshell](Self::enter_subshell)
    /// and no [trap action has been modified](Self::set_action) after entering
    /// the subshell, the state that was active before entering the subshell is
    /// returned.
    ///
    /// See also [`get_state`](Self::get_state), which returns `None` if the
    /// current state is not yet known.
    pub fn peek_state<S: SignalSystem, C: Into<Condition>>(
        &mut self,
        system: &S,
        cond: C,
    ) -> Result<&TrapState, Errno> {
        self.peek_state_impl(system, cond.into())
    }

    fn peek_state_impl<S: SignalSystem>(
        &mut self,
        system: &S,
        cond: Condition,
    ) -> Result<&TrapState, Errno> {
        let entry = self.traps.entry(cond);
        let state = GrandState::insert_from_system_if_vacant(system, entry)?;
        Ok(state.parent_state().unwrap_or(state.current_state()))
    }

    /// Sets a trap action for a condition.
    ///
    /// If the condition is a signal, this function installs a signal handler to
    /// the specified underlying system.
    ///
    /// If `override_ignore` is `false`, you cannot set a trap for a signal that
    /// has been ignored since the shell startup. An interactive shell should
    /// set `override_ignore` to `true` to bypass this restriction.
    ///
    /// You can never set a trap for `SIGKILL` or `SIGSTOP`.
    ///
    /// `origin` should be the location of the command performing this trap
    /// update. It is only informative: It does not affect the signal handling
    /// behavior and can be referenced later by [`get_state`](Self::get_state).
    ///
    /// This function clears all parent states remembered when [entering a
    /// subshell](Self::enter_subshell), not only for the specified condition
    /// but also for all other conditions.
    pub async fn set_action<S: SignalSystem, C: Into<Condition>>(
        &mut self,
        system: &S,
        cond: C,
        action: Action,
        origin: Location,
        override_ignore: bool,
    ) -> Result<(), SetActionError> {
        self.set_action_impl(system, cond.into(), action, origin, override_ignore)
            .await
    }

    async fn set_action_impl<S: SignalSystem>(
        &mut self,
        system: &S,
        cond: Condition,
        action: Action,
        origin: Location,
        override_ignore: bool,
    ) -> Result<(), SetActionError> {
        if let Condition::Signal(signal) = cond {
            if signal == S::SIGKILL {
                return Err(SetActionError::SIGKILL);
            }
            if signal == S::SIGSTOP {
                return Err(SetActionError::SIGSTOP);
            }
        }

        self.clear_parent_states();

        let entry = self.traps.entry(cond);
        GrandState::set_action(system, entry, action, origin, override_ignore).await
    }

    fn clear_parent_states(&mut self) {
        for state in self.traps.values_mut() {
            state.clear_parent_state();
        }
    }

    /// Returns an iterator over the signal actions configured in this trap set.
    ///
    /// The iterator yields tuples of the signal, the currently configured trap
    /// action, and the action set before
    /// [`enter_subshell`](Self::enter_subshell) was called.
    ///
    /// The iterator only emits conditions for which a trap action has been
    /// [set](Self::set_action) or [peeked](Self::peek_state). In other words,
    /// it does not include conditions for which the current state is not yet
    /// known. To get the state for all conditions, use
    /// [`peek_state`](Self::peek_state) for each condition.
    #[inline]
    pub fn iter(&self) -> Iter<'_> {
        let inner = self.traps.iter();
        Iter { inner }
    }

    /// Updates signal dispositions on entering a subshell.
    ///
    /// ## Resetting non-ignore traps
    ///
    /// POSIX requires that traps other than `Action::Ignore` be reset when
    /// entering a subshell. This function achieves that effect.
    ///
    /// The trap set will remember the original trap states as the parent
    /// states. You can get them from the second return value of
    /// [`get_state`](Self::get_state) or the third item of tuples yielded by an
    /// [iterator](Self::iter).
    ///
    /// Note that trap actions other than `Trap::Command` remain as before.
    ///
    /// ## Clearing internal dispositions
    ///
    /// Internal dispositions that have been installed are cleared except for
    /// the SIGCHLD signal.
    ///
    /// ## Ignoring SIGINT and SIGQUIT
    ///
    /// If `ignore_sigint_sigquit` is true, this function sets the dispositions
    /// for SIGINT and SIGQUIT to `Ignore`.
    ///
    /// ## Ignoring SIGTSTP, SIGTTIN, and SIGTTOU
    ///
    /// If `keep_internal_dispositions_for_stoppers` is true and the internal
    /// dispositions have been [enabled for SIGTSTP, SIGTTIN, and
    /// SIGTTOU](Self::enable_internal_dispositions_for_stoppers), this function
    /// leaves the dispositions for those signals set to `Ignore`.
    ///
    /// ## Errors
    ///
    /// This function ignores any errors that may occur when setting signal
    /// dispositions.
    pub async fn enter_subshell<S: SignalSystem>(
        &mut self,
        system: &S,
        ignore_sigint_sigquit: bool,
        keep_internal_dispositions_for_stoppers: bool,
    ) {
        self.clear_parent_states();

        for (&cond, state) in &mut self.traps {
            let option = match cond {
                Condition::Exit => EnterSubshellOption::ClearInternalDisposition,
                Condition::Signal(signal) =>
                {
                    #[allow(clippy::if_same_then_else)]
                    if signal == S::SIGCHLD {
                        EnterSubshellOption::KeepInternalDisposition
                    } else if ignore_sigint_sigquit && (signal == S::SIGINT || signal == S::SIGQUIT)
                    {
                        EnterSubshellOption::Ignore
                    } else if keep_internal_dispositions_for_stoppers
                        && (signal == S::SIGTSTP || signal == S::SIGTTIN || signal == S::SIGTTOU)
                        && state.internal_disposition() != Disposition::Default
                    {
                        EnterSubshellOption::Ignore
                    } else {
                        EnterSubshellOption::ClearInternalDisposition
                    }
                }
            };
            state.enter_subshell(system, cond, option).await.ok();
        }

        if ignore_sigint_sigquit {
            for signal in [S::SIGINT, S::SIGQUIT] {
                match self.traps.entry(Condition::Signal(signal)) {
                    Entry::Vacant(vacant) => {
                        GrandState::ignore(system, vacant).await.unwrap_or_default()
                    }
                    // If the entry is occupied, the signal is already ignored in the loop above.
                    Entry::Occupied(_) => {}
                }
            }
        }
    }

    /// Sets the `pending` flag of the [`TrapState`] for the specified signal.
    ///
    /// This function does nothing if no trap action has been
    /// [set](Self::set_action) for the signal.
    pub fn catch_signal(&mut self, signal: signal::Number) {
        if let Some(state) = self.traps.get_mut(&Condition::Signal(signal)) {
            state.mark_as_caught();
        }
    }

    /// Resets the `pending` flag of the [`TrapState`] for the specified signal.
    ///
    /// Returns the [`TrapState`] if the flag was set.
    pub fn take_signal_if_caught(&mut self, signal: signal::Number) -> Option<&TrapState> {
        self.traps
            .get_mut(&Condition::Signal(signal))
            .and_then(|state| state.handle_if_caught())
    }

    /// Returns a signal that has been [caught](Self::catch_signal).
    ///
    /// This function clears the `pending` flag of the [`TrapState`] for the
    /// specified signal.
    ///
    /// If there is more than one caught signal, it is unspecified which one of
    /// them is returned. If there is no caught signal, `None` is returned.
    pub fn take_caught_signal(&mut self) -> Option<(signal::Number, &TrapState)> {
        self.traps.iter_mut().find_map(|(&cond, state)| match cond {
            Condition::Signal(signal) => state.handle_if_caught().map(|trap| (signal, trap)),
            _ => None,
        })
    }

    async fn set_internal_disposition<S: SignalSystem>(
        &mut self,
        signal: signal::Number,
        disposition: Disposition,
        system: &S,
    ) -> Result<(), Errno> {
        let entry = self.traps.entry(Condition::Signal(signal));
        GrandState::set_internal_disposition(system, entry, disposition).await
    }

    /// Installs the internal disposition for `SIGCHLD`.
    ///
    /// You should install the internal disposition for `SIGCHLD` by using this
    /// function before waiting for `SIGCHLD` with [`crate::system::Wait::wait`]
    /// and [`Concurrent::wait_for_signals`]. The disposition allows catching
    /// `SIGCHLD`.
    ///
    /// This function remembers that the disposition has been installed, so a
    /// second call to the function will be a no-op.
    pub async fn enable_internal_disposition_for_sigchld<S: SignalSystem>(
        &mut self,
        system: &S,
    ) -> Result<(), Errno> {
        self.set_internal_disposition(S::SIGCHLD, Disposition::Catch, system)
            .await
    }

    /// Installs the internal dispositions for `SIGINT`, `SIGTERM`, and `SIGQUIT`.
    ///
    /// An interactive shell should install the internal dispositions for these
    /// signals by using this function. The dispositions catch `SIGINT` and
    /// ignore `SIGTERM` and `SIGQUIT`.
    ///
    /// This function remembers that the dispositions have been installed, so a
    /// second call to the function will be a no-op.
    pub async fn enable_internal_dispositions_for_terminators<S: SignalSystem>(
        &mut self,
        system: &S,
    ) -> Result<(), Errno> {
        self.set_internal_disposition(S::SIGINT, Disposition::Catch, system)
            .await?;
        self.set_internal_disposition(S::SIGTERM, Disposition::Ignore, system)
            .await?;
        self.set_internal_disposition(S::SIGQUIT, Disposition::Ignore, system)
            .await
    }

    /// Installs the internal dispositions for `SIGTSTP`, `SIGTTIN`, and `SIGTTOU`.
    ///
    /// An interactive job-controlling shell should install the internal
    /// dispositions for these signals by using this function. The dispositions
    /// ignore the signals.
    ///
    /// This function remembers that the dispositions have been installed, so a
    /// second call to the function will be a no-op.
    pub async fn enable_internal_dispositions_for_stoppers<S: SignalSystem>(
        &mut self,
        system: &S,
    ) -> Result<(), Errno> {
        self.set_internal_disposition(S::SIGTSTP, Disposition::Ignore, system)
            .await?;
        self.set_internal_disposition(S::SIGTTIN, Disposition::Ignore, system)
            .await?;
        self.set_internal_disposition(S::SIGTTOU, Disposition::Ignore, system)
            .await
    }

    /// Uninstalls the internal dispositions for `SIGINT`, `SIGTERM`, and `SIGQUIT`.
    pub async fn disable_internal_dispositions_for_terminators<S: SignalSystem>(
        &mut self,
        system: &S,
    ) -> Result<(), Errno> {
        self.set_internal_disposition(S::SIGINT, Disposition::Default, system)
            .await?;
        self.set_internal_disposition(S::SIGTERM, Disposition::Default, system)
            .await?;
        self.set_internal_disposition(S::SIGQUIT, Disposition::Default, system)
            .await
    }

    /// Uninstalls the internal dispositions for `SIGTSTP`, `SIGTTIN`, and `SIGTTOU`.
    pub async fn disable_internal_dispositions_for_stoppers<S: SignalSystem>(
        &mut self,
        system: &S,
    ) -> Result<(), Errno> {
        self.set_internal_disposition(S::SIGTSTP, Disposition::Default, system)
            .await?;
        self.set_internal_disposition(S::SIGTTIN, Disposition::Default, system)
            .await?;
        self.set_internal_disposition(S::SIGTTOU, Disposition::Default, system)
            .await
    }

    /// Uninstalls all internal dispositions.
    ///
    /// This function removes all internal dispositions that have been
    /// previously installed by `self`.
    /// Dispositions for any existing user-defined traps are not affected.
    pub async fn disable_internal_dispositions<S: SignalSystem>(
        &mut self,
        system: &S,
    ) -> Result<(), Errno> {
        self.set_internal_disposition(S::SIGCHLD, Disposition::Default, system)
            .await?;
        self.disable_internal_dispositions_for_terminators(system)
            .await?;
        self.disable_internal_dispositions_for_stoppers(system)
            .await
    }
}

impl<'a> IntoIterator for &'a TrapSet {
    /// Type of items yielded by this iterator
    ///
    /// Each item is a tuple of a condition, the currently configured trap state,
    /// and the parent state that was active before entering a subshell.
    type Item = (&'a Condition, &'a TrapState, Option<&'a TrapState>);
    type IntoIter = Iter<'a>;

    #[inline(always)]
    fn into_iter(self) -> Iter<'a> {
        self.iter()
    }
}

type PinFuture<'a, T> = Pin<Box<dyn Future<Output = T> + 'a>>;

/// Wrapper for running signal trap if caught
///
/// This struct declares a function type that runs a signal trap if the signal
/// has been caught. An implementation of this function type should be provided
/// and stored in the environment's [`any`](Env::any) storage so that it can
/// be used by modules that need to run signal traps.
///
/// This function takes a mutable reference to the environment and a signal
/// number to be checked. If the signal has been caught, the function runs the
/// corresponding trap action and returns `Some(result)`, where `result` is the
/// result of running the trap action. If the signal has not been caught, the
/// function returns `None`.
///
/// The most standard implementation of this function type is provided in the
/// [`yash-semantics` crate](https://crates.io/crates/yash-semantics):
///
/// ```
/// # use yash_env::Env;
/// # use yash_env::trap::RunSignalTrapIfCaught;
/// fn register_run_signal_trap_if_caught<S: yash_semantics::Runtime + 'static>(env: &mut Env<S>) {
///     env.any.insert(Box::new(RunSignalTrapIfCaught::<S>(|env, signal| {
///         Box::pin(async move { yash_semantics::trap::run_trap_if_caught(env, signal).await })
///     })));
/// }
/// # register_run_signal_trap_if_caught(&mut Env::new_virtual());
/// ```
pub struct RunSignalTrapIfCaught<S>(
    pub  for<'a> fn(
        env: &'a mut Env<S>,
        signal: signal::Number,
    ) -> PinFuture<'a, Option<crate::semantics::Result>>,
);

// Not derived automatically because S may not implement Clone, Copy, or Debug.
impl<S> Clone for RunSignalTrapIfCaught<S> {
    fn clone(&self) -> Self {
        *self
    }
}

impl<S> Copy for RunSignalTrapIfCaught<S> {}

impl<S> std::fmt::Debug for RunSignalTrapIfCaught<S> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_tuple("RunSignalTrapIfCaught")
            .field(&self.0)
            .finish()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::job::ProcessState;
    use crate::system::SendSignal as _;
    use crate::system::r#virtual::{
        SIGABRT, SIGALRM, SIGBUS, SIGCHLD, SIGCONT, SIGFPE, SIGHUP, SIGILL, SIGINT, SIGIOT,
        SIGKILL, SIGPIPE, SIGPROF, SIGQUIT, SIGSEGV, SIGSTOP, SIGSYS, SIGTERM, SIGTRAP, SIGTSTP,
        SIGTTIN, SIGTTOU, SIGURG, SIGUSR1, SIGUSR2, SIGVTALRM, SIGWINCH, SIGXCPU, SIGXFSZ,
    };
    use crate::test_helper::in_virtual_system;
    use futures_util::FutureExt as _;
    use std::cell::RefCell;
    use std::collections::HashMap;
    use std::future::ready;
    use std::ops::RangeInclusive;

    #[derive(Default)]
    pub struct DummySystem(pub RefCell<HashMap<signal::Number, Disposition>>);

    impl Signals for DummySystem {
        const SIGABRT: signal::Number = SIGABRT;
        const SIGALRM: signal::Number = SIGALRM;
        const SIGBUS: signal::Number = SIGBUS;
        const SIGCHLD: signal::Number = SIGCHLD;
        const SIGCLD: Option<signal::Number> = None;
        const SIGCONT: signal::Number = SIGCONT;
        const SIGEMT: Option<signal::Number> = None;
        const SIGFPE: signal::Number = SIGFPE;
        const SIGHUP: signal::Number = SIGHUP;
        const SIGILL: signal::Number = SIGILL;
        const SIGINFO: Option<signal::Number> = None;
        const SIGINT: signal::Number = SIGINT;
        const SIGIO: Option<signal::Number> = None;
        const SIGIOT: signal::Number = SIGIOT;
        const SIGKILL: signal::Number = SIGKILL;
        const SIGLOST: Option<signal::Number> = None;
        const SIGPIPE: signal::Number = SIGPIPE;
        const SIGPOLL: Option<signal::Number> = None;
        const SIGPROF: signal::Number = SIGPROF;
        const SIGPWR: Option<signal::Number> = None;
        const SIGQUIT: signal::Number = SIGQUIT;
        const SIGSEGV: signal::Number = SIGSEGV;
        const SIGSTKFLT: Option<signal::Number> = None;
        const SIGSTOP: signal::Number = SIGSTOP;
        const SIGSYS: signal::Number = SIGSYS;
        const SIGTERM: signal::Number = SIGTERM;
        const SIGTHR: Option<signal::Number> = None;
        const SIGTRAP: signal::Number = SIGTRAP;
        const SIGTSTP: signal::Number = SIGTSTP;
        const SIGTTIN: signal::Number = SIGTTIN;
        const SIGTTOU: signal::Number = SIGTTOU;
        const SIGURG: signal::Number = SIGURG;
        const SIGUSR1: signal::Number = SIGUSR1;
        const SIGUSR2: signal::Number = SIGUSR2;
        const SIGVTALRM: signal::Number = SIGVTALRM;
        const SIGWINCH: signal::Number = SIGWINCH;
        const SIGXCPU: signal::Number = SIGXCPU;
        const SIGXFSZ: signal::Number = SIGXFSZ;

        fn sigrt_range(&self) -> Option<RangeInclusive<signal::Number>> {
            None
        }
    }

    impl SignalSystem for DummySystem {
        fn get_disposition(&self, signal: signal::Number) -> Result<Disposition, Errno> {
            Ok(self.0.borrow().get(&signal).copied().unwrap_or_default())
        }

        fn set_disposition(
            &self,
            signal: signal::Number,
            disposition: Disposition,
        ) -> impl Future<Output = Result<Disposition, Errno>> + use<> {
            ready(Ok(self
                .0
                .borrow_mut()
                .insert(signal, disposition)
                .unwrap_or_default()))
        }
    }

    #[test]
    fn default_trap() {
        let trap_set = TrapSet::default();
        assert_eq!(trap_set.get_state(SIGCHLD), (None, None));
    }

    #[test]
    fn setting_trap_for_two_signals() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        let origin_1 = Location::dummy("foo");
        let result = trap_set
            .set_action(&system, SIGUSR1, Action::Ignore, origin_1.clone(), false)
            .now_or_never()
            .unwrap();
        assert_eq!(result, Ok(()));

        let command = Action::Command("echo".into());
        let origin_2 = Location::dummy("bar");
        let result = trap_set
            .set_action(&system, SIGUSR2, command.clone(), origin_2.clone(), false)
            .now_or_never()
            .unwrap();
        assert_eq!(result, Ok(()));

        assert_eq!(
            trap_set.get_state(SIGUSR1),
            (
                Some(&TrapState {
                    action: Action::Ignore,
                    origin: Origin::User(origin_1),
                    pending: false
                }),
                None
            )
        );
        assert_eq!(
            trap_set.get_state(SIGUSR2),
            (
                Some(&TrapState {
                    action: command,
                    origin: Origin::User(origin_2),
                    pending: false
                }),
                None
            )
        );
        assert_eq!(system.0.borrow()[&SIGUSR1], Disposition::Ignore);
        assert_eq!(system.0.borrow()[&SIGUSR2], Disposition::Catch);
    }

    #[test]
    fn setting_trap_for_sigkill() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        let origin = Location::dummy("origin");
        let result = trap_set
            .set_action(&system, SIGKILL, Action::Ignore, origin, false)
            .now_or_never()
            .unwrap();
        assert_eq!(result, Err(SetActionError::SIGKILL));
        assert_eq!(trap_set.get_state(SIGKILL), (None, None));
        assert_eq!(system.0.borrow().get(&SIGKILL), None);
    }

    #[test]
    fn setting_trap_for_sigstop() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        let origin = Location::dummy("origin");
        let result = trap_set
            .set_action(&system, SIGSTOP, Action::Ignore, origin, false)
            .now_or_never()
            .unwrap();
        assert_eq!(result, Err(SetActionError::SIGSTOP));
        assert_eq!(trap_set.get_state(SIGSTOP), (None, None));
        assert_eq!(system.0.borrow().get(&SIGSTOP), None);
    }

    #[test]
    fn peeking_state_with_default_inherited_disposition() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        let result = trap_set.peek_state(&system, SIGCHLD);
        assert_eq!(
            result,
            Ok(&TrapState {
                action: Action::Default,
                origin: Origin::Inherited,
                pending: false
            })
        );
    }

    #[test]
    fn peeking_state_with_inherited_disposition_of_ignore() {
        let system = DummySystem::default();
        system.0.borrow_mut().insert(SIGCHLD, Disposition::Ignore);
        let mut trap_set = TrapSet::default();
        let result = trap_set.peek_state(&system, SIGCHLD);
        assert_eq!(
            result,
            Ok(&TrapState {
                action: Action::Ignore,
                origin: Origin::Inherited,
                pending: false
            })
        );
    }

    #[test]
    fn peeking_state_with_parent_state() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        let origin = Location::dummy("foo");
        let command = Action::Command("echo".into());
        trap_set
            .set_action(&system, SIGUSR1, command.clone(), origin.clone(), false)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enter_subshell(&system, false, false)
            .now_or_never()
            .unwrap();

        let result = trap_set.peek_state(&system, SIGUSR1);
        assert_eq!(
            result,
            Ok(&TrapState {
                action: command,
                origin: Origin::User(origin),
                pending: false
            })
        );
    }

    #[test]
    fn basic_iteration() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        let origin_1 = Location::dummy("foo");
        trap_set
            .set_action(&system, SIGUSR1, Action::Ignore, origin_1.clone(), false)
            .now_or_never()
            .unwrap()
            .unwrap();
        let command = Action::Command("echo".into());
        let origin_2 = Location::dummy("bar");
        trap_set
            .set_action(&system, SIGUSR2, command.clone(), origin_2.clone(), false)
            .now_or_never()
            .unwrap()
            .unwrap();

        let mut i = trap_set.iter();
        let first = i.next().unwrap();
        assert_eq!(first.0, &Condition::Signal(SIGUSR1));
        assert_eq!(first.1.action, Action::Ignore);
        assert_eq!(first.1.origin, Origin::User(origin_1));
        assert_eq!(first.2, None);
        let second = i.next().unwrap();
        assert_eq!(second.0, &Condition::Signal(SIGUSR2));
        assert_eq!(second.1.action, command);
        assert_eq!(second.1.origin, Origin::User(origin_2));
        assert_eq!(first.2, None);
        assert_eq!(i.next(), None);
    }

    #[test]
    fn iteration_after_entering_subshell() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        let origin_1 = Location::dummy("foo");
        trap_set
            .set_action(&system, SIGUSR1, Action::Ignore, origin_1.clone(), false)
            .now_or_never()
            .unwrap()
            .unwrap();
        let command = Action::Command("echo".into());
        let origin_2 = Location::dummy("bar");
        trap_set
            .set_action(&system, SIGUSR2, command.clone(), origin_2.clone(), false)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enter_subshell(&system, false, false)
            .now_or_never()
            .unwrap();

        let mut i = trap_set.iter();
        let first = i.next().unwrap();
        assert_eq!(first.0, &Condition::Signal(SIGUSR1));
        assert_eq!(first.1.action, Action::Ignore);
        assert_eq!(first.1.origin, Origin::User(origin_1));
        assert_eq!(first.2, None);
        let second = i.next().unwrap();
        assert_eq!(second.0, &Condition::Signal(SIGUSR2));
        assert_eq!(second.1.action, Action::Default);
        assert_eq!(second.1.origin, Origin::Subshell);
        assert_eq!(second.2.unwrap().action, command);
        assert_eq!(second.2.unwrap().origin, Origin::User(origin_2));
        assert_eq!(i.next(), None);
    }

    #[test]
    fn iteration_after_setting_trap_in_subshell() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        let origin_1 = Location::dummy("foo");
        let command = Action::Command("echo".into());
        trap_set
            .set_action(&system, SIGUSR1, command, origin_1, false)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enter_subshell(&system, false, false)
            .now_or_never()
            .unwrap();
        let origin_2 = Location::dummy("bar");
        let command = Action::Command("ls".into());
        trap_set
            .set_action(&system, SIGUSR2, command.clone(), origin_2.clone(), false)
            .now_or_never()
            .unwrap()
            .unwrap();

        let mut i = trap_set.iter();
        let first = i.next().unwrap();
        assert_eq!(first.0, &Condition::Signal(SIGUSR1));
        assert_eq!(first.1.action, Action::Default);
        assert_eq!(first.1.origin, Origin::Subshell);
        assert_eq!(first.2, None);
        let second = i.next().unwrap();
        assert_eq!(second.0, &Condition::Signal(SIGUSR2));
        assert_eq!(second.1.action, command);
        assert_eq!(second.1.origin, Origin::User(origin_2));
        assert_eq!(second.2, None);
        assert_eq!(i.next(), None);
    }

    #[test]
    fn entering_subshell_resets_command_traps() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        let action = Action::Command("".into());
        let origin = Location::dummy("origin");
        trap_set
            .set_action(&system, SIGCHLD, action.clone(), origin.clone(), false)
            .now_or_never()
            .unwrap()
            .unwrap();

        trap_set
            .enter_subshell(&system, false, false)
            .now_or_never()
            .unwrap();
        assert_eq!(
            trap_set.get_state(SIGCHLD),
            (
                Some(&TrapState {
                    action: Action::Default,
                    origin: Origin::Subshell,
                    pending: false
                }),
                Some(&TrapState {
                    action,
                    origin: Origin::User(origin),
                    pending: false
                })
            )
        );
        assert_eq!(system.0.borrow()[&SIGCHLD], Disposition::Default);
    }

    #[test]
    fn entering_subshell_keeps_ignore_traps() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        let origin = Location::dummy("origin");
        trap_set
            .set_action(&system, SIGCHLD, Action::Ignore, origin.clone(), false)
            .now_or_never()
            .unwrap()
            .unwrap();

        trap_set
            .enter_subshell(&system, false, false)
            .now_or_never()
            .unwrap();
        assert_eq!(
            trap_set.get_state(SIGCHLD),
            (
                Some(&TrapState {
                    action: Action::Ignore,
                    origin: Origin::User(origin),
                    pending: false
                }),
                None
            )
        );
        assert_eq!(system.0.borrow()[&SIGCHLD], Disposition::Ignore);
    }

    #[test]
    fn entering_subshell_with_internal_disposition_for_sigchld() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        let action = Action::Command("".into());
        let origin = Location::dummy("origin");
        trap_set
            .set_action(&system, SIGCHLD, action.clone(), origin.clone(), false)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_disposition_for_sigchld(&system)
            .now_or_never()
            .unwrap()
            .unwrap();

        trap_set
            .enter_subshell(&system, false, false)
            .now_or_never()
            .unwrap();
        assert_eq!(
            trap_set.get_state(SIGCHLD),
            (
                Some(&TrapState {
                    action: Action::Default,
                    origin: Origin::Subshell,
                    pending: false
                }),
                Some(&TrapState {
                    action,
                    origin: Origin::User(origin),
                    pending: false
                })
            )
        );
        assert_eq!(system.0.borrow()[&SIGCHLD], Disposition::Catch);
    }

    #[test]
    fn entering_subshell_with_internal_disposition_for_sigint() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        let action = Action::Command("".into());
        let origin = Location::dummy("origin");
        trap_set
            .set_action(&system, SIGINT, action.clone(), origin.clone(), false)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_dispositions_for_terminators(&system)
            .now_or_never()
            .unwrap()
            .unwrap();

        trap_set
            .enter_subshell(&system, false, false)
            .now_or_never()
            .unwrap();
        assert_eq!(
            trap_set.get_state(SIGINT),
            (
                Some(&TrapState {
                    action: Action::Default,
                    origin: Origin::Subshell,
                    pending: false
                }),
                Some(&TrapState {
                    action,
                    origin: Origin::User(origin),
                    pending: false
                })
            )
        );
        assert_eq!(system.0.borrow()[&SIGINT], Disposition::Default);
    }

    #[test]
    fn entering_subshell_with_internal_disposition_for_sigterm() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        let action = Action::Command("".into());
        let origin = Location::dummy("origin");
        trap_set
            .set_action(&system, SIGTERM, action.clone(), origin.clone(), false)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_dispositions_for_terminators(&system)
            .now_or_never()
            .unwrap()
            .unwrap();

        trap_set
            .enter_subshell(&system, false, false)
            .now_or_never()
            .unwrap();
        assert_eq!(
            trap_set.get_state(SIGTERM),
            (
                Some(&TrapState {
                    action: Action::Default,
                    origin: Origin::Subshell,
                    pending: false
                }),
                Some(&TrapState {
                    action,
                    origin: Origin::User(origin),
                    pending: false
                })
            )
        );
        assert_eq!(system.0.borrow()[&SIGTERM], Disposition::Default);
    }

    #[test]
    fn entering_subshell_with_internal_disposition_for_sigquit() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        let action = Action::Command("".into());
        let origin = Location::dummy("origin");
        trap_set
            .set_action(&system, SIGQUIT, action.clone(), origin.clone(), false)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_dispositions_for_terminators(&system)
            .now_or_never()
            .unwrap()
            .unwrap();

        trap_set
            .enter_subshell(&system, false, false)
            .now_or_never()
            .unwrap();
        assert_eq!(
            trap_set.get_state(SIGQUIT),
            (
                Some(&TrapState {
                    action: Action::Default,
                    origin: Origin::Subshell,
                    pending: false
                }),
                Some(&TrapState {
                    action,
                    origin: Origin::User(origin),
                    pending: false
                })
            )
        );
        assert_eq!(system.0.borrow()[&SIGQUIT], Disposition::Default);
    }

    #[test]
    fn entering_subshell_with_internal_disposition_for_sigtstp() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        let action = Action::Command("".into());
        let origin = Location::dummy("origin");
        trap_set
            .set_action(&system, SIGTSTP, action.clone(), origin.clone(), false)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_dispositions_for_stoppers(&system)
            .now_or_never()
            .unwrap()
            .unwrap();

        trap_set
            .enter_subshell(&system, false, false)
            .now_or_never()
            .unwrap();
        assert_eq!(
            trap_set.get_state(SIGTSTP),
            (
                Some(&TrapState {
                    action: Action::Default,
                    origin: Origin::Subshell,
                    pending: false
                }),
                Some(&TrapState {
                    action,
                    origin: Origin::User(origin),
                    pending: false
                })
            )
        );
        assert_eq!(system.0.borrow()[&SIGTSTP], Disposition::Default);
    }

    #[test]
    fn entering_subshell_with_internal_disposition_for_sigttin() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        let action = Action::Command("".into());
        let origin = Location::dummy("origin");
        trap_set
            .set_action(&system, SIGTTIN, action.clone(), origin.clone(), false)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_dispositions_for_stoppers(&system)
            .now_or_never()
            .unwrap()
            .unwrap();

        trap_set
            .enter_subshell(&system, false, false)
            .now_or_never()
            .unwrap();
        assert_eq!(
            trap_set.get_state(SIGTTIN),
            (
                Some(&TrapState {
                    action: Action::Default,
                    origin: Origin::Subshell,
                    pending: false
                }),
                Some(&TrapState {
                    action,
                    origin: Origin::User(origin),
                    pending: false
                })
            )
        );
        assert_eq!(system.0.borrow()[&SIGTTIN], Disposition::Default);
    }

    #[test]
    fn entering_subshell_with_internal_disposition_for_sigttou() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        let action = Action::Command("".into());
        let origin = Location::dummy("origin");
        trap_set
            .set_action(&system, SIGTTOU, action.clone(), origin.clone(), false)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_dispositions_for_stoppers(&system)
            .now_or_never()
            .unwrap()
            .unwrap();

        trap_set
            .enter_subshell(&system, false, false)
            .now_or_never()
            .unwrap();
        assert_eq!(
            trap_set.get_state(SIGTTOU),
            (
                Some(&TrapState {
                    action: Action::Default,
                    origin: Origin::Subshell,
                    pending: false
                }),
                Some(&TrapState {
                    action,
                    origin: Origin::User(origin),
                    pending: false
                })
            )
        );
        assert_eq!(system.0.borrow()[&SIGTTOU], Disposition::Default);
    }

    #[test]
    fn setting_trap_after_entering_subshell_clears_parent_states() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        let origin_1 = Location::dummy("foo");
        let command = Action::Command("echo 1".into());
        trap_set
            .set_action(&system, SIGUSR1, command, origin_1, false)
            .now_or_never()
            .unwrap()
            .unwrap();
        let origin_2 = Location::dummy("bar");
        let command = Action::Command("echo 2".into());
        trap_set
            .set_action(&system, SIGUSR2, command, origin_2, false)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enter_subshell(&system, false, false)
            .now_or_never()
            .unwrap();

        let command = Action::Command("echo 9".into());
        let origin_3 = Location::dummy("qux");
        trap_set
            .set_action(&system, SIGUSR1, command.clone(), origin_3.clone(), false)
            .now_or_never()
            .unwrap()
            .unwrap();

        assert_eq!(
            trap_set.get_state(SIGUSR1),
            (
                Some(&TrapState {
                    action: command,
                    origin: Origin::User(origin_3),
                    pending: false
                }),
                None
            )
        );
        assert_eq!(
            trap_set.get_state(SIGUSR2),
            (
                Some(&TrapState {
                    action: Action::Default,
                    origin: Origin::Subshell,
                    pending: false
                }),
                None
            )
        );
        assert_eq!(system.0.borrow()[&SIGUSR1], Disposition::Catch);
        assert_eq!(system.0.borrow()[&SIGUSR2], Disposition::Default);
    }

    #[test]
    fn entering_nested_subshell_clears_parent_states() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        let origin_1 = Location::dummy("foo");
        let command = Action::Command("echo 1".into());
        trap_set
            .set_action(&system, SIGUSR1, command, origin_1, false)
            .now_or_never()
            .unwrap()
            .unwrap();
        let origin_2 = Location::dummy("bar");
        let command = Action::Command("echo 2".into());
        trap_set
            .set_action(&system, SIGUSR2, command, origin_2, false)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enter_subshell(&system, false, false)
            .now_or_never()
            .unwrap();
        trap_set
            .enter_subshell(&system, false, false)
            .now_or_never()
            .unwrap();

        assert_eq!(
            trap_set.get_state(SIGUSR1),
            (
                Some(&TrapState {
                    action: Action::Default,
                    origin: Origin::Subshell,
                    pending: false
                }),
                None
            )
        );
        assert_eq!(
            trap_set.get_state(SIGUSR2),
            (
                Some(&TrapState {
                    action: Action::Default,
                    origin: Origin::Subshell,
                    pending: false
                }),
                None
            )
        );
        assert_eq!(system.0.borrow()[&SIGUSR1], Disposition::Default);
        assert_eq!(system.0.borrow()[&SIGUSR2], Disposition::Default);
    }

    #[test]
    fn ignoring_sigint_on_entering_subshell_with_action_set() {
        in_virtual_system(|mut env, state| async move {
            env.traps
                .set_action(
                    &env.system,
                    SIGINT,
                    Action::Command("".into()),
                    Location::dummy(""),
                    false,
                )
                .await
                .unwrap();
            env.system.kill(env.main_pid, Some(SIGINT)).await.unwrap();
            env.traps.enter_subshell(&env.system, true, false).await;

            let state = state.borrow();
            let process = &state.processes[&env.main_pid];
            assert_eq!(process.disposition(SIGINT), Disposition::Ignore);
            assert_eq!(process.state(), ProcessState::Running);
        })
    }

    #[test]
    fn ignoring_sigquit_on_entering_subshell_with_action_set() {
        in_virtual_system(|mut env, state| async move {
            env.traps
                .set_action(
                    &env.system,
                    SIGQUIT,
                    Action::Command("".into()),
                    Location::dummy(""),
                    false,
                )
                .await
                .unwrap();
            env.system.kill(env.main_pid, Some(SIGQUIT)).await.unwrap();
            env.traps.enter_subshell(&env.system, true, false).await;

            let state = state.borrow();
            let process = &state.processes[&env.main_pid];
            assert_eq!(process.disposition(SIGQUIT), Disposition::Ignore);
            assert_eq!(process.state(), ProcessState::Running);
        })
    }

    #[test]
    fn ignoring_sigint_and_sigquit_on_entering_subshell_without_action_set() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        trap_set
            .enter_subshell(&system, true, false)
            .now_or_never()
            .unwrap();
        assert_eq!(system.0.borrow()[&SIGINT], Disposition::Ignore);
        assert_eq!(system.0.borrow()[&SIGQUIT], Disposition::Ignore);
    }

    #[test]
    fn keeping_stopper_internal_dispositions_ignored() {
        in_virtual_system(|mut env, state| async move {
            for signal in [SIGTSTP, SIGTTIN, SIGTTOU] {
                env.traps
                    .set_action(
                        &env.system,
                        signal,
                        Action::Command("".into()),
                        Location::dummy(""),
                        false,
                    )
                    .await
                    .unwrap();
            }
            env.traps
                .enable_internal_dispositions_for_stoppers(&env.system)
                .await
                .unwrap();
            for signal in [SIGTSTP, SIGTTIN, SIGTTOU] {
                env.system.kill(env.main_pid, Some(signal)).await.unwrap();
            }
            env.traps.enter_subshell(&env.system, false, true).await;

            let state = state.borrow();
            let process = &state.processes[&env.main_pid];
            assert_eq!(process.disposition(SIGTSTP), Disposition::Ignore);
            assert_eq!(process.disposition(SIGTTIN), Disposition::Ignore);
            assert_eq!(process.disposition(SIGTTOU), Disposition::Ignore);
            assert_eq!(process.state(), ProcessState::Running);
        })
    }

    #[test]
    fn no_stopper_internal_dispositions_enabled_to_be_kept_ignored() {
        in_virtual_system(|mut env, state| async move {
            for signal in [SIGTSTP, SIGTTIN, SIGTTOU] {
                env.traps
                    .set_action(
                        &env.system,
                        signal,
                        Action::Command("".into()),
                        Location::dummy(""),
                        false,
                    )
                    .await
                    .unwrap();
            }
            env.traps.enter_subshell(&env.system, false, true).await;

            let state = state.borrow();
            let process = &state.processes[&env.main_pid];
            assert_eq!(process.disposition(SIGTSTP), Disposition::Default);
            assert_eq!(process.disposition(SIGTTIN), Disposition::Default);
            assert_eq!(process.disposition(SIGTTOU), Disposition::Default);
        })
    }

    #[test]
    fn catching_signal() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        let command = Action::Command("echo INT".into());
        let origin = Location::dummy("origin");
        trap_set
            .set_action(&system, SIGINT, command, origin, false)
            .now_or_never()
            .unwrap()
            .unwrap();
        let command = Action::Command("echo TERM".into());
        let origin = Location::dummy("origin");
        trap_set
            .set_action(&system, SIGTERM, command, origin, false)
            .now_or_never()
            .unwrap()
            .unwrap();

        trap_set.catch_signal(SIGCHLD);
        trap_set.catch_signal(SIGINT);

        let trap_state = trap_set.get_state(SIGINT).0.unwrap();
        assert!(trap_state.pending, "trap_state = {trap_state:?}");
        let trap_state = trap_set.get_state(SIGTERM).0.unwrap();
        assert!(!trap_state.pending, "trap_state = {trap_state:?}");
    }

    #[test]
    fn taking_signal_if_caught() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        let command = Action::Command("echo INT".into());
        let origin = Location::dummy("origin");
        trap_set
            .set_action(&system, SIGINT, command, origin, false)
            .now_or_never()
            .unwrap()
            .unwrap();

        let result = trap_set.take_signal_if_caught(SIGINT);
        assert_eq!(result, None);

        trap_set.catch_signal(SIGINT);

        let result = trap_set.take_signal_if_caught(SIGINT);
        assert!(!result.unwrap().pending);

        let result = trap_set.take_signal_if_caught(SIGINT);
        assert_eq!(result, None);
    }

    #[test]
    fn taking_caught_signal() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        assert_eq!(trap_set.take_caught_signal(), None);

        let command = Action::Command("echo INT".into());
        let origin = Location::dummy("origin");
        trap_set
            .set_action(&system, SIGINT, command, origin, false)
            .now_or_never()
            .unwrap()
            .unwrap();
        let command = Action::Command("echo TERM".into());
        let origin = Location::dummy("origin");
        trap_set
            .set_action(&system, SIGTERM, command, origin, false)
            .now_or_never()
            .unwrap()
            .unwrap();
        let command = Action::Command("echo USR1".into());
        let origin = Location::dummy("origin");
        trap_set
            .set_action(&system, SIGUSR1, command, origin, false)
            .now_or_never()
            .unwrap()
            .unwrap();
        assert_eq!(trap_set.take_caught_signal(), None);

        trap_set.catch_signal(SIGINT);
        trap_set.catch_signal(SIGUSR1);
        // The order in which take_caught_signal returns the two signals is
        // unspecified, so we accept both the orders.
        let result = trap_set.take_caught_signal().unwrap();
        match result.0 {
            SIGINT => {
                assert_eq!(result.1.action, Action::Command("echo INT".into()));
                assert!(!result.1.pending);

                let result = trap_set.take_caught_signal().unwrap();
                assert_eq!(result.0, SIGUSR1);
                assert_eq!(result.1.action, Action::Command("echo USR1".into()));
                assert!(!result.1.pending);
            }
            SIGUSR1 => {
                assert_eq!(result.1.action, Action::Command("echo USR1".into()));
                assert!(!result.1.pending);

                let result = trap_set.take_caught_signal().unwrap();
                assert_eq!(result.0, SIGINT);
                assert_eq!(result.1.action, Action::Command("echo INT".into()));
                assert!(!result.1.pending);
            }
            _ => panic!("wrong signal: {result:?}"),
        }

        assert_eq!(trap_set.take_caught_signal(), None);
    }

    #[test]
    fn enabling_internal_disposition_for_sigchld() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        trap_set
            .enable_internal_disposition_for_sigchld(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        assert_eq!(system.0.borrow()[&SIGCHLD], Disposition::Catch);
    }

    #[test]
    fn enabling_internal_dispositions_for_terminators() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        trap_set
            .enable_internal_dispositions_for_terminators(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        assert_eq!(system.0.borrow()[&SIGINT], Disposition::Catch);
        assert_eq!(system.0.borrow()[&SIGTERM], Disposition::Ignore);
        assert_eq!(system.0.borrow()[&SIGQUIT], Disposition::Ignore);
    }

    #[test]
    fn enabling_internal_dispositions_for_stoppers() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        trap_set
            .enable_internal_dispositions_for_stoppers(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        assert_eq!(system.0.borrow()[&SIGTSTP], Disposition::Ignore);
        assert_eq!(system.0.borrow()[&SIGTTIN], Disposition::Ignore);
        assert_eq!(system.0.borrow()[&SIGTTOU], Disposition::Ignore);
    }

    #[test]
    fn disabling_internal_dispositions_for_initially_defaulted_signals() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        trap_set
            .enable_internal_disposition_for_sigchld(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_dispositions_for_terminators(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_dispositions_for_stoppers(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .disable_internal_dispositions(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        assert_eq!(system.0.borrow()[&SIGCHLD], Disposition::Default);
        assert_eq!(system.0.borrow()[&SIGINT], Disposition::Default);
        assert_eq!(system.0.borrow()[&SIGTERM], Disposition::Default);
        assert_eq!(system.0.borrow()[&SIGQUIT], Disposition::Default);
        assert_eq!(system.0.borrow()[&SIGTSTP], Disposition::Default);
        assert_eq!(system.0.borrow()[&SIGTTIN], Disposition::Default);
        assert_eq!(system.0.borrow()[&SIGTTOU], Disposition::Default);
    }

    fn ignore_signals(system: &mut DummySystem) {
        system.0.borrow_mut().extend(
            [SIGCHLD, SIGINT, SIGTERM, SIGQUIT, SIGTSTP, SIGTTIN, SIGTTOU]
                .into_iter()
                .map(|signal| (signal, Disposition::Ignore)),
        )
    }

    #[test]
    fn disabling_internal_dispositions_for_initially_ignored_signals() {
        let mut system = DummySystem::default();
        ignore_signals(&mut system);
        let mut trap_set = TrapSet::default();
        trap_set
            .enable_internal_disposition_for_sigchld(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_dispositions_for_terminators(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_dispositions_for_stoppers(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .disable_internal_dispositions(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        assert_eq!(system.0.borrow()[&SIGCHLD], Disposition::Ignore);
        assert_eq!(system.0.borrow()[&SIGINT], Disposition::Ignore);
        assert_eq!(system.0.borrow()[&SIGTERM], Disposition::Ignore);
        assert_eq!(system.0.borrow()[&SIGQUIT], Disposition::Ignore);
        assert_eq!(system.0.borrow()[&SIGTSTP], Disposition::Ignore);
        assert_eq!(system.0.borrow()[&SIGTTIN], Disposition::Ignore);
        assert_eq!(system.0.borrow()[&SIGTTOU], Disposition::Ignore);
    }

    #[test]
    fn disabling_internal_dispositions_after_enabling_twice() {
        let mut system = DummySystem::default();
        ignore_signals(&mut system);
        let mut trap_set = TrapSet::default();
        trap_set
            .enable_internal_disposition_for_sigchld(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_disposition_for_sigchld(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_dispositions_for_terminators(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_dispositions_for_terminators(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_dispositions_for_stoppers(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_dispositions_for_stoppers(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .disable_internal_dispositions(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        assert_eq!(system.0.borrow()[&SIGCHLD], Disposition::Ignore);
        assert_eq!(system.0.borrow()[&SIGINT], Disposition::Ignore);
        assert_eq!(system.0.borrow()[&SIGTERM], Disposition::Ignore);
        assert_eq!(system.0.borrow()[&SIGQUIT], Disposition::Ignore);
        assert_eq!(system.0.borrow()[&SIGTSTP], Disposition::Ignore);
        assert_eq!(system.0.borrow()[&SIGTTIN], Disposition::Ignore);
        assert_eq!(system.0.borrow()[&SIGTTOU], Disposition::Ignore);
    }

    #[test]
    fn disabling_internal_dispositions_without_enabling() {
        let mut system = DummySystem::default();
        ignore_signals(&mut system);
        let mut trap_set = TrapSet::default();
        trap_set
            .disable_internal_dispositions(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        assert_eq!(system.0.borrow()[&SIGCHLD], Disposition::Ignore);
        assert_eq!(system.0.borrow()[&SIGINT], Disposition::Ignore);
        assert_eq!(system.0.borrow()[&SIGTERM], Disposition::Ignore);
        assert_eq!(system.0.borrow()[&SIGQUIT], Disposition::Ignore);
        assert_eq!(system.0.borrow()[&SIGTSTP], Disposition::Ignore);
        assert_eq!(system.0.borrow()[&SIGTTIN], Disposition::Ignore);
        assert_eq!(system.0.borrow()[&SIGTTOU], Disposition::Ignore);
    }

    #[test]
    fn reenabling_internal_dispositions() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        trap_set
            .enable_internal_disposition_for_sigchld(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_disposition_for_sigchld(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_dispositions_for_terminators(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_dispositions_for_terminators(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_dispositions_for_stoppers(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_dispositions_for_stoppers(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .disable_internal_dispositions(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_disposition_for_sigchld(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_dispositions_for_terminators(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_dispositions_for_stoppers(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        assert_eq!(system.0.borrow()[&SIGCHLD], Disposition::Catch);
        assert_eq!(system.0.borrow()[&SIGINT], Disposition::Catch);
        assert_eq!(system.0.borrow()[&SIGTERM], Disposition::Ignore);
        assert_eq!(system.0.borrow()[&SIGQUIT], Disposition::Ignore);
        assert_eq!(system.0.borrow()[&SIGTSTP], Disposition::Ignore);
        assert_eq!(system.0.borrow()[&SIGTTIN], Disposition::Ignore);
        assert_eq!(system.0.borrow()[&SIGTTOU], Disposition::Ignore);
    }

    #[test]
    fn setting_trap_to_ignore_after_enabling_internal_disposition() {
        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        trap_set
            .enable_internal_disposition_for_sigchld(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        let origin = Location::dummy("origin");
        let result = trap_set
            .set_action(&system, SIGCHLD, Action::Ignore, origin, false)
            .now_or_never()
            .unwrap();
        assert_eq!(result, Ok(()));
        assert_eq!(system.0.borrow()[&SIGCHLD], Disposition::Catch);
    }

    #[test]
    fn resetting_trap_from_ignore_no_override_after_enabling_internal_dispositions() {
        let mut system = DummySystem::default();
        ignore_signals(&mut system);
        let mut trap_set = TrapSet::default();
        trap_set
            .enable_internal_disposition_for_sigchld(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_dispositions_for_terminators(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_dispositions_for_stoppers(&system)
            .now_or_never()
            .unwrap()
            .unwrap();

        for signal in [SIGCHLD, SIGINT] {
            let origin = Location::dummy("origin");
            let result = trap_set
                .set_action(&system, signal, Action::Default, origin, false)
                .now_or_never()
                .unwrap();
            assert_eq!(result, Err(SetActionError::InitiallyIgnored));
            assert_eq!(system.0.borrow()[&signal], Disposition::Catch);
        }
        for signal in [SIGTERM, SIGQUIT, SIGTSTP, SIGTTIN, SIGTTOU] {
            let origin = Location::dummy("origin");
            let result = trap_set
                .set_action(&system, signal, Action::Default, origin, false)
                .now_or_never()
                .unwrap();
            assert_eq!(result, Err(SetActionError::InitiallyIgnored));
            assert_eq!(system.0.borrow()[&signal], Disposition::Ignore);
        }
    }

    #[test]
    fn resetting_trap_from_ignore_override_after_enabling_internal_dispositions() {
        let mut system = DummySystem::default();
        ignore_signals(&mut system);
        let mut trap_set = TrapSet::default();
        trap_set
            .enable_internal_disposition_for_sigchld(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_dispositions_for_terminators(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_dispositions_for_stoppers(&system)
            .now_or_never()
            .unwrap()
            .unwrap();

        for signal in [SIGCHLD, SIGINT] {
            let origin = Location::dummy("origin");
            let result = trap_set
                .set_action(&system, signal, Action::Ignore, origin.clone(), true)
                .now_or_never()
                .unwrap();
            assert_eq!(result, Ok(()));
            assert_eq!(
                trap_set.get_state(signal),
                (
                    Some(&TrapState {
                        action: Action::Ignore,
                        origin: Origin::User(origin),
                        pending: false
                    }),
                    None
                )
            );
            assert_eq!(system.0.borrow()[&signal], Disposition::Catch);
        }
        for signal in [SIGTERM, SIGQUIT, SIGTSTP, SIGTTIN, SIGTTOU] {
            let origin = Location::dummy("origin");
            let result = trap_set
                .set_action(&system, signal, Action::Ignore, origin.clone(), true)
                .now_or_never()
                .unwrap();
            assert_eq!(result, Ok(()));
            assert_eq!(
                trap_set.get_state(signal),
                (
                    Some(&TrapState {
                        action: Action::Ignore,
                        origin: Origin::User(origin),
                        pending: false
                    }),
                    None
                )
            );
            assert_eq!(system.0.borrow()[&signal], Disposition::Ignore);
        }
    }

    #[test]
    fn disabling_internal_disposition_with_ignore_trap() {
        let signals = [SIGCHLD, SIGINT, SIGTERM, SIGQUIT, SIGTSTP, SIGTTIN, SIGTTOU];

        let system = DummySystem::default();
        let mut trap_set = TrapSet::default();
        trap_set
            .enable_internal_disposition_for_sigchld(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        trap_set
            .enable_internal_dispositions_for_terminators(&system)
            .now_or_never()
            .unwrap()
            .unwrap();
        let origin = Location::dummy("origin");
        for signal in signals {
            trap_set
                .set_action(&system, signal, Action::Ignore, origin.clone(), false)
                .now_or_never()
                .unwrap()
                .unwrap();
        }
        trap_set
            .disable_internal_dispositions(&system)
            .now_or_never()
            .unwrap()
            .unwrap();

        for signal in signals {
            assert_eq!(
                trap_set.get_state(signal),
                (
                    Some(&TrapState {
                        action: Action::Ignore,
                        origin: Origin::User(origin.clone()),
                        pending: false
                    }),
                    None
                )
            );
            assert_eq!(system.0.borrow()[&signal], Disposition::Ignore);
        }
    }
}