zccache 1.12.9

//! Integration tests for precompiled header (PCH) caching — invalidation scenarios.
//!
//! Verifies:
//! - Sub-header changes (headers included BY the PCH source header) correctly
//!   invalidate both PCH generation and consuming compilations
//! - Build-directory separation (PCH binary in a different dir than source)
//!   doesn't cause stale cache hits
//! - Chained PCH (`base.h.pch` consumed by `test_pch.h.pch`) propagates
//!   sub-header invalidation through the chain
//! - PCH rebuilds don't create spurious `.pch` files in the source tree
//!
//! Basic PCH usage / generation cacheability lives in
//! `daemon_pch_cache_basic_test.rs`.

use zccache::daemon::DaemonServer;
use zccache::protocol::{Request, Response};

/// Platform-correct client connection type.
#[cfg(unix)]
type ClientConn = zccache::ipc::IpcConnection;
#[cfg(windows)]
type ClientConn = zccache::ipc::IpcClientConnection;

async fn start_daemon() -> (
    String,
    tokio::task::JoinHandle<()>,
    std::sync::Arc<tokio::sync::Notify>,
) {
    let endpoint = zccache::ipc::unique_test_endpoint();
    let mut server = DaemonServer::bind(&endpoint).unwrap();
    let shutdown = server.shutdown_handle();
    let handle = tokio::spawn(async move { server.run(0).await.unwrap() });
    (endpoint, handle, shutdown)
}

async fn start_session(client: &mut ClientConn, cwd: &str, log_file: &str) -> String {
    client
        .send(&Request::SessionStart {
            client_pid: std::process::id(),
            working_dir: cwd.to_string().into(),
            log_file: Some(log_file.to_string().into()),
            track_stats: false,
            journal_path: None,
            profile: false,
            private_daemon: None,
        })
        .await
        .unwrap();
    match client.recv().await.unwrap() {
        Some(Response::SessionStarted { session_id, .. }) => session_id,
        other => panic!("expected SessionStarted, got: {other:?}"),
    }
}

async fn compile_raw(
    client: &mut ClientConn,
    session_id: &str,
    compiler: &str,
    args: Vec<String>,
    cwd: &str,
) -> (i32, bool, Vec<u8>) {
    client
        .send(&Request::Compile {
            session_id: session_id.to_string(),
            args,
            cwd: cwd.to_string().into(),
            compiler: compiler.to_string().into(),
            env: None,
            stdin: Vec::new(),
        })
        .await
        .unwrap();

    match client.recv().await.unwrap() {
        Some(Response::CompileResult {
            exit_code,
            cached,
            stderr,
            ..
        }) => (exit_code, cached, (*stderr).clone()),
        Some(Response::Error { message }) => panic!("compile error: {message}"),
        other => panic!("expected CompileResult, got: {other:?}"),
    }
}

/// Adversarial test: modifying a SUB-HEADER included by the PCH source header
/// (not the PCH source header itself) must invalidate both PCH generation and
/// all consuming compilations.
///
/// This is the scenario reported by users: a header that is *part of* the PCH
/// changes, and the cache must detect this. The PCH source header (`pch.h`)
/// content does NOT change — only `sub.h` (which `pch.h` includes) changes.
///
/// Covers:
/// 1. PCH gen with sub-headers → cache miss (first run)
/// 2. Compile with PCH → cache miss → cache hit
/// 3. Modify sub-header → PCH regen → cache miss (sub.h hash changed)
/// 4. Compile with new PCH → cache miss (artifact key changed via sub.h)
/// 5. Compile again → cache hit (stable)
#[tokio::test]
#[ignore] // integration: spawns clang + watcher sleeps, run with --full
async fn pch_sub_header_change_invalidates_cache() {
    let clang = match zccache::test_support::find_clang() {
        Some(p) => p,
        None => {
            eprintln!("skipping test: clang not found");
            return;
        }
    };

    let tmp = tempfile::tempdir().unwrap();
    let cwd = tmp.path().to_string_lossy().into_owned();
    let log_dir = tmp.path().join("logs");
    std::fs::create_dir_all(&log_dir).unwrap();
    let log = log_dir.join("session.log");
    let compiler = clang.to_string_lossy().into_owned();

    // ── Set up files: pch.h includes sub.h ─────────────────────
    let sub_header = tmp.path().join("sub.h");
    let pch_header = tmp.path().join("pch.h");
    let pch_file = tmp.path().join("pch.h.pch");
    let source = tmp.path().join("main.cpp");
    let obj = tmp.path().join("main.o");

    // sub.h defines a value; pch.h includes it but adds nothing else.
    std::fs::write(
        &sub_header,
        "#ifndef SUB_H\n#define SUB_H\n#define SUB_VALUE 42\n#endif\n",
    )
    .unwrap();
    // pch.h is a thin wrapper — its own content NEVER changes.
    std::fs::write(
        &pch_header,
        "#ifndef PCH_H\n#define PCH_H\n#include \"sub.h\"\n#endif\n",
    )
    .unwrap();
    std::fs::write(&source, "int main() { return SUB_VALUE; }\n").unwrap();

    let (endpoint, server_handle, shutdown) = start_daemon().await;
    let mut client = zccache::ipc::connect(&endpoint).await.unwrap();
    let sid = start_session(&mut client, &cwd, &log.to_string_lossy()).await;

    let pch_gen_args = || {
        vec![
            "-x".to_string(),
            "c++-header".to_string(),
            "-c".to_string(),
            pch_header.to_string_lossy().into_owned(),
            "-o".to_string(),
            pch_file.to_string_lossy().into_owned(),
        ]
    };
    let compile_args = || {
        vec![
            "-c".to_string(),
            source.to_string_lossy().into_owned(),
            "-o".to_string(),
            obj.to_string_lossy().into_owned(),
            "-include-pch".to_string(),
            pch_file.to_string_lossy().into_owned(),
        ]
    };

    // ── Step 1: Generate PCH (cold cache) ──────────────────────
    let (exit_code, _, stderr) =
        compile_raw(&mut client, &sid, &compiler, pch_gen_args(), &cwd).await;
    let stderr_str = String::from_utf8_lossy(&stderr);
    assert_eq!(exit_code, 0, "PCH generation failed: {stderr_str}");

    // ── Step 2: Compile with PCH → cache miss ──────────────────
    let (exit_code, cached, stderr) =
        compile_raw(&mut client, &sid, &compiler, compile_args(), &cwd).await;
    let stderr_str = String::from_utf8_lossy(&stderr);
    assert_eq!(exit_code, 0, "compile with PCH failed: {stderr_str}");
    assert!(!cached, "first compile should be a cache miss");
    let first_obj = std::fs::read(&obj).unwrap();

    // ── Step 3: Compile again → cache hit ──────────────────────
    std::fs::remove_file(&obj).unwrap();
    let (exit_code, cached, _) =
        compile_raw(&mut client, &sid, &compiler, compile_args(), &cwd).await;
    assert_eq!(exit_code, 0);
    assert!(cached, "second compile should be a cache hit");

    // ── Step 4: Modify SUB-HEADER ONLY (pch.h content unchanged) ────
    std::thread::sleep(std::time::Duration::from_millis(100));
    std::fs::write(
        &sub_header,
        "#ifndef SUB_H\n#define SUB_H\n#define SUB_VALUE 99\n\
         typedef struct { int x; int y; } SubExtra;\n\
         #endif\n",
    )
    .unwrap();
    // Verify pch.h is unchanged
    let pch_content = std::fs::read_to_string(&pch_header).unwrap();
    assert!(
        pch_content.contains("#include \"sub.h\""),
        "pch.h should be unchanged"
    );

    // Wait for watcher to process the sub.h change.
    // Windows watcher latency can exceed 500ms under load.
    std::thread::sleep(std::time::Duration::from_millis(2000));

    // ── Step 5: Regenerate PCH → must be cache miss ────────────
    let (exit_code, cached, _) =
        compile_raw(&mut client, &sid, &compiler, pch_gen_args(), &cwd).await;
    assert_eq!(exit_code, 0, "PCH regen should succeed");
    assert!(
        !cached,
        "PCH regen after sub-header change MUST be a cache miss"
    );

    // ── Step 6: Compile with new PCH → must be cache miss ──────
    std::fs::remove_file(&obj).unwrap();
    let (exit_code, cached, _) =
        compile_raw(&mut client, &sid, &compiler, compile_args(), &cwd).await;
    assert_eq!(exit_code, 0, "compile with updated PCH should succeed");
    assert!(
        !cached,
        "compile after sub-header change MUST be a cache miss (not a stale hit)"
    );
    let second_obj = std::fs::read(&obj).unwrap();
    assert_ne!(
        first_obj, second_obj,
        "different SUB_VALUE should produce different .o"
    );

    // ── Step 7: Compile again → cache hit (stable) ─────────────
    std::fs::remove_file(&obj).unwrap();
    let (exit_code, cached, _) =
        compile_raw(&mut client, &sid, &compiler, compile_args(), &cwd).await;
    assert_eq!(exit_code, 0);
    assert!(
        cached,
        "re-compile with unchanged PCH should be a cache hit"
    );

    // ── Step 8: PCH regen with no changes → cache hit ──────────
    let pch_before = std::fs::read(&pch_file).unwrap();
    let (exit_code, cached, _) =
        compile_raw(&mut client, &sid, &compiler, pch_gen_args(), &cwd).await;
    assert_eq!(exit_code, 0);
    assert!(
        cached,
        "PCH regen with no further changes should be a cache hit"
    );
    let pch_after = std::fs::read(&pch_file).unwrap();
    assert_eq!(
        pch_before, pch_after,
        "cached PCH should be identical to previous"
    );

    let log_text = std::fs::read_to_string(&log).unwrap();
    eprintln!("=== sub-header test log ===\n{log_text}");

    shutdown.notify_one();
    server_handle.await.unwrap();
}

/// Adversarial test: PCH binary in a separate BUILD directory (not sibling to
/// source header). This tests the `pch_source_header()` resolution when the
/// PCH lives at e.g. `.build/pch.h.pch` while the source is at `src/pch.h`.
///
/// If `pch_source_header()` can't find the source header, it falls back to
/// hashing the PCH binary directly. Since PCH binaries embed timestamps
/// (non-deterministic), this can cause spurious cache misses or, worse,
/// stale hits if the binary bytes happen to be the same.
///
/// The critical assertion: after modifying a sub-header, the compilation
/// using the PCH MUST get a cache miss even when pch_source_header fails.
#[tokio::test]
#[ignore] // integration: spawns clang + watcher sleeps, run with --full
async fn pch_build_dir_separation_sub_header_change() {
    let clang = match zccache::test_support::find_clang() {
        Some(p) => p,
        None => {
            eprintln!("skipping test: clang not found");
            return;
        }
    };

    let tmp = tempfile::tempdir().unwrap();
    let log_dir = tmp.path().join("logs");
    std::fs::create_dir_all(&log_dir).unwrap();
    let log = log_dir.join("session.log");
    let compiler = clang.to_string_lossy().into_owned();

    // Source in src/, PCH output in build/ — different directories.
    let src_dir = tmp.path().join("src");
    let build_dir = tmp.path().join("build");
    std::fs::create_dir_all(&src_dir).unwrap();
    std::fs::create_dir_all(&build_dir).unwrap();

    let cwd = tmp.path().to_string_lossy().into_owned();

    let sub_header = src_dir.join("sub.h");
    let pch_header = src_dir.join("pch.h");
    // PCH binary is in the BUILD dir, not next to source
    let pch_file = build_dir.join("pch.h.pch");
    let source = src_dir.join("main.cpp");
    let obj = build_dir.join("main.o");

    std::fs::write(
        &sub_header,
        "#ifndef SUB_H\n#define SUB_H\n#define SUB_VALUE 42\n#endif\n",
    )
    .unwrap();
    std::fs::write(
        &pch_header,
        "#ifndef PCH_H\n#define PCH_H\n#include \"sub.h\"\n#endif\n",
    )
    .unwrap();
    std::fs::write(&source, "int main() { return SUB_VALUE; }\n").unwrap();

    let (endpoint, server_handle, shutdown) = start_daemon().await;
    let mut client = zccache::ipc::connect(&endpoint).await.unwrap();
    let sid = start_session(&mut client, &cwd, &log.to_string_lossy()).await;

    let pch_gen_args = || {
        vec![
            "-x".to_string(),
            "c++-header".to_string(),
            "-c".to_string(),
            pch_header.to_string_lossy().into_owned(),
            "-o".to_string(),
            pch_file.to_string_lossy().into_owned(),
            // Include path so pch.h can find sub.h
            "-I".to_string(),
            src_dir.to_string_lossy().into_owned(),
        ]
    };
    let compile_args = || {
        vec![
            "-c".to_string(),
            source.to_string_lossy().into_owned(),
            "-o".to_string(),
            obj.to_string_lossy().into_owned(),
            "-include-pch".to_string(),
            pch_file.to_string_lossy().into_owned(),
            "-I".to_string(),
            src_dir.to_string_lossy().into_owned(),
        ]
    };

    // ── Step 1: Generate PCH (in build dir) ────────────────────
    let (exit_code, _, stderr) =
        compile_raw(&mut client, &sid, &compiler, pch_gen_args(), &cwd).await;
    let stderr_str = String::from_utf8_lossy(&stderr);
    assert_eq!(exit_code, 0, "PCH gen failed: {stderr_str}");

    // ── Step 2: Compile with PCH → miss ────────────────────────
    let (exit_code, cached, stderr) =
        compile_raw(&mut client, &sid, &compiler, compile_args(), &cwd).await;
    let stderr_str = String::from_utf8_lossy(&stderr);
    assert_eq!(exit_code, 0, "compile failed: {stderr_str}");
    assert!(!cached, "first compile should miss");
    let first_obj = std::fs::read(&obj).unwrap();

    // ── Step 3: Compile again → hit ────────────────────────────
    std::fs::remove_file(&obj).unwrap();
    let (exit_code, cached, _) =
        compile_raw(&mut client, &sid, &compiler, compile_args(), &cwd).await;
    assert_eq!(exit_code, 0);
    assert!(cached, "second compile should hit");

    // ── Step 4: Modify sub-header (pch.h unchanged) ────────────
    std::thread::sleep(std::time::Duration::from_millis(100));
    std::fs::write(
        &sub_header,
        "#ifndef SUB_H\n#define SUB_H\n#define SUB_VALUE 99\n\
         inline int sub_extra() { return 7; }\n\
         #endif\n",
    )
    .unwrap();
    // Wait for watcher to process the sub.h change.
    // On Windows, ReadDirectoryChangesW may fail to deliver events for
    // subdirectories of temp dirs — this is the root cause of the bug
    // this test is designed to catch.
    std::thread::sleep(std::time::Duration::from_millis(2000));

    // ── Step 5: Regen PCH → must miss (sub.h changed) ──────────
    let (exit_code, cached, _) =
        compile_raw(&mut client, &sid, &compiler, pch_gen_args(), &cwd).await;
    assert_eq!(exit_code, 0);
    assert!(
        !cached,
        "PCH regen after sub.h change must miss (build-dir separation)"
    );

    // ── Step 6: Compile → must miss (stale hit = BUG) ──────────
    std::fs::remove_file(&obj).unwrap();
    let (exit_code, cached, _) =
        compile_raw(&mut client, &sid, &compiler, compile_args(), &cwd).await;
    assert_eq!(exit_code, 0);
    assert!(
        !cached,
        "compile after sub.h change MUST miss even with build-dir-separated PCH"
    );
    let second_obj = std::fs::read(&obj).unwrap();
    assert_ne!(
        first_obj, second_obj,
        "different SUB_VALUE must produce different .o"
    );

    // ── Step 7: Compile again → hit ────────────────────────────
    std::fs::remove_file(&obj).unwrap();
    let (exit_code, cached, _) =
        compile_raw(&mut client, &sid, &compiler, compile_args(), &cwd).await;
    assert_eq!(exit_code, 0);
    assert!(cached, "re-compile with no changes should hit");

    let log_text = std::fs::read_to_string(&log).unwrap();
    eprintln!("=== build-dir separation log ===\n{log_text}");

    shutdown.notify_one();
    server_handle.await.unwrap();
}

/// Adversarial test: chained PCH scenario (like FastLED).
///
/// base.h includes sub.h → base.h.pch
/// test_pch.h uses -include-pch base.h.pch → test_pch.h.pch
/// main.cpp uses -include-pch test_pch.h.pch
///
/// When sub.h changes:
/// - base.h.pch must be regenerated (cache miss)
/// - test_pch.h.pch must be regenerated (cache miss — base PCH changed)
/// - main.cpp must be recompiled (cache miss — test PCH changed)
#[tokio::test]
#[ignore] // integration: spawns clang + watcher sleeps, run with --full
async fn pch_chained_sub_header_change() {
    let clang = match zccache::test_support::find_clang() {
        Some(p) => p,
        None => {
            eprintln!("skipping test: clang not found");
            return;
        }
    };

    let tmp = tempfile::tempdir().unwrap();
    let cwd = tmp.path().to_string_lossy().into_owned();
    let log_dir = tmp.path().join("logs");
    std::fs::create_dir_all(&log_dir).unwrap();
    let log = log_dir.join("session.log");
    let compiler = clang.to_string_lossy().into_owned();

    let sub_h = tmp.path().join("sub.h");
    let base_h = tmp.path().join("base.h");
    let base_pch = tmp.path().join("base.h.pch");
    let test_h = tmp.path().join("test_pch.h");
    let test_pch = tmp.path().join("test_pch.h.pch");
    let source = tmp.path().join("main.cpp");
    let obj = tmp.path().join("main.o");

    std::fs::write(
        &sub_h,
        "#ifndef SUB_H\n#define SUB_H\n#define SUB_VALUE 42\n#endif\n",
    )
    .unwrap();
    std::fs::write(
        &base_h,
        "#ifndef BASE_H\n#define BASE_H\n#include \"sub.h\"\n#endif\n",
    )
    .unwrap();
    std::fs::write(
        &test_h,
        "#ifndef TEST_PCH_H\n#define TEST_PCH_H\n#define TEST_EXTRA 1\n#endif\n",
    )
    .unwrap();
    std::fs::write(&source, "int main() { return SUB_VALUE + TEST_EXTRA; }\n").unwrap();

    let (endpoint, server_handle, shutdown) = start_daemon().await;
    let mut client = zccache::ipc::connect(&endpoint).await.unwrap();
    let sid = start_session(&mut client, &cwd, &log.to_string_lossy()).await;

    // ── Build the PCH chain ─────────────────────────────────────
    // 1. Generate base PCH
    let (exit_code, _, stderr) = compile_raw(
        &mut client,
        &sid,
        &compiler,
        vec![
            "-x".into(),
            "c++-header".into(),
            "-c".into(),
            base_h.to_string_lossy().into_owned(),
            "-o".into(),
            base_pch.to_string_lossy().into_owned(),
        ],
        &cwd,
    )
    .await;
    let stderr_str = String::from_utf8_lossy(&stderr);
    assert_eq!(exit_code, 0, "base PCH gen failed: {stderr_str}");

    // 2. Generate test PCH (chained, includes base PCH)
    let (exit_code, _, stderr) = compile_raw(
        &mut client,
        &sid,
        &compiler,
        vec![
            "-x".into(),
            "c++-header".into(),
            "-c".into(),
            test_h.to_string_lossy().into_owned(),
            "-o".into(),
            test_pch.to_string_lossy().into_owned(),
            "-include-pch".into(),
            base_pch.to_string_lossy().into_owned(),
        ],
        &cwd,
    )
    .await;
    let stderr_str = String::from_utf8_lossy(&stderr);
    assert_eq!(exit_code, 0, "test PCH gen failed: {stderr_str}");

    // 3. Compile with chained PCH → miss
    let (exit_code, cached, stderr) = compile_raw(
        &mut client,
        &sid,
        &compiler,
        vec![
            "-c".into(),
            source.to_string_lossy().into_owned(),
            "-o".into(),
            obj.to_string_lossy().into_owned(),
            "-include-pch".into(),
            test_pch.to_string_lossy().into_owned(),
        ],
        &cwd,
    )
    .await;
    let stderr_str = String::from_utf8_lossy(&stderr);
    assert_eq!(
        exit_code, 0,
        "compile with chained PCH failed: {stderr_str}"
    );
    assert!(!cached, "first compile should miss");
    let first_obj = std::fs::read(&obj).unwrap();

    // 4. Compile again → hit
    std::fs::remove_file(&obj).unwrap();
    let (exit_code, cached, _) = compile_raw(
        &mut client,
        &sid,
        &compiler,
        vec![
            "-c".into(),
            source.to_string_lossy().into_owned(),
            "-o".into(),
            obj.to_string_lossy().into_owned(),
            "-include-pch".into(),
            test_pch.to_string_lossy().into_owned(),
        ],
        &cwd,
    )
    .await;
    assert_eq!(exit_code, 0);
    assert!(cached, "second compile should hit");

    // ── Modify sub.h (base.h and test_pch.h unchanged) ─────────
    std::thread::sleep(std::time::Duration::from_millis(100));
    std::fs::write(
        &sub_h,
        "#ifndef SUB_H\n#define SUB_H\n#define SUB_VALUE 99\n#endif\n",
    )
    .unwrap();
    // Windows watcher latency can exceed 500ms under load.
    std::thread::sleep(std::time::Duration::from_millis(2000));

    // ── Rebuild the entire chain ────────────────────────────────
    // 5. Regen base PCH → must miss
    let (exit_code, cached, _) = compile_raw(
        &mut client,
        &sid,
        &compiler,
        vec![
            "-x".into(),
            "c++-header".into(),
            "-c".into(),
            base_h.to_string_lossy().into_owned(),
            "-o".into(),
            base_pch.to_string_lossy().into_owned(),
        ],
        &cwd,
    )
    .await;
    assert_eq!(exit_code, 0);
    assert!(!cached, "base PCH regen must miss after sub.h change");

    // 6. Regen test PCH → must miss (base PCH changed)
    let (exit_code, cached, _) = compile_raw(
        &mut client,
        &sid,
        &compiler,
        vec![
            "-x".into(),
            "c++-header".into(),
            "-c".into(),
            test_h.to_string_lossy().into_owned(),
            "-o".into(),
            test_pch.to_string_lossy().into_owned(),
            "-include-pch".into(),
            base_pch.to_string_lossy().into_owned(),
        ],
        &cwd,
    )
    .await;
    assert_eq!(exit_code, 0);
    assert!(
        !cached,
        "chained test PCH regen must miss after sub.h change"
    );

    // 7. Compile with new chained PCH → must miss
    std::fs::remove_file(&obj).unwrap();
    let (exit_code, cached, _) = compile_raw(
        &mut client,
        &sid,
        &compiler,
        vec![
            "-c".into(),
            source.to_string_lossy().into_owned(),
            "-o".into(),
            obj.to_string_lossy().into_owned(),
            "-include-pch".into(),
            test_pch.to_string_lossy().into_owned(),
        ],
        &cwd,
    )
    .await;
    assert_eq!(exit_code, 0);
    assert!(
        !cached,
        "compile with changed chained PCH MUST miss (sub.h changed transitively)"
    );
    let second_obj = std::fs::read(&obj).unwrap();
    assert_ne!(
        first_obj, second_obj,
        "different SUB_VALUE must produce different .o"
    );

    // 8. Compile again → hit (stable)
    std::fs::remove_file(&obj).unwrap();
    let (exit_code, cached, _) = compile_raw(
        &mut client,
        &sid,
        &compiler,
        vec![
            "-c".into(),
            source.to_string_lossy().into_owned(),
            "-o".into(),
            obj.to_string_lossy().into_owned(),
            "-include-pch".into(),
            test_pch.to_string_lossy().into_owned(),
        ],
        &cwd,
    )
    .await;
    assert_eq!(exit_code, 0);
    assert!(cached, "re-compile after stabilization should hit");

    let log_text = std::fs::read_to_string(&log).unwrap();
    eprintln!("=== chained PCH log ===\n{log_text}");

    shutdown.notify_one();
    server_handle.await.unwrap();
}

/// Regression test: modifying a sub-header included by a PCH must NOT create
/// a spurious `.pch` file next to the modified header in the source tree.
///
/// Reproduces the bug reported in BUG_PCH_SPURIOUS_GENERATION.md:
/// - Source tree has `src/sub.h` (dependency) and `src/pch.h` (PCH target)
/// - PCH output goes to a separate `build/` directory via explicit `-o`
/// - After modifying `sub.h` and rebuilding, `src/sub.h.pch` must NOT exist
///
/// Root cause: `default_output()` used to preserve directory components for
/// header files (e.g., `src/sub.h` → `src/sub.h.pch`), which the daemon
/// could resolve into the source tree during cache restoration.
#[tokio::test]
#[ignore] // integration: spawns clang + watcher sleeps, run with --full
async fn pch_rebuild_no_spurious_output_in_source_tree() {
    let clang = match zccache::test_support::find_clang() {
        Some(p) => p,
        None => {
            eprintln!("skipping test: clang not found");
            return;
        }
    };

    let tmp = tempfile::tempdir().unwrap();
    let log_dir = tmp.path().join("logs");
    std::fs::create_dir_all(&log_dir).unwrap();
    let log = log_dir.join("session.log");
    let compiler = clang.to_string_lossy().into_owned();

    // Source in src/, PCH output in build/ — separate directories.
    let src_dir = tmp.path().join("src");
    let build_dir = tmp.path().join("build");
    std::fs::create_dir_all(&src_dir).unwrap();
    std::fs::create_dir_all(&build_dir).unwrap();

    let cwd = tmp.path().to_string_lossy().into_owned();

    // sub.h — the header we'll modify
    let sub_h = src_dir.join("sub.h");
    std::fs::write(&sub_h, "#pragma once\ninline int sub() { return 1; }\n").unwrap();

    // pch.h — the PCH target that includes sub.h
    let pch_h = src_dir.join("pch.h");
    std::fs::write(&pch_h, "#pragma once\n#include \"sub.h\"\n").unwrap();

    // main.cpp — source file
    let main_cpp = src_dir.join("main.cpp");
    std::fs::write(
        &main_cpp,
        "#include \"sub.h\"\nint main() { return sub(); }\n",
    )
    .unwrap();

    let pch_output = build_dir.join("pch.h.pch");
    let main_obj = build_dir.join("main.o");

    let (endpoint, server_handle, shutdown) = start_daemon().await;
    let mut client = zccache::ipc::connect(&endpoint).await.unwrap();
    let sid = start_session(&mut client, &cwd, &log.to_string_lossy()).await;

    let isrc = format!("-I{}", src_dir.to_string_lossy());

    // ── Step 1: Generate PCH (explicit -o into build dir) ────────
    let (exit_code, _, stderr) = compile_raw(
        &mut client,
        &sid,
        &compiler,
        vec![
            "-x".into(),
            "c++-header".into(),
            pch_h.to_string_lossy().into_owned(),
            "-o".into(),
            pch_output.to_string_lossy().into_owned(),
            isrc.clone(),
        ],
        &cwd,
    )
    .await;
    let stderr_str = String::from_utf8_lossy(&stderr);
    assert_eq!(exit_code, 0, "PCH gen failed: {stderr_str}");
    assert!(pch_output.exists(), "PCH file should be created");

    // ── Step 2: Compile main.cpp using PCH ───────────────────────
    let (exit_code, _, stderr) = compile_raw(
        &mut client,
        &sid,
        &compiler,
        vec![
            "-c".into(),
            main_cpp.to_string_lossy().into_owned(),
            "-o".into(),
            main_obj.to_string_lossy().into_owned(),
            "-include-pch".into(),
            pch_output.to_string_lossy().into_owned(),
            isrc.clone(),
        ],
        &cwd,
    )
    .await;
    let stderr_str = String::from_utf8_lossy(&stderr);
    assert_eq!(exit_code, 0, "compile with PCH failed: {stderr_str}");

    // ── Step 3: Modify sub.h ─────────────────────────────────────
    std::thread::sleep(std::time::Duration::from_millis(100));
    std::fs::write(&sub_h, "#pragma once\ninline int sub() { return 2; }\n").unwrap();
    std::thread::sleep(std::time::Duration::from_millis(2000));

    // ── Step 4: Rebuild PCH ──────────────────────────────────────
    let (exit_code, _, _) = compile_raw(
        &mut client,
        &sid,
        &compiler,
        vec![
            "-x".into(),
            "c++-header".into(),
            pch_h.to_string_lossy().into_owned(),
            "-o".into(),
            pch_output.to_string_lossy().into_owned(),
            isrc.clone(),
        ],
        &cwd,
    )
    .await;
    assert_eq!(exit_code, 0, "PCH rebuild failed");

    // ── Step 5: Recompile main.cpp ───────────────────────────────
    let (exit_code, _, _) = compile_raw(
        &mut client,
        &sid,
        &compiler,
        vec![
            "-c".into(),
            main_cpp.to_string_lossy().into_owned(),
            "-o".into(),
            main_obj.to_string_lossy().into_owned(),
            "-include-pch".into(),
            pch_output.to_string_lossy().into_owned(),
            isrc.clone(),
        ],
        &cwd,
    )
    .await;
    assert_eq!(exit_code, 0, "recompile with PCH failed");

    // ── Step 6: ASSERTION — no .pch files in source tree ─────────
    for entry in std::fs::read_dir(&src_dir).unwrap() {
        let path = entry.unwrap().path();
        assert!(
            path.extension().and_then(|e| e.to_str()) != Some("pch"),
            "BUG: spurious PCH file found in source tree: {}",
            path.display()
        );
    }

    let log_text = std::fs::read_to_string(&log).unwrap();
    eprintln!("=== spurious PCH test log ===\n{log_text}");

    shutdown.notify_one();
    server_handle.await.unwrap();
}