decy 2.2.0

CLI tool for C-to-Rust transpilation with EXTREME quality standards
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

//! CLI Testing Tools
//!
//! Shared helpers for CLI contract testing.
//! Provides common utilities for creating test files, running commands, and assertions.
//!
//! **Pattern**: Following ruchy's proven CLI testing approach
//! **Reference**: CLAUDE.md CLI Contract Testing section

use assert_cmd::Command;
use std::fs;
use std::path::PathBuf;
use tempfile::TempDir;

/// Helper: Create decy command
#[allow(deprecated)]
pub fn decy_cmd() -> Command {
    Command::cargo_bin("decy").expect("Failed to find decy binary")
}

/// Helper: Create temp file with content
pub fn create_temp_file(dir: &TempDir, name: &str, content: &str) -> PathBuf {
    let path = dir.path().join(name);
    fs::write(&path, content).expect("Failed to write temp file");
    path
}

/// Helper: Create temp directory with files
pub fn create_temp_dir_with_files(files: &[(&str, &str)]) -> TempDir {
    let dir = TempDir::new().expect("Failed to create temp dir");
    for (name, content) in files {
        create_temp_file(&dir, name, content);
    }
    dir
}

/// Sample valid C code for testing
#[allow(dead_code)]
pub const VALID_C_CODE: &str = r#"
int main() {
    return 0;
}
"#;

/// Sample C code with syntax error
#[allow(dead_code)]
pub const INVALID_C_CODE: &str = r#"
int main( {
    return 0;
}
"#;

/// Sample C code with functions
#[allow(dead_code)]
pub const C_WITH_FUNCTION: &str = r#"
int add(int a, int b) {
    return a + b;
}

int main() {
    int result = add(2, 3);
    return result;
}
"#;

/// Sample C code with pointers
#[allow(dead_code)]
pub const C_WITH_POINTERS: &str = r#"
void increment(int* ptr) {
    (*ptr)++;
}

int main() {
    int x = 5;
    increment(&x);
    return x;
}
"#;

/// Sample C code with malloc/free
#[allow(dead_code)]
pub const C_WITH_MALLOC: &str = r#"
#include <stdlib.h>

int main() {
    int* ptr = (int*)malloc(sizeof(int));
    *ptr = 42;
    free(ptr);
    return 0;
}
"#;

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

    #[test]
    fn test_decy_cmd_exists() {
        // Should be able to create command
        let _cmd = decy_cmd();
    }

    #[test]
    fn test_create_temp_file() {
        let dir = TempDir::new().unwrap();
        let path = create_temp_file(&dir, "test.c", "int main() { return 0; }");

        assert!(path.exists());
        let content = fs::read_to_string(&path).unwrap();
        assert!(content.contains("int main"));
    }

    #[test]
    fn test_create_temp_dir_with_files() {
        let files = vec![("file1.c", "int x = 1;"), ("file2.c", "int y = 2;")];
        let dir = create_temp_dir_with_files(&files);

        assert!(dir.path().join("file1.c").exists());
        assert!(dir.path().join("file2.c").exists());
    }
}