use std::io::Write;
use std::path::PathBuf;
use std::process::Command;
fn rustrip_bin() -> PathBuf {
PathBuf::from(env!("CARGO_BIN_EXE_rustrip"))
}
#[test]
fn cli_version_prints_pkg_version() {
let out = Command::new(rustrip_bin())
.arg("--version")
.output()
.expect("run rustrip --version");
assert!(
out.status.success(),
"{:?}",
String::from_utf8_lossy(&out.stderr)
);
let s = String::from_utf8_lossy(&out.stdout);
assert!(
s.contains(env!("CARGO_PKG_VERSION")),
"version output {s:?} does not contain pkg version"
);
}
#[test]
fn cli_help_contains_killer_tagline() {
let out = Command::new(rustrip_bin())
.arg("--help")
.output()
.expect("run rustrip --help");
assert!(
out.status.success(),
"stderr: {:?}",
String::from_utf8_lossy(&out.stderr)
);
let combined =
String::from_utf8_lossy(&out.stdout).into_owned() + &String::from_utf8_lossy(&out.stderr);
assert!(
combined.contains("Make stripped Rust binaries readable again"),
"tagline missing from --help"
);
}
#[test]
fn cli_on_self_binary_produces_table_output() {
let exe = rustrip_bin();
let out = Command::new(&exe)
.arg(&exe)
.arg("-f")
.arg("table")
.output()
.expect("run rustrip self-analysis table");
assert!(
out.status.success(),
"stderr: {:?}",
String::from_utf8_lossy(&out.stderr)
);
let s = String::from_utf8_lossy(&out.stdout);
assert!(s.contains("vaddr"), "no vaddr header: {s:?}");
assert!(
s.lines().nth(2).is_some(),
"self-analysis table must contain at least one annotation: {s:?}"
);
}
#[test]
fn cli_selective_flags_all_combinatorial() {
let exe = rustrip_bin();
let cases: &[&[&str]] = &[
&["--no-strings"],
&["--no-symbols"],
&["--no-panics"],
&["--no-strings", "--no-symbols"],
&["--no-strings", "--no-panics"],
&["--no-symbols", "--no-panics"],
&["--no-strings", "--no-symbols", "--no-panics"],
];
let run_json = |flags: &[&str]| {
let mut cmd = Command::new(&exe);
cmd.arg(&exe).arg("-f").arg("json");
for flag in flags {
cmd.arg(flag);
}
let out = cmd.output().expect("run rustrip selective");
assert!(
out.status.success(),
"flag combination {flags:?} failed. stderr: {:?}",
String::from_utf8_lossy(&out.stderr)
);
out.stdout
};
let baseline = run_json(&[]);
let baseline: serde_json::Value = serde_json::from_slice(&baseline).expect("baseline JSON");
let baseline = baseline.as_array().expect("baseline JSON array");
for flags in cases {
let stdout = run_json(flags);
if flags.len() == 3 {
assert_eq!(
stdout, b"[]\n",
"all analyzers disabled must produce exactly an empty JSON array"
);
}
let annotations: serde_json::Value =
serde_json::from_slice(&stdout).expect("selective JSON");
let annotations = annotations.as_array().expect("selective JSON array");
for (flag, kind) in [
("--no-strings", "string"),
("--no-symbols", "symbol"),
("--no-panics", "panic"),
] {
let disabled = flags.contains(&flag);
let baseline_has_kind = baseline.iter().any(|annotation| {
annotation.get("kind").and_then(serde_json::Value::as_str) == Some(kind)
});
if disabled && baseline_has_kind {
assert!(
annotations.iter().all(|annotation| {
annotation.get("kind").and_then(serde_json::Value::as_str) != Some(kind)
}),
"{flag} must remove externally observable {kind} annotations: {annotations:?}"
);
}
}
}
}
#[test]
fn cli_format_aliases_all_accepted() {
let exe = rustrip_bin();
let aliases = [
"text",
"json",
"cli",
"ghidra",
"ghidra-py",
"py-ghidra",
"binja",
"binary-ninja",
"bn",
"py-binja",
];
for alias in aliases {
let mut cmd = Command::new(&exe);
cmd.arg(&exe).arg("-f").arg(alias);
let out = cmd.output().expect("run rustrip with alias");
assert!(
out.status.success(),
"alias {alias} failed: stderr: {:?}",
String::from_utf8_lossy(&out.stderr)
);
}
}
#[test]
fn cli_format_unknown_non_zero_exit() {
let exe = rustrip_bin();
let out = Command::new(&exe)
.arg(&exe)
.arg("-f")
.arg("garbage-format")
.output()
.expect("run rustrip with bad format");
assert!(
!out.status.success(),
"garbage --format should fail; stderr: {:?}",
String::from_utf8_lossy(&out.stderr)
);
let stderr = String::from_utf8_lossy(&out.stderr).to_lowercase();
assert!(
stderr.contains("invalid value") && stderr.contains("--format"),
"unknown format must be rejected as an argument: {stderr:?}"
);
}
#[test]
fn cli_missing_path_non_zero_exit() {
let exe = rustrip_bin();
let dir = tempfile::tempdir().expect("tempdir");
let missing = dir.path().join("does-not-exist.bin");
let out = Command::new(&exe)
.arg(&missing)
.output()
.expect("run rustrip with missing path");
assert!(
!out.status.success(),
"missing path should error; stderr: {:?}",
String::from_utf8_lossy(&out.stderr)
);
let stderr = String::from_utf8_lossy(&out.stderr);
assert!(
stderr.to_lowercase().contains("opening") || stderr.to_lowercase().contains("path"),
"stderr should mention the path/IO: {stderr:?}"
);
}
#[test]
fn cli_reads_from_stdin_via_dash() {
let mut child = Command::new(rustrip_bin())
.arg("-")
.arg("-f")
.arg("text")
.stdin(std::process::Stdio::piped())
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::piped())
.spawn()
.expect("spawn rustrip with stdin");
let mut stdin = child.stdin.take().expect("stdin handle");
stdin
.write_all(&std::fs::read(rustrip_bin()).expect("read self binary"))
.expect("stdin write");
drop(stdin);
let out = child.wait_with_output().expect("wait rustrip");
assert!(
out.status.success(),
"stdin self-analysis failed; stderr: {:?}",
String::from_utf8_lossy(&out.stderr)
);
}
#[test]
fn cli_max_string_len_zero_disables_string_backed_recovery() {
let exe = rustrip_bin();
let out = Command::new(&exe)
.arg(&exe)
.arg("-f")
.arg("json")
.arg("--max-string-len")
.arg("0")
.output()
.expect("run rustrip max-string-len=0");
assert!(
out.status.success(),
"max-string-len=0 should run cleanly; stderr: {:?}",
String::from_utf8_lossy(&out.stderr)
);
let annotations: serde_json::Value =
serde_json::from_slice(&out.stdout).expect("max-string-len=0 JSON parses");
let annotations = annotations.as_array().expect("top-level JSON array");
assert!(
annotations.iter().all(|annotation| {
!matches!(
annotation.get("kind").and_then(serde_json::Value::as_str),
Some("string" | "panic")
)
}),
"max-string-len=0 must suppress string and panic recovery: {annotations:?}"
);
}
#[test]
fn cli_output_file_writes_table_to_disk_without_stdout() {
let dir = tempfile::tempdir().expect("tempdir");
let out_path = dir.path().join("rustrip-table.txt");
let exe = rustrip_bin();
let out = Command::new(&exe)
.arg(&exe)
.arg("-f")
.arg("table")
.arg("-o")
.arg(&out_path)
.output()
.expect("run rustrip -o table");
assert!(
out.status.success(),
"stderr: {:?}",
String::from_utf8_lossy(&out.stderr)
);
assert!(
out.stdout.is_empty(),
"-o must suppress rendered stdout: {:?}",
String::from_utf8_lossy(&out.stdout)
);
let on_disk = std::fs::read_to_string(&out_path).expect("read output");
assert!(
on_disk.contains("vaddr"),
"no vaddr header on disk: {on_disk:?}"
);
}
#[test]
fn cli_invalid_input_does_not_create_output_file() {
let dir = tempfile::tempdir().expect("tempdir");
let invalid = dir.path().join("truncated-elf.bin");
let output = dir.path().join("report.json");
std::fs::write(&invalid, b"\x7fELF").expect("write truncated ELF magic");
let out = Command::new(rustrip_bin())
.arg(&invalid)
.arg("-f")
.arg("json")
.arg("-o")
.arg(&output)
.output()
.expect("run rustrip with invalid input and output path");
assert!(
!out.status.success(),
"invalid input must fail before rendering; stderr: {:?}",
String::from_utf8_lossy(&out.stderr)
);
assert!(
!output.exists(),
"invalid input must not create an output file: {}",
output.display()
);
}
#[test]
fn cli_output_file_writes_json_to_disk() {
let dir = tempfile::tempdir().expect("tempdir");
let out_path = dir.path().join("rustrip-report.json");
let exe = rustrip_bin();
let out = Command::new(&exe)
.arg(&exe)
.arg("-f")
.arg("json")
.arg("-o")
.arg(&out_path)
.output()
.expect("run rustrip -o json");
assert!(
out.status.success(),
"stderr: {:?}",
String::from_utf8_lossy(&out.stderr)
);
let on_disk = std::fs::read_to_string(&out_path).expect("read json");
let parsed: serde_json::Value = serde_json::from_str(&on_disk).expect("json parses");
assert!(parsed.is_array(), "top-level must be array");
}
#[test]
fn cli_output_file_writes_ghidra_python_to_disk() {
let dir = tempfile::tempdir().expect("tempdir");
let out_path = dir.path().join("rustrip-report_ghidra.py");
let exe = rustrip_bin();
let out = Command::new(&exe)
.arg(&exe)
.arg("-f")
.arg("ghidra")
.arg("-o")
.arg(&out_path)
.output()
.expect("run rustrip -o ghidra");
assert!(
out.status.success(),
"stderr: {:?}",
String::from_utf8_lossy(&out.stderr)
);
let on_disk = std::fs::read_to_string(&out_path).expect("read ghidra py");
assert!(on_disk.contains("currentProgram"));
assert!(on_disk.contains("_comments"));
}
#[test]
fn cli_output_file_writes_binja_python_to_disk() {
let dir = tempfile::tempdir().expect("tempdir");
let out_path = dir.path().join("rustrip-report_binja.py");
let exe = rustrip_bin();
let out = Command::new(&exe)
.arg(&exe)
.arg("-f")
.arg("binja")
.arg("-o")
.arg(&out_path)
.output()
.expect("run rustrip -o binja");
assert!(
out.status.success(),
"stderr: {:?}",
String::from_utf8_lossy(&out.stderr)
);
let on_disk = std::fs::read_to_string(&out_path).expect("read binja py");
assert!(on_disk.contains("binaryninja"));
assert!(on_disk.contains("_labels"));
}
#[test]
fn cli_output_same_path_is_rejected_without_modifying_input() {
let dir = tempfile::tempdir().expect("tempdir");
let input = dir.path().join("input-binary");
let original = std::fs::read(rustrip_bin()).expect("read self binary");
std::fs::write(&input, &original).expect("write input copy");
let out = Command::new(rustrip_bin())
.arg(&input)
.arg("-f")
.arg("json")
.arg("-o")
.arg(&input)
.output()
.expect("run rustrip with identical output");
assert!(!out.status.success(), "same-path output must be rejected");
assert_eq!(std::fs::read(&input).expect("read input"), original);
}
#[cfg(unix)]
#[test]
fn cli_output_symlink_to_input_is_rejected_without_modifying_input() {
use std::os::unix::fs::symlink;
let dir = tempfile::tempdir().expect("tempdir");
let input = dir.path().join("input-binary");
let output = dir.path().join("output-link");
let original = std::fs::read(rustrip_bin()).expect("read self binary");
std::fs::write(&input, &original).expect("write input copy");
symlink(&input, &output).expect("create output symlink");
let out = Command::new(rustrip_bin())
.arg(&input)
.arg("-f")
.arg("json")
.arg("-o")
.arg(&output)
.output()
.expect("run rustrip with symlink output");
assert!(!out.status.success(), "symlink alias must be rejected");
assert_eq!(std::fs::read(&input).expect("read input"), original);
}
#[test]
fn cli_output_hardlink_to_input_is_rejected_without_modifying_input() {
let dir = tempfile::tempdir().expect("tempdir");
let input = dir.path().join("input-binary");
let output = dir.path().join("output-hardlink");
let original = std::fs::read(rustrip_bin()).expect("read self binary");
std::fs::write(&input, &original).expect("write input copy");
std::fs::hard_link(&input, &output).expect("create output hardlink");
let out = Command::new(rustrip_bin())
.arg(&input)
.arg("-f")
.arg("json")
.arg("-o")
.arg(&output)
.output()
.expect("run rustrip with hardlink output");
assert!(!out.status.success(), "hardlink alias must be rejected");
assert_eq!(std::fs::read(&input).expect("read input"), original);
assert_eq!(std::fs::read(&output).expect("read hardlink"), original);
}
#[test]
fn cli_existing_output_is_rejected_without_modifying_contents() {
let dir = tempfile::tempdir().expect("tempdir");
let output = dir.path().join("existing-output.json");
let original = b"old contents";
std::fs::write(&output, original).expect("write existing output");
let out = Command::new(rustrip_bin())
.arg(rustrip_bin())
.arg("-f")
.arg("json")
.arg("-o")
.arg(&output)
.output()
.expect("run rustrip with existing output");
assert!(!out.status.success(), "existing output must be rejected");
assert_eq!(std::fs::read(&output).expect("read output"), original);
}
#[test]
fn cli_tiny_binary_bails_with_friendly_message() {
let dir = tempfile::tempdir().expect("tempdir");
let tiny = dir.path().join("tiny.bin");
std::fs::write(&tiny, [0u8, 0, 0]).expect("write tiny");
let exe = rustrip_bin();
let out = Command::new(&exe)
.arg(&tiny)
.arg("-f")
.arg("text")
.output()
.expect("run rustrip tiny");
assert!(
!out.status.success(),
"tiny input should fail; stderr: {:?}",
String::from_utf8_lossy(&out.stderr)
);
let stderr = String::from_utf8_lossy(&out.stderr).to_lowercase();
assert!(
stderr.contains("too small") || stderr.contains("small"),
"stderr should mention 'too small': {stderr:?}"
);
}
#[test]
fn cli_four_byte_or_larger_does_not_bail_tiny() {
let dir = tempfile::tempdir().expect("tempdir");
let tiny = dir.path().join("four.bin");
std::fs::write(&tiny, [0x7f, b'E', b'L', b'F']).expect("write ELF magic");
let exe = rustrip_bin();
let out = Command::new(&exe)
.arg(&tiny)
.arg("-f")
.arg("text")
.output()
.expect("run rustrip 4-byte ELF magic");
let stderr = String::from_utf8_lossy(&out.stderr).to_lowercase();
assert!(
!stderr.contains("binary too small"),
"4-byte ELF magic should not hit rustrip's tiny-file bail: {stderr:?}"
);
}
#[test]
fn cli_max_string_len_accepts_non_default_limit() {
let exe = rustrip_bin();
let out = Command::new(&exe)
.arg(&exe)
.arg("-f")
.arg("json")
.arg("--max-string-len")
.arg("8")
.output()
.expect("run rustrip --max-string-len");
assert!(
out.status.success(),
"non-default --max-string-len failed: {:?}",
String::from_utf8_lossy(&out.stderr)
);
let parsed: serde_json::Value = serde_json::from_slice(&out.stdout).expect("json parses");
assert!(parsed.is_array());
}