Scale computer-use 2.0 with open-source drivers, cross-OS sandboxes, and benchmarks for training, evaluation, and data generation.
Rust agentai-agentapplecomputer-usecomputer-use-agentcontainerizationcuadesktop-automationhacktoberfestlumemacosmanusoperatorswiftvirtualizationvirtualization-frameworkwindowswindows-sandbox
Install QEMU user-locally on apt hosts without sudo
injaneityf80471fbb575
diff --git a/libs/cua/crates/cua-daemon/src/local.rs b/libs/cua/crates/cua-daemon/src/local.rsindex 6895913c55..57b22bfbb8 100644--- a/libs/cua/crates/cua-daemon/src/local.rs+++ b/libs/cua/crates/cua-daemon/src/local.rs@@ -1391,6 +1391,13 @@ async fn kvm_step(dry_run: bool) -> Option<cua_proto::daemon::v1::SetupStep> {}let denied = cua_vmm::host::kvm_usable().is_err_and(|e| e.kind() == std::io::ErrorKind::PermissionDenied);+ if denied && !dry_run && !cua_vmm::host::sudo_available() {+ return Some(SetupStep {+ name: "kvm".into(),+ status: CheckStatus::Ok as i32,+ detail: "KVM access denied; using slow TCG emulation (sudo unavailable)".into(),+ });+ }let user = std::env::var("USER").ok();let run = async |program: &str, args: &[&str]| cua_vmm::host::run(program, args).await;let (status, detail) =diff --git a/libs/cua/crates/cua-vmm/src/auto.rs b/libs/cua/crates/cua-vmm/src/auto.rsindex 55f59db127..ad3552f408 100644--- a/libs/cua/crates/cua-vmm/src/auto.rs+++ b/libs/cua/crates/cua-vmm/src/auto.rs@@ -259,6 +259,12 @@ pub async fn doctor() -> DoctorReport {.push(format!("qemu-system-{native} / qemu-img"));let step = match host_os {HostOs::Macos if host::which("brew").is_some() => Some("brew install qemu".into()),+ HostOs::Linux if host::which("apt-get").is_some() && !host::sudo_available() => {+ Some(format!(+ "user-local QEMU at {}",+ host::cua_home().join("qemu").display()+ ))+ }HostOs::Linux => QemuPackageManager::detect().map(|(manager, _)| manager.render()),_ => None,};@@ -267,6 +273,12 @@ pub async fn doctor() -> DoctorReport {qemu_status.provisioning.push(s);}}+ if host::cua_home().join("qemu").is_dir() {+ qemu_status.detail.push_str(&format!(+ "; user-local wrappers at {}",+ host::cua_home().join("bin").display()+ ));+ }note_kvm(&mut qemu_status, host_os, &kvm);// Lume.@@ -416,14 +428,32 @@ pub async fn doctor() -> DoctorReport {}fn note_kvm(status: &mut BackendStatus, host_os: HostOs, kvm: &std::io::Result<()>) {+ note_kvm_with(status, host_os, kvm, host::sudo_available);+}++fn note_kvm_with(+ status: &mut BackendStatus,+ host_os: HostOs,+ kvm: &std::io::Result<()>,+ sudo: impl Fn() -> bool,+) {if let Err(e) = kvm&& host_os == HostOs::Linux{- if host::qemu_accel(host_os, Arch::host(), kvm).is_err() {+ if host::qemu_accel_with(host_os, Arch::host(), kvm, sudo, |_| {}).is_err() {status.ready = false;status.missing.push(host::kvm_hint(e));} else {- status.detail = format!("{}; {}", status.detail, host::kvm_hint(e));+ status.detail = format!(+ "{}; {}{}",+ status.detail,+ if e.kind() == std::io::ErrorKind::PermissionDenied {+ "TCG ready; "+ } else {+ ""+ },+ host::kvm_hint(e)+ );}}}@@ -696,27 +726,30 @@ mod tests {#[test]fn doctor_reports_why_native_qemu_has_no_kvm() {- let noted = |kvm: std::io::Result<()>| {+ let noted = |kvm: std::io::Result<()>, sudo| {let mut q = report(true, false, false, false, HostOs::Linux).backends[1].clone();q.detail = "QEMU 10".into();q.missing.clear();- note_kvm(&mut q, HostOs::Linux, &kvm);+ note_kvm_with(&mut q, HostOs::Linux, &kvm, || sudo);q};- let missing = noted(Err(std::io::ErrorKind::NotFound.into()));+ let missing = noted(Err(std::io::ErrorKind::NotFound.into()), true);assert!(missing.ready && missing.missing.is_empty(), "{missing:?}");assert!(missing.detail.starts_with("QEMU 10; "), "{missing:?}");assert!(missing.detail.contains("nested virtualization"),"{missing:?}");- let denied = noted(Err(std::io::ErrorKind::PermissionDenied.into()));+ let denied = noted(Err(std::io::ErrorKind::PermissionDenied.into()), true);assert!(!denied.ready && !denied.provisionable, "{denied:?}");assert!(denied.missing[0].contains("sudo usermod -aG kvm"),"{denied:?}");- let ok = noted(Ok(()));+ let denied = noted(Err(std::io::ErrorKind::PermissionDenied.into()), false);+ assert!(denied.ready && denied.missing.is_empty(), "{denied:?}");+ assert!(denied.detail.contains("TCG ready"), "{denied:?}");+ let ok = noted(Ok(()), true);assert!(ok.ready && ok.missing.is_empty() && ok.detail == "QEMU 10","{ok:?}"diff --git a/libs/cua/crates/cua-vmm/src/host.rs b/libs/cua/crates/cua-vmm/src/host.rsindex f7747efe8d..7e7400d80a 100644--- a/libs/cua/crates/cua-vmm/src/host.rs+++ b/libs/cua/crates/cua-vmm/src/host.rs@@ -163,16 +163,48 @@ pub async fn run(program: impl AsRef<std::ffi::OsStr>, args: &[&str]) -> Result<Ok(String::from_utf8_lossy(&out.stdout).into_owned())}+static SUDO_AVAILABLE: std::sync::OnceLock<bool> = std::sync::OnceLock::new();++pub fn sudo_available() -> bool {+ *SUDO_AVAILABLE.get_or_init(|| {+ which("sudo").is_some_and(|sudo| {+ std::process::Command::new(sudo)+ .args(["-n", "true"])+ .stdout(Stdio::null())+ .stderr(Stdio::null())+ .status()+ .is_ok_and(|s| s.success())+ })+ })+}+/// Whether hardware virtualisation is usable for a guest of `guest` arch, and/// which QEMU accelerator to use.pub fn qemu_accel(os: HostOs, guest: Arch, kvm: &std::io::Result<()>) -> Result<&'static str> {+ qemu_accel_with(os, guest, kvm, sudo_available, |message| {+ tracing::warn!("{message}")+ })+}++pub(crate) fn qemu_accel_with(+ os: HostOs,+ guest: Arch,+ kvm: &std::io::Result<()>,+ sudo: impl Fn() -> bool,+ mut warn: impl FnMut(&str),+) -> Result<&'static str> {let host = Arch::host();match (os, kvm) {// HVF only virtualises the host's own architecture.(HostOs::Macos, _) if host == guest => Ok("hvf"),(HostOs::Linux, Ok(())) if host == guest => Ok("kvm"),(HostOs::Linux, Err(e)) if host == guest && e.kind() != std::io::ErrorKind::NotFound => {- Err(VmmError::missing("KVM", kvm_hint(e)))+ if e.kind() == std::io::ErrorKind::PermissionDenied && !sudo() {+ warn("KVM access denied and sudo unavailable; using slow TCG emulation");+ Ok("tcg")+ } else {+ Err(VmmError::missing("KVM", kvm_hint(e)))+ }}(HostOs::Windows, _) if host == guest => Ok("whpx"),_ => Ok("tcg"),@@ -312,7 +344,7 @@ mod tests {#[test]fn native_linux_accel_tells_missing_from_unopenable_kvm() {- let native = |kvm| qemu_accel(HostOs::Linux, Arch::host(), &kvm);+ let native = |kvm| qemu_accel_with(HostOs::Linux, Arch::host(), &kvm, || true, |_| {});assert_eq!(native(Ok(())).unwrap(), "kvm");assert_eq!(native(Err(std::io::ErrorKind::NotFound.into())).unwrap(),@@ -320,14 +352,29 @@ mod tests {);let missing = kvm_hint(&std::io::ErrorKind::NotFound.into());assert!(missing.contains("nested virtualization"), "{missing}");- let denied = native(Err(std::io::ErrorKind::PermissionDenied.into()))- .unwrap_err()- .to_string();+ let denied = native(Err(std::io::ErrorKind::PermissionDenied.into()));+ let denied = denied.unwrap_err().to_string();assert!(denied.contains("permission denied"), "{denied}");assert!(denied.contains("sudo usermod -aG kvm \"$USER\""),"{denied}");+ let mut warning = String::new();+ assert_eq!(+ qemu_accel_with(+ HostOs::Linux,+ Arch::host(),+ &Err(std::io::ErrorKind::PermissionDenied.into()),+ || false,+ |message| warning.push_str(message)+ )+ .unwrap(),+ "tcg"+ );+ assert_eq!(+ warning,+ "KVM access denied and sudo unavailable; using slow TCG emulation"+ );let other = native(Err(std::io::Error::other("device busy"))).unwrap_err().to_string();diff --git a/libs/cua/crates/cua-vmm/src/qemu/firmware.rs b/libs/cua/crates/cua-vmm/src/qemu/firmware.rsindex 886f1e90b8..b4dd5c485a 100644--- a/libs/cua/crates/cua-vmm/src/qemu/firmware.rs+++ b/libs/cua/crates/cua-vmm/src/qemu/firmware.rs@@ -25,6 +25,11 @@ pub struct Uefi {fn candidates(arch: Arch) -> &'static [(&'static str, &'static str)] {match arch {Arch::Aarch64 => &[+ (+ "qemu/usr/share/AAVMF/AAVMF_CODE.fd",+ "qemu/usr/share/AAVMF/AAVMF_VARS.fd",+ ),+ ("qemu/usr/share/qemu-efi-aarch64/QEMU_EFI.fd", ""),("share/qemu/edk2-aarch64-code.fd","share/qemu/edk2-arm-vars.fd",@@ -44,6 +49,10 @@ fn candidates(arch: Arch) -> &'static [(&'static str, &'static str)] {("/usr/share/qemu-efi-aarch64/QEMU_EFI.fd", ""),],Arch::X86_64 => &[+ (+ "qemu/usr/share/OVMF/OVMF_CODE_4M.fd",+ "qemu/usr/share/OVMF/OVMF_VARS_4M.fd",+ ),("share/qemu/edk2-x86_64-code.fd","share/qemu/edk2-i386-vars.fd",@@ -131,6 +140,34 @@ mod tests {use super::*;use std::collections::HashSet;+ #[test]+ fn local_wrapper_firmware() {+ let code = "/local/qemu/usr/share/qemu-efi-aarch64/QEMU_EFI.fd";+ let found = find_uefi_with(+ Arch::Aarch64,+ Path::new("/local/bin/qemu-system-aarch64"),+ fs(&[code]),+ )+ .unwrap();+ assert_eq!(found.code, Path::new(code));+ assert!(found.vars_template.is_none());+ for (arch, code, vars) in [+ (Arch::X86_64, "OVMF/OVMF_CODE_4M.fd", "OVMF/OVMF_VARS_4M.fd"),+ (Arch::Aarch64, "AAVMF/AAVMF_CODE.fd", "AAVMF/AAVMF_VARS.fd"),+ ] {+ let code = format!("/local/qemu/usr/share/{code}");+ let vars = format!("/local/qemu/usr/share/{vars}");+ let found = find_uefi_with(+ arch,+ Path::new("/local/bin/qemu-system-test"),+ fs(&[&code, &vars]),+ )+ .unwrap();+ assert_eq!(found.code, Path::new(&code));+ assert_eq!(found.vars_template.as_deref(), Some(Path::new(&vars)));+ }+ }+fn fs(paths: &[&str]) -> impl Fn(&Path) -> bool {let set: HashSet<PathBuf> = paths.iter().map(PathBuf::from).collect();move |p: &Path| set.contains(p)diff --git a/libs/cua/crates/cua-vmm/src/qemu/install-local.sh b/libs/cua/crates/cua-vmm/src/qemu/install-local.shnew file mode 100644index 0000000000..3d75400089--- /dev/null+++ b/libs/cua/crates/cua-vmm/src/qemu/install-local.sh@@ -0,0 +1,54 @@+#!/bin/sh+set -eu+home=$1+case $(uname -m) in+ x86_64) system=qemu-system-x86_64; packages='qemu-system-x86 seabios ipxe-qemu ovmf' ;;+ aarch64|arm64) system=qemu-system-aarch64; packages='qemu-system-arm qemu-efi-aarch64' ;;+ *) echo 'unsupported QEMU host architecture' >&2; exit 1 ;;+esac+mkdir -p "$home/bin"+stage=$(mktemp -d "$home/.qemu-XXXXXXXX")+old=$stage/old+trap 'rm -rf "$stage"' EXIT+trap 'exit 1' HUP INT TERM+mkdir -p "$stage/lists/partial" "$stage/cache/archives/partial" "$stage/root"+set -- -o "Dir::State::Lists=$stage/lists" -o "Dir::Cache=$stage/cache" -o Debug::NoLocking=1+apt-get "$@" update+apt-get "$@" --download-only --reinstall --no-install-recommends -y install $packages qemu-system-common qemu-system-data qemu-utils+for deb in "$stage/cache/archives/"*.deb; do dpkg-deb -x "$deb" "$stage/root"; done+find "$stage/root" -type l -exec sh -c '+ root=$1; shift+ for link do+ target=$(readlink "$link")+ case $target in /*)+ if [ -e "$root$target" ]; then+ relative=$(realpath -s --relative-to="$(dirname "$link")" "$root$target")+ ln -snf "$relative" "$link"+ fi ;;+ esac+ done+' sh "$stage/root" {} ++wrapper() {+ root=$1; binary=$2; destination=$3+ quoted=$(printf '%s' "$root" | sed "s/'/'\\\\''/g")+ {+ printf "#!/bin/sh\nroot='%s'\n" "$quoted"+ printf '%s\n' 'export LD_LIBRARY_PATH="$root/usr/lib:$(find "$root/usr/lib" -mindepth 1 -maxdepth 1 -type d | paste -sd: -)${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"' 'export QEMU_MODULE_DIR="$(find "$root/usr/lib" -mindepth 2 -maxdepth 2 -type d -path "*-linux-gnu*/qemu" | head -n 1)"'+ if [ "$binary" = qemu-img ]; then+ printf 'exec "$root/usr/bin/%s" "$@"\n' "$binary"+ else+ printf 'exec "$root/usr/bin/%s" -L "$root/usr/share/qemu" "$@"\n' "$binary"+ fi+ } > "$destination"+ chmod +x "$destination"+}+for binary in "$system" qemu-img; do+ wrapper "$stage/root" "$binary" "$stage/$binary"+ "$stage/$binary" --version+done+[ ! -e "$home/qemu" ] || mv "$home/qemu" "$old"+mv "$stage/root" "$home/qemu"+for binary in "$system" qemu-img; do+ wrapper "$home/qemu" "$binary" "$stage/$binary"+ mv "$stage/$binary" "$home/bin/$binary"+donediff --git a/libs/cua/crates/cua-vmm/src/qemu/mod.rs b/libs/cua/crates/cua-vmm/src/qemu/mod.rsindex dd5a8a7360..c85e69913c 100644--- a/libs/cua/crates/cua-vmm/src/qemu/mod.rs+++ b/libs/cua/crates/cua-vmm/src/qemu/mod.rs@@ -298,10 +298,21 @@ impl QemuRuntime {}fn accel_for(&self, arch: Arch, kvm: &std::io::Result<()>) -> Result<String> {+ self.accel_for_with(arch, kvm, host::sudo_available)+ }++ fn accel_for_with(+ &self,+ arch: Arch,+ kvm: &std::io::Result<()>,+ sudo: impl Fn() -> bool,+ ) -> Result<String> {if let Some(accel) = &self.cfg.accel {return Ok(accel.clone());}- let accel = host::qemu_accel(host::HostOs::current(), arch, kvm)?;+ let accel = host::qemu_accel_with(host::HostOs::current(), arch, kvm, sudo, |message| {+ tracing::warn!("{message}")+ })?;if let Err(e) = kvm&& accel == "tcg"&& arch == Arch::host()@@ -1023,6 +1034,19 @@ pub async fn grant_kvm(const PACKAGE_ATTEMPTS: u32 = 3;pub async fn install_qemu() -> Result<()> {+ install_qemu_with(+ QemuPackageManager::detect(),+ host::sudo_available,+ async |p, a| host::run(p, a).await,+ )+ .await+}++async fn install_qemu_with(+ manager: Option<(QemuPackageManager, PathBuf)>,+ sudo: impl Fn() -> bool,+ run: impl AsyncFn(&str, &[&str]) -> Result<String>,+) -> Result<()> {match host::HostOs::current() {host::HostOs::Macos => {let brew = host::which("brew").ok_or_else(|| {@@ -1032,19 +1056,37 @@ pub async fn install_qemu() -> Result<()> {)})?;tracing::info!("installing QEMU with Homebrew");- host::run(brew, &["install", "qemu"]).await?;+ run(&brew.to_string_lossy(), &["install", "qemu"]).await?;}host::HostOs::Linux => {- let (manager, program) = QemuPackageManager::detect().ok_or_else(|| {+ let (manager, program) = manager.ok_or_else(|| {VmmError::missing("QEMU", "no supported package manager found (apt-get/dnf)")})?;+ if matches!(manager, QemuPackageManager::Apt) && !sudo() {+ let home = host::cua_home();+ tracing::info!(+ "installing user-local QEMU at {}",+ home.join("qemu").display()+ );+ return run(+ "sh",+ &[+ "-c",+ include_str!("install-local.sh"),+ "cua-qemu",+ &home.to_string_lossy(),+ ],+ )+ .await+ .map(|_| ());+ }let program = program.display().to_string();tracing::info!("installing QEMU with {manager:?} (sudo -n)");for args in manager.commands(&program) {let refresh = args.last() == Some(&"update");let mut attempt = 1;loop {- match host::run("sudo", &args).await {+ match run("sudo", &args).await {Ok(_) => break,Err(e) if attempt < PACKAGE_ATTEMPTS => {tracing::warn!(@@ -1601,15 +1643,94 @@ mod tests {assert!(err.to_string().contains("DiskResolver"));}+ #[cfg(target_os = "linux")]+ #[tokio::test]+ async fn install_without_sudo_runs_local_script() {+ let calls = std::sync::Mutex::new(Vec::new());+ install_qemu_with(+ Some((QemuPackageManager::Apt, PathBuf::from("apt-get"))),+ || false,+ async |program, args| {+ calls.lock().unwrap().push((+ program.to_string(),+ args.iter().map(|a| a.to_string()).collect::<Vec<_>>(),+ ));+ Ok(String::new())+ },+ )+ .await+ .unwrap();+ let calls = calls.lock().unwrap();+ assert_eq!(calls.len(), 1);+ assert_eq!(calls[0].0, "sh");+ assert_eq!(calls[0].1[1], include_str!("install-local.sh"));+ assert_eq!(calls[0].1[3], host::cua_home().to_string_lossy());+ assert!(calls.iter().all(|(program, _)| program != "sudo"));+ }++ #[cfg(target_os = "linux")]+ #[tokio::test]+ async fn install_with_sudo_preserves_package_commands() {+ let calls = std::sync::Mutex::new(Vec::new());+ install_qemu_with(+ Some((QemuPackageManager::Apt, PathBuf::from("apt-get"))),+ || true,+ async |program, args| {+ assert_eq!(program, "sudo");+ calls+ .lock()+ .unwrap()+ .push(args.iter().map(|a| a.to_string()).collect::<Vec<_>>());+ Ok(String::new())+ },+ )+ .await+ .unwrap();+ let expected: Vec<Vec<String>> = QemuPackageManager::Apt+ .commands("apt-get")+ .iter()+ .map(|args| args.iter().map(|a| a.to_string()).collect())+ .collect();+ assert_eq!(*calls.lock().unwrap(), expected);+ }++ #[cfg(target_os = "linux")]+ #[test]+ fn local_installer_fixtures() {+ let python = std::process::Command::new("python3")+ .arg("--version")+ .output();+ if python.is_err_and(|e| e.kind() == std::io::ErrorKind::NotFound) {+ return;+ }+ assert!(+ std::process::Command::new("python3")+ .arg(concat!(+ env!("CARGO_MANIFEST_DIR"),+ "/tests/install_local.py"+ ))+ .status()+ .unwrap()+ .success()+ );+ }+#[cfg(target_os = "linux")]#[test]fn native_launch_refuses_unopenable_kvm_and_falls_back_when_missing() {let tmp = tempfile::tempdir().unwrap();let r = rt(tmp.path());let denied = Err(std::io::ErrorKind::PermissionDenied.into());- let err = r.accel_for(Arch::host(), &denied).unwrap_err().to_string();- assert!(err.contains("permission denied"), "{err}");- assert!(err.contains("sudo usermod -aG kvm"), "{err}");+ let error = r+ .accel_for_with(Arch::host(), &denied, || true)+ .unwrap_err()+ .to_string();+ assert!(error.contains("permission denied"), "{error}");+ assert!(error.contains("sudo usermod -aG kvm \"$USER\""), "{error}");+ assert_eq!(+ r.accel_for_with(Arch::host(), &denied, || false).unwrap(),+ "tcg"+ );let missing = Err(std::io::ErrorKind::NotFound.into());assert_eq!(r.accel_for(Arch::host(), &missing).unwrap(), "tcg");}diff --git a/libs/cua/crates/cua-vmm/tests/install_local.py b/libs/cua/crates/cua-vmm/tests/install_local.pynew file mode 100644index 0000000000..6281db7342--- /dev/null+++ b/libs/cua/crates/cua-vmm/tests/install_local.py@@ -0,0 +1,65 @@+"""Hermetic installer regression: no apt network, sudo, or VM execution."""+import os+from pathlib import Path+import subprocess+import tempfile+import unittest++SCRIPT = Path(__file__).parents[1] / 'src/qemu/install-local.sh'++class LocalInstall(unittest.TestCase):+ def test_install_and_failed_reinstall(self):+ with tempfile.TemporaryDirectory() as directory:+ base = Path(directory)+ home = base / "home with 'quote"+ tools = base / 'tools'+ tools.mkdir()+ def tool(name, body):+ path = tools / name+ path.write_text('#!/bin/sh\nset -eu\n' + body)+ path.chmod(0o755)+ tool('uname', 'echo x86_64\n')+ tool('find', '''+/usr/bin/find "$@" | awk '/\\/ipxe\\/qemu$/ { print; next } { rest = rest $0 "\\n" } END { printf "%s", rest }'+''')+ tool('apt-get', '''+case "$*" in *--download-only*)+ case "$*" in *--reinstall*--no-install-recommends*) ;; *) exit 20;; esac+ for arg do case $arg in Dir::Cache=*) cache=${arg#*=};; esac; done+ touch "$cache/archives/qemu.deb";;+esac+''')+ tool('dpkg-deb', '''+[ "${FAIL:-}" != yes ] || exit 21+root=$3+mkdir -p "$root/usr/bin" "$root/usr/lib/ipxe/qemu" "$root/usr/lib/qemu" "$root/usr/lib/x86_64-linux-gnu/qemu" "$root/usr/share/qemu" "$root/usr/share/seabios"+touch "$root/usr/share/seabios/bios.bin"+ln -s /usr/share/seabios/bios.bin "$root/usr/share/qemu/bios.bin"+ln -s /host-only "$root/usr/share/qemu/host"+for binary in qemu-system-x86_64 qemu-img; do+ printf '#!/bin/sh\\nprintf "%%s\\\\n" "$QEMU_MODULE_DIR" "$LD_LIBRARY_PATH" "$@"\\n' > "$root/usr/bin/$binary"+ chmod +x "$root/usr/bin/$binary"+done+''')+ env = dict(os.environ, PATH=f'{tools}:/usr/bin:/bin')+ subprocess.run(['sh', str(SCRIPT), str(home)], env=env, check=True, capture_output=True)+ root = home / 'qemu'+ link = root / 'usr/share/qemu/bios.bin'+ self.assertFalse(os.readlink(link).startswith('/'))+ self.assertTrue(link.exists())+ self.assertEqual(os.readlink(root / 'usr/share/qemu/host'), '/host-only')+ for binary in ('qemu-system-x86_64', 'qemu-img'):+ output = subprocess.check_output([str(home / 'bin' / binary), 'a b', 'c"d'], env=env, text=True)+ self.assertEqual(output.splitlines()[0], str(root / 'usr/lib/x86_64-linux-gnu/qemu'))+ self.assertIn('a b\nc"d\n', output)+ self.assertEqual('\n-L\n' in output, binary != 'qemu-img')+ (root / 'sentinel').touch()+ result = subprocess.run(['sh', str(SCRIPT), str(home)], env=dict(env, FAIL='yes'), capture_output=True)+ self.assertNotEqual(result.returncode, 0)+ self.assertTrue((root / 'sentinel').exists())+ self.assertFalse(list(home.glob('.qemu-*')))+ subprocess.run(['sh', str(SCRIPT), str(home)], env=env, check=True, capture_output=True)+ self.assertFalse((root / 'sentinel').exists())++if __name__ == '__main__':+ unittest.main()