Skip to content

The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.

105 KB
Raw Blame
use crate::apply::{
    apply_to_run_configs, configure_server, jdtls_jdk, maven_command, maven_options, project_jdk, python_interpreter,
    ruff_configuration, terminal_activation, tool_install_environment, tsdk, without_derived,
};
use crate::python::parse_pip_list;
use crate::{bin_dir, exe, venv_of};
use ide_core::settings::Settings;
use ide_language::LanguageServerConfig;
use ide_run::RunConfig;
use std::collections::BTreeMap;
use std::path::Path;

fn fake_venv(root: &Path, name: &str) -> std::path::PathBuf {
    let venv = root.join(name);
    std::fs::create_dir_all(venv.join(bin_dir())).unwrap();
    std::fs::write(venv.join("pyvenv.cfg"), "home = /usr/bin\nversion = 3.12.1\n").unwrap();
    let py = venv.join(bin_dir()).join(exe("python"));
    std::fs::write(&py, "").unwrap();
    std::fs::write(venv.join(bin_dir()).join("activate"), "").unwrap();
    py
}

fn server(name: &str) -> LanguageServerConfig {
    LanguageServerConfig {
        name: name.into(),
        command: name.into(),
        args: vec![],
        env: BTreeMap::new(),
        root_markers: vec![],
        require_root_marker: false,
        initialization_options: None,
        settings: None,
        install_hint: None,
        connect: None,
        fallback: false,
        features: Vec::new(),
        code_action_kinds: Vec::new(),
        max_java: None,
        launch_error: None,
        tsserver_project: false,
        tsserver_project_extras: Default::default(),
        resync_on_configuration: false,
        pinned: None,
        target: None,
        target_key: None,
    }
}

fn run(kind: &str, command: &str, args: &[&str]) -> RunConfig {
    RunConfig {
        id: format!("{kind}:x"),
        name: "x".into(),
        kind: kind.into(),
        command: command.into(),
        args: args.iter().map(|s| (*s).to_owned()).collect(),
        cwd: None,
        env: BTreeMap::new(),
        detected: true,
        is_test: false,
        debug_adapter: None,
        allow_parallel: false,
        extras: Default::default(),
    }
}

#[test]
fn project_venv_is_the_default_interpreter() {
    if cfg!(windows) {
        return; // Unix paths and shells
    }
    let tmp = tempfile::tempdir().unwrap();
    let s = Settings::default();
    assert_eq!(python_interpreter(tmp.path(), &s), None);
    let py = fake_venv(tmp.path(), ".venv");
    assert_eq!(python_interpreter(tmp.path(), &s), Some(py.clone()));
    assert_eq!(venv_of(&py), Some(tmp.path().join(".venv")));
    let mut s = Settings::default();
    s.languages.python.interpreter = "/opt/py/bin/python3".into();
    assert_eq!(python_interpreter(tmp.path(), &s).unwrap(), Path::new("/opt/py/bin/python3"));
}

#[test]
#[cfg(unix)]
fn an_interpreter_outside_detection_is_named_like_a_detected_one() {
    let tmp = tempfile::tempdir().unwrap();
    let root = tmp.path().join("shop");
    let member = fake_venv(&root.join("backend"), ".venv");
    working_python(&member);
    let sdk = crate::python_interpreter_sdk(&member, Some(&root)).unwrap();
    assert_eq!(
        (sdk.name.as_str(), sdk.version.as_deref(), sdk.source.as_str()),
        ("Python 3.12 (backend)", Some("3.12.1"), "venv")
    );
    let own = fake_venv(&root, ".venv");
    working_python(&own);
    assert_eq!(crate::python_interpreter_sdk(&own, Some(&root)).unwrap().name, "Python 3.12 (shop)");
    // Outside the project the folder name says which one it is.
    let elsewhere = fake_venv(&tmp.path().join("other"), ".venv");
    working_python(&elsewhere);
    assert_eq!(crate::python_interpreter_sdk(&elsewhere, Some(&root)).unwrap().name, "Python 3.12 (.venv)");
}

#[cfg(unix)]
fn working_python(path: &Path) {
    use std::os::unix::fs::PermissionsExt;
    std::fs::write(path, "#!/bin/sh\n[ \"$1\" = '-I' ] && [ \"$2\" = '-c' ] || exit 1\necho 3.12.1\n").unwrap();
    std::fs::set_permissions(path, std::fs::Permissions::from_mode(0o755)).unwrap();
}

#[test]
#[cfg(unix)]
fn picked_venv_folders_and_executables_are_validated_without_resolving_symlinks() {
    let tmp = tempfile::tempdir().unwrap();
    let base = tmp.path().join("base-python");
    working_python(&base);
    for (name, cfg) in [("venv", "version = 3.12.1\n"), (".venv", "uv = 0.9.0\nversion_info = 3.12.1\n")] {
        let python = fake_venv(tmp.path(), name);
        let home = python.parent().unwrap().parent().unwrap();
        std::fs::write(home.join("pyvenv.cfg"), cfg).unwrap();
        std::fs::remove_file(&python).unwrap();
        std::os::unix::fs::symlink(&base, &python).unwrap();
        for picked in [home, python.as_path()] {
            let sdk = crate::python_interpreter_sdk(picked, None).unwrap();
            assert_eq!(&*sdk.path, python.as_path());
            assert_eq!(sdk.source, "venv");
            assert_eq!(sdk.version.as_deref(), Some("3.12.1"));
        }
    }
    assert_eq!(crate::python_interpreter_sdk(&base, None).unwrap().source, "system");
    std::fs::remove_file(&base).unwrap();
    assert!(crate::python_interpreter_sdk(&tmp.path().join(".venv"), None).is_none());
}

#[test]
fn a_real_existing_virtualenv_resolves_from_its_folder_or_platform_executable() {
    let Some(base) = crate::exec::which("python3").or_else(|| crate::exec::which("python")) else { return };
    let tmp = tempfile::tempdir().unwrap();
    let home = tmp.path().join("existing");
    let status =
        std::process::Command::new(base).args(["-I", "-m", "venv", "--without-pip"]).arg(&home).status().unwrap();
    assert!(status.success());
    let python = home.join(bin_dir()).join(exe("python"));
    for picked in [&home, &python] {
        let sdk = crate::python_interpreter_sdk(picked, None).unwrap();
        assert_eq!(&*sdk.path, python.as_path());
        assert_eq!(&**sdk.home.as_ref().unwrap(), home.as_path());
        assert_eq!(sdk.source, "venv");
        assert!(sdk.name.ends_with("(existing)"));
    }
}

#[test]
#[cfg(unix)]
fn picked_interpreters_must_run_python_code_even_with_valid_venv_metadata() {
    use std::os::unix::fs::PermissionsExt;
    let tmp = tempfile::tempdir().unwrap();
    let python = fake_venv(tmp.path(), "broken");
    // A broken runtime can still answer --version.
    std::fs::write(&python, "#!/bin/sh\n[ \"$1\" = '--version' ] && echo 'Python 3.12.1' && exit 0\nexit 1\n").unwrap();
    std::fs::set_permissions(&python, std::fs::Permissions::from_mode(0o755)).unwrap();
    assert!(crate::python_interpreter_sdk(&python, None).is_none());
    std::fs::write(&python, "#!/bin/sh\necho not-python\n").unwrap();
    assert!(crate::python_interpreter_sdk(&python, None).is_none());
    std::fs::remove_file(&python).unwrap();
    assert!(crate::python_interpreter_sdk(&python, None).is_none());
    assert!(crate::python_interpreter_sdk(tmp.path(), None).is_none());
}

#[test]
fn pyright_gets_python_path_and_venv_env() {
    let tmp = tempfile::tempdir().unwrap();
    let py = fake_venv(tmp.path(), ".venv");
    let mut cfg = server("basedpyright");
    configure_server(&mut cfg, tmp.path(), tmp.path(), &Settings::default());
    let opts = serde_json::to_value(cfg.initialization_options.unwrap()).unwrap();
    assert_eq!(opts["python"]["pythonPath"], py.to_string_lossy().as_ref());
    assert_eq!(cfg.env["VIRTUAL_ENV"], tmp.path().join(".venv").to_string_lossy());
    assert!(cfg.env["PATH"].starts_with(&*tmp.path().join(".venv").join(bin_dir()).to_string_lossy()));
}

#[test]
fn jdtls_vm_args() {
    let tmp = tempfile::tempdir().unwrap();
    let mut s = Settings::default();
    s.languages.java.jdtls_vm_args = " -Xmx2g  -javaagent:/opt/lombok.jar ".into();
    let mut cfg = server("jdtls");
    configure_server(&mut cfg, tmp.path(), tmp.path(), &s);
    assert_eq!(cfg.args, ["--jvm-arg=-Xmx2g", "--jvm-arg=-javaagent:/opt/lombok.jar"]);
}

#[test]
fn jdtls_honors_the_configured_maven_local_repository() {
    let tmp = tempfile::tempdir().unwrap();
    let repo = tmp.path().join("m2-repo");
    let mut s = Settings::default();
    s.languages.java.maven.local_repository = repo.to_string_lossy().into_owned();
    let mut cfg = server("jdtls");
    configure_server(&mut cfg, tmp.path(), tmp.path(), &s);
    assert_eq!(cfg.args, [format!("--jvm-arg=-Dmaven.repo.local={}", repo.to_string_lossy())]);
    // A `-Dmaven.repo.local` the user put in their own jdtls VM options wins.
    s.languages.java.jdtls_vm_args = "-Xmx2g -Dmaven.repo.local=/user/repo".into();
    let mut cfg = server("jdtls");
    configure_server(&mut cfg, tmp.path(), tmp.path(), &s);
    assert_eq!(cfg.args, ["--jvm-arg=-Xmx2g", "--jvm-arg=-Dmaven.repo.local=/user/repo"]);
    // Unset: jdtls keeps m2e's own default (no arg at all).
    let mut cfg = server("jdtls");
    configure_server(&mut cfg, tmp.path(), tmp.path(), &Settings::default());
    assert!(cfg.args.iter().all(|a| !a.contains("maven.repo.local")));
}

#[test]
fn jdtls_m2e_gets_effective_settings_with_local_repository() {
    fn user_settings(cfg: &LanguageServerConfig) -> Option<std::path::PathBuf> {
        let opts = serde_json::to_value(cfg.initialization_options.clone()?).ok()?;
        opts.pointer("/settings/java/configuration/maven/userSettings")?.as_str().map(std::path::PathBuf::from)
    }

    // Configured repository, no user settings: a derived file is passed (#1739).
    let tmp = tempfile::tempdir().unwrap();
    let repo = tmp.path().join("m2-repo");
    let mut s = Settings::default();
    s.languages.java.maven.local_repository = repo.to_string_lossy().into_owned();
    let mut cfg = server("jdtls");
    configure_server(&mut cfg, tmp.path(), tmp.path(), &s);
    let derived = tmp.path().join(".openidea").join("maven-settings.xml");
    assert_eq!(user_settings(&cfg), Some(derived.clone()));
    let text = std::fs::read_to_string(&derived).unwrap();
    assert!(text.contains(&format!("<localRepository>{}</localRepository>", repo.to_string_lossy())));
    // Stable across runs (no rewrite churn).
    let mut cfg = server("jdtls");
    configure_server(&mut cfg, tmp.path(), tmp.path(), &s);
    assert_eq!(user_settings(&cfg), Some(derived.clone()));

    // User settings without `<localRepository>`: the derived copy keeps the
    // user's mirrors and gains the configured repository.
    let settings = tmp.path().join("mine.xml");
    std::fs::write(&settings, "<settings><mirrors><mirror><id>m</id></mirror></mirrors></settings>").unwrap();
    s.languages.java.maven.user_settings = settings.to_string_lossy().into_owned();
    let mut cfg = server("jdtls");
    configure_server(&mut cfg, tmp.path(), tmp.path(), &s);
    assert_eq!(user_settings(&cfg), Some(derived.clone()));
    let text = std::fs::read_to_string(&derived).unwrap();
    assert!(text.contains("<mirror><id>m</id></mirror>"));
    assert!(text.contains(&format!("<localRepository>{}</localRepository>", repo.to_string_lossy())));

    // User settings already declaring `<localRepository>`: passed through untouched.
    std::fs::write(&settings, "<settings><localRepository>/user/repo</localRepository></settings>").unwrap();
    let mut cfg = server("jdtls");
    configure_server(&mut cfg, tmp.path(), tmp.path(), &s);
    assert_eq!(user_settings(&cfg), Some(settings.clone()));

    // Neither configured: no userSettings at all.
    let mut cfg = server("jdtls");
    configure_server(&mut cfg, tmp.path(), tmp.path(), &Settings::default());
    assert_eq!(user_settings(&cfg), None);
}

#[test]
fn rust_analyzer_check_command_and_toolchain() {
    if cfg!(windows) {
        return; // Unix paths and shells
    }
    let tmp = tempfile::tempdir().unwrap();
    let mut s = Settings::default();
    s.languages.rust.check_command = "clippy".into();
    s.languages.rust.stdlib = "/src/rust/library".into();
    s.languages.rust.rustfmt_args = "--edition 2024".into();
    let mut cfg = server("rust-analyzer");
    cfg.initialization_options =
        Some(toml::Value::try_from(serde_json::json!({ "cargo": { "features": "all" } })).unwrap());
    configure_server(&mut cfg, tmp.path(), tmp.path(), &s);
    let opts = serde_json::to_value(cfg.initialization_options.clone().unwrap()).unwrap();
    assert_eq!(opts["check"]["command"], "clippy");
    assert_eq!(opts["cargo"]["features"], "all", "existing options are kept");
    assert_eq!(opts["rustfmt"]["extraArgs"], serde_json::json!(["--edition", "2024"]));
    assert_eq!(cfg.env["RUST_SRC_PATH"], "/src/rust/library");
    // Unchanged settings produce an identical config (no needless restarts).
    let mut again = server("rust-analyzer");
    again.initialization_options =
        Some(toml::Value::try_from(serde_json::json!({ "cargo": { "features": "all" } })).unwrap());
    configure_server(&mut again, tmp.path(), tmp.path(), &s);
    assert_eq!(again, cfg);
}

#[test]
fn typescript_workspace_version() {
    let tmp = tempfile::tempdir().unwrap();
    let lib = tmp.path().join("node_modules/typescript/lib");
    std::fs::create_dir_all(&lib).unwrap();
    std::fs::write(lib.join("tsserver.js"), "").unwrap();
    let mut s = Settings::default();
    assert_eq!(tsdk(tmp.path(), &s), None);
    s.languages.typescript.version = "workspace".into();
    assert_eq!(tsdk(tmp.path(), &s), Some(lib.clone()));
    let mut cfg = server("vtsls");
    configure_server(&mut cfg, tmp.path(), tmp.path(), &s);
    let opts = serde_json::to_value(cfg.initialization_options.unwrap()).unwrap();
    assert_eq!(opts["typescript"]["tsdk"], lib.to_string_lossy().as_ref());
}

#[test]
fn run_configs_use_selected_interpreter_and_package_manager() {
    if cfg!(windows) {
        return; // Unix paths and shells
    }
    let tmp = tempfile::tempdir().unwrap();
    let mut s = Settings::default();
    s.languages.python.interpreter = "/opt/py/bin/python3".into();
    s.languages.node.package_manager = "pnpm".into();
    let mut configs = vec![
        run("python", "uv", &["run", "python", "-m", "app"]),
        run("pytest", ".venv/bin/pytest", &[]),
        run("pytest", "uv", &["run", "pytest", "-x"]),
        run("npm", "npm", &["run", "dev"]),
        run("shell", "python3", &["x.py"]),
        run("django-test", "uv", &["run", "python", "manage.py", "test"]),
        run("django-test", ".venv/bin/python", &["manage.py", "test", "polls"]),
    ];
    apply_to_run_configs(&mut configs, tmp.path(), &s);
    assert_eq!(configs[0].command, "/opt/py/bin/python3");
    assert_eq!(configs[0].args, ["-m", "app"]);
    assert_eq!(configs[1].command, "/opt/py/bin/python3");
    assert_eq!(configs[1].args, ["-m", "pytest"]);
    assert_eq!(configs[2].args, ["-m", "pytest", "-x"]);
    assert_eq!(configs[3].command, "pnpm");
    assert_eq!(configs[4].command, "python3", "shell configs are left alone");
    // Django tests run on the selected interpreter, like `manage.py runserver`.
    assert_eq!(configs[5].command, "/opt/py/bin/python3");
    assert_eq!(configs[5].args, ["manage.py", "test"]);
    assert_eq!(configs[6].command, "/opt/py/bin/python3");
    assert_eq!(configs[6].args, ["manage.py", "test", "polls"]);
}

#[test]
fn npm_config_runs_on_its_own_node_interpreter() {
    if cfg!(windows) {
        return; // Unix paths
    }
    let tmp = tempfile::tempdir().unwrap();
    let mut s = Settings::default();
    s.languages.node.interpreter = "/opt/node22/bin/node".into();
    let mut own = run("npm", "npm", &["run", "dev"]);
    own.extras.params.insert("nodeInterpreter".into(), "/opt/node18/bin/node".into());
    let mut configs = vec![own, run("npm", "npm", &["run", "build"])];
    apply_to_run_configs(&mut configs, tmp.path(), &s);
    let first = |c: &RunConfig| c.env["PATH"].split(':').next().unwrap().to_owned();
    assert_eq!(first(&configs[0]), "/opt/node18/bin");
    assert_eq!(first(&configs[1]), "/opt/node22/bin", "the project's Node.js without one");
    // Saved without the derived PATH, keeping the choice itself.
    let saved = without_derived(&configs[0], tmp.path(), &s);
    assert!(!saved.env.contains_key("PATH"));
    assert_eq!(saved.extras.params["nodeInterpreter"], "/opt/node18/bin/node");
    // Chosen on a configuration loaded with the project's PATH: that PATH isn't kept either.
    let mut edited = configs[1].clone();
    edited.extras.params.insert("nodeInterpreter".into(), "/opt/node18/bin/node".into());
    let saved = without_derived(&edited, tmp.path(), &s);
    assert!(!saved.env.contains_key("PATH"));
    let mut reloaded = vec![saved];
    apply_to_run_configs(&mut reloaded, tmp.path(), &s);
    assert_eq!(first(&reloaded[0]), "/opt/node18/bin");
}

fn fake_jdk(dir: &Path) {
    std::fs::create_dir_all(dir.join("bin")).unwrap();
    crate::java::write_test_java(dir);
    std::fs::write(
        dir.join("release"),
        "JAVA_VERSION=\"17.0.9\"\nMODULES=\"java.base jdk.compiler jdk.jdi jdk.unsupported\"\n",
    )
    .unwrap();
    std::fs::write(dir.join("bin").join(crate::exe("javac")), "").unwrap();
}

#[test]
fn project_jdk_and_maven_settings() {
    if cfg!(windows) {
        return; // Unix paths and shells
    }
    let tmp = tempfile::tempdir().unwrap();
    let jdk = tmp.path().join("jdk17");
    fake_jdk(&jdk);
    let maven = tmp.path().join("maven");
    std::fs::create_dir_all(maven.join("bin")).unwrap();
    std::fs::write(maven.join("bin/mvn"), "").unwrap();

    let mut s = Settings::default();
    assert_eq!(project_jdk(tmp.path(), &s), None);
    assert_eq!(maven_command(tmp.path(), &s), None);
    assert!(maven_options(tmp.path(), &s).is_empty());

    // Project-relative paths, a JDK's `bin/java`, a Maven home.
    s.languages.java.jdk = "jdk17/bin/java".into();
    s.languages.java.maven.home = maven.to_string_lossy().into_owned();
    s.languages.java.maven.user_settings = "/m2/settings.xml".into();
    s.languages.java.maven.toolchains = "/m2/toolchains.xml".into();
    s.languages.java.maven.local_repository = "/m2/repo".into();
    assert_eq!(project_jdk(tmp.path(), &s).map(|j| j.major), Some(17));
    assert_eq!(maven_command(tmp.path(), &s), Some(maven.join("bin/mvn")));
    assert_eq!(
        maven_options(tmp.path(), &s),
        ["-s", "/m2/settings.xml", "-t", "/m2/toolchains.xml", "-Dmaven.repo.local=/m2/repo"]
    );

    let mut configs = vec![run("maven", "./mvnw", &["package"]), run("gradle", "./gradlew", &["build"])];
    apply_to_run_configs(&mut configs, tmp.path(), &s);
    let home = project_jdk(tmp.path(), &s).unwrap().home.to_string_lossy().into_owned();
    assert_eq!(configs[0].command, maven.join("bin/mvn").to_string_lossy());
    assert_eq!(
        configs[0].args,
        ["-s", "/m2/settings.xml", "-t", "/m2/toolchains.xml", "-Dmaven.repo.local=/m2/repo", "package"]
    );
    assert_eq!(configs[0].env["JAVA_HOME"], home);
    assert_eq!(configs[1].env["JAVA_HOME"], home);
    apply_to_run_configs(&mut configs, tmp.path(), &s);
    assert_eq!(configs[0].args.len(), 6, "applied once");

    s.languages.java.jdk = "missing".into();
    assert_eq!(project_jdk(tmp.path(), &s), None);
}

#[test]
fn maven_runner_jre_overrides_the_project_jdk() {
    let tmp = tempfile::tempdir().unwrap();
    let root = dunce::canonicalize(tmp.path()).unwrap();
    for name in ["project-jdk", "runner-jdk", "next-jdk"] {
        fake_jdk(&root.join(name));
    }
    let mut settings: Settings = serde_json::from_value(serde_json::json!({
        "languages": { "java": {
            "jdk": "project-jdk",
            "maven": { "runnerJre": "runner-jdk" }
        } }
    }))
    .unwrap();
    for runner in ["", "runner-jdk", "runner-jdk/bin", "runner-jdk/bin/java"] {
        settings.languages.java.maven.runner_jre =
            if runner.ends_with("java") { format!("runner-jdk/bin/{}", exe("java")) } else { runner.into() };
        let expected = root.join(if runner.is_empty() { "project-jdk" } else { "runner-jdk" });
        assert_eq!(crate::apply::maven_build_env(&root, &settings, Some(8))["JAVA_HOME"], expected.to_string_lossy());
        for (detected, is_test, debug) in
            [(true, false, false), (false, false, false), (true, true, false), (true, true, true)]
        {
            let mut config = run("maven", "mvn", &["test"]);
            config.detected = detected;
            config.is_test = is_test;
            if debug {
                config.env.insert(
                    "MAVEN_OPTS".into(),
                    "-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=5005".into(),
                );
            }
            let mut configs =
                [config.clone(), run("gradle", "gradle", &["build"]), run("tomcat", "catalina", &["run"])];
            apply_to_run_configs(&mut configs, &root, &settings);
            assert_eq!(configs[0].env["JAVA_HOME"], expected.to_string_lossy());
            for other in &configs[1..] {
                assert_eq!(other.env["JAVA_HOME"], root.join("project-jdk").to_string_lossy());
            }
            let saved = without_derived(&configs[0], &root, &settings);
            assert!(!saved.env.contains_key("JAVA_HOME"));
            let mut next_settings = settings.clone();
            next_settings.languages.java.maven.runner_jre = "next-jdk".into();
            let mut next = saved;
            crate::apply::prepare_maven_run(&mut next, &root, &next_settings);
            assert_eq!(next.env["JAVA_HOME"], root.join("next-jdk").to_string_lossy());
            config.env.insert("JAVA_HOME".into(), "explicit-jdk".into());
            apply_to_run_configs(std::slice::from_mut(&mut config), &root, &settings);
            assert_eq!(config.env["JAVA_HOME"], "explicit-jdk");
        }
    }
    settings.languages.java.jdk.clear();
    settings.languages.java.maven.runner_jre.clear();
    assert!(crate::apply::maven_build_env(&root, &settings, None).is_empty());
    for release in [8, 17, 21] {
        let installed = crate::java::installed_jdks();
        let expected = crate::java::pick_jdk(&installed, Some(release));
        assert_eq!(crate::apply::maven_jdk(&root, &settings, Some(release)).as_ref(), expected);
    }
}

#[test]
fn maven_daemon_uses_the_runner_jre_version() {
    let tmp = tempfile::tempdir().unwrap();
    let root = dunce::canonicalize(tmp.path()).unwrap();
    for major in [8, 21] {
        let home = root.join(format!("jdk{major}"));
        fake_jdk(&home);
        std::fs::write(home.join("release"), format!("JAVA_VERSION=\"{major}\"\n")).unwrap();
    }
    let mvn = root.join("maven/bin").join(if cfg!(windows) { "mvn.cmd" } else { "mvn" });
    let mvnd = root.join("mvnd/bin").join(if cfg!(windows) { "mvnd.cmd" } else { "mvnd" });
    for path in [&mvn, &mvnd] {
        std::fs::create_dir_all(path.parent().unwrap()).unwrap();
        std::fs::write(path, "").unwrap();
    }
    let mut settings = Settings::default();
    settings.languages.java.maven.home = "maven".into();
    settings.languages.java.maven.mvnd_home = "mvnd".into();
    settings.languages.java.maven.daemon = true;
    for (project, runner, expected) in [(8, 21, &mvnd), (21, 8, &mvn)] {
        settings.languages.java.jdk = format!("jdk{project}");
        settings.languages.java.maven.runner_jre = format!("jdk{runner}");
        assert_eq!(maven_command(&root, &settings).as_ref(), Some(expected));
    }
}

#[test]
fn maven_options_carry_active_profiles_into_the_command_line() {
    let tmp = tempfile::tempdir().unwrap();
    let mut s = Settings::default();
    s.languages.java.maven.active_profiles = "dev, integration".into();
    assert_eq!(maven_options(tmp.path(), &s), ["-P", "dev, integration"]);
    s.languages.java.maven.active_profiles = "  ".into();
    assert!(maven_options(tmp.path(), &s).is_empty());

    // A run configuration's own -P wins; repeated application does not duplicate the settings group.
    s.languages.java.maven.active_profiles = "dev".into();
    let mut configs = vec![run("maven", "./mvnw", &["package"])];
    apply_to_run_configs(&mut configs, tmp.path(), &s);
    assert_eq!(configs[0].args, ["-P", "dev", "package"]);
    apply_to_run_configs(&mut configs, tmp.path(), &s);
    assert_eq!(configs[0].args, ["-P", "dev", "package"]);
    let mut configured = vec![run("maven", "./mvnw", &["-P", "prod", "package"])];
    apply_to_run_configs(&mut configured, tmp.path(), &s);
    assert_eq!(configured[0].args, ["-P", "prod", "package"]);
}

#[test]
fn maven_profile_and_toolchain_overrides_accept_every_option_form() {
    let tmp = tempfile::tempdir().unwrap();
    let mut s = Settings::default();
    s.languages.java.maven.active_profiles = "a".into();
    s.languages.java.maven.toolchains = "config files/toolchains.xml".into();
    let toolchains = tmp.path().join("config files/toolchains.xml").to_string_lossy().into_owned();
    assert_eq!(maven_options(tmp.path(), &s), ["-t", &toolchains, "-P", "a"]);
    for own in [
        vec!["-P", "b,!c", "-t", "own file.xml"],
        vec!["-Pb,!c", "-town file.xml"],
        vec!["--activate-profiles", "b,!c", "--toolchains", "own file.xml"],
        vec!["--activate-profiles=b,!c", "--toolchains=own file.xml"],
    ] {
        let mut args = own.clone();
        args.push("test");
        let mut config = run("maven", "mvn", &args);
        config.detected = false;
        for _ in 0..3 {
            apply_to_run_configs(std::slice::from_mut(&mut config), tmp.path(), &s);
            assert_eq!(config.args, args, "configuration options win: {own:?}");
        }
    }
}

#[test]
fn maven_goal_profiles_combine_settings_and_checkboxes_but_keep_explicit_overrides() {
    use crate::apply::prepare_maven_run;

    let tmp = tempfile::tempdir().unwrap();
    let mut s = Settings::default();
    s.languages.java.maven.active_profiles = "a".into();
    s.languages.java.maven.toolchains = "config files/toolchains.xml".into();
    let mut config = run("maven", "mvn", &["test", "-Pb,!c"]);
    config.id = "maven:goal:pom.xml:test".into();
    config.detected = false;
    let mut expected = maven_options(tmp.path(), &s);
    expected.extend(["test".into(), "-Pb,!c".into()]);
    for _ in 0..3 {
        prepare_maven_run(&mut config, tmp.path(), &s);
        assert_eq!(config.args, expected);
        apply_to_run_configs(std::slice::from_mut(&mut config), tmp.path(), &s);
        assert_eq!(config.args, expected);
    }
    s.languages.java.maven.active_profiles = "new".into();
    prepare_maven_run(&mut config, tmp.path(), &s);
    assert_eq!(&config.args[2..], ["-P", "new", "test", "-Pb,!c"]);

    for own in
        [vec!["-P", "prod"], vec!["-Pprod"], vec!["--activate-profiles", "prod"], vec!["--activate-profiles=prod"]]
    {
        let mut args = vec!["test"];
        args.extend(own);
        let mut config = run("maven", "mvn", &args);
        config.id = format!("maven:goal:pom.xml:{}", args.join(" "));
        config.detected = false;
        for _ in 0..3 {
            prepare_maven_run(&mut config, tmp.path(), &s);
            assert_eq!(&config.args[2..], args);
        }
    }
}

#[test]
fn maven_launch_refreshes_attached_and_long_settings_prefixes() {
    use crate::apply::prepare_maven_run;

    let tmp = tempfile::tempdir().unwrap();
    std::fs::write(tmp.path().join("pom.xml"), "<project/>").unwrap();
    let mut s = Settings::default();
    s.languages.java.maven.active_profiles = "new".into();
    s.languages.java.maven.toolchains = "new toolchains.xml".into();
    for prefix in [
        vec!["-told file.xml", "-Pa"],
        vec!["--toolchains", "old file.xml", "--activate-profiles", "a"],
        vec!["--toolchains=old file.xml", "--activate-profiles=a"],
    ] {
        for id in
            ["maven:goal:pom.xml:test", "maven:test", "context:maven:test:ExampleTest", "workspace:abc:maven:test"]
        {
            let mut args = prefix.clone();
            args.push("test");
            let mut config = run("maven", "mvn", &args);
            config.id = id.into();
            config.detected = !id.starts_with("maven:goal:");
            let mut expected = maven_options(tmp.path(), &s);
            expected.push("test".into());
            for _ in 0..3 {
                prepare_maven_run(&mut config, tmp.path(), &s);
                assert_eq!(config.args, expected, "{id}: {prefix:?}");
            }
        }
    }
}

#[test]
fn maven_options_carry_the_thread_count_into_the_command_line() {
    let tmp = tempfile::tempdir().unwrap();
    let mut s = Settings::default();
    assert!(maven_options(tmp.path(), &s).is_empty(), "empty settings add nothing");

    s.languages.java.maven.user_settings = "m2/settings.xml".into();
    s.languages.java.maven.local_repository = "m2/repo".into();
    s.languages.java.maven.threads = "4".into();
    let settings_file = tmp.path().join("m2/settings.xml").to_string_lossy().into_owned();
    let repo = tmp.path().join("m2/repo").to_string_lossy().into_owned();
    assert_eq!(
        maven_options(tmp.path(), &s),
        ["-s", settings_file.as_str(), &format!("-Dmaven.repo.local={repo}"), "-T", "4"]
    );

    // A core multiplier passes through; anything Maven would reject is dropped
    // rather than failing every build.
    s.languages.java.maven.threads = "2.5C".into();
    assert!(maven_options(tmp.path(), &s).ends_with(&["-T".to_owned(), "2.5C".to_owned()]));
    s.languages.java.maven.threads = "abc".into();
    assert!(!maven_options(tmp.path(), &s).iter().any(|a| a == "-T"));

    // Run configurations get the options ahead of the goals, once per launch.
    s.languages.java.maven.threads = "2C".into();
    let mut configs = vec![run("maven", "./mvnw", &["package"]), run("maven", "./mvnw", &["-T", "8", "package"])];
    apply_to_run_configs(&mut configs, tmp.path(), &s);
    let args: Vec<String> = configs[0].args.clone();
    assert_eq!(args[args.len() - 3..].join(" "), "-T 2C package", "the settings' thread count leads the goals");
    let args: Vec<String> = configs[1].args.clone();
    assert_eq!(args[args.len() - 3..].join(" "), "-T 8 package", "the configuration's own -T wins");
    apply_to_run_configs(&mut configs, tmp.path(), &s);
    assert_eq!(configs[0].args.iter().filter(|a| a.as_str() == "-T").count(), 1, "applied once");
}

#[test]
fn saved_maven_goal_configs_take_the_configured_launcher() {
    if cfg!(windows) {
        return; // Unix paths
    }
    let tmp = tempfile::tempdir().unwrap();
    let maven = tmp.path().join("maven");
    std::fs::create_dir_all(maven.join("bin")).unwrap();
    std::fs::write(maven.join("bin/mvn"), "").unwrap();
    let mut s = Settings::default();
    s.languages.java.maven.home = maven.to_string_lossy().into_owned();
    s.languages.java.maven.user_settings = "/m2/settings.xml".into();

    // A goal configuration saved from the tool window (`mvn -s … clean`):
    // the bare launcher resolves to the configured Maven home (#328) and its
    // own args are left alone.
    let mut saved = run("maven", "mvn", &["-s", "/m2/settings.xml", "clean"]);
    saved.detected = false;
    // A custom path / the wrapper stay as configured.
    let mut custom = run("maven", "/opt/other/bin/mvn", &["package"]);
    custom.detected = false;
    let mut wrapper = run("maven", "./mvnw", &["package"]);
    wrapper.detected = false;
    let mut configs = vec![saved, custom, wrapper];
    apply_to_run_configs(&mut configs, tmp.path(), &s);
    assert_eq!(configs[0].command, maven.join("bin/mvn").to_string_lossy());
    assert_eq!(configs[0].args, ["-s", "/m2/settings.xml", "clean"], "saved args are kept");
    assert_eq!(configs[1].command, "/opt/other/bin/mvn");
    assert_eq!(configs[2].command, "./mvnw");
}

#[test]
fn maven_launch_refreshes_legacy_defaults_but_keeps_user_overrides() {
    use crate::apply::prepare_maven_run;

    let tmp = tempfile::tempdir().unwrap();
    std::fs::write(tmp.path().join("pom.xml"), "<project/>").unwrap();
    let home = tmp.path().join("new-maven");
    std::fs::create_dir_all(home.join("bin")).unwrap();
    let launcher = home.join("bin").join(if cfg!(windows) { "mvn.cmd" } else { "mvn" });
    std::fs::write(&launcher, "").unwrap();
    let mut s = Settings::default();
    s.languages.java.maven.home = home.to_string_lossy().into_owned();
    s.languages.java.maven.user_settings = "new-settings.xml".into();
    s.languages.java.maven.local_repository = "new-repo".into();
    let options = maven_options(tmp.path(), &s);

    for id in [
        "maven:goal:pom.xml:test",
        "maven:test",
        "context:maven:test:src/test/java/ExampleTest.java",
        "context:target:context:maven:test:src/test/java/ExampleTest.java:ExampleTest#example",
        "workspace:abc:maven:test",
        "context:target:context:workspace:abc:maven:test:src/test/java/ExampleTest.java:ExampleTest#example",
    ] {
        let mut config = run(
            "maven",
            "//?/UNC/server/old-maven/bin/mvn.cmd",
            &["-s", "old-settings.xml", "-Dmaven.repo.local=old-repo", "test", "-Dtest=ExampleTest#example"],
        );
        config.id = id.into();
        config.detected = !id.starts_with("maven:goal:");
        let original = config.clone();
        prepare_maven_run(&mut config, tmp.path(), &s);
        assert_eq!(config.command, launcher.to_string_lossy(), "{id}");
        assert_eq!(
            config.args,
            [options.clone(), vec!["test".into(), "-Dtest=ExampleTest#example".into()]].concat(),
            "{id}"
        );
        // Rerunning the stored configuration reads settings again, without changing the stored input.
        s.languages.java.maven.local_repository = "other-repo".into();
        let mut rerun = original;
        prepare_maven_run(&mut rerun, tmp.path(), &s);
        assert!(rerun.args.contains(&format!("-Dmaven.repo.local={}", tmp.path().join("other-repo").display())));
        s.languages.java.maven.local_repository = "new-repo".into();
    }

    for args in [
        vec!["-s", "own-settings.xml", "-Dmaven.repo.local=own-repo", "test"],
        vec!["--settings=own-settings.xml", "-D", "maven.repo.local=own-repo", "test"],
    ] {
        let mut config = run("maven", "mvn", &args);
        config.detected = false;
        prepare_maven_run(&mut config, tmp.path(), &s);
        assert_eq!(config.command, launcher.to_string_lossy());
        assert_eq!(config.args, args);
    }

    let mut explicit = run("maven", "/custom/mvn", &["-s", "own-settings.xml", "-Dmaven.repo.local=own-repo", "test"]);
    explicit.detected = false;
    prepare_maven_run(&mut explicit, tmp.path(), &s);
    assert_eq!(explicit.command, "/custom/mvn");
    assert_eq!(explicit.args, ["-s", "own-settings.xml", "-Dmaven.repo.local=own-repo", "test"]);

    // A gutter configuration derived from a user-edited default must keep that user's choices.
    let mut saved = explicit.clone();
    saved.id = "maven:test".into();
    ide_run::save_user_configs(tmp.path(), &[saved]).unwrap();
    explicit.id = "context:maven:test:src/test/java/ExampleTest.java".into();
    explicit.detected = true;
    prepare_maven_run(&mut explicit, tmp.path(), &s);
    assert_eq!(explicit.command, "/custom/mvn");
    assert_eq!(explicit.args, ["-s", "own-settings.xml", "-Dmaven.repo.local=own-repo", "test"]);

    std::fs::create_dir(tmp.path().join("child")).unwrap();
    std::fs::write(tmp.path().join("child/pom.xml"), "<project/>").unwrap();
    let mut nested = explicit.clone();
    nested.id = "maven:test:child".into();
    nested.detected = false;
    ide_run::save_user_configs(tmp.path(), &[nested]).unwrap();
    explicit.id = "context:maven:test:child:src/test/java/ExampleTest.java".into();
    prepare_maven_run(&mut explicit, tmp.path(), &s);
    assert_eq!(explicit.command, "/custom/mvn", "an edited child must not fall back to the parent's defaults");
    assert_eq!(explicit.args, ["-s", "own-settings.xml", "-Dmaven.repo.local=own-repo", "test"]);
}

#[test]
fn maven_goal_keeps_explicit_settings_and_nested_wrapper() {
    use crate::apply::prepare_maven_run;

    let tmp = tempfile::tempdir().unwrap();
    std::fs::create_dir(tmp.path().join("child")).unwrap();
    let wrapper = tmp.path().join("child").join(if cfg!(windows) { "mvnw.cmd" } else { "mvnw" });
    std::fs::write(&wrapper, "").unwrap();
    let mut config = run("maven", "old-maven", &["-s", "old-settings.xml", "-s", "own-settings.xml", "test"]);
    config.id = "maven:goal:child/pom.xml:-s own-settings.xml test".into();
    config.cwd = Some("child".into());
    config.detected = false;
    let mut s = Settings::default();
    s.languages.java.maven.user_settings = "new-settings.xml".into();
    prepare_maven_run(&mut config, tmp.path(), &s);
    assert_eq!(config.command, wrapper.to_string_lossy());
    assert_eq!(config.args, ["-s", "own-settings.xml", "test"]);
}

#[test]
fn persisting_a_maven_goal_keeps_explicit_options_equal_to_the_defaults() {
    let tmp = tempfile::tempdir().unwrap();
    let mut s = Settings::default();
    s.languages.java.maven.user_settings = tmp.path().join("settings.xml").to_string_lossy().into_owned();
    s.languages.java.maven.local_repository = tmp.path().join("repo").to_string_lossy().into_owned();
    let options = maven_options(tmp.path(), &s);
    for goals in [vec![options[2].clone(), "test".into()], [options.clone(), vec!["test".into()]].concat()] {
        let mut config = run("maven", "mvn", &[]);
        config.id = format!("maven:goal:pom.xml:{}", goals.join(" "));
        config.detected = false;
        config.args = goals.clone();
        apply_to_run_configs(std::slice::from_mut(&mut config), tmp.path(), &s);
        let kept = without_derived(&config, tmp.path(), &s);
        assert_eq!(kept.args, goals);
    }
}

#[test]
fn language_server_settings_disable_add_and_override() {
    use crate::apply::{language_servers, server_launch_overrides, server_protocol_overrides, with_custom_servers};
    use ide_core::settings::LanguageServerSettings;
    use serde_json::json;

    let mut s = Settings::default();
    s.language_servers.insert("pylsp".into(), LanguageServerSettings { enabled: false, ..Default::default() });
    s.language_servers.insert(
        "pylyzer".into(),
        LanguageServerSettings {
            command: "pylyzer".into(),
            args: Some(vec!["--server".into()]),
            languages: vec!["python".into()],
            root_markers: vec!["pyproject.toml".into()],
            ..Default::default()
        },
    );
    let defined = [server("basedpyright"), server("pylsp")];
    let names = |v: Vec<LanguageServerConfig>| v.into_iter().map(|c| c.name).collect::<Vec<_>>();
    assert_eq!(names(language_servers("python", &defined, &s)), ["basedpyright", "pylyzer"]);
    assert_eq!(names(language_servers("rust", &[server("rust-analyzer")], &s)), ["rust-analyzer"]);

    // Listed with the tools even while disabled.
    let mut langs = ide_language::LanguageRegistry::load(None).unwrap().all();
    with_custom_servers(&mut langs, &s);
    let python = langs.iter().find(|l| l.id.as_str() == "python").unwrap();
    let mut pylyzer = python.language_servers.iter().find(|c| c.name == "pylyzer").unwrap().clone();
    assert_eq!(pylyzer.root_markers, ["pyproject.toml"]);
    server_launch_overrides(&mut pylyzer, &s);
    assert_eq!((pylyzer.command.as_str(), pylyzer.args.as_slice()), ("pylyzer", &["--server".to_string()][..]));

    // A hand-defined server named like a built-in one only overrides how it
    // launches: languages and root markers stay the built-in definition's.
    s.language_servers.insert(
        "ruff".into(),
        LanguageServerSettings {
            command: "/opt/ruff".into(),
            args: Some(vec!["server".into(), "--preview".into()]),
            languages: vec!["python".into()],
            root_markers: vec!["pyproject.toml".into()],
            ..Default::default()
        },
    );
    let mut langs = ide_language::LanguageRegistry::load(None).unwrap().all();
    with_custom_servers(&mut langs, &s);
    let python = langs.iter().find(|l| l.id.as_str() == "python").unwrap();
    assert_eq!(python.language_servers.iter().filter(|c| c.name == "ruff").count(), 1);
    let mut ruff = python.language_servers.iter().find(|c| c.name == "ruff").unwrap().clone();
    assert_eq!(ruff.root_markers, ["ruff.toml", ".ruff.toml", "pyproject.toml#tool.ruff"]);
    assert!(ruff.require_root_marker);
    server_launch_overrides(&mut ruff, &s);
    assert_eq!(
        (ruff.command.as_str(), ruff.args.as_slice()),
        ("/opt/ruff", &["server".to_string(), "--preview".to_string()][..])
    );
    s.languages.ruff.configuration_directory = "ruff-config".into();
    let defined = [server("ruff")];
    assert!(!language_servers("python", &defined, &s)[0].require_root_marker);

    s.language_servers.insert(
        "rust-analyzer".into(),
        LanguageServerSettings {
            env: BTreeMap::from([("RA_LOG".into(), "info".into())]),
            initialization_options: Some(json!({ "check": { "command": "clippy" } })),
            settings: Some(json!({ "rust-analyzer": { "cargo": { "features": "all" } } })),
            ..Default::default()
        },
    );
    let mut ra = server("rust-analyzer");
    ra.args = vec!["--stdio".into()];
    ra.initialization_options = Some(toml::Value::Table(toml::toml! { checkOnSave = false }));
    server_launch_overrides(&mut ra, &s);
    assert_eq!(ra.args, ["--stdio"], "no args setting keeps the definition's");
    server_protocol_overrides(&mut ra, &s);
    assert_eq!(ra.env["RA_LOG"], "info");
    let init = serde_json::to_value(ra.initialization_options.unwrap()).unwrap();
    assert_eq!(init, json!({ "checkOnSave": false, "check": { "command": "clippy" } }));
    assert_eq!(ra.settings, Some(json!({ "rust-analyzer": { "cargo": { "features": "all" } } })));
    assert!(ra.features.is_empty() && ra.code_action_kinds.is_empty(), "no setting keeps the definition's");

    // `features` / `codeActionKinds` replace the definition's; empty lifts them.
    let mut pylsp = server("pylsp");
    pylsp.features = vec!["code-action".into()];
    pylsp.code_action_kinds = vec!["refactor".into()];
    s.language_servers.insert(
        "pylsp".into(),
        LanguageServerSettings {
            features: Some(vec!["code-action".into(), "hover".into()]),
            code_action_kinds: Some(vec![]),
            ..Default::default()
        },
    );
    server_protocol_overrides(&mut pylsp, &s);
    assert_eq!(pylsp.features, ["code-action", "hover"]);
    assert!(pylsp.code_action_kinds.is_empty());
    let parsed: LanguageServerSettings =
        serde_json::from_value(json!({ "features": ["code-action"], "codeActionKinds": ["refactor"] })).unwrap();
    assert_eq!(parsed.code_action_kinds, Some(vec!["refactor".to_string()]));
}

#[test]
fn ruff_configuration_directory_resolves_files_and_validates_pyproject() {
    let tmp = tempfile::tempdir().unwrap();
    let root = tmp.path();
    let dir = root.join("shared ruff");
    std::fs::create_dir_all(&dir).unwrap();
    assert_eq!(ruff_configuration(root, "").unwrap(), None);
    assert!(ruff_configuration(root, &dir.to_string_lossy()).unwrap_err().message.contains("has no"));

    let ruff = dir.join("ruff.toml");
    std::fs::write(&ruff, "line-length = 100\n").unwrap();
    assert_eq!(ruff_configuration(root, &dir.to_string_lossy()).unwrap(), Some(ruff.clone()));
    assert_eq!(ruff_configuration(root, &ruff.to_string_lossy()).unwrap(), Some(ruff));

    std::fs::remove_file(dir.join("ruff.toml")).unwrap();
    let pyproject = dir.join("pyproject.toml");
    std::fs::write(&pyproject, "[project]\nname = \"x\"\n").unwrap();
    assert!(ruff_configuration(root, &dir.to_string_lossy()).unwrap_err().message.contains("has no"));
    std::fs::write(&pyproject, "[tool.ruff]\nline-length = 100\n").unwrap();
    assert_eq!(ruff_configuration(root, &dir.to_string_lossy()).unwrap(), Some(pyproject.clone()));

    let mut settings = Settings::default();
    settings.languages.ruff.configuration_directory = dir.to_string_lossy().into_owned();
    let mut cfg = server("ruff");
    configure_server(&mut cfg, root, root, &settings);
    let configured = dir.join("pyproject.toml").to_string_lossy().into_owned();
    assert_eq!(
        cfg.settings.as_ref().and_then(|s| s.get("configuration")).and_then(|v| v.as_str()),
        Some(configured.as_str())
    );
}

#[test]
fn jdtls_jdk_setting() {
    if cfg!(windows) {
        return; // Unix paths
    }
    let tmp = tempfile::tempdir().unwrap();
    fake_jdk(&tmp.path().join("jdk17"));
    let mut s = Settings::default();
    assert_eq!(jdtls_jdk(tmp.path(), &s), Ok(None));
    // Separate from the project JDK, which run configurations keep using.
    s.languages.java.jdk = "jdk17".into();
    assert_eq!(jdtls_jdk(tmp.path(), &s), Ok(None));
    s.languages.java.jdtls_jdk = "jdk17/bin".into();
    assert_eq!(jdtls_jdk(tmp.path(), &s).unwrap().map(|j| j.major), Some(17));
    std::fs::write(
        tmp.path().join("jdk17/release"),
        "JAVA_VERSION=\"25\"\nIMAGE_TYPE=\"JRE\"\nMODULES=\"java.base jdk.compiler jdk.jdi jdk.unsupported\"\n",
    )
    .unwrap();
    assert!(jdtls_jdk(tmp.path(), &s).unwrap_err().contains("full JDK"));
    // A chosen path that is not a JDK is an error, not a silent fallback.
    std::fs::create_dir(tmp.path().join("not-a-jdk")).unwrap();
    s.languages.java.jdtls_jdk = "not-a-jdk".into();
    assert!(jdtls_jdk(tmp.path(), &s).unwrap_err().contains("is not a JDK home"));
    // A JDK removed after it was chosen (a version manager upgraded it) says so.
    s.languages.java.jdtls_jdk = "jdk17.0.1".into();
    let err = jdtls_jdk(tmp.path(), &s).unwrap_err();
    assert!(err.contains("jdk17.0.1 does not exist") && err.contains("Languages & Frameworks › Java"), "{err}");

    let bundle = tmp.path().join("outside-scan/jdk25.jdk");
    let home = bundle.join("Contents/Home");
    fake_jdk(&home);
    for path in [&bundle, &home, &home.join("bin"), &home.join("bin/java")] {
        s.languages.java.jdtls_jdk = path.to_string_lossy().into_owned();
        assert_eq!(jdtls_jdk(tmp.path(), &s).unwrap().unwrap().home, dunce::canonicalize(&home).unwrap());
    }
    std::fs::write(home.join("bin/java"), "#!/bin/sh\nexit 126\n").unwrap();
    let error = jdtls_jdk(tmp.path(), &s).unwrap_err();
    assert!(error.contains(home.to_string_lossy().as_ref()) && error.contains("cannot run"), "{error}");
}

#[test]
fn terminal_activation_for_project_venv() {
    if cfg!(windows) {
        return; // Unix paths and shells
    }
    let tmp = tempfile::tempdir().unwrap();
    let mut s = Settings::default();
    assert_eq!(terminal_activation(tmp.path(), &s, "/bin/zsh"), None);
    fake_venv(tmp.path(), ".venv");
    let line = terminal_activation(tmp.path(), &s, "/bin/zsh").unwrap();
    assert!(line.starts_with("source '") && line.ends_with("/activate'"), "{line}");
    assert_eq!(terminal_activation(tmp.path(), &s, "/usr/bin/fish"), None, "no activate.fish");
    assert_eq!(terminal_activation(tmp.path(), &s, "docker"), None, "not a shell");
    s.languages.python.activate_virtualenv = false;
    assert_eq!(terminal_activation(tmp.path(), &s, "/bin/zsh"), None);
}

#[test]
fn terminal_activation_for_windows_shell_paths() {
    let tmp = tempfile::tempdir().unwrap();
    let mut s = Settings::default();
    s.languages.python.interpreter = fake_venv(tmp.path(), ".venv with spaces 'quoted'").to_string_lossy().into_owned();
    let bin = tmp.path().join(".venv with spaces 'quoted'").join(bin_dir());
    for (shell, script, powershell) in [
        (r"C:\Program Files\PowerShell\7\pwsh.exe", "Activate.ps1", true),
        (r"C:\Windows\System32\WindowsPowerShell\v1.0\powershell.exe", "Activate.ps1", true),
        (r"C:\Windows\System32\cmd.exe", "activate.bat", false),
    ] {
        assert_eq!(terminal_activation(tmp.path(), &s, shell), None, "missing {script}");
        let path = bin.join(script);
        std::fs::write(&path, "").unwrap();
        let expected = if powershell {
            format!("& '{}'", path.to_string_lossy().replace('\'', "''"))
        } else {
            format!("\"{}\"", path.display())
        };
        assert_eq!(terminal_activation(tmp.path(), &s, shell), Some(expected), "{shell}");
        std::fs::remove_file(path).unwrap();
    }
    assert_eq!(terminal_activation(tmp.path(), &s, ""), None);
    assert_eq!(terminal_activation(tmp.path(), &s, "   "), None);
}

#[test]
fn pip_list_output_is_parsed() {
    let out = "$ python -m pip list\n[{\"name\": \"requests\", \"version\": \"2.32.0\"}]\n";
    let pkgs = parse_pip_list(out).unwrap();
    assert_eq!(pkgs[0].name, "requests");
    assert_eq!(pkgs[0].version, "2.32.0");
}

/// A directory whose `typing.py` breaks any interpreter that imports it from there.
fn shadowing_dir() -> tempfile::TempDir {
    let dir = tempfile::tempdir().unwrap();
    std::fs::write(dir.path().join("typing.py"), "raise ImportError('shadowed stdlib')\n").unwrap();
    std::fs::write(dir.path().join("logging.py"), "raise ImportError('shadowed stdlib')\n").unwrap();
    dir
}

#[test]
fn venv_creation_ignores_modules_in_the_working_directory() {
    let Some(python) = crate::exec::which("python3") else { return };
    let shadow = shadowing_dir();
    // Precondition: without isolation the shadowing module is picked up.
    let plain =
        std::process::Command::new(&python).args(["-c", "import typing"]).current_dir(shadow.path()).output().unwrap();
    assert!(!plain.status.success());
    let target = tempfile::tempdir().unwrap();
    let location = target.path().join(".venv");
    // `--without-pip` keeps the test fast; the stdlib imports of `venv` still happen.
    let mut args = crate::python::venv_args(&location);
    args.push("--without-pip".into());
    crate::exec::stream(&python, &args, Some(shadow.path()), &[], &Default::default(), &|_| {}).unwrap();
    assert!(location.join("pyvenv.cfg").is_file());
}

#[test]
fn env_tools_are_reported_missing_before_they_run() {
    // Without uv / Poetry on PATH the error names the install, not a spawn failure.
    let dir = tempfile::tempdir().unwrap();
    let location = dir.path().join(".venv");
    let base = dir.path().join("python");
    fn none(_: &str) -> Option<std::path::PathBuf> {
        None
    }
    let uv = crate::python::create_venv_with(
        crate::python::VenvTool::Uv,
        &base,
        &location,
        none,
        &Default::default(),
        &|_| {},
    )
    .unwrap_err();
    assert!(uv.message.contains("uv is not installed"), "{}", uv.message);
    let poetry = crate::python::create_venv_with(
        crate::python::VenvTool::Poetry,
        &base,
        &location,
        none,
        &Default::default(),
        &|_| {},
    )
    .unwrap_err();
    assert!(poetry.message.contains("Poetry is not installed"), "{}", poetry.message);
    let conda = crate::python::create_venv_with(
        crate::python::VenvTool::Conda,
        &base,
        &location,
        none,
        &Default::default(),
        &|_| {},
    )
    .unwrap_err();
    assert!(conda.message.contains("conda is not installed"), "{}", conda.message);
    // An existing environment is refused before any tool runs.
    std::fs::create_dir_all(&location).unwrap();
    std::fs::write(location.join("pyvenv.cfg"), "home = /python").unwrap();
    let again = crate::python::create_venv_with(
        crate::python::VenvTool::Uv,
        &base,
        &location,
        none,
        &Default::default(),
        &|_| {},
    )
    .unwrap_err();
    assert!(again.message.contains("already contains a virtual environment"), "{}", again.message);
}

#[test]
fn an_existing_conda_environment_is_not_recreated() {
    // `conda-meta/` marks a conda prefix: refuse before `conda create` would fail obscurely.
    let dir = tempfile::tempdir().unwrap();
    let location = dir.path().join("envs").join("ds");
    let base = dir.path().join("python");
    std::fs::create_dir_all(location.join("conda-meta")).unwrap();
    fn none(_: &str) -> Option<std::path::PathBuf> {
        None
    }
    let err = crate::python::create_venv_with(
        crate::python::VenvTool::Conda,
        &base,
        &location,
        none,
        &Default::default(),
        &|_| {},
    )
    .unwrap_err();
    assert!(err.message.contains("already contains a conda environment"), "{}", err.message);
}

#[test]
fn neutral_dir_is_fresh_and_empty() {
    let a = crate::python::neutral_dir().unwrap();
    let b = crate::python::neutral_dir().unwrap();
    assert_ne!(a.path(), b.path());
    assert_eq!(std::fs::read_dir(a.path()).unwrap().count(), 0);
}

#[test]
fn relative_requirements_resolve_against_the_project() {
    use crate::python::resolve_requirement;
    let root = Path::new("/work/app");
    assert_eq!(resolve_requirement("requests==2.0", Some(root)).unwrap(), "requests==2.0");
    assert_eq!(resolve_requirement("./pkg", Some(root)).unwrap(), root.join("./pkg").to_string_lossy());
    assert_eq!(resolve_requirement(".[dev]", Some(root)).unwrap(), root.join(".[dev]").to_string_lossy());
    assert!(resolve_requirement("../lib", None).is_err());
}

#[test]
fn excluded_folders_become_anchored_globs() {
    let mut s = Settings::default();
    s.project_structure.excluded = vec!["build/".into(), " ".into()];
    let globs = s.exclude_globs();
    assert!(globs.contains(&"/build".to_owned()));
    assert_eq!(globs.len(), s.file_excludes().len() + 1);
}

/// Prints what this machine has installed.
#[test]
#[ignore]
fn detect_on_this_machine() {
    for kind in [
        crate::SdkKind::Python,
        crate::SdkKind::Node,
        crate::SdkKind::PackageManager,
        crate::SdkKind::Rust,
        crate::SdkKind::Go,
    ] {
        let t = std::time::Instant::now();
        let found = crate::detect(kind, Some(Path::new(env!("CARGO_MANIFEST_DIR"))));
        eprintln!("{kind:?} ({} ms)", t.elapsed().as_millis());
        for sdk in found {
            eprintln!("  {} {:?} [{}] {}", sdk.name, sdk.version, sdk.source, sdk.path.display());
        }
    }
}

#[test]
fn custom_tool_path_replaces_the_command() {
    let tmp = tempfile::tempdir().unwrap();
    let mut s = Settings::default();
    s.tools.insert("elixir-ls".into(), ide_core::settings::ToolSettings { path: "tools/ls/language_server.sh".into() });
    s.tools.insert("zls".into(), ide_core::settings::ToolSettings { path: "  ".into() });
    let mut cfg = server("elixir-ls");
    configure_server(&mut cfg, tmp.path(), tmp.path(), &s);
    assert_eq!(Path::new(&cfg.command), tmp.path().join("tools/ls/language_server.sh"));
    // A blank path keeps auto-detection.
    let mut cfg = server("zls");
    configure_server(&mut cfg, tmp.path(), tmp.path(), &s);
    assert_eq!(cfg.command, "zls");
}

#[test]
fn the_godot_setting_applies_to_server_debugger_and_run_configurations() {
    let tmp = tempfile::tempdir().unwrap();
    let mut s = Settings::default();
    s.tools.insert("godot".into(), ide_core::settings::ToolSettings { path: "~/Godot/godot".into() });
    let expected = crate::home_dir().unwrap().join("Godot/godot");
    assert_eq!(crate::apply::tool_command(tmp.path(), &s, "godot"), Some(expected.clone()));
    let mut cfg = LanguageServerConfig { command: "godot".into(), ..server("godot") };
    configure_server(&mut cfg, tmp.path(), tmp.path(), &s);
    assert_eq!(Path::new(&cfg.command), expected);
    let mut run = RunConfig {
        id: "godot:project".into(),
        name: "Godot Project".into(),
        kind: "godot".into(),
        command: "godot".into(),
        args: vec!["--path".into(), ".".into()],
        cwd: None,
        env: BTreeMap::new(),
        detected: true,
        is_test: false,
        debug_adapter: Some("godot".into()),
        allow_parallel: false,
        extras: Default::default(),
    };
    apply_to_run_configs(std::slice::from_mut(&mut run), tmp.path(), &s);
    assert_eq!(Path::new(&run.command), expected);
    // Other commands keep their name without a setting.
    assert_eq!(crate::apply::tool_command(tmp.path(), &s, "zls"), None);
}

#[test]
fn python_library_paths_are_parsed_and_deduplicated() {
    let tmp = tempfile::tempdir().unwrap();
    let stdlib = tmp.path().join("lib/python3.12");
    let site = stdlib.join("site-packages");
    std::fs::create_dir_all(&site).unwrap();
    let json = serde_json::to_string(&[Some(&stdlib), Some(&stdlib), Some(&site), None]).unwrap();
    let paths = crate::libraries::parse_python_paths(&format!("warning: something\n{json}"));
    assert_eq!(paths.len(), 3);
    let roots = crate::libraries::library_roots([paths, vec![tmp.path().join("gone")]].concat());
    assert_eq!(roots.iter().map(|r| r.name.as_str()).collect::<Vec<_>>(), ["python3.12", "site-packages"]);
    assert!(crate::libraries::parse_python_paths("not json").is_empty());
}

#[test]
fn no_libraries_without_an_interpreter() {
    let tmp = tempfile::tempdir().unwrap();
    assert!(crate::libraries::project_libraries(tmp.path(), &Settings::default(), &[]).is_empty());
}

#[test]
fn node_libraries_list_direct_dependencies_and_core_typings() {
    let tmp = tempfile::tempdir().unwrap();
    let root = tmp.path();
    std::fs::write(
        root.join("package.json"),
        r#"{"dependencies":{"react":"^18","@scope/ui":"1"},"devDependencies":{"vitest":"2","react":"^18"}}"#,
    )
    .unwrap();
    for dir in ["react", "@scope/ui", "@types/node", "transitive"] {
        std::fs::create_dir_all(root.join("node_modules").join(dir)).unwrap();
    }
    #[cfg(unix)]
    {
        let package = root.join("node_modules/.pnpm/@scope+ui@1/node_modules/@scope/ui");
        std::fs::create_dir_all(&package).unwrap();
        std::fs::remove_dir(root.join("node_modules/@scope/ui")).unwrap();
        std::os::unix::fs::symlink(package, root.join("node_modules/@scope/ui")).unwrap();
    }
    let groups = crate::libraries::node_libraries(root, None);
    let summary: Vec<(&str, &str, Vec<&str>)> = groups
        .iter()
        .map(|g| (g.name.as_str(), g.kind.as_str(), g.roots.iter().map(|r| r.name.as_str()).collect()))
        .collect();
    assert_eq!(
        summary,
        [
            ("Node.js Core", "nodeCore", vec!["@types/node"]),
            ("node_modules", "nodeModules", vec!["@scope/ui", "react"])
        ]
    );
    assert_eq!(crate::libraries::package_dependencies("{"), Vec::<String>::new());
}

#[test]
fn libraries_include_nested_packages_and_refresh_after_install() {
    let tmp = tempfile::tempdir().unwrap();
    let root = tmp.path();
    for dir in ["", "packages/web", "packages/api", "node_modules/ignored", "target/ignored"] {
        let package = root.join(dir);
        std::fs::create_dir_all(&package).unwrap();
        std::fs::write(package.join("package.json"), r#"{"dependencies":{"dep":"1"}}"#).unwrap();
    }
    let settings = Settings::default();
    assert!(crate::libraries::project_libraries(root, &settings, &[]).is_empty());
    for dir in ["packages/web", "packages/api", "node_modules/ignored", "target/ignored"] {
        std::fs::create_dir_all(root.join(dir).join("node_modules/dep")).unwrap();
    }
    let groups = crate::libraries::project_libraries(root, &settings, &[]);
    let node = groups.iter().find(|g| g.kind == "nodeModules").expect("nested packages after install");
    assert_eq!(node.roots.len(), 2);
    assert!(node.roots.iter().all(|r| r.path.starts_with(root.join("packages"))));
    std::fs::remove_dir(root.join("packages/web/node_modules/dep")).unwrap();
    std::fs::create_dir_all(root.join("node_modules/dep")).unwrap();
    let groups = crate::libraries::project_libraries(root, &settings, &[]);
    let node = groups.iter().find(|g| g.kind == "nodeModules").unwrap();
    assert_eq!(node.roots.len(), 2, "hoisted dependencies are shared across members");
}

#[test]
fn cargo_metadata_lists_registry_and_non_workspace_path_dependencies() {
    let tmp = tempfile::tempdir().unwrap();
    let serde = tmp.path().join("registry/src/index/serde-1.0.200");
    let json = serde_json::json!({ "packages": [
        { "name": "app", "id": "app", "version": "0.1.0", "source": null, "manifest_path": tmp.path().join("Cargo.toml") },
        { "name": "serde", "version": "1.0.200", "source": "registry+https://github.com/rust-lang/crates.io-index",
          "manifest_path": serde.join("Cargo.toml") },
        { "name": "local", "id": "local", "version": "0.2.0", "source": null,
          "manifest_path": tmp.path().join("local/Cargo.toml") },
    ], "workspace_members": ["app"]});
    assert_eq!(
        crate::libraries::parse_cargo_metadata(&json.to_string()).unwrap(),
        [("local 0.2.0".to_owned(), tmp.path().join("local")), ("serde 1.0.200".to_owned(), serde),]
    );
    assert!(crate::libraries::parse_cargo_metadata("error: no Cargo.toml").is_none());
}

#[test]
fn go_modules_skip_the_main_module_and_missing_downloads() {
    let out = r#"{"Path":"example.com/app","Main":true,"Dir":"/p"}
{"Path":"golang.org/x/text","Version":"v0.14.0","Dir":"/gopath/pkg/mod/golang.org/x/[email protected]"}
{"Path":"example.com/missing","Version":"v1.0.0","Error":{"Err":"module lookup disabled"}}"#;
    assert_eq!(
        crate::libraries::parse_go_modules(out),
        [(
            "golang.org/x/[email protected]".to_owned(),
            std::path::PathBuf::from("/gopath/pkg/mod/golang.org/x/[email protected]")
        )]
    );
}

#[test]
fn jdk_library_is_the_jdk_home() {
    let tmp = tempfile::tempdir().unwrap();
    let home = tmp.path().join("temurin-21.jdk/Contents/Home");
    std::fs::create_dir_all(&home).unwrap();
    assert_eq!(crate::libraries::jdk_name(&home).as_deref(), Some("temurin-21"));
    assert_eq!(crate::libraries::jdk_name(&tmp.path().join("jdk-17")).as_deref(), Some("jdk-17"));
    let group = crate::libraries::jdk_library(&crate::java::Jdk { major: 21, home: home.clone() }).unwrap();
    assert_eq!((group.name.as_str(), group.kind.as_str()), ("temurin-21", "jdk"));
    assert_eq!(group.roots[0].path, ide_core::IpcPath::from(home.clone()));
    assert_eq!(group.roots.len(), 1, "no sources archive");

    std::fs::create_dir_all(home.join("lib")).unwrap();
    std::fs::write(home.join("lib/src.zip"), "").unwrap();
    let group = crate::libraries::jdk_library(&crate::java::Jdk { major: 21, home: home.clone() }).unwrap();
    assert_eq!(group.roots[1].name, "src.zip");
    assert_eq!(group.roots[1].path, ide_core::IpcPath::from(ide_vfs::archive_root(&home.join("lib/src.zip"))));
}

#[test]
fn build_dependencies_resolve_to_local_jars() {
    use crate::libraries::{BuildDependency, dependency_libraries};
    let tmp = tempfile::tempdir().unwrap();
    let (m2, gradle) = (tmp.path().join("m2"), tmp.path().join("gradle"));
    let touch = |p: std::path::PathBuf| {
        std::fs::create_dir_all(p.parent().unwrap()).unwrap();
        std::fs::write(&p, "").unwrap();
        p
    };
    let guava = touch(m2.join("com/google/guava/guava/33.0/guava-33.0.jar"));
    touch(m2.join("com/google/guava/guava/33.0/guava-33.0-sources.jar"));
    let junit = touch(m2.join("junit/junit/4.13/junit-4.13.jar"));
    let files = gradle.join("caches/modules-2/files-2.1/org.slf4j/slf4j-api/2.0.9");
    let slf4j = touch(files.join("a1b2/slf4j-api-2.0.9.jar"));
    touch(files.join("c3d4/slf4j-api-2.0.9-sources.jar"));
    let dep = |gradle: bool, g: &str, a: &str, v: &str| BuildDependency {
        gradle,
        group: g.into(),
        artifact: a.into(),
        version: v.into(),
    };
    let deps = [
        dep(false, "junit", "junit", "4.13"),
        dep(false, "com.google.guava", "guava", "33.0"),
        dep(false, "com.google.guava", "guava", "33.0"),
        dep(true, "org.slf4j", "slf4j-api", "2.0.9"),
        dep(false, "missing", "nope", "1.0"),
        dep(false, "..", "evil", "1"),
    ];
    let groups = dependency_libraries(&deps, Some(&m2), Some(&gradle));
    let shown: Vec<(&str, &str, &str)> =
        groups.iter().map(|g| (g.name.as_str(), g.kind.as_str(), g.roots[0].name.as_str())).collect();
    assert_eq!(
        shown,
        [
            ("Maven: com.google.guava:guava:33.0", "maven", "guava-33.0.jar"),
            ("Maven: junit:junit:4.13", "maven", "junit-4.13.jar"),
            ("Gradle: org.slf4j:slf4j-api:2.0.9", "gradle", "slf4j-api-2.0.9.jar"),
        ]
    );
    assert_eq!(groups[0].roots[0].path, ide_core::IpcPath::from(ide_vfs::archive_root(&guava)));
    assert_eq!(groups[1].roots[0].path, ide_core::IpcPath::from(ide_vfs::archive_root(&junit)));
    assert_eq!(groups[2].roots[0].path, ide_core::IpcPath::from(ide_vfs::archive_root(&slf4j)));
    // A Gradle build also finds jars installed in the Maven local repository (`mavenLocal()`).
    let groups = dependency_libraries(&[dep(true, "junit", "junit", "4.13")], Some(&m2), Some(&gradle));
    assert_eq!(groups[0].name, "Gradle: junit:junit:4.13");
}

#[test]
fn library_detection_is_cached_until_a_manifest_changes() {
    let tmp = tempfile::tempdir().unwrap();
    let manifest = tmp.path().join("package.json");
    std::fs::write(&manifest, "{}").unwrap();
    let runs = std::cell::Cell::new(0);
    let detect = || {
        runs.set(runs.get() + 1);
        Vec::new()
    };
    let files = [manifest.clone()];
    crate::libraries::cached(tmp.path(), "test", "a".into(), &files, detect);
    crate::libraries::cached(tmp.path(), "test", "a".into(), &files, detect);
    assert_eq!(runs.get(), 1);
    std::fs::write(&manifest, r#"{"dependencies":{}}"#).unwrap();
    crate::libraries::cached(tmp.path(), "test", "a".into(), &files, detect);
    assert_eq!(runs.get(), 2);
    crate::libraries::cached(tmp.path(), "test", "b".into(), &files, detect);
    assert_eq!(runs.get(), 3);
}

#[test]
fn no_ecosystem_libraries_without_manifests() {
    let tmp = tempfile::tempdir().unwrap();
    std::fs::create_dir_all(tmp.path().join("node_modules/react")).unwrap();
    assert!(crate::libraries::project_libraries(tmp.path(), &Settings::default(), &[]).is_empty());
}

/// Tools dir with vue-language-server and the given TypeScript files, plus a
/// project; returns (tools, project).
fn vue_setup(tmp: &Path, tools_ts: &str, project_ts: &str) -> (std::path::PathBuf, std::path::PathBuf) {
    let tools = tmp.join("tools/node_modules");
    let project = tmp.join("app");
    for (p, content) in [
        (tools.join(".bin/vue-language-server"), ""),
        (tools.join("@vue/language-server/package.json"), "{}"),
        (tools.join("typescript/lib").join(tools_ts), ""),
        (project.join("node_modules/typescript/lib").join(project_ts), ""),
        (project.join("node_modules/typescript/lib/tsserver.js"), ""),
    ] {
        std::fs::create_dir_all(p.parent().unwrap()).unwrap();
        std::fs::write(p, content).unwrap();
    }
    (tools, project)
}

#[test]
fn vue_language_server_gets_a_typescript_with_the_language_service_api() {
    // Issue #25: `typescript@latest` (7.x) in the tools dir has no `ts.server`.
    let s = Settings::default();
    let cases = [
        // (tools TypeScript, project TypeScript, expected --tsdk = project lib, launch error)
        ("typescript.js", "typescript.js", false, false), // own TypeScript 5/6 works
        ("tsc.js", "typescript.js", true, false),         // own TS 7: the project's
        ("tsc.js", "tsc.js", false, true),                // nothing usable: clear error
    ];
    for (tools_ts, project_ts, uses_project, error) in cases {
        let tmp = tempfile::tempdir().unwrap();
        let (tools, project) = vue_setup(tmp.path(), tools_ts, project_ts);
        let mut cfg = server("vue-language-server");
        cfg.command = tools.join(".bin/vue-language-server").to_string_lossy().into_owned();
        configure_server(&mut cfg, &project, &project, &s);
        let tsdk = cfg.args.iter().find_map(|a| a.strip_prefix("--tsdk=")).map(std::path::PathBuf::from);
        let project_lib = project.join("node_modules/typescript/lib");
        assert_eq!(tsdk, uses_project.then_some(project_lib), "{tools_ts} / {project_ts}");
        assert_eq!(cfg.launch_error.is_some(), error, "{tools_ts} / {project_ts}");
    }

    // A selected version wins over the server's own.
    let tmp = tempfile::tempdir().unwrap();
    let (tools, project) = vue_setup(tmp.path(), "typescript.js", "typescript.js");
    let mut s = Settings::default();
    s.languages.typescript.version = "workspace".into();
    let mut cfg = server("vue-language-server");
    cfg.command = tools.join(".bin/vue-language-server").to_string_lossy().into_owned();
    configure_server(&mut cfg, &project, &project, &s);
    let lib = project.join("node_modules/typescript/lib");
    assert_eq!(cfg.args, [format!("--tsdk={}", lib.to_string_lossy())]);
}

/// An npm shim for `name` in `dir`: `name.cmd` on Windows, an executable elsewhere.
fn npm_shim(dir: &Path, name: &str) -> std::path::PathBuf {
    std::fs::create_dir_all(dir).unwrap();
    let shim = dir.join(if cfg!(windows) { format!("{name}.cmd") } else { name.to_owned() });
    std::fs::write(&shim, "").unwrap();
    #[cfg(unix)]
    std::fs::set_permissions(&shim, std::os::unix::fs::PermissionsExt::from_mode(0o755)).unwrap();
    shim
}

#[test]
fn angular_language_server_probes_its_own_package_then_the_project() {
    let tmp = tempfile::tempdir().unwrap();
    let tools = tmp.path().join("tools/node_modules");
    let project = tmp.path().join("app");
    let ngserver = npm_shim(&tools.join(".bin"), "ngserver");
    for (p, content) in [
        (tools.join("@angular/language-server/package.json"), "{}"),
        (project.join("node_modules/@angular/core/package.json"), r#"{"version":"17.3.0"}"#),
        (project.join("node_modules/typescript/lib/tsserver.js"), ""),
    ] {
        std::fs::create_dir_all(p.parent().unwrap()).unwrap();
        std::fs::write(p, content).unwrap();
    }
    let configured = |command: &str, s: &Settings| {
        let mut cfg = server("angular-language-server");
        cfg.command = command.into();
        cfg.args = vec!["--stdio".into()];
        configure_server(&mut cfg, &project, &project, s);
        cfg
    };
    let probes = format!("{},{}", tools.join("@angular/language-server").to_string_lossy(), project.to_string_lossy());
    let cfg = configured(&ngserver.to_string_lossy(), &Settings::default());
    assert_eq!(
        cfg.args,
        [
            "--stdio",
            "--ngProbeLocations",
            &probes,
            "--tsProbeLocations",
            &probes,
            "--angularCoreVersion",
            "17.3.0",
            "--disableLetSyntax"
        ]
    );
    assert_eq!(cfg.launch_error, None);

    // The project's TypeScript when selected.
    let mut s = Settings::default();
    s.languages.typescript.version = "workspace".into();
    let args = configured(&ngserver.to_string_lossy(), &s).args;
    let tsdk = args.iter().position(|a| a == "--tsdk").map(|i| args[i + 1].clone());
    assert_eq!(tsdk, Some(project.join("node_modules/typescript/lib").to_string_lossy().into_owned()));

    // Found on the selected Node.js's PATH like the launcher finds it, and
    // launched from there.
    let mut s = Settings::default();
    s.languages.node.interpreter = tools.join(".bin/node").to_string_lossy().into_owned();
    let cfg = configured("ngserver", &s);
    assert_eq!(dunce::canonicalize(&cfg.command).unwrap(), dunce::canonicalize(&ngserver).unwrap());
    assert!(cfg.args.contains(&probes));

    // Without its package the server can't start; not installed, it asks to be.
    let lone = npm_shim(&tmp.path().join("bin"), "ngserver");
    let cfg = configured(&lone.to_string_lossy(), &Settings::default());
    assert!(cfg.launch_error.is_some_and(|m| m.contains("@angular/language-server")));
    assert_eq!(cfg.args, ["--stdio"]);
    let cfg = configured(&tmp.path().join("nowhere/ngserver").to_string_lossy(), &Settings::default());
    assert_eq!((cfg.launch_error, cfg.args), (None, vec!["--stdio".to_owned()]));
}

#[test]
fn angular_language_server_is_found_behind_version_manager_shims() {
    let tmp = tempfile::tempdir().unwrap();
    let project = tmp.path().join("app");
    std::fs::create_dir_all(&project).unwrap();
    let install = |node_modules: &Path| {
        let package = node_modules.join("@angular/language-server");
        std::fs::create_dir_all(&package).unwrap();
        std::fs::write(package.join("package.json"), "{}").unwrap();
        package
    };
    let probes = |command: &Path, s: &Settings, env: &[(&str, &str)]| {
        let mut cfg = server("angular-language-server");
        cfg.command = command.to_string_lossy().into_owned();
        cfg.env.extend(env.iter().map(|(k, v)| (k.to_string(), v.to_string())));
        configure_server(&mut cfg, &project, &project, s);
        cfg.args.iter().position(|a| a == "--ngProbeLocations").map(|i| cfg.args[i + 1].clone())
    };
    let with_project = |package: &Path| Some(format!("{},{}", package.to_string_lossy(), project.to_string_lossy()));

    // pnpm: the shim script runs the package from pnpm's global directory.
    let pnpm = tmp.path().join("pnpm");
    let package = install(&pnpm.join("global/v11/abc/node_modules"));
    let shim = npm_shim(&pnpm.join("bin"), "ngserver");
    let script = "exec node \"$basedir/../global/v11/abc/node_modules/@angular/language-server/bin/ngserver\" \"$@\"\n";
    std::fs::write(&shim, format!("#!/bin/sh\n{script}")).unwrap();
    assert_eq!(probes(&shim, &Settings::default(), &[]), with_project(&dunce::canonicalize(&package).unwrap()));

    // Volta: the package's image, next to the shim's directory. Joined as the lookup
    // joins it: the probe locations compare as text, and Windows keeps a `/` as given.
    let volta = tmp.path().join("volta");
    let image = volta.join("tools").join("image").join("packages").join("@angular/language-server");
    let package = install(&image.join("lib").join("node_modules"));
    let shim = npm_shim(&volta.join("bin"), "ngserver");
    assert_eq!(probes(&shim, &Settings::default(), &[]), with_project(&package));

    // asdf, mise: the shim names only the command; the manager's npm shim knows
    // where global packages are, run as the server is: in the project (whose
    // `.tool-versions` picks the Node), with the login shell's and its own variables.
    let root_of = |package: &Path| package.parent().unwrap().parent().unwrap().display().to_string();
    let package = install(&tmp.path().join("asdf/installs/nodejs/24/lib/node_modules"));
    std::fs::write(project.join(".tool-versions"), "nodejs 24\n").unwrap();
    // The only writer in this test binary.
    ide_core::process::set_shell_env(vec![("OPENIDEA_TEST_SHELL".into(), "1".into())]);
    let shims = tmp.path().join(".asdf/shims");
    // The manager's npm runs on the first Node on PATH (`#!/usr/bin/env node`).
    std::fs::write(
        npm_shim(&shims, "npm"),
        if cfg!(windows) {
            "@if exist .tool-versions if \"%OPENIDEA_TEST_SHELL%\"==\"1\" call node\r\n"
        } else {
            "#!/bin/sh\n[ -f .tool-versions ] && [ \"$OPENIDEA_TEST_SHELL\" = 1 ] && exec node\n"
        },
    )
    .unwrap();
    std::fs::write(
        npm_shim(&shims, "node"),
        if cfg!(windows) {
            "@echo %OPENIDEA_TEST_NPM_ROOT%\r\n"
        } else {
            "#!/bin/sh\necho \"$OPENIDEA_TEST_NPM_ROOT\"\n"
        },
    )
    .unwrap();
    // Another installation's npm and Node, first on PATH.
    let node = tmp.path().join("node/bin");
    let other = root_of(&install(&tmp.path().join("node/lib/node_modules")));
    for name in ["npm", "node"] {
        std::fs::write(
            npm_shim(&node, name),
            if cfg!(windows) { format!("@echo {other}\r\n") } else { format!("#!/bin/sh\necho '{other}'\n") },
        )
        .unwrap();
    }
    let mut s = Settings::default();
    s.languages.node.interpreter = node.join("node").to_string_lossy().into_owned();
    let root = root_of(&package);
    let env = [("OPENIDEA_TEST_NPM_ROOT", root.as_str())];
    assert_eq!(probes(&npm_shim(&shims, "ngserver"), &s, &env), with_project(&package));
    // Not without the manager's own npm, nor for an executable elsewhere: the npm
    // on PATH may be another installation's.
    assert_eq!(probes(&npm_shim(&tmp.path().join("mise/shims"), "ngserver"), &s, &env), None);
    assert_eq!(probes(&npm_shim(&tmp.path().join("bin"), "ngserver"), &s, &env), None);
}

#[cfg(unix)]
#[test]
fn query_output_is_read_within_the_deadline() {
    // Keep process startup outside a tight timing budget even under workspace load.
    let timeout = std::time::Duration::from_secs(60);
    let env = [("PATH", "/usr/bin:/bin")];
    let started = std::time::Instant::now();
    let out = crate::exec::query_in(Path::new("/bin/sh"), &["-c", "printf /global/root"], None, &env, timeout);
    assert_eq!(out.as_deref(), Some("/global/root"));
    // EOF must return promptly, without waiting for the generous deadline.
    assert!(started.elapsed() < std::time::Duration::from_secs(30));
}

#[cfg(unix)]
#[test]
fn query_drains_both_pipes_before_the_child_exits() {
    let out = crate::exec::query_in(
        Path::new("/bin/sh"),
        &["-c", "head -c 262144 /dev/zero; head -c 262144 /dev/zero >&2"],
        None,
        &[("PATH", "/usr/bin:/bin")],
        std::time::Duration::from_secs(60),
    )
    .unwrap();
    assert_eq!(out.len(), 262144);
}

#[cfg(unix)]
#[test]
fn query_is_bounded_when_descendants_keep_pipes_open() {
    let tmp = tempfile::tempdir().unwrap();
    let pid = tmp.path().join("pid");
    // The descendant outlives the query; clean it up even if an assertion fails.
    struct Descendant(std::path::PathBuf);
    impl Drop for Descendant {
        fn drop(&mut self) {
            if let Ok(pid) = std::fs::read_to_string(&self.0) {
                let _ = std::process::Command::new("/bin/kill").arg(pid.trim()).status();
            }
        }
    }
    let _descendant = Descendant(pid.clone());
    let started = std::time::Instant::now();
    let out = crate::exec::query_in(
        Path::new("/bin/sh"),
        &["-c", "sleep 120 & echo $! > \"$1\"; printf /global/root", "wrapper", pid.to_str().unwrap()],
        None,
        &[("PATH", "/usr/bin:/bin")],
        std::time::Duration::from_secs(30),
    );
    assert_eq!(out.as_deref(), Some("/global/root"));
    // The descendant keeps both pipes open for longer than the query deadline.
    assert!(started.elapsed() < std::time::Duration::from_secs(90));
}

#[cfg(unix)]
#[test]
fn query_times_out_when_the_child_does_not_exit() {
    // exec avoids leaving a descendant behind when the timed-out child is killed.
    let out = crate::exec::query_in(
        Path::new("/bin/sh"),
        &["-c", "printf /global/root; exec sleep 120"],
        None,
        &[("PATH", "/usr/bin:/bin")],
        std::time::Duration::from_millis(100),
    );
    assert_eq!(out, None);
}

#[test]
fn max_java_picks_an_older_jdk() {
    let dir = tempfile::tempdir().unwrap();
    let jdk = |major: u32| {
        let home = dir.path().join(format!("jdk-{major}"));
        std::fs::create_dir_all(home.join("bin")).unwrap();
        std::fs::write(home.join("release"), format!("JAVA_VERSION=\"{major}.0.1\"\n")).unwrap();
        std::fs::write(home.join("bin").join(exe("java")), "").unwrap();
        crate::java::jdk_at(&home).unwrap()
    };
    let (j17, j21, j25) = (jdk(17), jdk(21), jdk(25));
    let jdks = [j25.clone(), j21.clone(), j17];
    let mut cfg = LanguageServerConfig { max_java: Some(21), ..server("kotlin-language-server") };
    cfg.env.insert("JAVA_HOME".into(), j25.home.to_string_lossy().into_owned());
    crate::java::cap_java_home(&mut cfg, &jdks);
    assert_eq!(cfg.env["JAVA_HOME"], j21.home.to_string_lossy());

    // A JAVA_HOME that fits, or no limit: left alone.
    crate::java::cap_java_home(&mut cfg, &[]);
    assert_eq!(cfg.env["JAVA_HOME"], j21.home.to_string_lossy());
    let mut free = server("other");
    free.env.insert("JAVA_HOME".into(), j25.home.to_string_lossy().into_owned());
    crate::java::cap_java_home(&mut free, &jdks);
    assert_eq!(free.env["JAVA_HOME"], j25.home.to_string_lossy());
}

#[test]
fn gradle_settings_precedence() {
    use crate::apply::{gradle_command, gradle_env};
    use ide_core::settings::GradleDistribution;
    let tmp = tempfile::tempdir().unwrap();
    let root = tmp.path();
    let plain = if cfg!(windows) { "gradle.bat" } else { "gradle" };
    let wrapper = root.join(if cfg!(windows) { "gradlew.bat" } else { "gradlew" });
    let mut settings = Settings::default();
    assert_eq!(gradle_command(root, root, &settings), std::path::PathBuf::from(plain));
    std::fs::write(&wrapper, "").unwrap();
    assert_eq!(gradle_command(root, root, &settings), wrapper);
    let fallback = std::collections::BTreeMap::from([("JAVA_HOME".into(), "project-jdk".into())]);
    assert_eq!(gradle_env(root, &settings, fallback.clone()), fallback);
    settings.languages.java.gradle.jvm = "gradle-jdk".into();
    settings.languages.java.gradle.user_home = "gradle-cache".into();
    settings.languages.java.gradle.home = "local-gradle".into();
    let env = gradle_env(root, &settings, fallback);
    assert_eq!(env["JAVA_HOME"], root.join("gradle-jdk").to_string_lossy());
    assert_eq!(env["GRADLE_USER_HOME"], root.join("gradle-cache").to_string_lossy());
    // A stored local home is inactive in wrapper mode.
    assert_eq!(gradle_command(root, root, &settings), wrapper);
    for local in [false, true] {
        settings.languages.java.gradle.distribution =
            if local { GradleDistribution::Local } else { GradleDistribution::Wrapper };
        let expected = if local { root.join("local-gradle").join("bin").join(plain) } else { plain.into() };
        for explicit_java in [false, true] {
            for is_test in [false, true] {
                let mut configs =
                    [run("gradle", wrapper.to_str().unwrap(), &["test"]), run("gradle", plain, &["test"])];
                for c in &mut configs {
                    c.is_test = is_test;
                    if explicit_java {
                        c.env.insert("JAVA_HOME".into(), "explicit-jdk".into());
                    }
                }
                apply_to_run_configs(&mut configs, root, &settings);
                assert_eq!(configs[0].command, wrapper.to_string_lossy());
                assert_eq!(configs[1].command, expected.to_string_lossy());
                for c in &configs {
                    assert_eq!(
                        c.env["JAVA_HOME"],
                        if explicit_java {
                            "explicit-jdk".into()
                        } else {
                            root.join("gradle-jdk").to_string_lossy().into_owned()
                        }
                    );
                }
            }
        }
        assert_eq!(gradle_command(root, root, &settings), if local { expected } else { wrapper.clone() });
    }
}

/// The reporter of #440 has Node 26 in `~/.local/bin` and an 18 in `/usr/bin`; an SSH
/// exec channel's PATH puts `/usr/bin` first, so only the system's Node was listed.
#[test]
fn node_lists_every_install_on_the_search_path_not_only_the_first() {
    let tmp = tempfile::tempdir().unwrap();
    let (system, user) = (tmp.path().join("usr-bin"), tmp.path().join("local-bin"));
    for dir in [&system, &user] {
        std::fs::create_dir(dir).unwrap();
        std::fs::write(dir.join(exe("node")), "").unwrap();
    }
    let found = crate::exec::executables_in("node", [system.clone(), user.clone()].into_iter());
    assert_eq!(found, [system.join(exe("node")), user.join(exe("node"))]);
    // A directory without the executable contributes nothing.
    let found = crate::exec::executables_in("node", [tmp.path().join("empty"), user.clone()].into_iter());
    assert_eq!(found, [user.join(exe("node"))]);
}

#[test]
fn node_on_the_search_path_keeps_its_version_manager_as_source() {
    let home = Path::new("/home/me");
    let source = |p: &str| crate::discover::node_source(Path::new(p), Some(home));
    assert_eq!(source("/home/me/.nvm/versions/node/v24.0.0/bin/node"), "nvm");
    assert_eq!(source("/home/me/.volta/tools/image/node/24.0.0/bin/node"), "volta");
    assert_eq!(source("/home/me/.local/share/fnm/node-versions/v24/installation/bin/node"), "fnm");
    assert_eq!(source("/home/me/.local/bin/node"), "path");
    assert_eq!(source("/usr/bin/node"), "system");
}

#[test]
fn php_sources_and_selected_interpreter() {
    let home = Path::new("/home/me");
    let source = |p: &str| crate::discover::php_source(Path::new(p), Some(home));
    assert_eq!(source("/home/me/.phpbrew/php/php-8.3.1/bin/php"), "phpbrew");
    assert_eq!(source("/home/me/.config/herd-lite/bin/php"), "herd");
    assert_eq!(source("/opt/homebrew/opt/[email protected]/bin/php"), "homebrew");
    assert_eq!(source("/home/me/bin/php"), "path");

    use crate::discover::{is_versioned_php_name, newest_first, versioned_php_in};
    let sdk = |path: &str, version: &str| crate::Sdk {
        path: std::path::PathBuf::from(path).into(),
        name: format!("PHP {version}"),
        version: Some(version.into()),
        source: "path".into(),
        home: None,
        extra: None,
    };
    let mut sdks = vec![
        sdk("/opt/homebrew/bin/php", "8.4.1"),
        sdk("/opt/homebrew/opt/[email protected]/bin/php", "8.1.31"),
        sdk("/opt/homebrew/opt/[email protected]/bin/php", "8.2.20"),
        sdk("/home/me/.phpbrew/php/php-8.3.9/bin/php", "8.3.9"),
        sdk("/home/me/.phpbrew/php/php-8.3.12/bin/php", "8.3.12"),
        sdk("/home/me/.phpbrew/php/php-7.4.33/bin/php", "7.4.33"),
        sdk("/usr/bin/php", "8.4.1"),
    ];
    newest_first(&mut sdks);
    let order: Vec<_> = sdks.iter().map(|s| s.version.clone().unwrap()).collect();
    assert_eq!(order, ["8.4.1", "8.4.1", "8.3.12", "8.3.9", "8.2.20", "8.1.31", "7.4.33"]);
    // Stable: on equal versions the PATH install stays first.
    assert_eq!(sdks[0].path.0, std::path::PathBuf::from("/opt/homebrew/bin/php"));
    for name in ["php8.1", "php81", "php8", "php8.3.exe"] {
        assert!(is_versioned_php_name(name), "{name}");
    }
    for name in ["php", "php-cgi8.1", "phpize8.1", "phpdbg8.1", "php-fpm8.1", "php8.", "php.8", "php8.1.2x", "phpunit"]
    {
        assert!(!is_versioned_php_name(name), "{name}");
    }

    if cfg!(windows) {
        return; // Unix paths
    }
    let bins = tempfile::tempdir().unwrap();
    for name in ["php", "php8.3", "php8.1", "php-cgi8.1", "phpize8.1", "phpdbg8.1"] {
        std::fs::write(bins.path().join(name), "").unwrap();
    }
    std::fs::create_dir(bins.path().join("php9.0")).unwrap();
    assert_eq!(
        versioned_php_in([bins.path().to_path_buf()]),
        vec![bins.path().join("php8.1"), bins.path().join("php8.3")]
    );

    let tmp = tempfile::tempdir().unwrap();
    let mut s = Settings::default();
    assert_eq!(crate::apply::php_dir(tmp.path(), &s), None);
    s.languages.php.interpreter = "/opt/php82/bin/php".into();
    assert_eq!(crate::apply::php_dir(tmp.path(), &s), Some("/opt/php82/bin".into()));
    let mut configs = vec![
        run("php", "php", &["artisan", "serve"]),
        run("phpunit", "vendor/bin/phpunit", &[]),
        run("composer", "composer", &["run-script", "test"]),
        run("npm", "npm", &["run", "dev"]),
    ];
    apply_to_run_configs(&mut configs, tmp.path(), &s);
    assert_eq!(configs[0].command, "/opt/php82/bin/php");
    // Scripts with a `#!/usr/bin/env php` shebang find the selected PHP first on `PATH`.
    for c in &configs[..3] {
        assert!(c.env["PATH"].starts_with("/opt/php82/bin"), "{}: {:?}", c.kind, c.env.get("PATH"));
    }
    assert_eq!(configs[1].command, "vendor/bin/phpunit");
    assert!(configs[3].env.get("PATH").is_none_or(|p| !p.contains("php82")));
}

#[test]
fn intelephense_gets_the_php_language_level() {
    use serde_json::json;
    let tmp = tempfile::tempdir().unwrap();
    let configured = |name: &str, s: &Settings| {
        let mut cfg = server(name);
        configure_server(&mut cfg, tmp.path(), tmp.path(), s);
        cfg
    };
    let options = |cfg: LanguageServerConfig| serde_json::to_value(cfg.initialization_options).unwrap();

    // Nothing to resolve: the options stay as they were (the rest depends on the machine's tools).
    assert_eq!(configured("intelephense", &Settings::default()).initialization_options, None);

    std::fs::write(tmp.path().join("composer.json"), r#"{"require": {"php": "^7.4 || ^8.0"}}"#).unwrap();
    assert_eq!(
        options(configured("intelephense", &Settings::default())),
        json!({"environment": {"phpVersion": "7.4.0"}})
    );
    for other in ["phpactor", "basedpyright", "vtsls"] {
        assert_eq!(options(configured(other, &Settings::default())).get("environment"), None, "{other}");
    }

    let mut s = Settings::default();
    s.languages.php.language_level = "8.1".into();
    let mut cfg = server("intelephense");
    cfg.initialization_options = Some(toml::Value::try_from(json!({"clearCache": true})).unwrap());
    configure_server(&mut cfg, tmp.path(), tmp.path(), &s);
    assert_eq!(options(cfg), json!({"clearCache": true, "environment": {"phpVersion": "8.1.0"}}));
}

#[test]
fn intelephense_gets_the_required_stubs_and_include_paths() {
    use serde_json::json;
    let tmp = tempfile::tempdir().unwrap();
    std::fs::write(tmp.path().join("composer.json"), r#"{"require": {"php": "^8.1", "ext-redis": "*"}}"#).unwrap();
    let mut s = Settings::default();
    s.languages.php.stubs = vec!["wordpress".into()];
    s.languages.php.include_paths = vec!["../platform".into()];
    let mut cfg = server("intelephense");
    configure_server(&mut cfg, tmp.path(), tmp.path(), &s);
    let options = serde_json::to_value(cfg.initialization_options).unwrap();
    let stubs: Vec<&str> = options["stubs"].as_array().unwrap().iter().filter_map(|v| v.as_str()).collect();
    assert_eq!(stubs.len(), 70);
    assert_eq!((stubs[0], &stubs[68..]), ("apache", &["redis", "wordpress"][..]));
    assert_eq!(
        options["environment"],
        json!({"phpVersion": "8.1.0", "includePaths": [tmp.path().join("../platform").to_string_lossy()]})
    );

    let mut other = server("phpactor");
    configure_server(&mut other, tmp.path(), tmp.path(), &s);
    assert_eq!(other.initialization_options, None);
}

#[test]
fn go_constraints_change_only_protocol_settings() {
    use serde_json::json;
    let tmp = tempfile::tempdir().unwrap();
    let mut settings = Settings::default();
    let mut original = server("gopls");
    original.settings = Some(json!({"analyses":{"unusedparams":true}}));
    let mut defaults = original.clone();
    configure_server(&mut defaults, tmp.path(), tmp.path(), &settings);
    assert_eq!(defaults.settings, Some(json!({"analyses":{"unusedparams":true}, "buildFlags":[], "env":{}})));
    defaults.settings = original.settings.clone();
    assert_eq!(defaults, original);
    settings.languages.go.build_tags.custom = "integration".into();
    settings.languages.go.build_tags.os = "linux".into();
    let mut configured = original.clone();
    configure_server(&mut configured, tmp.path(), tmp.path(), &settings);
    assert_eq!(
        configured.settings.take(),
        Some(json!({
            "analyses":{"unusedparams":true}, "buildFlags":["-tags=integration"], "env":{"GOOS":"linux"}
        }))
    );
    configured.settings = original.settings.clone();
    assert_eq!(configured, original, "launch configuration stays unchanged for in-place reconfiguration");
    let mut other = server("rust-analyzer");
    configure_server(&mut other, tmp.path(), tmp.path(), &settings);
    assert_eq!(other.settings, None);
}

#[test]
fn go_empty_constraints_preserve_explicit_server_defaults() {
    use serde_json::json;
    let tmp = tempfile::tempdir().unwrap();
    let mut cfg = server("gopls");
    cfg.initialization_options =
        Some(toml::Value::try_from(json!({"buildFlags":["-tags=legacy"], "env":{"GOPROXY":"direct"}})).unwrap());
    configure_server(&mut cfg, tmp.path(), tmp.path(), &Settings::default());
    assert_eq!(cfg.settings, Some(json!({"buildFlags":["-tags=legacy"], "env":{"GOPROXY":"direct"}})));
}

#[test]
fn go_modules_configure_gopls_in_place_and_commands_with_explicit_run_overrides() {
    use serde_json::json;
    let tmp = tempfile::tempdir().unwrap();
    let mut settings = Settings::default();
    settings.languages.go.modules.env = BTreeMap::from([
        ("GOPROXY".into(), "https://proxy.example".into()),
        ("GOPRIVATE".into(), "example.com/private".into()),
        ("GOFLAGS".into(), "-race".into()),
    ]);
    settings.languages.go.modules.auto_vendor = false;
    let mut cfg = server("gopls");
    configure_server(&mut cfg, tmp.path(), tmp.path(), &settings);
    let protocol = cfg.settings.take().unwrap();
    assert_eq!(protocol["env"]["GOFLAGS"], "-race -mod=mod");
    assert_eq!(protocol["env"]["GOPRIVATE"], "example.com/private");
    assert!(cfg.env.is_empty(), "module environment changes must not restart gopls");
    let mut run = run("go", "go", &["mod", "tidy"]);
    run.env.insert("GOPROXY".into(), "off".into());
    apply_to_run_configs(std::slice::from_mut(&mut run), tmp.path(), &settings);
    assert_eq!(run.env["GOPROXY"], "off");
    assert_eq!(run.env["GOPRIVATE"], "example.com/private");
    let mut cleared = server("gopls");
    configure_server(&mut cleared, tmp.path(), tmp.path(), &Settings::default());
    assert_eq!(cleared.settings.unwrap()["env"], json!({}));
}

#[test]
fn saving_a_loaded_run_configuration_drops_what_settings_derived() {
    if cfg!(windows) {
        return; // Unix paths
    }
    let tmp = tempfile::tempdir().unwrap();
    let root = tmp.path();
    let touch = |rel: &str| {
        let p = root.join(rel);
        std::fs::create_dir_all(p.parent().unwrap()).unwrap();
        std::fs::write(&p, "").unwrap();
        p.to_string_lossy().into_owned()
    };
    let mut s = Settings::default();
    s.languages.python.interpreter = fake_venv(root, ".venv").to_string_lossy().into_owned();
    s.languages.node.interpreter = touch("node/bin/node");
    touch("rustup/toolchains/stable/bin/cargo");
    s.languages.rust.toolchain = root.join("rustup/toolchains/stable").to_string_lossy().into_owned();
    touch("go/bin/go");
    s.languages.go.goroot = root.join("go").to_string_lossy().into_owned();
    s.languages.go.gopath = root.join("gopath").to_string_lossy().into_owned();
    s.languages.go.modules.env = BTreeMap::from([("GOPROXY".into(), "https://proxy.example".into())]);
    fake_jdk(&root.join("jdk17"));
    s.languages.java.jdk = root.join("jdk17").to_string_lossy().into_owned();
    touch("maven/bin/mvn");
    s.languages.java.maven.home = root.join("maven").to_string_lossy().into_owned();
    s.languages.java.maven.user_settings = "/m2/settings.xml".into();
    s.languages.java.maven.local_repository = "/m2/repo".into();
    s.languages.ruby.interpreter = touch("ruby/bin/ruby");
    touch("ruby/bin/bundle");
    s.tools.insert("godot".into(), ide_core::settings::ToolSettings { path: touch("Godot/godot") });

    let saved = |kind: &str, command: &str, args: &[&str], env: &[(&str, &str)]| {
        let mut c = run(kind, command, args);
        c.detected = false;
        c.env = env.iter().map(|(k, v)| ((*k).to_owned(), (*v).to_owned())).collect();
        c
    };
    // As the user saved them: bare tools, only their own environment.
    let configs = [
        saved("python", "python", &["app.py"], &[]),
        saved("pytest", ".venv/bin/pytest", &["-x"], &[("FOO", "1")]),
        saved("npm", "npm", &["run", "dev"], &[]),
        saved("cargo", "cargo", &["run"], &[]),
        saved("go", "go", &["run", "."], &[]),
        saved("go", "go", &["mod", "tidy"], &[("GOPROXY", "off")]),
        saved("maven", "mvn", &["package"], &[]),
        saved("tomcat", "catalina", &[], &[]),
        saved("ruby", "ruby", &["app.rb"], &[]),
        saved("rake", "bundle", &["exec", "rake"], &[("RAILS_ENV", "test")]),
        saved("godot", "godot", &["--path", "."], &[]),
        // The user's own values that merely look like derived ones stay.
        saved("cargo", "/opt/rust/bin/cargo", &["build"], &[("PATH", "/custom/bin")]),
        saved("maven", "mvn", &["verify"], &[("JAVA_HOME", "/other/jdk")]),
        saved("python", "python", &["x.py"], &[("VIRTUAL_ENV", "/elsewhere/venv")]),
    ];
    for user in configs {
        let mut loaded = user.clone();
        apply_to_run_configs(std::slice::from_mut(&mut loaded), root, &s);
        assert_ne!(loaded, user, "{} {}: settings apply to it", user.kind, user.command);
        let stored = without_derived(&loaded, root, &s);
        assert_eq!(stored, user, "{} {}: saved as the user left it", user.kind, user.command);
        let mut reloaded = stored;
        apply_to_run_configs(std::slice::from_mut(&mut reloaded), root, &s);
        assert_eq!(reloaded, loaded, "{} {}: runs the same after a save", user.kind, user.command);
    }

    // Another bare name for the interpreter comes back as the interpreter's own.
    let mut loaded = saved("python", "python3", &["app.py"], &[]);
    apply_to_run_configs(std::slice::from_mut(&mut loaded), root, &s);
    assert_eq!(without_derived(&loaded, root, &s).command, exe("python"));

    // A saved configuration follows a later interpreter change instead of a frozen PATH.
    let mut loaded = saved("ruby", "ruby", &["app.rb"], &[]);
    apply_to_run_configs(std::slice::from_mut(&mut loaded), root, &s);
    let mut next = without_derived(&loaded, root, &s);
    s.languages.ruby.interpreter = touch("ruby2/bin/ruby");
    apply_to_run_configs(std::slice::from_mut(&mut next), root, &s);
    let ruby2 = root.join("ruby2/bin");
    assert_eq!(next.command, ruby2.join("ruby").to_string_lossy());
    assert!(next.env["PATH"].starts_with(&*ruby2.to_string_lossy()), "{}", next.env["PATH"]);

    // A Maven configuration (a detected one narrowed to a test, a tool window goal) follows a
    // later Maven home, settings file, local repository and JDK; options it sets itself stay.
    for detected in [true, false] {
        let mut goal = saved("maven", "mvn", &["test", "-Dtest=AppTest"], &[]);
        goal.detected = detected;
        let mut own = saved("maven", "mvn", &["-s", "/mine.xml", "test"], &[]);
        own.detected = detected;
        let mut loaded = [goal, own];
        apply_to_run_configs(&mut loaded, root, &s);
        let mut next = loaded.map(|c| without_derived(&c, root, &s));
        touch("maven2/bin/mvn");
        fake_jdk(&root.join("jdk21"));
        let mut s2 = s.clone();
        s2.languages.java.maven.home = root.join("maven2").to_string_lossy().into_owned();
        s2.languages.java.maven.user_settings = "/m3/settings.xml".into();
        s2.languages.java.maven.local_repository = "/m3/repo".into();
        s2.languages.java.jdk = root.join("jdk21").to_string_lossy().into_owned();
        apply_to_run_configs(&mut next, root, &s2);
        assert_eq!(next[0].command, root.join("maven2/bin/mvn").to_string_lossy());
        assert_eq!(next[0].args, ["-s", "/m3/settings.xml", "-Dmaven.repo.local=/m3/repo", "test", "-Dtest=AppTest"]);
        assert!(next[0].env["JAVA_HOME"].ends_with("jdk21"), "{}", next[0].env["JAVA_HOME"]);
        assert_eq!(next[1].args, ["-Dmaven.repo.local=/m3/repo", "-s", "/mine.xml", "test"]);
    }
}

#[test]
fn nested_python_configs_get_their_own_virtualenv_but_explicit_settings_stay_project_relative() {
    let temp = tempfile::tempdir().unwrap();
    let root = temp.path();
    let outer = fake_venv(root, ".venv");
    let nested = fake_venv(&root.join("apps").join("python"), ".venv");
    let mut config = run("python", "python3", &["main.py"]);
    config.extras.module = Some("apps/python".into());
    apply_to_run_configs(std::slice::from_mut(&mut config), root, &Settings::default());
    assert_eq!(config.env["VIRTUAL_ENV"], nested.parent().unwrap().parent().unwrap().to_string_lossy());
    // A workspace member without its own virtualenv uses the one at the project root (uv workspaces).
    let mut member = run("pytest", "python3", &["-m", "pytest"]);
    member.extras.module = Some("packages/lib".into());
    apply_to_run_configs(std::slice::from_mut(&mut member), root, &Settings::default());
    assert_eq!(member.env["VIRTUAL_ENV"], outer.parent().unwrap().parent().unwrap().to_string_lossy());
    let mut settings = Settings::default();
    settings.languages.python.interpreter = "custom/bin/python".into();
    let mut config = run("python", "python3", &["main.py"]);
    config.extras.module = Some("apps/python".into());
    apply_to_run_configs(std::slice::from_mut(&mut config), root, &settings);
    assert_eq!(config.command, root.join("custom/bin/python").to_string_lossy());
}

#[test]
fn file_runtime_uses_nearest_virtualenv_and_explicit_project_settings_win() {
    let temp = tempfile::tempdir().unwrap();
    let root = temp.path();
    let outer = fake_venv(root, ".venv");
    let inner = fake_venv(&root.join("apps/api"), ".venv");
    let near = root.join("apps/api/src/package");
    let mut settings = Settings::default();
    assert_eq!(crate::apply::python_interpreter_near(root, Some(&near), &settings), Some(inner));
    assert_eq!(crate::apply::python_interpreter_near(root, Some(&root.join("apps/other")), &settings), Some(outer));
    settings.languages.python.interpreter = "selected/python".into();
    assert_eq!(crate::apply::python_interpreter_near(root, Some(&near), &settings), Some(root.join("selected/python")));
}

#[test]
fn project_structure_module_jdk_language_level_and_external_libraries() {
    let temp = tempfile::tempdir().unwrap();
    let root_buf = dunce::canonicalize(temp.path()).unwrap();
    let root = root_buf.as_path();
    let jdk17 = root.join("jdk17");
    let jdk21 = root.join("jdk21");
    fake_jdk(&jdk17);
    fake_jdk(&jdk21);

    let mut settings = Settings::default();
    settings.languages.java.jdk = jdk17.to_string_lossy().into_owned();
    settings.languages.java.language_level = "8".into();
    settings.project_structure.modules.insert(
        "service".into(),
        ide_core::settings::ModuleStructureSettings {
            jdk: jdk21.to_string_lossy().into_owned(),
            language_level: "21".into(),
            ..Default::default()
        },
    );

    assert_eq!(crate::apply::module_jdk(root, root, &settings).map(|j| j.home), Some(jdk17));
    assert_eq!(crate::apply::module_jdk(root, &root.join("service"), &settings).map(|j| j.home), Some(jdk21));
    assert_eq!(
        crate::apply::module_jdk(root, &root.join("nested/service"), &settings).map(|j| j.home),
        crate::apply::project_jdk(root, &settings).map(|j| j.home)
    );
    assert_eq!(crate::apply::effective_java_language_level(root, root, &settings), Some("8"));
    assert_eq!(crate::apply::effective_java_language_level(root, &root.join("service"), &settings), Some("21"));

    let mut cfg: ide_language::LanguageServerConfig = toml::from_str("name = 'jdtls'\ncommand = 'jdtls'").unwrap();
    crate::apply::configure_java_compiler_with_level(&mut cfg, root, &settings.inspections, Some("8"));
    let prefs_files: Vec<_> = std::fs::read_dir(root.join("lsp/jdtls"))
        .unwrap()
        .filter_map(|e| e.ok())
        .map(|e| std::fs::read_to_string(e.path()).unwrap())
        .collect();
    assert_eq!(prefs_files.len(), 1);
    assert!(prefs_files[0].contains("org.eclipse.jdt.core.compiler.source=1.8"));
    assert!(prefs_files[0].contains("org.eclipse.jdt.core.compiler.compliance=1.8"));
    assert!(prefs_files[0].contains("org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8"));

    let lib_dir = root.join("lib");
    std::fs::create_dir_all(&lib_dir).unwrap();
    let jar_file = lib_dir.join("servlet-api.jar");
    std::fs::write(&jar_file, b"").unwrap();
    settings.project_structure.libraries.push(ide_core::settings::ProjectLibrary {
        name: "servlet-api".into(),
        classes: vec!["lib/servlet-api.jar".into()],
        sources: vec![],
        javadocs: vec![],
        scope: ide_core::settings::DependencyScope::Provided,
    });
    let groups = crate::libraries::project_libraries(root, &settings, &[]);
    assert!(groups.iter().any(|g| g.name == "servlet-api" && g.kind == "library" && g.roots.len() == 1));
}

#[test]
fn plugin_interpreter_targets_route_all_php_node_command_families() {
    let mut settings = Settings::default();
    settings.languages.php.run_target = "plugin-target:php".into();
    settings.languages.node.run_target = "plugin-target:node".into();
    settings.languages.php.interpreter = "/local/php".into();
    settings.languages.node.interpreter = "/local/node".into();
    for (command, kind, expected) in [
        ("php", "php", "php"),
        ("composer", "composer", "php"),
        ("vendor/bin/phpunit", "phpunit", "php"),
        ("node", "node", "node"),
        ("npm", "npm", "node"),
        ("node_modules/.bin/vitest", "vitest", "node"),
        ("npx", "node", "node"),
    ] {
        let mut config: ide_run::RunConfig = serde_json::from_value(serde_json::json!({ "id":"run", "name":"run", "kind":kind, "command":command, "args":[], "env":{}, "detected":true, "isTest":false })).unwrap();
        crate::apply::apply_to_run_configs(std::slice::from_mut(&mut config), Path::new("/project"), &settings);
        assert_eq!(config.extras.target.as_deref(), Some(format!("plugin-target:{expected}").as_str()));
        assert_eq!(config.command, command);
        assert!(config.env.is_empty());
        assert!(crate::apply::without_derived(&config, Path::new("/project"), &settings).extras.target.is_none());
        config.extras.target = Some(String::new());
        crate::apply::apply_to_run_configs(std::slice::from_mut(&mut config), Path::new("/project"), &settings);
        assert_eq!(config.extras.target.as_deref(), Some(""));
    }
}

#[test]
fn tool_installs_resolve_project_relative_sdks_and_leave_path_fallback_unconfigured() {
    let tmp = tempfile::tempdir().unwrap();
    let root = tmp.path();
    let mut s = Settings::default();
    let defaults = tool_install_environment(root, &s);
    assert!(!defaults.commands.contains_key("go"));
    assert!(!defaults.commands.contains_key("node"));
    assert!(!defaults.commands.contains_key("python"));
    assert!(!defaults.env.contains_key("GOROOT"));
    s.languages.go.goroot = "go-sdk".into();
    s.languages.node.interpreter = "node-sdk/bin/node".into();
    s.languages.python.interpreter = "python-sdk/bin/python3.14".into();
    s.languages.ruby.interpreter = "ruby-sdk/bin/ruby".into();
    let runtime = tool_install_environment(root, &s);
    assert_eq!(runtime.commands["go"], root.join("go-sdk/bin").join(if cfg!(windows) { "go.exe" } else { "go" }));
    assert_eq!(runtime.env["GOROOT"], root.join("go-sdk").to_string_lossy());
    assert_eq!(runtime.commands["node"], root.join("node-sdk/bin/node"));
    assert_eq!(runtime.commands["python"], root.join("python-sdk/bin/python3.14"));
    assert_eq!(runtime.commands["ruby"], root.join("ruby-sdk/bin/ruby"));
}