yash_env/

subshell.rs

// This file is part of yash, an extended POSIX shell.
// Copyright (C) 2023 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/>.

//! Utility for starting subshells
//!
//! This module defines [`Config`], a builder for starting a subshell. It is a
//! collection of options for starting a subshell, and provides methods to start
//! a subshell with the configured options. These methods are implemented as
//! wrappers around [`Env::run_in_child_process`], which in turn uses
//! [`Fork::run_in_child_process`]. You should prefer `Config` for the purpose
//! of creating a subshell because it helps to arrange the child process
//! properly.
//!
//! This module also defines a deprecated struct [`Subshell`] with a similar API
//! to `Config` for backward compatibility. New code should use `Config` instead
//! of `Subshell`.

use crate::Env;
use crate::job::Pid;
use crate::job::ProcessResult;
use crate::job::RunBlocking;
use crate::job::RunUnblocking;
use crate::system::Close;
use crate::system::Dup;
use crate::system::Errno;
use crate::system::Exit;
use crate::system::Fork;
use crate::system::GetPid;
use crate::system::Open;
use crate::system::SendSignal;
use crate::system::SetPgid;
use crate::system::Sigmask;
use crate::system::SigmaskOp;
use crate::system::Signals;
use crate::system::Sigset as _;
use crate::system::TcSetPgrp;
use crate::system::Wait;
use crate::system::concurrency::WaitForSignals;
use crate::system::resource::SetRlimit;
use crate::trap::SignalSystem;
use std::marker::PhantomData;
use std::pin::Pin;

/// Job state of a newly created subshell
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum JobControl {
    /// The subshell becomes the foreground process group.
    Foreground,
    /// The subshell becomes a background process group.
    Background,
}

/// Subshell builder
///
/// This is a helper for starting a subshell provided before [`Config`] was
/// introduced. Use `Config` instead since it provides a better API.
#[deprecated(
    note = "use `Config` for subshell configuration instead",
    since = "0.14.0"
)]
#[must_use = "a subshell is not started unless you call `Subshell::start`"]
pub struct Subshell<S, F> {
    task: F,
    job_control: Option<JobControl>,
    ignores_sigint_sigquit: bool,
    phantom_data: PhantomData<fn(&mut Env<S>)>,
}

#[allow(deprecated, reason = "for backward compatible API")]
impl<S, F> std::fmt::Debug for Subshell<S, F> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Subshell")
            .field("job_control", &self.job_control)
            .field("ignores_sigint_sigquit", &self.ignores_sigint_sigquit)
            .finish_non_exhaustive()
    }
}

#[allow(deprecated, reason = "for backward compatible API")]
impl<S, F> Subshell<S, F>
where
    S: BlockSignals
        + Close
        + Dup
        + Exit
        + Fork
        + GetPid
        + Open
        + RunBlocking
        + RunUnblocking
        + SendSignal
        + SetPgid
        + SetRlimit
        + SignalSystem
        + TcSetPgrp
        + WaitForSignals
        + 'static,
    F: for<'a> FnOnce(&'a mut Env<S>, Option<JobControl>) -> Pin<Box<dyn Future<Output = ()> + 'a>>
        + 'static,
    // TODO Revisit to simplify this function type when impl Future is allowed in return type
{
    /// Creates a new subshell builder with a task.
    ///
    /// The task will run in a subshell after it is started. The task takes two
    /// arguments:
    ///
    /// 1. The environment in which the subshell runs, and
    /// 2. Job control status for the subshell.
    ///
    /// If the task returns an `Err(Divert::...)`, it is handled as follows:
    ///
    /// - `Interrupt` and `Exit` with `Some(exit_status)` override the exit
    ///   status in `Env`.
    /// - Other `Divert` values are ignored.
    pub fn new(task: F) -> Self {
        Subshell {
            task,
            job_control: None,
            ignores_sigint_sigquit: false,
            phantom_data: PhantomData,
        }
    }

    /// Specifies disposition of the subshell with respect to job control.
    ///
    /// If the argument is `None` (which is the default), the subshell runs in
    /// the same process group as the parent process. If it is `Some(_)`, the
    /// subshell becomes a new process group. For `JobControl::Foreground`, it
    /// also brings itself to the foreground.
    ///
    /// This parameter is ignored if the shell is not [controlling
    /// jobs](Env::controls_jobs) when starting the subshell. You can tell the
    /// actual job control status of the subshell by the second return value of
    /// [`start`](Self::start) in the parent environment and the second argument
    /// passed to the task in the subshell environment.
    ///
    /// If the parent process is a job-controlling interactive shell, but the
    /// subshell is not job-controlled, the subshell's signal dispositions for
    /// SIGTSTP, SIGTTIN, and SIGTTOU are set to `Ignore`. This is to prevent
    /// the subshell from being stopped by a job-stopping signal. Were the
    /// subshell stopped, you could never resume it since it is not
    /// job-controlled.
    pub fn job_control<J: Into<Option<JobControl>>>(mut self, job_control: J) -> Self {
        self.job_control = job_control.into();
        self
    }

    /// Makes the subshell ignore SIGINT and SIGQUIT.
    ///
    /// If `ignore` is true and the subshell is not job-controlled, the subshell
    /// sets its signal dispositions for SIGINT and SIGQUIT to `Ignore`.
    ///
    /// The default is `false`.
    pub fn ignore_sigint_sigquit(mut self, ignore: bool) -> Self {
        self.ignores_sigint_sigquit = ignore;
        self
    }

    fn into_config_and_task(self) -> (Config, F) {
        let config = Config {
            job_control: self.job_control,
            ignores_sigint_sigquit: self.ignores_sigint_sigquit,
        };
        (config, self.task)
    }

    /// Starts the subshell.
    ///
    /// This function creates a new child process that runs the task contained
    /// in this builder.
    ///
    /// Although this function is `async`, it does not wait for the child to
    /// finish, which means the parent and child processes will run
    /// concurrently. To wait for the child to finish, you need to call
    /// [`Env::wait_for_subshell`] or [`Env::wait_for_subshell_to_finish`]. If
    /// job control is active, you may want to add the process ID to `env.jobs`
    /// before waiting.
    ///
    /// If you set [`job_control`](Self::job_control) to
    /// `JobControl::Foreground`, this function opens `env.tty` by calling
    /// [`Env::get_tty`]. The `tty` is used to change the foreground job to the
    /// new subshell. However, `job_control` is effective only when the shell is
    /// [controlling jobs](Env::controls_jobs).
    ///
    /// If the subshell started successfully, the return value is a pair of the
    /// child process ID and the actual job control. Otherwise, it indicates the
    /// error.
    pub async fn start(self, env: &mut Env<S>) -> Result<(Pid, Option<JobControl>), Errno> {
        let (config, task) = self.into_config_and_task();
        config
            .start(env, async move |env, job_control| {
                task(env, job_control).await
            })
            .await
    }

    /// Starts the subshell and waits for it to finish.
    ///
    /// This function [starts](Self::start) `self` and
    /// [waits](Env::wait_for_subshell) for it to finish. This function returns
    /// when the subshell process exits or is killed by a signal. If the
    /// subshell is job-controlled, the function also returns when the job is
    /// suspended.
    ///
    /// If the subshell started successfully, the return value is the process ID
    /// and the process result of the subshell. If there was an error starting
    /// the subshell, this function returns the error.
    ///
    /// If you set [`job_control`](Self::job_control) to
    /// `JobControl::Foreground` and job control is effective as per
    /// [`Env::controls_jobs`], this function makes the shell the foreground job
    /// after the subshell terminated or suspended.
    ///
    /// When a job-controlled subshell suspends, this function does not add it
    /// to `env.jobs`. You have to do it for yourself if necessary.
    pub async fn start_and_wait(self, env: &mut Env<S>) -> Result<(Pid, ProcessResult), Errno>
    where
        S: Wait,
    {
        let (config, task) = self.into_config_and_task();
        config
            .start_and_wait(env, async move |env, job_control| {
                task(env, job_control).await
            })
            .await
    }
}

/// Trait to temporarily block the SIGINT and SIGQUIT signals
///
/// This trait represents the capability required by [`Config::start`] to
/// temporarily block SIGINT and SIGQUIT while starting a subshell. Any type
/// that implements [`Sigmask`] automatically implements this trait.
/// Additionally, [`Concurrent`] implements this trait by delegating to the
/// inner system while not implementing `Sigmask` itself, which allows
/// `Concurrent` to maintain internal consistency about signal masks while still
/// providing this capability to its users.
///
/// This trait defines a higher-level interface to temporarily modify the signal
/// mask. Typically, implementors of this trait will internally depend on
/// `Sigmask` to perform the actual signal mask modification, but the details
/// are abstracted away.
///
/// [`Concurrent`]: crate::system::concurrency::Concurrent
pub trait BlockSignals: Signals {
    type SavedMask;

    /// Blocks SIGINT and SIGQUIT, returning the previous signal mask.
    ///
    /// After this function returns successfully, one of the following must be
    /// performed:
    ///
    /// - Call [`restore_sigmask`](Self::restore_sigmask) with the returned mask
    ///   to restore the original signal mask,
    /// - Call [`SignalSystem::set_disposition`] to re-set the disposition of
    ///   SIGINT and SIGQUIT, which installs a new signal mask,
    /// - [Exit](Exit::exit) the process without restoring the signal mask.
    fn block_sigint_sigquit(
        &self,
    ) -> impl Future<Output = Result<Self::SavedMask, Errno>> + use<'_, Self>;

    /// Restores the signal mask.
    ///
    /// This function restores the signal mask to the state represented by
    /// `mask`, which should be a value returned by a previous call to
    /// [`block_sigint_sigquit`](Self::block_sigint_sigquit).
    fn restore_sigmask(
        &self,
        mask: Self::SavedMask,
    ) -> impl Future<Output = Result<(), Errno>> + use<'_, Self>;
}

impl<S> BlockSignals for S
where
    S: Sigmask + ?Sized,
{
    type SavedMask = S::Sigset;

    async fn block_sigint_sigquit(&self) -> Result<Self::SavedMask, Errno> {
        let mut old_mask = S::Sigset::new();
        self.sigmask(
            Some((
                SigmaskOp::Add,
                &S::Sigset::from_signals([S::SIGINT, S::SIGQUIT])?,
            )),
            Some(&mut old_mask),
        )
        .await?;
        Ok(old_mask)
    }

    async fn restore_sigmask(&self, mask: Self::SavedMask) -> Result<(), Errno> {
        self.sigmask(Some((SigmaskOp::Set, &mask)), None).await
    }
}

mod config;
pub use config::Config;

#[allow(deprecated, reason = "for backward compatible API")]
#[cfg(test)]
mod tests {
    use super::*;
    use crate::job::{Job, ProcessState};
    use crate::option::Option::{Interactive, Monitor};
    use crate::option::State::On;
    use crate::semantics::ExitStatus;
    use crate::source::Location;
    use crate::stack::Frame;
    use crate::system::r#virtual::{Inode, SystemState, VirtualSystem};
    use crate::system::r#virtual::{SIGCHLD, SIGINT, SIGQUIT, SIGTSTP, SIGTTIN, SIGTTOU};
    use crate::system::{Concurrent, Disposition};
    use crate::test_helper::in_virtual_system;
    use crate::trap::Action;
    use assert_matches::assert_matches;
    use futures_executor::LocalPool;
    use std::cell::Cell;
    use std::cell::RefCell;
    use std::rc::Rc;

    fn stub_tty(state: &RefCell<SystemState>) {
        state
            .borrow_mut()
            .file_system
            .save("/dev/tty", Rc::new(RefCell::new(Inode::new([]))))
            .unwrap();
    }

    #[test]
    fn subshell_start_returns_child_process_id() {
        in_virtual_system(|mut env, _state| async move {
            let parent_pid = env.main_pid;
            let child_pid = Rc::new(Cell::new(None));
            let child_pid_2 = Rc::clone(&child_pid);
            let subshell = Subshell::new(
                move |env: &mut Env<Rc<Concurrent<VirtualSystem>>>, _job_control| {
                    Box::pin(async move {
                        child_pid_2.set(Some(env.system.getpid()));
                        assert_eq!(env.system.getppid(), parent_pid);
                    })
                },
            );
            let result = subshell.start(&mut env).await.unwrap().0;
            env.wait_for_subshell(result).await.unwrap();
            assert_eq!(Some(result), child_pid.get());
        });
    }

    #[test]
    fn subshell_start_failing() {
        let mut executor = LocalPool::new();
        let env = &mut Env::new_virtual();
        let subshell =
            Subshell::new(|_env, _job_control| unreachable!("subshell not expected to run"));
        let result = executor.run_until(subshell.start(env));
        assert_eq!(result, Err(Errno::ENOSYS));
    }

    #[test]
    fn stack_frame_in_subshell() {
        in_virtual_system(|mut env, _state| async move {
            let subshell = Subshell::new(|env, _job_control| {
                Box::pin(async { assert_eq!(env.stack[..], [Frame::Subshell]) })
            });
            let pid = subshell.start(&mut env).await.unwrap().0;
            assert_eq!(env.stack[..], []);

            env.wait_for_subshell(pid).await.unwrap();
        });
    }

    #[test]
    fn jobs_disowned_in_subshell() {
        in_virtual_system(|mut env, _state| async move {
            let index = env.jobs.insert(Job::new(Pid(123)));
            let subshell = Subshell::new(move |env, _job_control| {
                Box::pin(async move { assert!(!env.jobs[index].is_owned) })
            });
            let pid = subshell.start(&mut env).await.unwrap().0;
            env.wait_for_subshell(pid).await.unwrap();

            assert!(env.jobs[index].is_owned);
        });
    }

    #[test]
    fn trap_reset_in_subshell() {
        in_virtual_system(|mut env, _state| async move {
            env.traps
                .set_action(
                    &env.system,
                    SIGCHLD,
                    Action::Command("echo foo".into()),
                    Location::dummy(""),
                    false,
                )
                .await
                .unwrap();
            let subshell = Subshell::new(|env, _job_control| {
                Box::pin(async {
                    let (current, parent) = env.traps.get_state(SIGCHLD);
                    assert_eq!(current.unwrap().action, Action::Default);
                    assert_matches!(
                        &parent.unwrap().action,
                        Action::Command(body) => assert_eq!(&**body, "echo foo")
                    );
                })
            });
            let pid = subshell.start(&mut env).await.unwrap().0;
            env.wait_for_subshell(pid).await.unwrap();
        });
    }

    #[test]
    fn subshell_with_no_job_control() {
        in_virtual_system(|mut parent_env, state| async move {
            parent_env.options.set(Monitor, On);

            let parent_pgid = state.borrow().processes[&parent_env.main_pid].pgid;
            let state_2 = Rc::clone(&state);
            let (child_pid, job_control) = Subshell::new(
                move |child_env: &mut Env<Rc<Concurrent<VirtualSystem>>>, job_control| {
                    Box::pin(async move {
                        let child_pid = child_env.system.getpid();
                        assert_eq!(state_2.borrow().processes[&child_pid].pgid, parent_pgid);
                        assert_eq!(state_2.borrow().foreground, None);
                        assert_eq!(job_control, None);
                    })
                },
            )
            .job_control(None)
            .start(&mut parent_env)
            .await
            .unwrap();
            assert_eq!(job_control, None);
            assert_eq!(state.borrow().processes[&child_pid].pgid, parent_pgid);
            assert_eq!(state.borrow().foreground, None);

            parent_env.wait_for_subshell(child_pid).await.unwrap();
            assert_eq!(state.borrow().processes[&child_pid].pgid, parent_pgid);
            assert_eq!(state.borrow().foreground, None);
        });
    }

    #[test]
    fn subshell_in_background() {
        in_virtual_system(|mut parent_env, state| async move {
            parent_env.options.set(Monitor, On);

            let state_2 = Rc::clone(&state);
            let (child_pid, job_control) = Subshell::new(
                move |child_env: &mut Env<Rc<Concurrent<VirtualSystem>>>, job_control| {
                    Box::pin(async move {
                        let child_pid = child_env.system.getpid();
                        assert_eq!(state_2.borrow().processes[&child_pid].pgid, child_pid);
                        assert_eq!(state_2.borrow().foreground, None);
                        assert_eq!(job_control, Some(JobControl::Background));
                    })
                },
            )
            .job_control(JobControl::Background)
            .start(&mut parent_env)
            .await
            .unwrap();
            assert_eq!(job_control, Some(JobControl::Background));
            assert_eq!(state.borrow().processes[&child_pid].pgid, child_pid);
            assert_eq!(state.borrow().foreground, None);

            parent_env.wait_for_subshell(child_pid).await.unwrap();
            assert_eq!(state.borrow().processes[&child_pid].pgid, child_pid);
            assert_eq!(state.borrow().foreground, None);
        });
    }

    #[test]
    fn subshell_in_foreground() {
        in_virtual_system(|mut parent_env, state| async move {
            parent_env.options.set(Monitor, On);
            stub_tty(&state);

            let state_2 = Rc::clone(&state);
            let (child_pid, job_control) = Subshell::new(
                move |child_env: &mut Env<Rc<Concurrent<VirtualSystem>>>, job_control| {
                    Box::pin(async move {
                        let child_pid = child_env.system.getpid();
                        assert_eq!(state_2.borrow().processes[&child_pid].pgid, child_pid);
                        assert_eq!(state_2.borrow().foreground, Some(child_pid));
                        assert_eq!(job_control, Some(JobControl::Foreground));
                    })
                },
            )
            .job_control(JobControl::Foreground)
            .start(&mut parent_env)
            .await
            .unwrap();
            assert_eq!(job_control, Some(JobControl::Foreground));
            assert_eq!(state.borrow().processes[&child_pid].pgid, child_pid);
            // The child may not yet have become the foreground job.
            // assert_eq!(state.borrow().foreground, Some(child_pid));

            parent_env.wait_for_subshell(child_pid).await.unwrap();
            assert_eq!(state.borrow().processes[&child_pid].pgid, child_pid);
            assert_eq!(state.borrow().foreground, Some(child_pid));
        });
    }

    #[test]
    fn tty_after_starting_foreground_subshell() {
        in_virtual_system(|mut parent_env, state| async move {
            parent_env.options.set(Monitor, On);
            stub_tty(&state);

            let _ = Subshell::new(move |_, _| Box::pin(std::future::ready(())))
                .job_control(JobControl::Foreground)
                .start(&mut parent_env)
                .await
                .unwrap();
            assert_matches!(parent_env.tty, Some(_));
        });
    }

    #[test]
    fn job_control_without_tty() {
        // When /dev/tty is not available, the shell cannot bring the subshell to
        // the foreground. The subshell should still be in a new process group.
        // This is the behavior required by POSIX.
        in_virtual_system(async |mut parent_env, state| {
            parent_env.options.set(Monitor, On);

            let state_2 = Rc::clone(&state);
            let (child_pid, job_control) = Subshell::new(
                move |child_env: &mut Env<Rc<Concurrent<VirtualSystem>>>, job_control| {
                    Box::pin(async move {
                        let child_pid = child_env.system.getpid();
                        assert_eq!(state_2.borrow().processes[&child_pid].pgid, child_pid);
                        assert_eq!(job_control, Some(JobControl::Foreground));
                    })
                },
            )
            .job_control(JobControl::Foreground)
            .start(&mut parent_env)
            .await
            .unwrap();
            assert_eq!(job_control, Some(JobControl::Foreground));
            assert_eq!(state.borrow().processes[&child_pid].pgid, child_pid);

            parent_env.wait_for_subshell(child_pid).await.unwrap();
            assert_eq!(state.borrow().processes[&child_pid].pgid, child_pid);
        })
    }

    #[test]
    fn no_job_control_with_option_disabled() {
        in_virtual_system(|mut parent_env, state| async move {
            stub_tty(&state);

            let parent_pgid = state.borrow().processes[&parent_env.main_pid].pgid;
            let state_2 = Rc::clone(&state);
            let (child_pid, job_control) = Subshell::new(
                move |child_env: &mut Env<Rc<Concurrent<VirtualSystem>>>, _job_control| {
                    Box::pin(async move {
                        let child_pid = child_env.system.getpid();
                        assert_eq!(state_2.borrow().processes[&child_pid].pgid, parent_pgid);
                        assert_eq!(state_2.borrow().foreground, None);
                    })
                },
            )
            .job_control(JobControl::Foreground)
            .start(&mut parent_env)
            .await
            .unwrap();
            assert_eq!(job_control, None);
            assert_eq!(state.borrow().processes[&child_pid].pgid, parent_pgid);
            assert_eq!(state.borrow().foreground, None);

            parent_env.wait_for_subshell(child_pid).await.unwrap();
            assert_eq!(state.borrow().processes[&child_pid].pgid, parent_pgid);
            assert_eq!(state.borrow().foreground, None);
        });
    }

    #[test]
    fn no_job_control_for_nested_subshell() {
        in_virtual_system(|mut parent_env, state| async move {
            let mut parent_env = parent_env.push_frame(Frame::Subshell);
            parent_env.options.set(Monitor, On);
            stub_tty(&state);

            let parent_pgid = state.borrow().processes[&parent_env.main_pid].pgid;
            let state_2 = Rc::clone(&state);
            let (child_pid, job_control) = Subshell::new(
                move |child_env: &mut Env<Rc<Concurrent<VirtualSystem>>>, _job_control| {
                    Box::pin(async move {
                        let child_pid = child_env.system.getpid();
                        assert_eq!(state_2.borrow().processes[&child_pid].pgid, parent_pgid);
                        assert_eq!(state_2.borrow().foreground, None);
                    })
                },
            )
            .job_control(JobControl::Foreground)
            .start(&mut parent_env)
            .await
            .unwrap();
            assert_eq!(job_control, None);
            assert_eq!(state.borrow().processes[&child_pid].pgid, parent_pgid);
            assert_eq!(state.borrow().foreground, None);

            parent_env.wait_for_subshell(child_pid).await.unwrap();
            assert_eq!(state.borrow().processes[&child_pid].pgid, parent_pgid);
            assert_eq!(state.borrow().foreground, None);
        });
    }

    #[test]
    fn wait_without_job_control() {
        in_virtual_system(|mut env, _state| async move {
            let subshell = Subshell::new(|env, _job_control| {
                Box::pin(async { env.exit_status = ExitStatus(42) })
            });
            let (_pid, process_result) = subshell.start_and_wait(&mut env).await.unwrap();
            assert_eq!(process_result, ProcessResult::exited(42));
        });
    }

    #[test]
    fn wait_for_foreground_job_to_exit() {
        in_virtual_system(|mut env, state| async move {
            env.options.set(Monitor, On);
            stub_tty(&state);

            let subshell = Subshell::new(|env, _job_control| {
                Box::pin(async { env.exit_status = ExitStatus(123) })
            })
            .job_control(JobControl::Foreground);
            let (_pid, process_result) = subshell.start_and_wait(&mut env).await.unwrap();
            assert_eq!(process_result, ProcessResult::exited(123));
            assert_eq!(state.borrow().foreground, Some(env.main_pgid));
        });
    }

    // TODO wait_for_foreground_job_to_be_signaled
    // TODO wait_for_foreground_job_to_be_stopped

    #[test]
    fn sigint_sigquit_not_ignored_by_default() {
        in_virtual_system(|mut parent_env, state| async move {
            let (child_pid, _) = Subshell::new(|env, _job_control| {
                Box::pin(async { env.exit_status = ExitStatus(123) })
            })
            .job_control(JobControl::Background)
            .start(&mut parent_env)
            .await
            .unwrap();
            parent_env.wait_for_subshell(child_pid).await.unwrap();

            let state = state.borrow();
            let process = &state.processes[&child_pid];
            assert_eq!(process.disposition(SIGINT), Disposition::Default);
            assert_eq!(process.disposition(SIGQUIT), Disposition::Default);
        })
    }

    #[test]
    fn sigint_sigquit_ignored_in_uncontrolled_job() {
        in_virtual_system(|mut parent_env, state| async move {
            let (child_pid, _) = Subshell::new(|env, _job_control| {
                Box::pin(async { env.exit_status = ExitStatus(123) })
            })
            .job_control(JobControl::Background)
            .ignore_sigint_sigquit(true)
            .start(&mut parent_env)
            .await
            .unwrap();

            parent_env
                .system
                .kill(child_pid, Some(SIGINT))
                .await
                .unwrap();
            parent_env
                .system
                .kill(child_pid, Some(SIGQUIT))
                .await
                .unwrap();

            let child_result = parent_env.wait_for_subshell(child_pid).await.unwrap();
            assert_eq!(child_result, (child_pid, ProcessState::exited(123)));

            let state = state.borrow();
            let parent_process = &state.processes[&parent_env.main_pid];
            assert_eq!(parent_process.blocked_signals().contains(SIGINT), Ok(false));
            assert_eq!(
                parent_process.blocked_signals().contains(SIGQUIT),
                Ok(false)
            );
            let child_process = &state.processes[&child_pid];
            assert_eq!(child_process.disposition(SIGINT), Disposition::Ignore);
            assert_eq!(child_process.disposition(SIGQUIT), Disposition::Ignore);
        })
    }

    #[test]
    fn sigint_sigquit_not_ignored_if_job_controlled() {
        in_virtual_system(|mut parent_env, state| async move {
            parent_env.options.set(Monitor, On);
            stub_tty(&state);

            let (child_pid, _) = Subshell::new(|env, _job_control| {
                Box::pin(async { env.exit_status = ExitStatus(123) })
            })
            .job_control(JobControl::Background)
            .ignore_sigint_sigquit(true)
            .start(&mut parent_env)
            .await
            .unwrap();
            parent_env.wait_for_subshell(child_pid).await.unwrap();

            let state = state.borrow();
            let process = &state.processes[&child_pid];
            assert_eq!(process.disposition(SIGINT), Disposition::Default);
            assert_eq!(process.disposition(SIGQUIT), Disposition::Default);
        })
    }

    #[test]
    fn internal_dispositions_for_stoppers_kept_in_uncontrolled_subshell_of_controlling_interactive_shell()
     {
        in_virtual_system(|mut parent_env, state| async move {
            parent_env.options.set(Interactive, On);
            parent_env.options.set(Monitor, On);
            parent_env
                .traps
                .enable_internal_dispositions_for_stoppers(&parent_env.system)
                .await
                .unwrap();
            stub_tty(&state);

            let (child_pid, _) = Subshell::new(|env, _job_control| {
                Box::pin(async { env.exit_status = ExitStatus(123) })
            })
            .start(&mut parent_env)
            .await
            .unwrap();

            let child_result = parent_env.wait_for_subshell(child_pid).await.unwrap();
            assert_eq!(child_result, (child_pid, ProcessState::exited(123)));

            let state = state.borrow();
            let child_process = &state.processes[&child_pid];
            assert_eq!(child_process.disposition(SIGTSTP), Disposition::Ignore);
            assert_eq!(child_process.disposition(SIGTTIN), Disposition::Ignore);
            assert_eq!(child_process.disposition(SIGTTOU), Disposition::Ignore);
        })
    }

    #[test]
    fn internal_dispositions_for_stoppers_reset_in_controlled_subshell_of_interactive_shell() {
        in_virtual_system(|mut parent_env, state| async move {
            parent_env.options.set(Interactive, On);
            parent_env.options.set(Monitor, On);
            parent_env
                .traps
                .enable_internal_dispositions_for_stoppers(&parent_env.system)
                .await
                .unwrap();
            stub_tty(&state);

            let (child_pid, _) = Subshell::new(|env, _job_control| {
                Box::pin(async { env.exit_status = ExitStatus(123) })
            })
            .job_control(JobControl::Background)
            .start(&mut parent_env)
            .await
            .unwrap();

            let child_result = parent_env.wait_for_subshell(child_pid).await.unwrap();
            assert_eq!(child_result, (child_pid, ProcessState::exited(123)));

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

    #[test]
    fn internal_dispositions_for_stoppers_unset_in_subshell_of_non_controlling_interactive_shell() {
        in_virtual_system(|mut parent_env, state| async move {
            parent_env.options.set(Interactive, On);
            stub_tty(&state);

            let (child_pid, _) = Subshell::new(|env, _job_control| {
                Box::pin(async { env.exit_status = ExitStatus(123) })
            })
            .start(&mut parent_env)
            .await
            .unwrap();

            let child_result = parent_env.wait_for_subshell(child_pid).await.unwrap();
            assert_eq!(child_result, (child_pid, ProcessState::exited(123)));

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

    #[test]
    fn internal_dispositions_for_stoppers_unset_in_uncontrolled_subshell_of_controlling_non_interactive_shell()
     {
        in_virtual_system(|mut parent_env, state| async move {
            parent_env.options.set(Monitor, On);
            stub_tty(&state);

            let (child_pid, _) = Subshell::new(|env, _job_control| {
                Box::pin(async { env.exit_status = ExitStatus(123) })
            })
            .start(&mut parent_env)
            .await
            .unwrap();

            let child_result = parent_env.wait_for_subshell(child_pid).await.unwrap();
            assert_eq!(child_result, (child_pid, ProcessState::exited(123)));

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