testlint_sdk/runtime_coverage/

cpp.rs

use crate::platform::{process_exists, signal_process, ProcessSignal};
use crate::runtime_coverage::{CoverageSummary, RuntimeCoverageResult};
use std::fs;
use std::process::Command;
use std::thread;
use std::time::Duration;

pub struct CppRuntimeCoverage;

impl Default for CppRuntimeCoverage {
    fn default() -> Self {
        Self::new()
    }
}

impl CppRuntimeCoverage {
    pub fn new() -> Self {
        CppRuntimeCoverage
    }

    /// Attach to a running C++ process and collect coverage
    /// REQUIRES: Process must be built with -fprofile-arcs -ftest-coverage
    pub fn attach_and_collect(&self, pid: u32) -> Result<RuntimeCoverageResult, String> {
        println!(
            "⚙️  Attempting to collect coverage from C++ process PID: {}",
            pid
        );
        println!();
        println!("⚠️  IMPORTANT: This only works if the C++ binary was compiled with:");
        println!("   g++ -fprofile-arcs -ftest-coverage myapp.cpp -o myapp");
        println!("   or");
        println!("   clang++ -fprofile-instr-generate -fcoverage-mapping myapp.cpp -o myapp");
        println!();

        // Check if process exists
        self.check_process_exists(pid)?;

        // Detect binary path
        let binary_path = self.get_binary_path(pid)?;
        println!("📦 Binary: {}", binary_path);

        println!("💡 C++ coverage via gcov/llvm-cov:");
        println!("   - Process must be built with coverage flags");
        println!("   - .gcda files written on process exit");
        println!("   - We'll monitor for coverage files after signal");
        println!();

        // Wait for Ctrl+C
        use std::sync::atomic::{AtomicBool, Ordering};
        use std::sync::Arc;

        let running = Arc::new(AtomicBool::new(true));
        let r = running.clone();

        ctrlc::set_handler(move || {
            r.store(false, Ordering::SeqCst);
        })
        .expect("Error setting Ctrl-C handler");

        let start_time = std::time::Instant::now();

        println!("⏳ Monitoring process... Press Ctrl+C to trigger coverage dump");

        while running.load(Ordering::SeqCst) {
            thread::sleep(Duration::from_millis(100));
        }

        let duration_secs = start_time.elapsed().as_secs();

        // Signal the process to exit gracefully (this writes .gcda files)
        println!("\n📝 Sending SIGTERM to process to trigger gcov data write...");

        #[cfg(unix)]
        {
            signal_process(pid, ProcessSignal::Terminate)?;
        }

        #[cfg(windows)]
        {
            // On Windows, create a trigger file for graceful shutdown
            let trigger_file = std::env::temp_dir().join(format!("coverage_trigger_{}.txt", pid));
            fs::write(&trigger_file, "terminate")?;
            println!(
                "ℹ️  Created trigger file (Windows alternative to SIGTERM): {}",
                trigger_file.display()
            );
            println!("   Note: C++ process must watch for this file to trigger graceful shutdown");
        }

        // Wait for process to write .gcda files and exit
        println!("⏳ Waiting for process to write coverage data...");
        thread::sleep(Duration::from_secs(3));

        // Find .gcda files
        let gcda_files = self.find_gcda_files()?;

        if gcda_files.is_empty() {
            return Err(self.get_coverage_instructions());
        }

        println!("✓ Found {} .gcda file(s)", gcda_files.len());

        // Generate lcov report
        let coverage_file = self.generate_lcov_report(&gcda_files, pid)?;

        // Parse the lcov file
        let summary = self.parse_lcov_file(&coverage_file)?;

        Ok(RuntimeCoverageResult {
            language: "C++".to_string(),
            pid,
            duration_secs,
            coverage_file,
            summary,
        })
    }

    /// Check if the process exists
    fn check_process_exists(&self, pid: u32) -> Result<(), String> {
        if !process_exists(pid)? {
            return Err(format!("Process {} not found", pid));
        }
        Ok(())
    }

    /// Get the binary path of the running process
    fn get_binary_path(&self, pid: u32) -> Result<String, String> {
        #[cfg(target_os = "linux")]
        {
            let exe_path = format!("/proc/{}/exe", pid);
            match fs::read_link(&exe_path) {
                Ok(path) => Ok(path.to_string_lossy().to_string()),
                Err(e) => Err(format!("Failed to read process binary: {}", e)),
            }
        }

        #[cfg(target_os = "macos")]
        {
            let output = Command::new("ps")
                .args(["-p", &pid.to_string(), "-o", "comm="])
                .output()
                .map_err(|e| format!("Failed to get process info: {}", e))?;

            Ok(String::from_utf8_lossy(&output.stdout).trim().to_string())
        }

        #[cfg(not(any(target_os = "linux", target_os = "macos")))]
        {
            Err("Binary path detection not supported on this platform".to_string())
        }
    }

    /// Find .gcda files generated by the process
    fn find_gcda_files(&self) -> Result<Vec<String>, String> {
        let mut gcda_files = Vec::new();

        // Search current directory and subdirectories
        if let Ok(entries) = fs::read_dir(".") {
            for entry in entries.flatten() {
                if let Ok(file_name) = entry.file_name().into_string() {
                    if file_name.ends_with(".gcda") {
                        // Check if file was recently modified
                        if let Ok(metadata) = entry.metadata() {
                            if let Ok(modified) = metadata.modified() {
                                if let Ok(elapsed) = modified.elapsed() {
                                    if elapsed.as_secs() < 10 {
                                        gcda_files.push(file_name);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        Ok(gcda_files)
    }

    /// Get instructions for building with coverage
    fn get_coverage_instructions(&self) -> String {
        "No .gcda coverage files found.\n\
        \n\
        The C++ binary was likely NOT compiled with coverage flags.\n\
        \n\
        To enable coverage in C++ applications:\n\
        \n\
        Using GCC/gcov:\n\
        1. Compile with coverage flags:\n\
           g++ -fprofile-arcs -ftest-coverage -O0 myapp.cpp -o myapp\n\
        \n\
        2. Run your application:\n\
           ./myapp\n\
        \n\
        3. .gcda files are written on exit\n\
        \n\
        Using Clang/llvm-cov:\n\
        1. Compile with:\n\
           clang++ -fprofile-instr-generate -fcoverage-mapping myapp.cpp -o myapp\n\
        \n\
        2. Set profile output:\n\
           export LLVM_PROFILE_FILE=\"cpp-%p.profraw\"\n\
        \n\
        3. Run application\n\
        \n\
        Or use Coverage Orchestrator to wrap execution automatically."
            .to_string()
    }

    /// Generate lcov report from .gcda files
    fn generate_lcov_report(&self, _gcda_files: &[String], pid: u32) -> Result<String, String> {
        println!("📄 Generating lcov report from gcda files...");

        let lcov_file = format!("cpp-coverage-{}.lcov", pid);

        // Run lcov to capture coverage
        let output = Command::new("lcov")
            .args([
                "--capture",
                "--directory",
                ".",
                "--output-file",
                &lcov_file,
                "--rc",
                "lcov_branch_coverage=1",
            ])
            .output()
            .map_err(|e| {
                format!(
                    "Failed to run lcov (is it installed?): {}\n\
                Install with: apt-get install lcov  or  brew install lcov",
                    e
                )
            })?;

        if !output.status.success() {
            return Err(format!(
                "lcov failed: {}",
                String::from_utf8_lossy(&output.stderr)
            ));
        }

        println!("✓ Generated lcov report");

        Ok(lcov_file)
    }

    /// Parse lcov format coverage file
    fn parse_lcov_file(&self, lcov_file: &str) -> Result<CoverageSummary, String> {
        println!("📊 Parsing coverage report...");

        let content = fs::read_to_string(lcov_file)
            .map_err(|e| format!("Failed to read lcov file: {}", e))?;

        let mut total_lines = 0;
        let mut covered_lines = 0;
        let mut total_branches = 0;
        let mut covered_branches = 0;

        // LCOV format:
        // DA:line,count (line coverage)
        // BRDA:line,block,branch,taken (branch coverage)
        for line in content.lines() {
            if line.starts_with("DA:") {
                let parts: Vec<&str> = line.strip_prefix("DA:").unwrap().split(',').collect();
                if parts.len() >= 2 {
                    if let Ok(count) = parts[1].parse::<usize>() {
                        total_lines += 1;
                        if count > 0 {
                            covered_lines += 1;
                        }
                    }
                }
            } else if line.starts_with("BRDA:") {
                let parts: Vec<&str> = line.strip_prefix("BRDA:").unwrap().split(',').collect();
                if parts.len() >= 4 {
                    total_branches += 1;
                    if parts[3] != "-" && parts[3] != "0" {
                        covered_branches += 1;
                    }
                }
            }
        }

        if total_lines == 0 {
            return Err("No coverage data found in lcov file".to_string());
        }

        let coverage_percentage = (covered_lines as f64 / total_lines as f64) * 100.0;

        let branch_percentage = if total_branches > 0 {
            Some((covered_branches as f64 / total_branches as f64) * 100.0)
        } else {
            None
        };

        Ok(CoverageSummary {
            total_lines,
            covered_lines,
            coverage_percentage,
            total_branches: if total_branches > 0 {
                Some(total_branches)
            } else {
                None
            },
            covered_branches: if total_branches > 0 {
                Some(covered_branches)
            } else {
                None
            },
            branch_percentage,
        })
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_runtime_coverage_new() {
        let coverage = CppRuntimeCoverage::new();
        assert_eq!(std::mem::size_of_val(&coverage), 0);
    }

    #[test]
    fn test_runtime_coverage_default() {
        let coverage = CppRuntimeCoverage;
        assert_eq!(std::mem::size_of_val(&coverage), 0);
    }
}