[cc] integration test matrix

Author: jgarzik

cc/Cargo.toml

@@ -16,6 +16,10 @@ plib = { path = "../plib" }
 [dev-dependencies]
 tempfile = "3"
 
+[features]
+# Enable full compile matrix (4 configs) instead of default single config (-O -g)
+test_matrix = []
+
 [lib]
 name = "posixutils_cc"
 path = "./lib.rs"

cc/tests/common/mod.rs

@@ -15,6 +15,28 @@ use std::path::PathBuf;
 use std::process::Command;
 use tempfile::NamedTempFile;
 
+// ============================================================================
+// Compile Matrix Configuration
+// ============================================================================
+
+/// Full compile matrix (enabled with --features test_matrix).
+/// Tests all 4 configurations: default, debug-only, optimized-only, and both.
+#[cfg(feature = "test_matrix")]
+pub const COMPILE_MATRIX: &[(&str, &[&str])] = &[
+    ("default", &[]),
+    ("debug", &["-g"]),
+    ("optimized", &["-O"]),
+    ("debug_opt", &["-g", "-O"]),
+];
+
+/// Default compile config: -O -g only (fastest while still catching optimization bugs).
+#[cfg(not(feature = "test_matrix"))]
+pub const COMPILE_MATRIX: &[(&str, &[&str])] = &[("debug_opt", &["-g", "-O"])];
+
+// ============================================================================
+// File Path Utilities
+// ============================================================================
+
 /// Get path to a test input file in a specific test directory
 pub fn get_test_file_path(test_dir: &str, filename: &str) -> PathBuf {
     let mut path = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
@@ -37,23 +59,31 @@ pub fn create_c_file(name: &str, content: &str) -> NamedTempFile {
     file
 }
 
+// ============================================================================
+// Low-level Compile/Run Utilities (for backward compatibility)
+// ============================================================================
+
 /// Compile a C file using pcc and return the path to the executable
 /// The executable is placed in temp dir and must be cleaned up by caller
+#[allow(dead_code)]
 pub fn compile(c_file: &PathBuf) -> Option<PathBuf> {
+    compile_with_opts(c_file, &[])
+}
+
+/// Compile a C file with extra options
+pub fn compile_with_opts(c_file: &PathBuf, extra_opts: &[&str]) -> Option<PathBuf> {
+    let thread_id = format!("{:?}", std::thread::current().id());
     let exe_path = std::env::temp_dir().join(format!(
-        "pcc_exe_{}",
-        c_file.file_stem().unwrap().to_string_lossy()
+        "pcc_exe_{}_{}",
+        c_file.file_stem().unwrap().to_string_lossy(),
+        thread_id.replace(|c: char| !c.is_alphanumeric(), "_")
     ));
 
-    let output = run_test_base(
-        "pcc",
-        &vec![
-            "-o".to_string(),
-            exe_path.to_string_lossy().to_string(),
-            c_file.to_string_lossy().to_string(),
-        ],
-        &[],
-    );
+    let mut args = vec!["-o".to_string(), exe_path.to_string_lossy().to_string()];
+    args.extend(extra_opts.iter().map(|s| s.to_string()));
+    args.push(c_file.to_string_lossy().to_string());
+
+    let output = run_test_base("pcc", &args, &[]);
 
     if output.status.success() {
         Some(exe_path)
@@ -64,6 +94,7 @@ pub fn compile(c_file: &PathBuf) -> Option<PathBuf> {
 }
 
 /// Compile a C file from a specific test directory
+#[allow(dead_code)]
 pub fn compile_test_file(test_dir: &str, filename: &str) -> Option<PathBuf> {
     let c_file = get_test_file_path(test_dir, filename);
     compile(&c_file)
@@ -89,34 +120,33 @@ pub fn run_with_output(exe: &PathBuf) -> (i32, String) {
 }
 
 /// Clean up an executable file
+#[allow(dead_code)]
 pub fn cleanup_exe(exe_file: &Option<PathBuf>) {
     if let Some(exe) = exe_file {
         let _ = std::fs::remove_file(exe);
     }
 }
 
-/// Compile inline C code and run, returning exit code
-/// Temp files are cleaned up automatically via tempfile
-pub fn compile_and_run(name: &str, content: &str) -> i32 {
-    compile_and_run_with_opts(name, content, &[])
-}
-
-/// Compile inline C code with optimization and run, returning exit code
-pub fn compile_and_run_optimized(name: &str, content: &str) -> i32 {
-    compile_and_run_with_opts(name, content, &["-O1".to_string()])
-}
+// ============================================================================
+// Matrix-aware Compile and Run (main API)
+// ============================================================================
 
-/// Compile inline C code with extra options and run, returning exit code
-/// Temp files are cleaned up automatically via tempfile
-pub fn compile_and_run_with_opts(name: &str, content: &str, extra_opts: &[String]) -> i32 {
+/// Internal: Compile and run with a single specific configuration (no matrix loop)
+fn compile_and_run_single(
+    name: &str,
+    content: &str,
+    extra_opts: &[String],
+    config_name: &str,
+) -> i32 {
     let c_file = create_c_file(name, content);
     let c_path = c_file.path().to_path_buf();
 
-    // Use thread ID to make exe path unique for parallel test execution
+    // Use thread ID and config name to make exe path unique for parallel test execution
     let thread_id = format!("{:?}", std::thread::current().id());
     let exe_path = std::env::temp_dir().join(format!(
-        "pcc_exe_{}_{}",
+        "pcc_exe_{}_{}_{}",
         name,
+        config_name,
         thread_id.replace(|c: char| !c.is_alphanumeric(), "_")
     ));
 
@@ -128,8 +158,9 @@ pub fn compile_and_run_with_opts(name: &str, content: &str, extra_opts: &[String
 
     if !output.status.success() {
         eprintln!(
-            "pcc compilation failed for {}:\n{}",
+            "pcc compilation failed for {} [config: {}]:\n{}",
             name,
+            config_name,
             String::from_utf8_lossy(&output.stderr)
         );
         return -1;
@@ -146,3 +177,100 @@ pub fn compile_and_run_with_opts(name: &str, content: &str, extra_opts: &[String
 
     exit_code
 }
+
+/// Compile inline C code with extra options and run with all matrix configurations.
+/// Returns 0 if all configurations pass, or the first non-zero exit code on failure.
+pub fn compile_and_run_with_opts(name: &str, content: &str, extra_opts: &[String]) -> i32 {
+    for (config_name, matrix_flags) in COMPILE_MATRIX {
+        // Combine matrix flags with caller's extra options
+        let mut combined: Vec<String> = matrix_flags.iter().map(|s| s.to_string()).collect();
+        combined.extend(extra_opts.iter().cloned());
+
+        let result = compile_and_run_single(name, content, &combined, config_name);
+        if result != 0 {
+            eprintln!(
+                "Test '{}' FAILED with config '{}': exit code {}",
+                name, config_name, result
+            );
+            return result;
+        }
+    }
+    0
+}
+
+/// Compile inline C code and run with all matrix configurations.
+/// Returns 0 if all configurations pass, or the first non-zero exit code on failure.
+pub fn compile_and_run(name: &str, content: &str) -> i32 {
+    compile_and_run_with_opts(name, content, &[])
+}
+
+/// Compile inline C code with optimization and run (single config, skips matrix).
+/// This is used by tests that specifically test optimization behavior.
+pub fn compile_and_run_optimized(name: &str, content: &str) -> i32 {
+    compile_and_run_single(name, content, &["-O1".to_string()], "optimized_only")
+}
+
+// ============================================================================
+// Matrix-aware File-based Compile and Run
+// ============================================================================
+
+/// Compile and run a fixed .c file with all matrix configurations.
+/// Returns the exit code (0 if all pass, first non-zero on failure).
+pub fn compile_and_run_file(test_dir: &str, filename: &str) -> i32 {
+    let c_file = get_test_file_path(test_dir, filename);
+
+    for (config_name, matrix_flags) in COMPILE_MATRIX {
+        let exe = compile_with_opts(&c_file, matrix_flags);
+        if exe.is_none() {
+            eprintln!(
+                "Compilation failed for {}/{} [config: {}]",
+                test_dir, filename, config_name
+            );
+            return -1;
+        }
+
+        let exit_code = run(exe.as_ref().unwrap());
+        cleanup_exe(&exe);
+
+        if exit_code != 0 {
+            eprintln!(
+                "Test {}/{} FAILED with config '{}': exit code {}",
+                test_dir, filename, config_name, exit_code
+            );
+            return exit_code;
+        }
+    }
+    0
+}
+
+/// Compile and run a fixed .c file with all matrix configurations, capturing stdout.
+/// Returns (exit_code, stdout) where exit_code is 0 if all configs pass.
+/// The stdout returned is from the last successful run (or the failing run).
+pub fn compile_and_run_file_with_output(test_dir: &str, filename: &str) -> (i32, String) {
+    let c_file = get_test_file_path(test_dir, filename);
+    let mut last_stdout = String::new();
+
+    for (config_name, matrix_flags) in COMPILE_MATRIX {
+        let exe = compile_with_opts(&c_file, matrix_flags);
+        if exe.is_none() {
+            eprintln!(
+                "Compilation failed for {}/{} [config: {}]",
+                test_dir, filename, config_name
+            );
+            return (-1, last_stdout);
+        }
+
+        let (exit_code, stdout) = run_with_output(exe.as_ref().unwrap());
+        last_stdout = stdout;
+        cleanup_exe(&exe);
+
+        if exit_code != 0 {
+            eprintln!(
+                "Test {}/{} FAILED with config '{}': exit code {}",
+                test_dir, filename, config_name, exit_code
+            );
+            return (exit_code, last_stdout);
+        }
+    }
+    (0, last_stdout)
+}