codex/codex-rs/terminal-detection/src/terminal_tests.rs

use super::*;
use pretty_assertions::assert_eq;
use std::collections::HashMap;

struct FakeEnvironment {
    vars: HashMap<String, String>,
}

impl FakeEnvironment {
    fn new() -> Self {
        Self {
            vars: HashMap::new(),
        }
    }

    fn with_var(mut self, key: &str, value: &str) -> Self {
        self.vars.insert(key.to_string(), value.to_string());
        self
    }
}

impl Environment for FakeEnvironment {
    fn var(&self, name: &str) -> Option<String> {
        self.vars.get(name).cloned()
    }
}

fn terminal_info(
    name: TerminalName,
    term_program: Option<&str>,
    version: Option<&str>,
    term: Option<&str>,
    multiplexer: Option<Multiplexer>,
) -> TerminalInfo {
    TerminalInfo {
        backend: None,
        name,
        term_program: term_program.map(ToString::to_string),
        version: version.map(ToString::to_string),
        term: term.map(ToString::to_string),
        multiplexer,
    }
}

#[test]
fn detects_term_program() {
    let env = FakeEnvironment::new()
        .with_var("TERM_PROGRAM", "iTerm.app")
        .with_var("TERM_PROGRAM_VERSION", "3.5.0")
        .with_var("WEZTERM_VERSION", "2024.2");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::Iterm2,
            Some("iTerm.app"),
            Some("3.5.0"),
            /*term*/ None,
            /*multiplexer*/ None,
        ),
        "term_program_with_version_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "iTerm.app/3.5.0",
        "term_program_with_version_user_agent"
    );

    let env = FakeEnvironment::new()
        .with_var("TERM_PROGRAM", "iTerm.app")
        .with_var("TERM_PROGRAM_VERSION", "");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::Iterm2,
            Some("iTerm.app"),
            /*version*/ None,
            /*term*/ None,
            /*multiplexer*/ None
        ),
        "term_program_without_version_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "iTerm.app",
        "term_program_without_version_user_agent"
    );

    let env = FakeEnvironment::new()
        .with_var("TERM_PROGRAM", "iTerm.app")
        .with_var("WEZTERM_VERSION", "2024.2");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::Iterm2,
            Some("iTerm.app"),
            /*version*/ None,
            /*term*/ None,
            /*multiplexer*/ None
        ),
        "term_program_overrides_wezterm_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "iTerm.app",
        "term_program_overrides_wezterm_user_agent"
    );
}

#[test]
fn terminal_info_reports_is_zellij() {
    let zellij = terminal_info(
        TerminalName::Unknown,
        /*term_program*/ None,
        /*version*/ None,
        /*term*/ None,
        Some(Multiplexer::Zellij { version: None }),
    );
    assert!(zellij.is_zellij());

    let non_zellij = terminal_info(
        TerminalName::Unknown,
        /*term_program*/ None,
        /*version*/ None,
        /*term*/ None,
        Some(Multiplexer::Tmux { version: None }),
    );
    assert!(!non_zellij.is_zellij());
}

#[test]
fn detects_iterm2() {
    let env = FakeEnvironment::new().with_var("ITERM_SESSION_ID", "w0t1p0");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::Iterm2,
            /*term_program*/ None,
            /*version*/ None,
            /*term*/ None,
            /*multiplexer*/ None
        ),
        "iterm_session_id_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "iTerm.app",
        "iterm_session_id_user_agent"
    );
}

#[test]
fn detects_apple_terminal() {
    let env = FakeEnvironment::new()
        .with_var("TERM_PROGRAM", "Apple_Terminal")
        .with_var("TERM_PROGRAM_VERSION", "455")
        .with_var("TERM_SESSION_ID", "A1B2C3");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::AppleTerminal,
            Some("Apple_Terminal"),
            Some("455"),
            /*term*/ None,
            /*multiplexer*/ None,
        ),
        "apple_term_program_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "Apple_Terminal/455",
        "apple_term_program_user_agent"
    );
}

#[test]
fn detects_ghostty() {
    let env = FakeEnvironment::new().with_var("TERM_PROGRAM", "Ghostty");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::Ghostty,
            Some("Ghostty"),
            /*version*/ None,
            /*term*/ None,
            /*multiplexer*/ None
        ),
        "ghostty_term_program_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "Ghostty",
        "ghostty_term_program_user_agent"
    );

    let env = FakeEnvironment::new().with_var("TERM", "xterm-ghostty");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::Ghostty,
            /*term_program*/ None,
            /*version*/ None,
            Some("xterm-ghostty"),
            /*multiplexer*/ None
        ),
        "ghostty_term_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "xterm-ghostty",
        "ghostty_term_user_agent"
    );
}

#[test]
fn detects_rex() {
    for (key, value) in [("TERM_PROGRAM", "rex"), ("TERM", "xterm-rex")] {
        let env = FakeEnvironment::new().with_var(key, value);
        assert_eq!(detect_terminal_info_from_env(&env).name, TerminalName::Rex);
    }
}

#[test]
fn detects_vscode() {
    let env = FakeEnvironment::new()
        .with_var("TERM_PROGRAM", "vscode")
        .with_var("TERM_PROGRAM_VERSION", "1.86.0");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::VsCode,
            Some("vscode"),
            Some("1.86.0"),
            /*term*/ None,
            /*multiplexer*/ None
        ),
        "vscode_term_program_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "vscode/1.86.0",
        "vscode_term_program_user_agent"
    );
}

#[test]
fn detects_warp_terminal() {
    let env = FakeEnvironment::new()
        .with_var("TERM_PROGRAM", "WarpTerminal")
        .with_var("TERM_PROGRAM_VERSION", "v0.2025.12.10.08.12.stable_03");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::WarpTerminal,
            Some("WarpTerminal"),
            Some("v0.2025.12.10.08.12.stable_03"),
            /*term*/ None,
            /*multiplexer*/ None,
        ),
        "warp_term_program_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "WarpTerminal/v0.2025.12.10.08.12.stable_03",
        "warp_term_program_user_agent"
    );
}

#[test]
fn detects_tmux_multiplexer() {
    let env = FakeEnvironment::new()
        .with_var("TMUX", "/tmp/tmux-1000/default,123,0")
        .with_var("TERM_PROGRAM", "tmux")
        .with_var("TERM_PROGRAM_VERSION", "3.5a");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::Unknown,
            /*term_program*/ None,
            /*version*/ None,
            /*term*/ None,
            Some(Multiplexer::Tmux {
                version: Some("3.5a".to_string())
            }),
        ),
        "tmux_multiplexer_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "unknown",
        "tmux_multiplexer_user_agent"
    );
}

#[test]
fn detects_zellij_multiplexer() {
    let env = FakeEnvironment::new().with_var("ZELLIJ", "1");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        TerminalInfo {
            backend: None,
            name: TerminalName::Unknown,
            term_program: None,
            version: None,
            term: None,
            multiplexer: Some(Multiplexer::Zellij { version: None }),
        },
        "zellij_multiplexer"
    );
}

#[test]
fn detects_zellij_multiplexer_version() {
    let env = FakeEnvironment::new().with_var("ZELLIJ_VERSION", "0.43.1");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::Unknown,
            /*term_program*/ None,
            /*version*/ None,
            /*term*/ None,
            Some(Multiplexer::Zellij {
                version: Some("0.43.1".to_string()),
            }),
        ),
        "zellij_multiplexer_version"
    );
}

#[test]
fn detects_wezterm() {
    let env = FakeEnvironment::new().with_var("WEZTERM_VERSION", "2024.2");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::WezTerm,
            /*term_program*/ None,
            Some("2024.2"),
            /*term*/ None,
            /*multiplexer*/ None
        ),
        "wezterm_version_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "WezTerm/2024.2",
        "wezterm_version_user_agent"
    );

    let env = FakeEnvironment::new()
        .with_var("TERM_PROGRAM", "WezTerm")
        .with_var("TERM_PROGRAM_VERSION", "2024.2");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::WezTerm,
            Some("WezTerm"),
            Some("2024.2"),
            /*term*/ None,
            /*multiplexer*/ None
        ),
        "wezterm_term_program_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "WezTerm/2024.2",
        "wezterm_term_program_user_agent"
    );

    let env = FakeEnvironment::new().with_var("WEZTERM_VERSION", "");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::WezTerm,
            /*term_program*/ None,
            /*version*/ None,
            /*term*/ None,
            /*multiplexer*/ None
        ),
        "wezterm_empty_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "WezTerm",
        "wezterm_empty_user_agent"
    );

    let env = FakeEnvironment::new().with_var("TERM", "wezterm");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::WezTerm,
            /*term_program*/ None,
            /*version*/ None,
            Some("wezterm"),
            /*multiplexer*/ None
        ),
        "wezterm_term_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "wezterm",
        "wezterm_term_user_agent"
    );

    let env = FakeEnvironment::new().with_var("TERM", "wezterm-mux");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::WezTerm,
            /*term_program*/ None,
            /*version*/ None,
            Some("wezterm-mux"),
            /*multiplexer*/ None
        ),
        "wezterm_mux_term_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "wezterm-mux",
        "wezterm_mux_term_user_agent"
    );
}

#[test]
fn detects_kitty() {
    let env = FakeEnvironment::new().with_var("KITTY_WINDOW_ID", "1");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::Kitty,
            /*term_program*/ None,
            /*version*/ None,
            /*term*/ None,
            /*multiplexer*/ None
        ),
        "kitty_window_id_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "kitty",
        "kitty_window_id_user_agent"
    );

    let env = FakeEnvironment::new()
        .with_var("TERM_PROGRAM", "kitty")
        .with_var("TERM_PROGRAM_VERSION", "0.30.1");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::Kitty,
            Some("kitty"),
            Some("0.30.1"),
            /*term*/ None,
            /*multiplexer*/ None
        ),
        "kitty_term_program_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "kitty/0.30.1",
        "kitty_term_program_user_agent"
    );

    let env = FakeEnvironment::new()
        .with_var("TERM", "xterm-kitty")
        .with_var("ALACRITTY_SOCKET", "/tmp/alacritty");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::Kitty,
            /*term_program*/ None,
            /*version*/ None,
            /*term*/ None,
            /*multiplexer*/ None
        ),
        "kitty_term_over_alacritty_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "kitty",
        "kitty_term_over_alacritty_user_agent"
    );
}

#[test]
fn detects_alacritty() {
    let env = FakeEnvironment::new().with_var("ALACRITTY_SOCKET", "/tmp/alacritty");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::Alacritty,
            /*term_program*/ None,
            /*version*/ None,
            /*term*/ None,
            /*multiplexer*/ None
        ),
        "alacritty_socket_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "Alacritty",
        "alacritty_socket_user_agent"
    );

    let env = FakeEnvironment::new()
        .with_var("TERM_PROGRAM", "Alacritty")
        .with_var("TERM_PROGRAM_VERSION", "0.13.2");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::Alacritty,
            Some("Alacritty"),
            Some("0.13.2"),
            /*term*/ None,
            /*multiplexer*/ None,
        ),
        "alacritty_term_program_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "Alacritty/0.13.2",
        "alacritty_term_program_user_agent"
    );

    let env = FakeEnvironment::new().with_var("TERM", "alacritty");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::Alacritty,
            /*term_program*/ None,
            /*version*/ None,
            /*term*/ None,
            /*multiplexer*/ None
        ),
        "alacritty_term_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "Alacritty",
        "alacritty_term_user_agent"
    );
}

#[test]
fn detects_konsole() {
    let env = FakeEnvironment::new().with_var("KONSOLE_VERSION", "230800");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::Konsole,
            /*term_program*/ None,
            Some("230800"),
            /*term*/ None,
            /*multiplexer*/ None
        ),
        "konsole_version_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "Konsole/230800",
        "konsole_version_user_agent"
    );

    let env = FakeEnvironment::new()
        .with_var("TERM_PROGRAM", "Konsole")
        .with_var("TERM_PROGRAM_VERSION", "230800");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::Konsole,
            Some("Konsole"),
            Some("230800"),
            /*term*/ None,
            /*multiplexer*/ None
        ),
        "konsole_term_program_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "Konsole/230800",
        "konsole_term_program_user_agent"
    );

    let env = FakeEnvironment::new().with_var("KONSOLE_VERSION", "");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::Konsole,
            /*term_program*/ None,
            /*version*/ None,
            /*term*/ None,
            /*multiplexer*/ None
        ),
        "konsole_empty_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "Konsole",
        "konsole_empty_user_agent"
    );
}

#[test]
fn detects_gnome_terminal() {
    let env = FakeEnvironment::new().with_var("GNOME_TERMINAL_SCREEN", "1");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::GnomeTerminal,
            /*term_program*/ None,
            /*version*/ None,
            /*term*/ None,
            /*multiplexer*/ None
        ),
        "gnome_terminal_screen_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "gnome-terminal",
        "gnome_terminal_screen_user_agent"
    );

    let env = FakeEnvironment::new()
        .with_var("TERM_PROGRAM", "gnome-terminal")
        .with_var("TERM_PROGRAM_VERSION", "3.50");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::GnomeTerminal,
            Some("gnome-terminal"),
            Some("3.50"),
            /*term*/ None,
            /*multiplexer*/ None,
        ),
        "gnome_terminal_term_program_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "gnome-terminal/3.50",
        "gnome_terminal_term_program_user_agent"
    );
}

#[test]
fn detects_vte() {
    let env = FakeEnvironment::new().with_var("VTE_VERSION", "7000");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        TerminalInfo {
            backend: Some(TerminalBackend::Vte {
                version: Some(7000)
            }),
            ..terminal_info(
                TerminalName::Vte,
                /*term_program*/ None,
                Some("7000"),
                /*term*/ None,
                /*multiplexer*/ None
            )
        },
        "vte_version_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "VTE/7000",
        "vte_version_user_agent"
    );

    let env = FakeEnvironment::new()
        .with_var("TERM_PROGRAM", "VTE")
        .with_var("TERM_PROGRAM_VERSION", "7000");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        TerminalInfo {
            backend: Some(TerminalBackend::Vte {
                version: Some(7000)
            }),
            ..terminal_info(
                TerminalName::Vte,
                Some("VTE"),
                Some("7000"),
                /*term*/ None,
                /*multiplexer*/ None
            )
        },
        "vte_term_program_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "VTE/7000",
        "vte_term_program_user_agent"
    );

    let env = FakeEnvironment::new().with_var("VTE_VERSION", "");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        TerminalInfo {
            backend: Some(TerminalBackend::Vte { version: None }),
            ..terminal_info(
                TerminalName::Vte,
                /*term_program*/ None,
                /*version*/ None,
                /*term*/ None,
                /*multiplexer*/ None
            )
        },
        "vte_empty_info"
    );
    assert_eq!(terminal.user_agent_token(), "VTE", "vte_empty_user_agent");
}

#[test]
fn detects_windows_terminal() {
    let env = FakeEnvironment::new()
        .with_var("WT_SESSION", "1")
        .with_var("TERM_SESSION_ID", "A1B2C3");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::WindowsTerminal,
            /*term_program*/ None,
            /*version*/ None,
            /*term*/ None,
            /*multiplexer*/ None
        ),
        "wt_session_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "WindowsTerminal",
        "wt_session_user_agent"
    );

    let env = FakeEnvironment::new()
        .with_var("TERM_PROGRAM", "WindowsTerminal")
        .with_var("TERM_PROGRAM_VERSION", "1.21");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::WindowsTerminal,
            Some("WindowsTerminal"),
            Some("1.21"),
            /*term*/ None,
            /*multiplexer*/ None,
        ),
        "windows_terminal_term_program_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "WindowsTerminal/1.21",
        "windows_terminal_term_program_user_agent"
    );
}

#[test]
fn detects_term_fallbacks() {
    let env = FakeEnvironment::new()
        .with_var("TERM", "xterm-256color")
        .with_var("TERM_SESSION_ID", "A1B2C3");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::Unknown,
            /*term_program*/ None,
            /*version*/ None,
            Some("xterm-256color"),
            /*multiplexer*/ None,
        ),
        "term_fallback_info"
    );
    assert_eq!(
        terminal.user_agent_token(),
        "xterm-256color",
        "term_fallback_user_agent"
    );

    let env = FakeEnvironment::new().with_var("TERM", "dumb");
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::Dumb,
            /*term_program*/ None,
            /*version*/ None,
            Some("dumb"),
            /*multiplexer*/ None
        ),
        "dumb_term_info"
    );
    assert_eq!(terminal.user_agent_token(), "dumb", "dumb_term_user_agent");

    let env = FakeEnvironment::new();
    let terminal = detect_terminal_info_from_env(&env);
    assert_eq!(
        terminal,
        terminal_info(
            TerminalName::Unknown,
            /*term_program*/ None,
            /*version*/ None,
            /*term*/ None,
            /*multiplexer*/ None
        ),
        "unknown_info"
    );
    assert_eq!(terminal.user_agent_token(), "unknown", "unknown_user_agent");
}

#[test]
fn tmux_preserves_safe_underlying_terminal_identifiers() {
    for (variable, value, name, version) in [
        (
            "WEZTERM_VERSION",
            "2024.2",
            TerminalName::WezTerm,
            Some("2024.2"),
        ),
        ("ITERM_SESSION_ID", "w0t1p0", TerminalName::Iterm2, None),
        ("KITTY_WINDOW_ID", "1", TerminalName::Kitty, None),
        ("WT_SESSION", "session", TerminalName::WindowsTerminal, None),
        (
            "ALACRITTY_SOCKET",
            "/tmp/alacritty",
            TerminalName::Alacritty,
            None,
        ),
        (
            "GHOSTTY_RESOURCES_DIR",
            "/Applications/Ghostty.app/Contents/Resources/ghostty",
            TerminalName::Ghostty,
            None,
        ),
    ] {
        let env = FakeEnvironment::new()
            .with_var("TMUX", "/tmp/tmux-1000/default,123,0")
            .with_var("TERM_PROGRAM", "tmux")
            .with_var("TERM_PROGRAM_VERSION", "3.5a")
            .with_var("TERM", "screen-256color")
            .with_var(variable, value);
        assert_eq!(
            detect_terminal_info_from_env(&env),
            terminal_info(
                name,
                /*term_program*/ None,
                version,
                /*term*/ None,
                Some(Multiplexer::Tmux {
                    version: Some("3.5a".to_string())
                }),
            ),
            "{variable}"
        );
    }
}

#[test]
fn captures_vte_backend_when_gnome_identity_takes_precedence() {
    let env = FakeEnvironment::new()
        .with_var("GNOME_TERMINAL_SCREEN", "1")
        .with_var("VTE_VERSION", "5204")
        .with_var("TMUX", "session");
    assert_eq!(
        detect_terminal_info_from_env(&env),
        TerminalInfo {
            name: TerminalName::GnomeTerminal,
            term_program: None,
            version: None,
            term: None,
            multiplexer: Some(Multiplexer::Tmux { version: None }),
            backend: Some(TerminalBackend::Vte {
                version: Some(5204)
            }),
        }
    );
}

#[test]
fn raw_vte_version_takes_precedence_even_when_malformed() {
    for (raw_version, version) in [("5204", Some(5204)), ("invalid", None), ("", None)] {
        let env = FakeEnvironment::new()
            .with_var("TERM_PROGRAM", "VTE")
            .with_var("TERM_PROGRAM_VERSION", "7600")
            .with_var("VTE_VERSION", raw_version);
        assert_eq!(
            detect_terminal_info_from_env(&env),
            TerminalInfo {
                name: TerminalName::Vte,
                term_program: Some("VTE".to_string()),
                version: Some("7600".to_string()),
                term: None,
                multiplexer: None,
                backend: Some(TerminalBackend::Vte { version }),
            },
            "VTE_VERSION={raw_version:?}"
        );
    }
}