use std::io::Write as _;
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::sync::atomic::{AtomicBool, Ordering};
use std::time::{Duration, Instant};
static CMP_STDERR: AtomicBool = AtomicBool::new(false);
struct Rng(u64);
impl Rng {
fn seed(s: u64) -> Rng {
Rng(s ^ 0x9E37_79B9_7F4A_7C15)
}
fn next_u64(&mut self) -> u64 {
self.0 = self.0.wrapping_add(0x9E37_79B9_7F4A_7C15);
let mut z = self.0;
z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
z ^ (z >> 31)
}
fn below(&mut self, n: usize) -> usize {
(self.next_u64() % n as u64) as usize
}
fn range(&mut self, lo: i64, hi: i64) -> i64 {
lo + (self.next_u64() % (hi - lo + 1) as u64) as i64
}
fn pick<'a, T>(&mut self, xs: &'a [T]) -> &'a T {
&xs[self.below(xs.len())]
}
}
fn ours_bin() -> PathBuf {
if let Ok(p) = std::env::var("CARGO_BIN_EXE_Rscript") {
return PathBuf::from(p);
}
if let Ok(exe) = std::env::current_exe() {
if let Some(dir) = exe.parent() {
let cand = dir.join("Rscript");
if cand.exists() {
return cand;
}
}
}
PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("target")
.join("debug")
.join("Rscript")
}
fn oracle_path() -> &'static str {
static ORACLE: std::sync::OnceLock<String> = std::sync::OnceLock::new();
ORACLE.get_or_init(|| {
if let Ok(p) = std::env::var("RLANG_FUZZ_RSCRIPT") {
if !Path::new(&p).exists() {
eprintln!("parity-fuzz: RLANG_FUZZ_RSCRIPT={p}: no such file");
std::process::exit(2);
}
return p;
}
for p in [
"/opt/homebrew/bin/Rscript",
"/usr/local/bin/Rscript",
"/usr/bin/Rscript",
] {
if Path::new(p).exists() {
return p.to_string();
}
}
"Rscript".to_string()
})
}
fn oracle_id() -> String {
let path = oracle_path();
let ver = Command::new(path)
.arg("--version")
.output()
.ok()
.filter(|o| o.status.success())
.map(|o| {
let s = if o.stdout.is_empty() {
&o.stderr
} else {
&o.stdout
};
String::from_utf8_lossy(s)
.lines()
.next()
.unwrap_or("")
.trim()
.to_string()
})
.filter(|s| !s.is_empty())
.unwrap_or_else(|| "unknown".to_string());
format!("{path} ({ver})")
}
fn ours_home() -> PathBuf {
PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("target")
.join("parity-fuzz")
.join("home")
}
struct RunOut {
stdout: Vec<u8>,
stderr: Vec<u8>,
exit: i32,
timed_out: bool,
}
fn render(bytes: &[u8]) -> String {
let text = String::from_utf8_lossy(bytes);
let text = text.trim_end_matches('\n');
if std::str::from_utf8(bytes).is_err() {
let hex: Vec<String> = bytes.iter().map(|b| format!("{b:02x}")).collect();
return format!("{text}\n (hex) {}", hex.join(" "));
}
text.to_string()
}
fn norm_stderr(s: &[u8]) -> Vec<u8> {
let text = String::from_utf8_lossy(s);
let mut out: Vec<String> = Vec::new();
let mut skip_warning = false;
for line in text.split('\n') {
let l = line.trim_end();
if l == "Execution halted" || l.is_empty() {
continue;
}
if l.starts_with("Warning message") || l.starts_with("Warning messages") {
skip_warning = true;
continue;
}
if skip_warning {
if l.starts_with(' ') || l.starts_with('\t') {
continue;
}
skip_warning = false;
}
let l = if let Some(rest) = l.strip_prefix("Error") {
match rest.find(':') {
Some(idx) => rest[idx + 1..].trim(),
None => rest.trim(),
}
} else {
l
};
let l = l.strip_prefix("Rscript: ").unwrap_or(l);
out.push(l.trim().to_string());
}
out.join("\n").into_bytes()
}
fn differs(a: &RunOut, b: &RunOut) -> bool {
if a.stdout != b.stdout || a.exit != b.exit {
return true;
}
if CMP_STDERR.load(Ordering::Relaxed) {
return norm_stderr(&a.stderr) != norm_stderr(&b.stderr);
}
false
}
fn no_signal(a: &RunOut, b: &RunOut) -> bool {
if !a.stdout.is_empty() || !b.stdout.is_empty() {
return false;
}
if CMP_STDERR.load(Ordering::Relaxed)
&& (!norm_stderr(&a.stderr).is_empty() || !norm_stderr(&b.stderr).is_empty())
{
return false;
}
true
}
fn run_with_timeout(mut cmd: Command, timeout: Duration) -> RunOut {
cmd.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped());
let mut child = match cmd.spawn() {
Ok(c) => c,
Err(_) => {
return RunOut {
stdout: Vec::new(),
stderr: Vec::new(),
exit: -999,
timed_out: false,
}
}
};
let start = Instant::now();
loop {
match child.try_wait() {
Ok(Some(status)) => {
use std::io::Read;
let mut buf = Vec::new();
if let Some(mut out) = child.stdout.take() {
let _ = out.read_to_end(&mut buf);
}
let mut ebuf = Vec::new();
if let Some(mut err) = child.stderr.take() {
let _ = err.read_to_end(&mut ebuf);
}
return RunOut {
stdout: buf,
stderr: ebuf,
exit: status.code().unwrap_or(-1),
timed_out: false,
};
}
Ok(None) => {
if start.elapsed() >= timeout {
let _ = child.kill();
let _ = child.wait();
return RunOut {
stdout: Vec::new(),
stderr: Vec::new(),
exit: -1,
timed_out: true,
};
}
std::thread::sleep(Duration::from_millis(2));
}
Err(_) => {
return RunOut {
stdout: Vec::new(),
stderr: Vec::new(),
exit: -998,
timed_out: false,
}
}
}
}
}
fn run_oracle(script: &str, timeout: Duration) -> RunOut {
let mut cmd = Command::new(oracle_path());
cmd.args(["--vanilla", "-e", script]);
run_with_timeout(cmd, timeout)
}
fn run_file(path: &Path, ours: Option<&Path>, timeout: Duration) -> RunOut {
let mut cmd;
match ours {
Some(bin) => {
cmd = Command::new(bin);
cmd.arg(path);
cmd.env("RLANG_NO_CRAN", "1");
cmd.env("HOME", ours_home());
}
None => {
cmd = Command::new(oracle_path());
cmd.arg("--vanilla").arg(path);
}
}
run_with_timeout(cmd, timeout)
}
fn run_ours(script: &str, bin: &Path, timeout: Duration) -> RunOut {
let mut cmd = Command::new(bin);
cmd.args(["-e", script]);
cmd.env("RLANG_NO_CRAN", "1");
cmd.env("HOME", ours_home());
run_with_timeout(cmd, timeout)
}
const INTS: &[&str] = &["0", "1", "2", "3", "5", "7", "10", "42", "100"];
const NEG_INTS: &[&str] = &["-1", "-2", "-3", "-7", "-10"];
const DBLS: &[&str] = &[
"0.5", "1.5", "2.25", "3.14", "10.0", "0.1", "0.333", "100.25",
];
const WORDS: &[&str] = &["foo", "bar", "baz", "hello", "world", "abc", "xyz", "quux"];
fn ii<'a>(r: &mut Rng) -> &'a str {
r.pick(INTS)
}
fn si<'a>(r: &mut Rng) -> &'a str {
if r.below(2) == 0 {
r.pick(INTS)
} else {
r.pick(NEG_INTS)
}
}
fn ff<'a>(r: &mut Rng) -> &'a str {
r.pick(DBLS)
}
fn ww<'a>(r: &mut Rng) -> &'a str {
r.pick(WORDS)
}
fn one(s: String) -> Vec<String> {
vec![s]
}
fn vec_int(r: &mut Rng) -> String {
let n = r.range(3, 5) as usize;
let items: Vec<&str> = (0..n).map(|_| si(r)).collect();
format!("c({})", items.join(", "))
}
fn vec_dbl(r: &mut Rng) -> String {
let n = r.range(3, 5) as usize;
let items: Vec<&str> = (0..n).map(|_| ff(r)).collect();
format!("c({})", items.join(", "))
}
fn vec_str(r: &mut Rng) -> String {
let n = r.range(3, 4) as usize;
let items: Vec<String> = (0..n).map(|_| format!("\"{}\"", ww(r))).collect();
format!("c({})", items.join(", "))
}
fn gen_arith(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let ops = ["+", "-", "*", "/", "%%", "%/%"];
let a = ii(r);
let b = si(r);
let c = si(r);
let op1 = r.pick(&ops);
let op2 = r.pick(&ops);
one(match r.below(6) {
0 => format!("{a} {op1} {b} {op2} {c}"),
1 => format!("({a} {op1} {b}) {op2} {c}"),
2 => format!("{a}L {op1} {b}L"),
3 => format!("abs({b} {op1} {c})"),
4 => format!("{a} ^ {} {op1} {b}", r.range(0, 5)),
_ => format!("({a} + 0.0) {op1} {b}"),
})
}
fn gen_numfmt(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let a = ff(r);
let b = ff(r);
one(match r.below(8) {
0 => format!("{a} / {b}"),
1 => format!("round({a} * pi, {})", r.range(0, 6)),
2 => format!("signif({a} * {b}, {})", r.range(1, 6)),
3 => format!("format({a} / {b}, nsmall = {})", r.range(0, 5)),
4 => format!("c({a}, {b}, {a} * {b})"),
5 => format!(
"formatC({a} / {b}, digits = {}, format = \"f\")",
r.range(0, 5)
),
6 => format!("prettyNum({}, big.mark = \",\")", r.range(1000, 9_999_999)),
_ => format!("sqrt({a}) + {b}"),
})
}
fn gen_vectors(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let v = vec_int(r);
let i = r.range(1, 4);
one(match r.below(9) {
0 => format!("{v}[{i}]"),
1 => format!("({v})[-{i}]"),
2 => format!("({v})[c({}, {})]", r.range(1, 3), r.range(1, 3)),
3 => format!("({v})[{v} > 0]"),
4 => format!("head({v}, {})", r.range(1, 3)),
5 => format!("tail({v}, {})", r.range(1, 3)),
6 => format!("length({v})"),
7 => format!("({v})[c(TRUE, FALSE)]"),
_ => format!("rev({v})"),
})
}
fn gen_seqrep(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let a = r.range(0, 4);
let b = r.range(a + 1, a + 9);
one(match r.below(9) {
0 => format!("seq({a}, {b})"),
1 => format!(
"seq({a}, {b}, by = {})",
*r.pick(&["0.5", "0.25", "2", "1.5"])
),
2 => format!("seq_len({})", r.range(0, 6)),
3 => format!("seq_along(c({}, {}, {}))", si(r), si(r), si(r)),
4 => format!("rep({}, {})", si(r), r.range(1, 5)),
5 => format!("rep(c({}, {}), times = {})", si(r), si(r), r.range(1, 4)),
6 => format!("rep(c({}, {}), each = {})", si(r), si(r), r.range(1, 4)),
7 => format!("seq({a}, {b}, length.out = {})", r.range(2, 6)),
_ => format!("{a}:{b}"),
})
}
fn gen_vecmath(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let v = if r.below(2) == 0 {
vec_int(r)
} else {
vec_dbl(r)
};
let vi = vec_int(r);
one(match r.below(12) {
0 => format!("sum({v})"),
1 => format!("prod({v})"),
2 => format!("mean({v})"),
3 => format!("max({v})"),
4 => format!("min({v})"),
5 => format!("range({v})"),
6 => format!("cumsum({v})"),
7 => format!("cumprod({v})"),
8 => format!("diff({v})"),
9 => format!("median({v})"),
10 => format!("var({vi})"),
_ => format!("sd({vi})"),
})
}
fn gen_sortops(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let v = vec_int(r);
one(match r.below(9) {
0 => format!("sort({v})"),
1 => format!("sort({v}, decreasing = TRUE)"),
2 => format!("order({v})"),
3 => format!("rank({v})"),
4 => format!("rev(sort({v}))"),
5 => format!("unique({v})"),
6 => format!("duplicated({v})"),
7 => format!("which.max({v})"),
_ => format!("which.min({v})"),
})
}
fn gen_strings(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let w = ww(r);
one(match r.below(11) {
0 => format!("paste(\"{w}\", \"{}\")", ww(r)),
1 => format!("paste0(\"{w}\", {})", r.range(1, 9)),
2 => format!("paste(\"{w}\", \"{}\", sep = \"-\")", ww(r)),
3 => format!("paste(c(\"{w}\", \"{}\"), collapse = \"+\")", ww(r)),
4 => format!("nchar(\"{w}\")"),
5 => format!("substr(\"{w}\", {}, {})", r.range(1, 3), r.range(3, 5)),
6 => format!("toupper(\"{w}\")"),
7 => format!("tolower(\"ABC{w}\")"),
8 => format!("substring(\"{w}\", {})", r.range(1, 4)),
9 => format!("trimws(\" {w} \")"),
_ => format!("rev(strsplit(\"{w}\", \"\")[[1]])"),
})
}
fn gen_strproc(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let s = format!("{}{}", ww(r), ww(r));
let pats = ["[a-c]+", "o+", "[aeiou]", "l+", "^.", ".$", "z", "[a-z]{2}"];
let p = r.pick(&pats);
one(match r.below(10) {
0 => format!("grepl(\"{p}\", \"{s}\")"),
1 => format!("sub(\"{p}\", \"X\", \"{s}\")"),
2 => format!("gsub(\"{p}\", \"X\", \"{s}\")"),
3 => format!("grep(\"{p}\", c(\"{s}\", \"{}\"))", ww(r)),
4 => format!("regmatches(\"{s}\", regexpr(\"{p}\", \"{s}\"))"),
5 => format!("startsWith(\"{s}\", \"{}\")", &s[..1.min(s.len())]),
6 => format!("endsWith(\"{s}\", \"{}\")", ww(r)),
7 => format!("strsplit(\"{s}\", \"{p}\")"),
8 => format!("nchar(gsub(\"{p}\", \"\", \"{s}\"))"),
_ => format!("length(gregexpr(\"{p}\", \"{s}\")[[1]])"),
})
}
fn gen_sprintf(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let n = si(r);
let f = ff(r);
let w = ww(r);
one(match r.below(10) {
0 => format!("sprintf(\"%.3f\", {f})"),
1 => format!("sprintf(\"%05d\", {})", r.range(0, 999)),
2 => format!("sprintf(\"%x\", {})", r.range(0, 999)),
3 => format!("sprintf(\"%e\", {f})"),
4 => format!("sprintf(\"%-8s|\", \"{w}\")"),
5 => format!("sprintf(\"%+d\", {n})"),
6 => format!("sprintf(\"%8.2f\", {f})"),
7 => format!("sprintf(\"%d-%s\", {}, \"{w}\")", r.range(0, 99)),
8 => format!("sprintf(\"%g\", {f} * {})", r.range(1, 1000)),
_ => format!("formatC({n}, width = 6, flag = \"0\")"),
})
}
fn gen_logical(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let v = vec_int(r);
let a = ii(r);
let b = si(r);
one(match r.below(11) {
0 => format!("{a} > {b}"),
1 => format!("({v}) > 0"),
2 => format!("any(({v}) > 0)"),
3 => format!("all(({v}) > 0)"),
4 => format!("which(({v}) %% 2 == 0)"),
5 => format!("xor({a} > 0, {b} > 0)"),
6 => format!("({v}) >= {a} & ({v}) <= {b}"),
7 => format!("sum(({v}) > 0)"),
8 => format!("isTRUE({a} == {b})"),
9 => format!(
"!c(TRUE, FALSE, {})",
if r.below(2) == 0 { "TRUE" } else { "NA" }
),
_ => format!("({a} > {b}) || ({a} < {b})"),
})
}
fn gen_ifelse(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let v = vec_int(r);
let n = r.range(0, 10);
one(match r.below(6) {
0 => format!("ifelse(({v}) > 0, \"pos\", \"nonpos\")"),
1 => format!("if ({n} > 5) \"hi\" else \"lo\""),
2 => format!("ifelse(({v}) %% 2 == 0, ({v}), 0L)"),
3 => format!("if ({n} %% 2 == 0) \"even\" else \"odd\""),
4 => format!("ifelse(is.na(c(1, NA, {})), -1, 0)", si(r)),
_ => format!("max(0, {})", si(r)),
})
}
fn gen_control(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let n = r.range(3, 7);
one(match r.below(6) {
0 => format!("s <- 0; for (i in 1:{n}) s <- s + i; s"),
1 => format!("v <- c(); for (i in 1:{n}) v <- c(v, i * i); v"),
2 => format!("i <- 1; s <- 0; while (i <= {n}) {{ s <- s + i; i <- i + 1 }}; s"),
3 => format!("acc <- 1; for (i in 1:{n}) acc <- acc * i; acc"),
4 => format!(
"out <- c(); for (w in c(\"{}\", \"{}\")) out <- c(out, nchar(w)); out",
ww(r),
ww(r)
),
_ => format!("i <- 0; repeat {{ i <- i + 1; if (i >= {n}) break }}; i"),
})
}
fn gen_funcs(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let n = r.range(2, 8);
one(match r.below(6) {
0 => format!("f <- function(x) x * x + 1; f({})", si(r)),
1 => format!("fact <- function(n) if (n <= 1) 1 else n * fact(n - 1); fact({n})"),
2 => format!(
"fib <- function(n) if (n < 2) n else fib(n - 1) + fib(n - 2); fib({})",
r.range(2, 12)
),
3 => format!(
"adder <- function(a) function(b) a + b; adder({})({})",
si(r),
si(r)
),
4 => format!("f <- function(x, y = {}) x + y; f({})", si(r), si(r)),
_ => format!(
"g <- function(...) sum(...); g({}, {}, {})",
si(r),
si(r),
si(r)
),
})
}
fn gen_apply(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let v = vec_int(r);
let n = r.range(2, 5);
one(match r.below(9) {
0 => format!("sapply(1:{n}, function(x) x ^ 2)"),
1 => format!("vapply(1:{n}, function(x) x * 2L, integer(1))"),
2 => format!("unlist(lapply({v}, function(x) x + 1))"),
3 => format!("mapply(function(a, b) a + b, 1:{n}, {n}:1)"),
4 => format!("Reduce(`+`, {v})"),
5 => format!("Reduce(function(a, b) a * b, 1:{n}, accumulate = TRUE)"),
6 => format!("Filter(function(x) x > 0, {v})"),
7 => format!("unlist(Map(function(a, b) a - b, 1:{n}, {n}:1))"),
_ => format!("do.call(paste, as.list(c(\"{}\", \"{}\")))", ww(r), ww(r)),
})
}
fn gen_lists(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let (a, b) = (si(r), si(r));
one(match r.below(8) {
0 => format!("l <- list(a = {a}, b = {b}); l$a + l$b"),
1 => format!("l <- list({a}, {b}, {}); l[[2]]", si(r)),
2 => format!("names(list(x = {a}, y = {b}))"),
3 => format!("unlist(list({a}, {b}, {}))", si(r)),
4 => format!("setNames(c({a}, {b}), c(\"{}\", \"{}\"))", ww(r), ww(r)),
5 => format!("l <- list(a = {a}); l$b <- {b}; unlist(l)"),
6 => format!("length(list({a}, {b}, list({}, {})))", si(r), si(r)),
_ => format!("lengths(list(1:{}, 1:{}))", r.range(1, 4), r.range(1, 4)),
})
}
fn gen_matrix(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let (nr, nc) = (r.range(2, 3), r.range(2, 3));
let n = nr * nc;
one(match r.below(9) {
0 => format!("matrix(1:{n}, nrow = {nr})"),
1 => format!("matrix(1:{n}, nrow = {nr}, byrow = TRUE)"),
2 => format!("t(matrix(1:{n}, nrow = {nr}))"),
3 => format!("dim(matrix(1:{n}, nrow = {nr}))"),
4 => format!("rowSums(matrix(1:{n}, nrow = {nr}))"),
5 => format!("colSums(matrix(1:{n}, nrow = {nr}))"),
6 => format!("apply(matrix(1:{n}, nrow = {nr}), 1, sum)"),
7 => format!("diag(matrix(1:{}, nrow = {n2}))", n * n, n2 = n),
_ => format!("matrix(1:{n}, nrow = {nr}) %*% diag({nc})"),
})
}
fn gen_types(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let n = si(r);
let f = ff(r);
one(match r.below(11) {
0 => format!("as.integer({f})"),
1 => format!("as.numeric(\"{f}\")"),
2 => format!("as.character({n})"),
3 => format!("as.logical({})", *r.pick(&["0", "1", "2"])),
4 => format!(
"class({})",
if r.below(2) == 0 {
format!("{n}L")
} else {
f.to_string()
}
),
5 => format!("typeof({n}L)"),
6 => format!("is.na(c({n}, NA, {f}))"),
7 => format!(
"as.integer(c(\"{}\", \"{}\"))",
r.range(0, 99),
r.range(0, 99)
),
8 => format!("storage.mode({n}L)"),
9 => format!("as.numeric(TRUE) + {f}"),
_ => format!("round(as.numeric(\"{f}\") * {})", r.range(1, 9)),
})
}
fn gen_setops(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let a = vec_int(r);
let b = vec_int(r);
one(match r.below(9) {
0 => format!("union({a}, {b})"),
1 => format!("intersect({a}, {b})"),
2 => format!("setdiff({a}, {b})"),
3 => format!("{a} %in% {b}"),
4 => format!("match({a}, {b})"),
5 => format!("unique(c({a}, {b}))"),
6 => format!("sort(unique(c({a}, {b})))"),
7 => format!("is.element({}, {b})", si(r)),
_ => format!("as.vector(table(c({a}, {b})))"),
})
}
fn gen_rounding(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let f = ff(r);
let g = ff(r);
one(match r.below(9) {
0 => format!("round({f} * pi, {})", r.range(0, 4)),
1 => format!("ceiling({f} * {g})"),
2 => format!("floor({f} * {g})"),
3 => format!("trunc({f} * {g})"),
4 => format!("signif({f} * {g}, {})", r.range(1, 5)),
5 => "round(c(0.5, 1.5, 2.5, 3.5))".to_string(),
6 => format!("round({f} * 100) / 100"),
7 => format!("ceiling(sqrt({}))", r.range(1, 200)),
_ => format!("floor(log2({}))", r.range(1, 1000)),
})
}
fn gen_bitops(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let a = r.range(0, 255);
let b = r.range(0, 255);
one(match r.below(6) {
0 => format!("bitwAnd({a}L, {b}L)"),
1 => format!("bitwOr({a}L, {b}L)"),
2 => format!("bitwXor({a}L, {b}L)"),
3 => format!("bitwShiftL({a}L, {})", r.range(0, 4)),
4 => format!("bitwShiftR({a}L, {})", r.range(0, 4)),
_ => format!("bitwNot({a}L)"),
})
}
fn gen_factor(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let s = vec_str(r);
one(match r.below(6) {
0 => format!("as.integer(factor({s}))"),
1 => format!("levels(factor({s}))"),
2 => format!("nlevels(factor({s}))"),
3 => format!("as.character(factor({s}))"),
4 => format!("table(factor({s}))"),
_ => format!("as.vector(table(factor({s})))"),
})
}
fn some_factor(r: &mut Rng, ordered: bool) -> String {
let n = r.range(3, 6) as usize;
let items: Vec<String> = (0..n)
.map(|_| format!("\"{}\"", r.pick(&["a", "b", "c", "d"])))
.collect();
format!(
"factor(c({}), levels = c(\"a\", \"b\", \"c\", \"d\"){})",
items.join(", "),
if ordered { ", ordered = TRUE" } else { "" }
)
}
fn gen_factorsub(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let ordered = r.below(4) == 0;
let f = some_factor(r, ordered);
let i = r.range(1, 3);
let j = r.range(3, 5);
one(match r.below(14) {
0 => format!("({f})[{i}:{j}]"),
1 => format!("({f})[-{i}]"),
2 => format!("({f})[[{i}]]"),
3 => format!("({f})[c(TRUE, FALSE)]"),
4 => format!("({f})[{i}:{j}, drop = TRUE]"),
5 => format!("head({f}, {i})"),
6 => format!("tail({f}, {i})"),
7 => format!("rev({f})"),
8 => format!("sort({f})"),
9 => format!("sort({f}, decreasing = TRUE)"),
10 => format!("unique({f})"),
11 => format!("rep({f}, {i})"),
12 => format!("c({}, {})", some_factor(r, false), some_factor(r, false)),
_ => format!("levels(({f})[{i}:{j}])"),
})
}
fn gen_factorops(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let f = some_factor(r, false);
let o = some_factor(r, true);
let w = *r.pick(&["a", "b", "c", "d", "z"]);
one(match r.below(14) {
0 => format!("({f}) == \"{w}\""),
1 => format!("({f}) != \"{w}\""),
2 => format!("(function(x) x[x == \"{w}\"])({f})"),
3 => format!("which(({f}) == \"{w}\")"),
4 => format!("({o}) < \"{w}\""),
5 => format!("({o}) >= \"{w}\""),
6 => format!("sum(({f}) == \"{w}\")"),
7 => format!("({f}) %in% c(\"a\", \"{w}\")"),
8 => format!("match({f}, c(\"a\", \"b\", \"c\", \"d\"))"),
9 => format!("paste({f}, collapse = \"-\")"),
10 => format!("as.vector({f})"),
11 => format!("toString({f})"),
12 => format!("droplevels(({f})[1:2])"),
_ => format!("table(({f})[1:2])"),
})
}
fn gen_conditions(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let w = ww(r);
let n = r.range(1, 9);
one(match r.below(16) {
0 => format!("tryCatch({n}, error = function(e) \"caught\")"),
1 => format!("tryCatch(stop(\"{w}\"), error = function(e) conditionMessage(e))"),
2 => format!("tryCatch(stop(\"{w}\"), error = function(e) class(e))"),
3 => format!("tryCatch(warning(\"{w}\"), warning = function(x) conditionMessage(x))"),
4 => format!("tryCatch(message(\"{w}\"), message = function(x) conditionMessage(x))"),
5 => format!("tryCatch(stop(\"{w}\"), condition = function(x) \"cond\")"),
6 => format!("tryCatch({n}, finally = cat(\"fin\\n\"))"),
7 => format!("tryCatch(stop(\"{w}\"), error = function(e) {n}, finally = cat(\"fin\\n\"))"),
8 => format!(
"tryCatch(tryCatch(stop(\"{w}\"), error = function(e) stop(\"outer\")), \
error = function(e) conditionMessage(e))"
),
9 => format!("(function() {{ on.exit(cat(\"x\\n\")); {n} }})()"),
10 => format!(
"(function() {{ on.exit(cat(\"a\\n\")); on.exit(cat(\"b\\n\"), add = TRUE); {n} }})()"
),
11 => format!(
"tryCatch((function() {{ on.exit(cat(\"cl\\n\")); stop(\"{w}\") }})(), \
error = function(e) conditionMessage(e))"
),
12 => format!("local({{ v <- {n}; v * 2 }})"),
13 => format!("class(try(stop(\"{w}\"), silent = TRUE))"),
14 => format!("inherits(try(stop(\"{w}\"), silent = TRUE), \"try-error\")"),
_ => format!(
"{{ f <- function(x) UseMethod(\"f\"); f.a <- function(x) c(\"a\", NextMethod()); \
f.default <- function(x) \"{w}\"; f(structure({n}, class = \"a\")) }}"
),
})
}
fn gen_calling(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let w = ww(r);
let n = r.range(1, 9);
one(match r.below(18) {
0 => format!(
"print(withCallingHandlers({{ warning(\"{w}\"); cat(\"resumed\\n\"); {n} }}, \
warning = function(x) {{ cat(\"H\", conditionMessage(x), \"\\n\"); \
invokeRestart(\"muffleWarning\") }}))"
),
1 => format!(
"print(withCallingHandlers({{ warning(\"{w}\"); cat(\"resumed\\n\"); {n} }}, \
warning = function(x) cat(\"H\\n\")))"
),
2 => format!(
"print(withCallingHandlers({{ message(\"{w}\"); cat(\"resumed\\n\"); {n} }}, \
message = function(x) {{ cat(\"H\", conditionMessage(x)); \
invokeRestart(\"muffleMessage\") }}))"
),
3 => format!(
"print(withCallingHandlers({{ message(\"{w}\"); cat(\"resumed\\n\"); {n} }}, \
message = function(x) cat(\"H\\n\")))"
),
4 => format!(
"withCallingHandlers(withCallingHandlers({{ warning(\"{w}\"); cat(\"resumed\\n\") }}, \
warning = function(x) cat(\"inner\\n\")), \
warning = function(x) {{ cat(\"outer\\n\"); invokeRestart(\"muffleWarning\") }})"
),
5 => format!(
"withCallingHandlers(withCallingHandlers({{ warning(\"{w}\"); cat(\"resumed\\n\") }}, \
warning = function(x) {{ cat(\"inner\\n\"); invokeRestart(\"muffleWarning\") }}), \
warning = function(x) cat(\"outer\\n\"))"
),
6 => format!(
"print(tryCatch(withCallingHandlers({{ warning(\"{w}\"); cat(\"resumed\\n\"); {n} }}, \
warning = function(x) cat(\"calling\\n\")), \
warning = function(x) paste(\"exiting\", conditionMessage(x))))"
),
7 => format!(
"print(withCallingHandlers(tryCatch({{ warning(\"{w}\"); {n} }}, \
warning = function(x) \"exiting\"), warning = function(x) cat(\"calling\\n\")))"
),
8 => format!(
"withCallingHandlers({{ warning(\"{w}\"); cat(\"resumed\\n\") }}, \
condition = function(x) cat(\"cond\\n\"), \
warning = function(x) {{ cat(\"warn\\n\"); invokeRestart(\"muffleWarning\") }})"
),
9 => format!(
"print(tryCatch(withCallingHandlers({{ stop(\"{w}\"); cat(\"NOT\\n\") }}, \
error = function(e) cat(\"calling\", conditionMessage(e), \"\\n\")), \
error = function(e) paste(\"exiting\", conditionMessage(e))))"
),
10 => format!("print(suppressWarnings({{ warning(\"{w}\"); cat(\"resumed\\n\"); {n} }}))"),
11 => format!("print(suppressMessages({{ message(\"{w}\"); cat(\"resumed\\n\"); {n} }}))"),
12 => format!(
"f <- function() {{ warning(\"{w}\"); cat(\"resumed\\n\"); {n} }}\n\
print(withCallingHandlers(f(), \
warning = function(x) invokeRestart(\"muffleWarning\")))"
),
13 => format!(
"withCallingHandlers({{ warning(\"{w}\"); cat(\"resumed\\n\") }}, \
warning = function(x) {{ cat(\"H\\n\"); suppressWarnings(warning(\"again\")); \
invokeRestart(\"muffleWarning\") }})"
),
14 => format!(
"cnd <- structure(class = c(\"{w}c\", \"condition\"), \
list(message = \"{w}\", call = NULL))\n\
print(withCallingHandlers({{ signalCondition(cnd); cat(\"resumed\\n\"); {n} }}, \
{w}c = function(x) cat(\"saw\", conditionMessage(x), \"\\n\")))"
),
15 => format!(
"withCallingHandlers({{ warning(\"{w}\"); cat(\"resumed\\n\") }}, \
warning = function(x) {{ print(class(x)); print(conditionMessage(x)); \
invokeRestart(\"muffleWarning\") }})"
),
16 => format!(
"withCallingHandlers(suppressWarnings({{ warning(\"{w}\"); cat(\"resumed\\n\") }}), \
warning = function(x) cat(\"NOT\\n\"))"
),
_ => format!(
"suppressWarnings(withCallingHandlers({{ warning(\"{w}\"); cat(\"resumed\\n\") }}, \
warning = function(x) cat(\"inner\\n\")))"
),
})
}
fn gen_restarts(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let w = ww(r);
let n = r.range(1, 9);
one(match r.below(18) {
0 => format!(
"print(withRestarts(invokeRestart(\"r1\", {n}), r1 = function(v) v * 2))"
),
1 => format!(
"print(withRestarts({{ cat(\"body\\n\"); invokeRestart(\"r1\"); cat(\"NOT\\n\") }}, \
r1 = function() \"{w}\"))"
),
2 => format!("print(withRestarts({{ cat(\"body\\n\"); {n} }}, r1 = function() 0))"),
3 => "withRestarts(print(length(computeRestarts())), r1 = function() 1, r2 = function() 2)"
.to_string(),
4 => "withRestarts(for (x in computeRestarts()) cat(x$name, \"\\n\"), \
r1 = function() 1, r2 = function() 2)"
.to_string(),
5 => format!(
"withRestarts(for (x in computeRestarts()) cat(\"[\", restartDescription(x), \"]\\n\"), \
r1 = list(handler = function() 1, description = \"{w}\"), r2 = \"desc {w}\")"
),
6 => format!(
"print(withRestarts(withRestarts(invokeRestart(\"r1\", {n}), \
r1 = function(v) paste(\"inner\", v)), r1 = function(v) paste(\"outer\", v)))"
),
7 => format!(
"print(withRestarts(withRestarts({{ x <- computeRestarts()[[2]]; \
invokeRestart(x, {n}) }}, r1 = function(v) paste(\"inner\", v)), \
r1 = function(v) paste(\"outer\", v)))"
),
8 => format!(
"print(withRestarts(tryCatch(invokeRestart(\"r1\", {n}), \
error = function(e) \"WRONG\", finally = cat(\"fin\\n\")), \
r1 = function(v) paste(\"restart\", v)))"
),
9 => format!(
"print(withRestarts((function() {{ on.exit(cat(\"exit\\n\")); \
invokeRestart(\"r1\", {n}) }})(), r1 = function(v) paste(\"restart\", v)))"
),
10 => format!(
"f <- function(k) if (k == 0) invokeRestart(\"r1\", \"{w}\") else f(k - 1)\n\
print(withRestarts(f({}), r1 = function(v) paste(\"caught\", v)))",
r.range(1, 12)
),
11 => format!(
"print(tryCatch(invokeRestart(\"{w}\"), error = function(e) conditionMessage(e)))"
),
12 => "withRestarts(print(computeRestarts()), r1 = function() 1)".to_string(),
13 => "withRestarts(print(sapply(computeRestarts(), class)), r1 = function() 1)".to_string(),
14 => format!(
"withCallingHandlers(warning(\"{w}\"), warning = function(x) {{ \
for (y in computeRestarts()) cat(y$name, \"\\n\"); \
invokeRestart(\"muffleWarning\") }})"
),
15 => format!(
"withCallingHandlers(message(\"{w}\"), message = function(x) {{ \
print(length(computeRestarts())); invokeRestart(\"muffleMessage\") }})"
),
16 => format!(
"withRestarts(invokeRestart(\"r1\", {n}), r1 = function(v) invisible(v))\n\
withRestarts(invokeRestart(\"r1\", {n}), r1 = function(v) v)"
),
_ => format!(
"print(withRestarts(withCallingHandlers({{ warning(\"{w}\"); \"NOT\" }}, \
warning = function(x) invokeRestart(\"r1\", {n})), \
r1 = function(v) paste(\"jumped\", v)))"
),
})
}
const UWORDS: &[&str] = &[
"café",
"naïve",
"日本語",
"한글",
"Привет",
"Ωμέγα",
"straße",
"fix",
"İstanbul",
"ΣΑΣ",
"e\\u0301",
"😀ok",
"a\\u3000b",
"→←",
];
fn uw<'a>(r: &mut Rng) -> &'a str {
r.pick(UWORDS)
}
fn vec_uw(r: &mut Rng) -> String {
let n = r.range(2, 3) as usize;
let items: Vec<String> = (0..n).map(|_| format!("\"{}\"", uw(r))).collect();
format!("c({})", items.join(", "))
}
fn gen_strwidth(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let s = uw(r);
let v = vec_uw(r);
let w = r.range(1, 10);
one(match r.below(20) {
0 => format!("nchar(\"{s}\")"),
1 => format!("nchar(\"{s}\", type = \"bytes\")"),
2 => format!("nchar(\"{s}\", type = \"width\")"),
3 => format!(
"nchar({v}, type = \"{}\")",
r.pick(&["chars", "bytes", "width"])
),
4 => format!("sprintf(\"[%{w}s]\", \"{s}\")"),
5 => format!("sprintf(\"[%-{w}s]\", \"{s}\")"),
6 => format!("print({v})"),
7 => format!("print(c(a = \"{s}\", bb = \"{}\"))", uw(r)),
8 => format!("print(matrix({v}, 1))"),
9 => format!("print(format({v}))"),
10 => format!("print(format(\"{s}\", width = {w}))"),
11 => format!("cat(\"[\", formatC(\"{s}\", width = {w}), \"]\\n\")"),
12 => format!("cat(\"[\", formatC(\"{s}\", width = {w}, flag = \"-\"), \"]\\n\")"),
13 => format!("cat(strtrim(\"{s}\", {w}), \"\\n\")"),
14 => format!("print(utf8ToInt(\"{s}\"))"),
15 => format!("print(intToUtf8(utf8ToInt(\"{s}\")))"),
16 => format!("print(intToUtf8(utf8ToInt(\"{s}\"), multiple = TRUE))"),
17 => format!("cat(toupper(\"{s}\"), tolower(\"{s}\"), \"\\n\")"),
18 => format!("print(nchar(toupper({v}), type = \"bytes\"))"),
_ => format!("print(substr(\"{s}\", 1, {}))", r.range(1, 4)),
})
}
const CWORDS: &[&str] = &[
"Apple", "apple", "banana", "Banana", "Cherry", "cherry", "aB", "Ab", "ab", "AB", "zoo", "Zoo",
"café", "Café", "élan", "Élan", "straße", "Strasse", "ñu", "Ñu", "ΣΑΣ", "σας", "_x", "0a",
];
fn cw<'a>(r: &mut Rng) -> &'a str {
r.pick(CWORDS)
}
fn vec_cw(r: &mut Rng) -> String {
let n = r.range(3, 5) as usize;
let items: Vec<String> = (0..n).map(|_| format!("\"{}\"", cw(r))).collect();
format!("c({})", items.join(", "))
}
const WIDE_DBLS: &[&str] = &[
"1e5",
"1e-5",
"123456789",
"0.000012345",
"1/3",
"pi",
"1e15",
"1e-15",
"-1e5",
"-0.000012345",
"99999",
"1234.5678",
"10^100",
"6.022e23",
"0.1",
"1e6",
];
fn dig(r: &mut Rng) -> i64 {
*r.pick(&[1, 2, 3, 5, 7, 10, 15, 16, 17, 21, 22])
}
fn spen(r: &mut Rng) -> i64 {
*r.pick(&[-9, -5, -2, -1, 0, 1, 2, 5, 10, 30])
}
fn gen_optsfmt(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let v = r.pick(WIDE_DBLS);
let w = r.pick(WIDE_DBLS);
let (d, s) = (dig(r), spen(r));
one(match r.below(18) {
0 => format!("options(digits = {d})\nprint({v})"),
1 => format!("options(scipen = {s})\nprint({v})"),
2 => format!("options(digits = {d}, scipen = {s})\nprint({v})"),
3 => format!("options(digits = {d}, scipen = {s})\n{v}"),
4 => format!("options(digits = {d}, scipen = {s})\ncat({v}, \"\\n\")"),
5 => format!("options(digits = {d}, scipen = {s})\ncat(format({v}), \"\\n\")"),
6 => format!("options(digits = {d}, scipen = {s})\nprint(c({v}, {w}))"),
7 => format!("options(digits = {d}, scipen = {s})\nprint(c(a = {v}, b = {w}))"),
8 => format!("options(digits = {d}, scipen = {s})\nprint(matrix(c({v}, {w}, 1, 2), 2))"),
9 => format!("options(digits = {d}, scipen = {s})\nprint(list({v}))"),
10 => format!("options(digits = {d}, scipen = {s})\ncat(as.character({v}), \"\\n\")"),
11 => format!("options(digits = {d}, scipen = {s})\ncat(paste({v}), \"\\n\")"),
12 => format!("options(digits = {d}, scipen = {s})\ncat(toString({v}), \"\\n\")"),
13 => "print(getOption(\"digits\"))\nprint(getOption(\"scipen\"))".to_string(),
14 => format!("old <- options(digits = {d})\nprint({v})\noptions(old)\nprint({v})"),
15 => format!("options(digits = {d})\nprint(names(options(\"digits\")))"),
16 => format!("print(getOption(\"nosuchoption\", {}))", ii(r)),
_ => format!(
"options(digits = {d})\nprint({v}, digits = {})\nprint({v})",
r.range(1, 8)
),
})
}
fn gen_collate(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let v = vec_cw(r);
let (a, b) = (cw(r), cw(r));
one(match r.below(14) {
0 => format!("print(sort({v}))"),
1 => format!("print(sort({v}, decreasing = TRUE))"),
2 => format!("print(order({v}))"),
3 => format!("print(rank({v}))"),
4 => format!("print(xtfrm({v}))"),
5 => format!("print(sort.list({v}))"),
6 => format!("cat(min({v}), max({v}), \"\\n\")"),
7 => format!("print(range({v}))"),
8 => format!("cat(\"{a}\" < \"{b}\", \"{a}\" > \"{b}\", \"{a}\" <= \"{b}\", \"\\n\")"),
9 => format!("cat(\"{a}\" == \"{b}\", \"{a}\" != \"{b}\", \"\\n\")"),
10 => format!("print(levels(factor({v})))"),
11 => format!("print(table({v}))"),
12 => format!("print(rev(sort({v})))"),
_ => format!("print(sort(unique({v})))"),
})
}
fn gen_trig(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let f = ff(r);
let unit = *r.pick(&["0.5", "0.25", "1.0", "0.75", "0.1"]);
one(match r.below(12) {
0 => format!("sin({f})"),
1 => format!("cos({f})"),
2 => format!("tan({f})"),
3 => format!("asin({unit})"),
4 => format!("acos({unit})"),
5 => format!("atan({f})"),
6 => format!("atan2({f}, {})", ff(r)),
7 => format!("sinh({unit})"),
8 => format!("cosh({unit})"),
9 => format!("tanh({f})"),
10 => format!("expm1({unit})"),
_ => format!("log1p({unit})"),
})
}
fn gen_mathfn(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let n = r.range(0, 10);
let k = r.range(0, 6);
one(match r.below(11) {
0 => format!("factorial({n})"),
1 => format!("choose({}, {k})", r.range(0, 12)),
2 => format!("gamma({})", r.range(1, 9)),
3 => format!("lgamma({})", r.range(1, 40)),
4 => format!("beta({}, {})", r.range(1, 6), r.range(1, 6)),
5 => format!("lbeta({}, {})", r.range(1, 9), r.range(1, 9)),
6 => format!("sign({})", si(r)),
7 => format!("cumsum({})", vec_int(r)),
8 => format!("cumprod(1:{})", r.range(1, 6)),
9 => format!("lfactorial({})", r.range(1, 20)),
_ => format!(
"factorial({}) / factorial({})",
r.range(3, 8),
r.range(1, 3)
),
})
}
fn gen_pmaxmin(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let a = vec_int(r);
let b = vec_int(r);
one(match r.below(9) {
0 => format!("pmax({a}, {b})"),
1 => format!("pmin({a}, {b})"),
2 => format!("pmax({a}, 0)"),
3 => format!("cummax({a})"),
4 => format!("cummin({a})"),
5 => format!(
"tabulate(c({}, {}, {}, {}), {})",
r.range(1, 4),
r.range(1, 4),
r.range(1, 4),
r.range(1, 4),
r.range(3, 5)
),
6 => format!(
"findInterval(c({}, {}), c(1, 2, 3, 4))",
r.range(0, 5),
r.range(0, 5)
),
7 => format!("pmin(pmax({a}, 0), 3)"),
_ => format!("range({a})"),
})
}
fn gen_linalg(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let n = r.range(2, 3);
let m = r.range(2, 3);
one(match r.below(9) {
0 => format!("outer(1:{n}, 1:{m})"),
1 => format!("outer(1:{n}, 1:{m}, \"+\")"),
2 => format!("cbind(1:{n}, {}:{})", n + 1, n + n),
3 => format!("rbind(1:{m}, {}:{})", m + 1, m + m),
4 => format!("crossprod(matrix(1:{}, nrow = {n}))", n * m),
5 => format!("tcrossprod(matrix(1:{}, nrow = {n}))", n * m),
6 => format!("t(outer(1:{n}, 1:{m}))"),
7 => format!("matrix(1:{}, nrow = {n}) %*% 1:{m}", n * m),
_ => format!("diag(outer(1:{n}, 1:{n}))"),
})
}
fn gen_stringx(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let w = ww(r);
one(match r.below(9) {
0 => format!("chartr(\"abc\", \"ABC\", \"{w}\")"),
1 => format!(
"strtoi(\"{}\", {})",
r.range(10, 999),
*r.pick(&["10", "8", "16"])
),
2 => format!("sprintf(\"%d:%s\", 1:3, \"{w}\")"),
3 => format!("toupper(chartr(\"aeiou\", \"AEIOU\", \"{w}\"))"),
4 => format!("paste(rev(strsplit(\"{w}\", \"\")[[1]]), collapse = \"\")"),
5 => format!("strtoi(\"{}\")", r.range(0, 9999)),
6 => format!(
"nchar(chartr(\"{}\", \"X\", \"{w}\"))",
&w[..1.min(w.len())]
),
7 => format!("sprintf(\"[%s]\", c(\"{w}\", \"{}\"))", ww(r)),
_ => format!("chartr(\"{w}\", \"{}\", \"{w}{w}\")", ww(r)),
})
}
fn gen_listx(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let n = r.range(3, 6);
one(match r.below(8) {
0 => format!(
"Position(function(x) x > {}, c({}, {}, {}))",
r.range(1, 3),
si(r),
si(r),
si(r)
),
1 => format!("Find(function(x) x %% 2 == 0, 1:{n})"),
2 => format!("Filter(function(x) x > 0, {})", vec_int(r)),
3 => format!("Reduce(function(a, b) a + b, 1:{n}, accumulate = TRUE)"),
4 => format!("mapply(function(a, b) a * b, 1:{n}, {n}:1)"),
5 => format!(
"lengths(list(1:{}, 1:{}, 1:{}))",
r.range(1, 4),
r.range(1, 4),
r.range(1, 4)
),
6 => "do.call(pmax, list(c(1, 5), c(3, 2)))".to_string(),
_ => format!("unlist(Map(`+`, 1:{n}, {n}:1))"),
})
}
fn special_vec(r: &mut Rng) -> String {
let atoms = ["1", "2", "-3", "0", "NA", "NaN", "Inf", "-Inf", "5.5"];
let n = r.range(3, 5) as usize;
let items: Vec<&str> = (0..n).map(|_| *r.pick(&atoms)).collect();
format!("c({})", items.join(", "))
}
fn gen_predicates(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let v = special_vec(r);
one(match r.below(9) {
0 => format!("is.na({v})"),
1 => format!("is.nan({v})"),
2 => format!("is.finite({v})"),
3 => format!("is.infinite({v})"),
4 => format!("anyNA({v})"),
5 => format!("complete.cases({v})"),
6 => format!("sum(is.na({v}))"),
7 => format!("which(is.finite({v}))"),
_ => format!("{v}[is.finite({v})]"),
})
}
fn gen_numedge(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let v = special_vec(r);
let empty = *r.pick(&["numeric(0)", "integer(0)"]);
one(match r.below(9) {
0 => format!("max({empty})"),
1 => format!("min({empty})"),
2 => format!("range({empty})"),
3 => format!("sum({v}, na.rm = TRUE)"),
4 => format!("max({v}, na.rm = TRUE)"),
5 => format!("mean({v}, na.rm = TRUE)"),
6 => format!("prod({empty})"),
7 => format!("cumsum(1:{})", r.range(1, 6)),
_ => format!("range({v}, na.rm = TRUE)"),
})
}
fn gen_strx2(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let w = ww(r);
one(match r.below(9) {
0 => format!("strrep(\"{w}\", {})", r.range(0, 4)),
1 => format!(
"trimws(\" {w} \", which = \"{}\")",
*r.pick(&["left", "right", "both"])
),
2 => format!("substring(\"{w}\", 1:{})", r.range(2, 4)),
3 => format!("encodeString(\"{w}\\t{w}\")"),
4 => format!(
"x <- \"{w}\"; substr(x, {}, {}) <- \"XY\"; x",
r.range(1, 3),
r.range(3, 5)
),
5 => format!("strrep(c(\"{w}\", \"{}\"), 2)", ww(r)),
6 => format!("nchar(strrep(\"{w}\", {}))", r.range(1, 5)),
7 => format!("toupper(substring(\"{w}{w}\", {}))", r.range(1, 4)),
_ => format!("encodeString(c(\"{w}\", \"a\\nb\"))"),
})
}
fn gen_listx2(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let n = r.range(4, 6);
let keys = "c(\"a\", \"b\", \"a\", \"b\", \"c\")";
one(match r.below(9) {
0 => format!("split(1:5, {keys})"),
1 => format!(
"tapply(c({}, {}, {}, {}, {}), {keys}, sum)",
si(r),
si(r),
si(r),
si(r),
si(r)
),
2 => format!(
"modifyList(list(a = {}, b = {}), list(b = {}))",
si(r),
si(r),
si(r)
),
3 => format!("Reduce(`-`, 1:{n}, right = TRUE)"),
4 => format!("Reduce(`+`, 1:{n}, accumulate = TRUE, right = TRUE)"),
5 => format!(
"rapply(list({}, {}), function(x) x * 2, how = \"unlist\")",
si(r),
si(r)
),
6 => format!("vapply(1:{n}, function(x) c(x, x * x), numeric(2))"),
7 => format!("sapply(1:{n}, function(x) c(x, -x))"),
_ => format!("tapply(1:5, {keys}, length)"),
})
}
fn gen_indexing(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let v = vec_int(r);
let i = r.range(1, 4);
one(match r.below(10) {
0 => format!("m <- matrix(1:6, nrow = 2); m[{}, ]", r.range(1, 2)),
1 => format!("m <- matrix(1:6, nrow = 2); m[, {}]", r.range(1, 3)),
2 => format!(
"m <- matrix(1:6, nrow = 2); m[{}, {}]",
r.range(1, 2),
r.range(1, 3)
),
3 => format!("({v})[-{i}]"),
4 => format!("({v})[c(TRUE, FALSE)]"),
5 => format!(
"x <- c(a = 1, b = 2, c = 3); x[\"{}\"]",
*r.pick(&["a", "b", "c"])
),
6 => format!("({v})[{i}:{}]", r.range(1, 4)),
7 => format!(
"l <- list({}, {}, {}); l[[{}]]",
si(r),
si(r),
si(r),
r.range(1, 3)
),
8 => format!("({v})[({v}) > 0]"),
_ => format!("({v})[c(-1, -2)]"),
})
}
fn gen_replace(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
one(match r.below(9) {
0 => format!("x <- 1:5; x[{}] <- {}; x", r.range(1, 5), si(r)),
1 => format!("x <- 1:5; x[x > {}] <- 0; x", r.range(1, 3)),
2 => "x <- 1:3; names(x) <- c(\"a\", \"b\", \"c\"); x".to_string(),
3 => "x <- 1:6; dim(x) <- c(2, 3); x".to_string(),
4 => format!("x <- c(1, 2); length(x) <- {}; x", r.range(3, 5)),
5 => format!(
"m <- matrix(1:4, 2); m[{}, {}] <- 9; m",
r.range(1, 2),
r.range(1, 2)
),
6 => format!("l <- list(a = 1, b = 2); l$c <- {}; l", si(r)),
7 => format!("x <- 1:5; x[[{}]] <- {}; x", r.range(1, 5), si(r)),
_ => "x <- 1:5; x[-1] <- 0; x".to_string(),
})
}
fn gen_switch(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let key = *r.pick(&["a", "b", "c", "z"]);
let n = r.range(1, 4);
one(match r.below(8) {
0 => format!("switch(\"{key}\", a = 1, b = 2, c = 3)"),
1 => format!("switch(\"{key}\", a = 1, b = 2, 99)"),
2 => format!("switch({n}, \"x\", \"y\", \"z\")"),
3 => format!("switch(\"{key}\", a = , b = 2, c = 3)"),
4 => format!("f <- function(t) switch(t, a = \"A\", b = \"B\", \"?\"); f(\"{key}\")"),
5 => format!("x <- switch(\"{key}\", a = 10); is.null(x)"),
6 => "sapply(c(\"a\", \"b\"), function(x) switch(x, a = 1, b = 2))".to_string(),
_ => format!("switch({n} + 1, {}, {}, {})", si(r), si(r), si(r)),
})
}
fn gen_strx3(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let w = ww(r);
one(match r.below(7) {
0 => format!("casefold(\"{}\")", w.to_uppercase()),
1 => format!("casefold(\"{w}\", upper = TRUE)"),
2 => format!("chartr(\"a-e\", \"A-E\", \"{w}\")"),
3 => format!("chartr(\"a-z\", \"A-Z\", \"{w}{w}\")"),
4 => format!(
"f <- function(n) if (n <= 1) 1 else n * Recall(n - 1); f({})",
r.range(1, 8)
),
5 => format!(
"fib <- function(n) if (n < 2) n else Recall(n - 1) + Recall(n - 2); fib({})",
r.range(2, 12)
),
_ => format!("casefold(chartr(\"a-c\", \"A-C\", \"{w}\"))"),
})
}
fn gen_regexflags(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let s = format!("{}{}", ww(r), ww(r));
let pats = ["[A-C]+", "O+", "[AEIOU]", "L+", "[A-Z]{2}"];
let p = r.pick(&pats);
one(match r.below(6) {
0 => format!("grepl(\"{p}\", \"{s}\", ignore.case = TRUE)"),
1 => format!("gsub(\"{p}\", \"X\", \"{s}\", ignore.case = TRUE)"),
2 => format!("sub(\"{p}\", \"X\", \"{s}\", ignore.case = TRUE)"),
3 => format!("grepl(\"{}\", \"{s}\", fixed = TRUE)", &s[..1.min(s.len())]),
4 => format!(
"grep(\"{p}\", c(\"{s}\", \"{}\"), ignore.case = TRUE)",
ww(r)
),
_ => format!("gsub(\"[aeiou]\", \"_\", \"{s}\", ignore.case = TRUE)"),
})
}
fn gen_factorx(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let s = vec_str(r);
one(match r.below(8) {
0 => format!("as.integer(cut(1:{}, c(0, 2, 4, 6, 8)))", r.range(3, 8)),
1 => format!("nlevels(cut(1:{}, c(0, 5, 10)))", r.range(2, 10)),
2 => format!(
"cut(c({}, {}, {}), c(0, 3, 6, 9))",
r.range(1, 8),
r.range(1, 8),
r.range(1, 8)
),
3 => "levels(cut(1:9, c(0, 3, 6, 9)))".to_string(),
4 => format!("as.integer(droplevels(factor({s}, levels = c(\"a\", \"b\", \"c\", \"d\"))))"),
5 => format!("droplevels(factor({s}, levels = c(\"a\", \"b\", \"c\", \"d\", \"e\")))"),
6 => format!("factor({s}, levels = c(\"a\", \"b\", \"c\"), ordered = TRUE)"),
_ => format!("nlevels(droplevels(factor({s}, levels = c(\"a\", \"b\", \"c\", \"d\"))))"),
})
}
fn gen_deparsex(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
one(match r.below(8) {
0 => format!("deparse({}:{})", r.range(1, 3), r.range(4, 9)),
1 => format!("deparse(c({}, {}, {}))", ff(r), ff(r), ff(r)),
2 => format!("deparse(c(\"{}\", \"{}\"))", ww(r), ww(r)),
3 => format!("deparse({}L)", si(r)),
4 => "deparse(c(TRUE, FALSE, NA))".to_string(),
5 => format!("deparse({})", si(r)),
6 => format!(
"diff(c({}, {}, {}, {}), differences = 2)",
si(r),
si(r),
si(r),
si(r)
),
_ => format!("diff(1:{}, lag = {})", r.range(5, 10), r.range(1, 3)),
})
}
fn gen_fmtx(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
one(match r.below(8) {
0 => format!("format(c({}, {}, {}))", si(r), si(r), si(r)),
1 => format!("format(c({}, {}, {}))", ff(r), ff(r), ff(r)),
2 => format!("format(c(\"{}\", \"{}\", \"{}\"))", ww(r), ww(r), ww(r)),
3 => format!("sprintf(\"%o\", {})", r.range(0, 999)),
4 => format!(
"sprintf(\"%o %x %X\", {}, {}, {})",
r.range(0, 500),
r.range(0, 500),
r.range(0, 500)
),
5 => format!(
"format(c({}, {}), nsmall = {})",
ff(r),
ff(r),
r.range(1, 4)
),
6 => format!(
"format(c({}, {}, {}), big.mark = \",\")",
r.range(1000, 99999),
r.range(1000, 99999),
r.range(1000, 99999)
),
_ => format!(
"format(seq({}, {}, {}))",
r.range(0, 3),
r.range(8, 20),
ff(r)
),
})
}
fn gen_seqx2(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
one(match r.below(9) {
0 => format!("rep_len(1:{}, {})", r.range(2, 4), r.range(1, 9)),
1 => format!(
"seq.int({}, {}, {})",
r.range(0, 3),
r.range(8, 16),
r.range(2, 4)
),
2 => format!("rev(c(a = {}, b = {}, c = {}))", si(r), si(r), si(r)),
3 => format!("unname(c(x = {}, y = {}))", si(r), si(r)),
4 => format!(
"isTRUE(all.equal({}, {} + 1e-10))",
r.range(1, 9),
r.range(1, 9)
),
5 => format!("isTRUE(all.equal({}, {}))", si(r), si(r)),
6 => format!(
"all.equal(c({}, {}), c({}, {}))",
ff(r),
ff(r),
ff(r),
ff(r)
),
7 => format!(
"rep_len(c(\"{}\", \"{}\"), {})",
ww(r),
ww(r),
r.range(1, 7)
),
_ => "rev(setNames(1:3, c(\"a\", \"b\", \"c\")))".to_string(),
})
}
fn gen_combinator(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let v = vec_int(r);
one(match r.below(8) {
0 => format!("Negate(is.na)(c({}, NA, {}))", si(r), si(r)),
1 => format!(
"Filter(Negate(is.na), c({}, NA, {}, NA, {}))",
si(r),
si(r),
si(r)
),
2 => format!("Negate(function(x) x > 0)({v})"),
3 => format!("Vectorize(function(x) x ^ 2)(1:{})", r.range(2, 6)),
4 => format!(
"Vectorize(function(x, y) x + y)(1:{n}, {n}:1)",
n = r.range(2, 5)
),
5 => format!("sapply({v}, Negate(function(x) x > 0))"),
6 => "is.function(Negate(is.null))".to_string(),
_ => format!(
"Filter(Negate(function(x) x %% 2 == 0), 1:{})",
r.range(3, 9)
),
})
}
fn gen_arrays(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let (d0, d1, d2) = (r.range(2, 3), r.range(2, 3), r.range(2, 4));
let n = d0 * d1 * d2;
one(match r.below(9) {
0 => format!(
"array(1:{n}, c({d0}, {d1}, {d2}))[{}, {}, {}]",
r.range(1, d0),
r.range(1, d1),
r.range(1, d2)
),
1 => format!("dim(array(1:{n}, c({d0}, {d1}, {d2})))"),
2 => format!("apply(array(1:{n}, c({d0}, {d1}, {d2})), 3, sum)"),
3 => format!("apply(array(1:{n}, c({d0}, {d1}, {d2})), 1, max)"),
4 => format!(
"a <- array(1:{n}, c({d0}, {d1}, {d2})); a[, , {}]",
r.range(1, d2)
),
5 => format!(
"a <- array(1:{n}, c({d0}, {d1}, {d2})); a[{}, , ]",
r.range(1, d0)
),
6 => format!("array(1:{n}, c({d0}, {d1}, {d2}))"),
7 => format!("aperm(matrix(1:{}, {d0}))", d0 * d1),
_ => format!("length(array(0, c({d0}, {d1}, {d2})))"),
})
}
fn gen_stat2(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let v = vec_int(r);
one(match r.below(9) {
0 => format!(
"quantile(1:{}, {})",
r.range(4, 20),
*r.pick(&["0.25", "0.5", "0.75", "0.1"])
),
1 => format!("quantile(1:{})", r.range(4, 20)),
2 => format!("cor(1:{n}, (1:{n}) * {})", r.range(2, 5), n = r.range(3, 8)),
3 => format!(
"rle(c({}, {}, {}, {}, {}))$lengths",
r.range(1, 3),
r.range(1, 3),
r.range(1, 3),
r.range(1, 3),
r.range(1, 3)
),
4 => format!(
"rle(c({}, {}, {}, {}, {}))",
r.range(1, 2),
r.range(1, 2),
r.range(1, 2),
r.range(1, 2),
r.range(1, 2)
),
5 => format!(
"inverse.rle(rle(c({}, {}, {}, {})))",
r.range(1, 3),
r.range(1, 3),
r.range(1, 3),
r.range(1, 3)
),
6 => format!("sort({v}, index.return = TRUE)$ix"),
7 => format!("quantile({v})"),
_ => format!("cor({v}, rev({v}))"),
})
}
const EDGE_INTS: &[&str] = &[
"2147483647L",
"-2147483647L",
"2147483646L",
"46340L",
"46341L",
"1L",
"2L",
"-1L",
"0L",
"1000000L",
];
fn gen_condtext(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let a = *r.pick(EDGE_INTS);
let b = *r.pick(EDGE_INTS);
let n = r.range(2, 7);
let m = r.range(2, 7);
let w = ww(r);
let catch = |expr: String| {
format!(
"tryCatch({expr}, warning = function(w) paste(\"W:\", conditionMessage(w)), \
error = function(e) paste(\"E:\", conditionMessage(e)))"
)
};
one(catch(match r.below(24) {
0 => format!("{a} + {b}"),
1 => format!("{a} * {b}"),
2 => format!("{a} - {b}"),
3 => format!("c({a}, {b}) + 1L"),
4 => format!("cumsum(c({a}, {b}, 1L))"),
5 => format!("1:{n} + 1:{m}"),
6 => format!("1:{n} * 1:{m}"),
7 => format!("1:{n} < 1:{m}"),
8 => format!("as.integer(\"{w}\")"),
9 => format!("as.numeric(c(\"1\", \"{w}\"))"),
10 => format!("sqrt(-{n})"),
11 => format!("log(-{n})"),
12 => format!("as.integer({n}e9)"),
13 => format!("\"{w}\" + {n}"),
14 => format!("-\"{w}\""),
15 => format!("{w}_undefined_{n}"),
16 => format!("{w}_undefined_fn({n})"),
17 => format!("stop(\"{w}\", {n})"),
18 => format!("warning(\"{w}\", {n})"),
19 => format!("c(1, 2)[[{}]]", r.range(3, 5)),
20 => format!("list(a = 1)[[\"{w}\"]][[\"z\"]]"),
21 => format!("stopifnot({n} < {})", n - 1),
22 => format!("match.arg(\"{w}\", c(\"alpha\", \"beta\"))"),
_ => format!("switch(c(\"a\", \"b\"), a = {n})"),
}))
}
fn gen_bitw(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let pool = [
"0L",
"1L",
"5L",
"12L",
"255L",
"-1L",
"-8L",
"2147483647L",
"-2147483647L",
"NA_integer_",
"1:5",
"c(3L, 6L, 12L)",
"c(a = 1L, b = 6L)",
"7",
"2^31",
"5.5",
"TRUE",
"\"a\"",
];
let x = *r.pick(&pool);
let y = *r.pick(&pool);
let sh = ["0L", "1L", "4L", "30L", "31L", "32L", "-1L", "NA"];
let s = *r.pick(&sh);
let guard = |e: String| {
format!(
"tryCatch(print({e}), warning = function(w) cat(\"W:\", conditionMessage(w), \"\\n\"), \
error = function(e) cat(\"E:\", conditionMessage(e), \"\\n\"))"
)
};
one(guard(match r.below(9) {
0 => format!("bitwAnd({x}, {y})"),
1 => format!("bitwOr({x}, {y})"),
2 => format!("bitwXor({x}, {y})"),
3 => format!("bitwNot({x})"),
4 => format!("bitwShiftL({x}, {s})"),
5 => format!("bitwShiftR({x}, {s})"),
6 => format!("typeof(bitwAnd({x}, {y}))"),
7 => format!("bitwShiftL(c(1L, 2L, 3L), {s})"),
_ => format!("bitwAnd(bitwShiftL({x}, 1L), bitwShiftR({y}, 1L))"),
}))
}
fn gen_sysframes(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let depth = r.range(1, 3);
let which = r.range(-2, 2);
let probe = match r.below(7) {
0 => format!("sys.call({which})"),
1 => "sys.call()".to_string(),
2 => "sys.nframe()".to_string(),
3 => "match.call()".to_string(),
4 => format!("deparse(sys.call({which}))"),
5 => "length(sys.calls())".to_string(),
_ => format!("class(sys.function({which}))"),
};
let mut src = String::new();
for i in 1..=depth {
if i == depth {
src.push_str(&format!(
"f{i} <- function(x = 0, ...) {{ r <- {probe}; r }}\n"
));
} else {
src.push_str(&format!(
"f{i} <- function(x = 0, ...) f{}(x + 1, k = {i})\n",
i + 1
));
}
}
let args = match r.below(3) {
0 => "".to_string(),
1 => ii(r).to_string(),
_ => format!("x = {}, z = {}", ii(r), ww(r).len()),
};
src.push_str(&format!("r <- f1({args})\nprint(r)"));
one(src)
}
fn gen_visibility(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let lit = match r.below(5) {
0 => ii(r).to_string(),
1 => format!("\"{}\"", ww(r)),
2 => "NULL".to_string(),
3 => "TRUE".to_string(),
_ => format!("{}L", ii(r)),
};
let pre = match r.below(7) {
0 => "x <- 1".to_string(),
1 => "on.exit(cat(\"bye\\n\"))".to_string(),
2 => "invisible(7)".to_string(),
3 => "cat(\"hi\\n\")".to_string(),
4 => "suppressWarnings(warning(\"w\"))".to_string(),
5 => "NULL".to_string(),
_ => "y <- c(1, 2)".to_string(),
};
let tail = match r.below(4) {
0 => lit.clone(),
1 => format!("if (TRUE) {lit}"),
2 => format!("{{ {lit} }}"),
_ => format!("(function() {lit})()"),
};
one(match r.below(3) {
0 => format!("f <- function() {{ {pre}; {tail} }}\nf()"),
1 => format!(
"withCallingHandlers({{ warning(\"w\"); {tail} }}, \
warning = function(w) {{ cat(\"H\\n\"); invokeRestart(\"muffleWarning\") }})"
),
_ => format!("f <- function() {{ {pre}; {tail} }}\nprint(withVisible(f())$visible)"),
})
}
fn gen_arrelem(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let (nr, nc) = (r.range(2, 4), r.range(2, 4));
let i = r.range(1, nr + 1);
let j = r.range(1, nc + 1);
let k = r.range(1, 3);
let setup = match r.below(3) {
0 => format!("m <- matrix(1:{}, {nr})", nr * nc),
1 => format!(
"m <- matrix(c({}), {nr}, dimnames = list(letters[1:{nr}], LETTERS[1:{nc}]))",
(1..=nr * nc)
.map(|v| format!("{v}.5"))
.collect::<Vec<_>>()
.join(", ")
),
_ => format!("m <- matrix(as.list(letters[1:{}]), {nr})", nr * nc),
};
let access = match r.below(8) {
0 => format!("m[[{i}, {j}]]"),
1 => format!("m[[{j}, {i}]]"),
2 => format!(
"m[[\"{}\", \"{}\"]]",
["a", "b"][r.below(2)],
["A", "B"][r.below(2)]
),
3 => format!("m[[{i}, {}]]", nc + 1),
4 => format!("m[[{i}]]"),
5 => "m[[1, 1, 1]]".to_string(),
6 => "m[[c(1, 2), 1]]".to_string(),
_ => format!("{{ m[[{i}, {j}]] <- 0L; m[{i}, {j}] }}"),
};
let arr = format!(
"a <- array(1:24, c(2, 3, 4))\na[[{}, {}, {k}]]",
r.range(1, 2),
r.range(1, 3)
);
if r.below(5) == 0 {
one(arr)
} else {
one(format!(
"{setup}\ntryCatch(print({access}), error = function(e) cat(\"E:\", conditionMessage(e), \"\\n\"))"
))
}
}
fn gen_withx(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let (a, b) = (r.range(1, 9), r.range(1, 9));
let data = match r.below(3) {
0 => format!("list(a = {a}, b = {b})"),
1 => format!("list(a = c({a}, {b}), b = {b})"),
_ => "e".to_string(),
};
let setup = format!("e <- new.env()\nassign(\"a\", {a}, e)\nassign(\"b\", {b}, e)\nz <- 100\n");
let expr = match r.below(8) {
0 => format!("with({data}, a + b)"),
1 => format!("with({data}, a * z)"),
2 => format!("with({data}, {{ s <- a + b; s * 2 }})"),
3 => format!("with({data}, sum(a, b))"),
4 => "evalq(a + b, e)".to_string(),
5 => "evalq({ c <- a * b; c }, e)".to_string(),
6 => format!("(function() {{ z <- 5; with({data}, a + z) }})()"),
_ => format!("tryCatch(with({data}, a + nosuch), error = function(e) conditionMessage(e))"),
};
one(format!("{setup}{expr}"))
}
fn gen_rapplyx(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let nested = format!(
"list(a = {}, b = \"{}\", c = list(d = {}.5, e = \"{}\", f = {}L))",
ii(r),
ww(r),
ii(r),
ww(r),
ii(r)
);
let cls = *r.pick(&[
"\"character\"",
"\"numeric\"",
"\"integer\"",
"c(\"integer\", \"character\")",
"\"ANY\"",
]);
let how = *r.pick(&["unlist", "list", "replace"]);
let f = *r.pick(&[
"toupper",
"function(x) x",
"function(x) nchar(as.character(x))",
"is.character",
]);
one(match r.below(9) {
0..=2 => format!("str(rapply({nested}, {f}, classes = {cls}, how = \"{how}\"))"),
3 => format!(
"rapply({nested}, function(x) 1, classes = {cls}, deflt = NA, how = \"unlist\")"
),
4 => format!(
"Reduce(function(a, b) paste0(a, b), {}, accumulate = TRUE)",
vec_str(r)
),
5 => format!("Filter(function(x) x > {}, {})", ii(r), vec_int(r)),
6 => format!("Map(function(a, b) a * b, {}, {})", vec_int(r), vec_int(r)),
7 => format!(
"c(Position(function(x) x > {n}, {v}), Find(function(x) x > {n}, {v}))",
n = ii(r),
v = vec_int(r)
),
_ => format!(
"do.call(paste, c(as.list({}), sep = \"{}\"))",
vec_str(r),
r.pick(&["-", "", "+"])
),
})
}
fn gen_numtype(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let operand = [
"TRUE",
"FALSE",
"NA",
"1L",
"5L",
"-3L",
"2.5",
"c(TRUE, FALSE)",
"1:3",
"c(1L, NA)",
];
let x = *r.pick(&operand);
let y = *r.pick(&operand);
let op = *r.pick(&["+", "-", "*", "/", "^", "%%", "%/%"]);
one(match r.below(8) {
0 => format!("typeof(-{x})"),
1 => format!("-{x}"),
2 => format!("typeof(+{x})"),
3 => format!("typeof({x} {op} {y})"),
4 => format!("{x} {op} {y}"),
5 => format!("typeof(sum({x}))"),
6 => format!("c(typeof(cumsum({x})), typeof(cumprod({x})), typeof(abs({x})))"),
_ => format!("c(typeof(max({x})), typeof(range({x})), typeof(mean({x})))"),
})
}
fn gen_pastecls(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let cls = *r.pick(&["money", "tag", "id"]);
let val = *r.pick(&["1", "c(1.5, 2)", "1:3"]);
let methods = match r.below(4) {
0 => format!("as.character.{cls} <- function(x, ...) paste0(\"<\", unclass(x), \">\")\n"),
1 => format!("format.{cls} <- function(x, ...) paste0(\"[\", unclass(x), \"]\")\n"),
2 => format!("as.character.{cls} <- function(x, ...) \"AC\"\nformat.{cls} <- function(x, ...) \"FM\"\n"),
_ => String::new(),
};
let call = match r.below(6) {
0 => format!("paste(x, \"{}\")", ww(r)),
1 => "paste0(\"v=\", x)".to_string(),
2 => "format(x)".to_string(),
3 => "as.character(x)".to_string(),
4 => "toString(x)".to_string(),
_ => "paste(x, collapse = \"|\")".to_string(),
};
one(format!(
"x <- structure({val}, class = \"{cls}\")\n{methods}print({call})"
))
}
fn rand_value(r: &mut Rng, depth: u32) -> String {
let pick = if depth == 0 { r.below(6) } else { r.below(9) };
match pick {
0 => ii(r).to_string(),
1 => format!("{}.5", ii(r)),
2 => format!("\"{}\"", ww(r)),
3 => format!("c({}, {})", ii(r), ii(r)),
4 => format!("c(x = {}, {})", ii(r), ii(r)),
5 => "NULL".to_string(),
6 => format!("c(\"{}\", \"{}\")", ww(r), ww(r)),
_ => {
let n = r.range(1, 3) as usize;
let tags = ["a", "b", "c", "d"];
let named = r.below(3) > 0;
let items: Vec<String> = (0..n)
.map(|_| {
let v = rand_value(r, depth - 1);
if named && r.below(4) > 0 {
format!("{} = {v}", r.pick(&tags))
} else {
v
}
})
.collect();
format!("list({})", items.join(", "))
}
}
}
fn gen_unlistx(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let v = rand_value(r, 3);
let w = rand_value(r, 2);
let guard = |e: String| {
format!(
"tryCatch(print({e}), error = function(e) cat(\"E:\", conditionMessage(e), \"\\n\"))"
)
};
one(guard(match r.below(10) {
0..=2 => format!("unlist({v})"),
3 => format!("unlist({v}, use.names = FALSE)"),
4 => format!("unlist({v}, recursive = FALSE)"),
5 => format!("c({v}, {w})"),
6 => format!("c(p = {v}, q = {w})"),
7 => format!("lengths(list(A = {v}, B = {w}))"),
8 => format!("names(unlist(list(k = {v}, {w})))"),
_ => format!("sapply(list({v}, {w}), length)"),
}))
}
fn gen_strx(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let v = rand_value(r, 2);
let extra = match r.below(6) {
0 => ", vec.len = 2".to_string(),
1 => ", give.attr = FALSE".to_string(),
2 => ", max.level = 1".to_string(),
3 => ", give.head = FALSE".to_string(),
_ => String::new(),
};
let more = match r.below(5) {
0 => format!(
"c({}, {}, {}, {}, {}, {})",
ff(r),
ff(r),
ff(r),
ff(r),
ff(r),
ff(r)
),
1 => format!("{}:{}", ii(r), r.range(11, 40)),
2 => format!(
"factor(c(\"{}\", \"{}\", \"{}\", \"{}\"))",
ww(r),
ww(r),
ww(r),
ww(r)
),
3 => format!("c({}e{}, {})", ii(r), r.range(3, 9), ff(r)),
_ => format!("c(TRUE, NA, FALSE, {})", ["TRUE", "NA"][r.below(2)]),
};
one(match r.below(3) {
0 => format!("str({v}{extra})"),
1 => format!("str({more}{extra})"),
_ => format!("str(list(a = {v}, b = {more}){extra})"),
})
}
fn gen_assignx(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let base = match r.below(6) {
0 => "x <- 1:6".to_string(),
1 => "x <- c(a = 1, b = 2, c = 3)".to_string(),
2 => "x <- c(\"p\", \"q\", \"r\")".to_string(),
3 => "x <- list(a = 1, b = \"z\", c = 1:2)".to_string(),
4 => "x <- matrix(1:6, 2, dimnames = list(c(\"r1\", \"r2\"), c(\"A\", \"B\", \"C\")))"
.to_string(),
_ => "x <- c(TRUE, FALSE, NA)".to_string(),
};
let val = match r.below(7) {
0 => ii(r).to_string(),
1 => format!("{}L", ii(r)),
2 => format!("\"{}\"", ww(r)),
3 => format!("c({}, {})", ii(r), ii(r)),
4 => format!("c({}, {}, {})", ii(r), ii(r), ii(r)),
5 => "NULL".to_string(),
_ => "NA".to_string(),
};
let idx = match r.below(9) {
0 => r.range(1, 3).to_string(),
1 => "7".to_string(),
2 => "c(1, 3)".to_string(),
3 => "-1".to_string(),
4 => "\"a\"".to_string(),
5 => "\"new\"".to_string(),
6 => "c(TRUE, FALSE)".to_string(),
7 => "NA".to_string(),
_ => "0".to_string(),
};
let stmt = match r.below(12) {
0..=2 => format!("x[{idx}] <- {val}"),
3 => format!("x[[{idx}]] <- {val}"),
4 => format!("x[{idx}, ] <- {val}"),
5 => format!("x[, {idx}] <- {val}"),
6 => format!("x$a <- {val}"),
7 => format!(
"names(x) <- c(\"u\", \"v\"{})",
["", ", \"w\"", ", \"w\", \"y\", \"z\", \"k\", \"m\""][r.below(3)]
),
8 => format!("length(x) <- {}", r.range(0, 9)),
9 => format!("dim(x) <- c({}, {})", r.range(1, 4), r.range(1, 4)),
10 => format!("is.na(x) <- {idx}"),
_ => format!(
"attr(x, \"{}\") <- {val}",
["names", "dim", "foo"][r.below(3)]
),
};
one(format!(
"{base}\nres <- withCallingHandlers(tryCatch({{ {stmt}; x }}, \
error = function(e) paste(\"E:\", conditionMessage(e))), \
warning = function(w) {{ cat(\"W:\", conditionMessage(w), \"\\n\"); invokeRestart(\"muffleWarning\") }})\n\
print(res)"
))
}
fn gen_tablex(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let col = |r: &mut Rng, pool: &[&str]| {
let n = r.range(3, 7) as usize;
let items: Vec<String> = (0..n)
.map(|_| match r.below(8) {
0 => "NA".to_string(),
_ => format!("\"{}\"", r.pick(pool)),
})
.collect();
format!("c({})", items.join(", "))
};
let g1 = col(r, &["a", "b", "c"]);
let g2 = col(r, &["x", "y"]);
let opts = match r.below(6) {
0 => ", useNA = \"always\"".to_string(),
1 => ", useNA = \"ifany\"".to_string(),
2 => ", exclude = NULL".to_string(),
3 => ", exclude = \"a\"".to_string(),
4 => ", dnn = c(\"first\", \"second\")".to_string(),
_ => String::new(),
};
let two = r.below(2) == 0;
let setup = if two {
format!("g1 <- {g1}\ng2 <- {g2}\nn <- min(length(g1), length(g2))\nt <- table(g1[1:n], g2[1:n]{opts})")
} else {
format!("g1 <- {g1}\nt <- table(g1{opts})")
};
let probe = match r.below(9) {
0 => "print(t)",
1 => "print(t * 2L)",
2 => "print(names(dimnames(t)))",
3 => "print(dim(t))",
4 => "print(margin.table(t, 1))",
5 => "print(round(prop.table(t), 2))",
6 => "print(t[1])",
7 => "print(as.vector(t))",
_ => "print(summary(as.vector(t)))",
};
one(format!("{setup}\n{probe}"))
}
fn gen_regexx(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let subject = match r.below(6) {
0 => "aabbcc",
1 => "hello world",
2 => "abcabc",
3 => "x1y22z333",
4 => "CamelCaseWords",
_ => "a.b.c",
};
let pat = match r.below(14) {
0 => "(.)BS1",
1 => "(a)(b)BS2BS1",
2 => "(?<=a)b",
3 => "a(?=b)",
4 => "(?<![a-z])[a-z]",
5 => "[0-9]+",
6 => "^.",
7 => ".$",
8 => "(?<=[a-z])(?=[A-Z])",
9 => "BSw+",
10 => "(BSw)(BSw)",
11 => "BS.",
12 => "o|l+",
_ => "[aeiou]",
};
let perl = pat.contains("(?") || r.below(3) == 0;
let rep = ["X", "<BS0>", "BS1-BS1", "BSUBS1", "[BS1]"][r.below(5)];
let call = match r.below(8) {
0 | 1 => format!(
"gsub(p, \"{rep}\", s{})",
if perl { ", perl = TRUE" } else { "" }
),
2 => format!(
"sub(p, \"{rep}\", s{})",
if perl { ", perl = TRUE" } else { "" }
),
3 => format!("grepl(p, s{})", if perl { ", perl = TRUE" } else { "" }),
4 => format!(
"regmatches(s, gregexpr(p, s{}))",
if perl { ", perl = TRUE" } else { "" }
),
5 => format!("strsplit(s, p{})", if perl { ", perl = TRUE" } else { "" }),
6 => format!(
"as.integer(regexpr(p, s{}))",
if perl { ", perl = TRUE" } else { "" }
),
_ => format!(
"lengths(gregexpr(p, s{}))",
if perl { ", perl = TRUE" } else { "" }
),
};
let rep_lit = |t: &str| t.replace("BS", "\" , bs, \"");
let build = |t: &str| format!("paste0(\"{}\")", t.replace("BS", "\", bs, \""));
let _ = rep_lit;
let call = call
.replace("p,", &format!("{},", build(pat)))
.replace("(p)", &format!("({})", build(pat)))
.replace(&format!("\"{rep}\""), &build(rep));
let _ = call.len();
one(format!(
"bs <- intToUtf8(92)\ns <- \"{subject}\"\ntryCatch(print({call}), error = function(e) cat(\"E:\", conditionMessage(e), \"\\n\"))"
))
}
fn gen_cutx(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let n = r.range(3, 8);
let xs: Vec<String> = (0..n).map(|_| format!("{}", r.range(0, 12))).collect();
let x = format!("c({})", xs.join(", "));
let nb = r.range(2, 4) as usize;
let mut brk: Vec<i64> = (0..nb).map(|_| r.range(0, 12)).collect();
brk.sort();
if r.below(5) > 0 {
brk.dedup();
}
let breaks = if r.below(4) == 0 {
format!("{}", r.range(2, 4))
} else {
format!(
"c({})",
brk.iter()
.map(|b| b.to_string())
.collect::<Vec<_>>()
.join(", ")
)
};
let mut opts = String::new();
if r.below(2) == 0 {
opts.push_str(", right = FALSE");
}
if r.below(2) == 0 {
opts.push_str(", include.lowest = TRUE");
}
if r.below(4) == 0 {
opts.push_str(", dig.lab = 2");
}
if r.below(5) == 0 {
opts.push_str(", ordered_result = TRUE");
}
if r.below(6) == 0 {
opts.push_str(", labels = FALSE");
}
let call = format!("cut({x}, {breaks}{opts})");
one(format!(
"tryCatch({}, error = function(e) cat(\"E:\", conditionMessage(e), \"\\n\"))",
match r.below(3) {
0 => format!("print({call})"),
1 => format!("print(table({call}))"),
_ => format!("print(levels({call}))"),
}
))
}
fn gen_applyx(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let (nr, nc) = (r.range(2, 3), r.range(2, 4));
let named = r.below(3);
let dn = match named {
0 => String::new(),
1 => format!(", dimnames = list(letters[1:{nr}], LETTERS[1:{nc}])"),
_ => format!(", dimnames = list(r = letters[1:{nr}], c = LETTERS[1:{nc}])"),
};
let m = format!("matrix(1:{}, {nr}{dn})", nr * nc);
let f = *r.pick(&[
"sum",
"range",
"function(v) v * 2",
"function(v) paste(v, collapse = \"-\")",
"function(v) list(v)",
"function(v) c(lo = min(v), hi = max(v))",
"function(v) v[v > 2]",
"length",
]);
one(match r.below(8) {
0 => format!("print(apply({m}, 1, {f}))"),
1 => format!("print(apply({m}, 2, {f}))"),
2 => format!("print(apply({m}, c(1, 2), function(v) v + 1))"),
3 => format!("print(sapply(1:{nc}, function(j) c(a = j, b = j^2)))"),
4 => format!("print(sapply(list(p = 1:3, q = 4:6), {f}))"),
5 => "print(vapply(list(p = 1:3, q = 4:6), function(v) c(s = sum(v), m = mean(v)), numeric(2)))".to_string(),
6 => format!("print(mapply(function(a, b) c(a, b), 1:{nc}, {nc}:1))"),
_ => "print(Map(function(a, b) a + b, c(u = 1, v = 2), 3:4))".to_string(),
})
}
fn gen_errtext2(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let n = r.range(2, 5);
let w = ww(r);
let both = |e: String| {
format!(
"tryCatch({e}, warning = function(w) paste(\"W:\", conditionMessage(w)), \
error = function(e) paste(\"E:\", conditionMessage(e)))"
)
};
one(both(match r.below(34) {
0 => format!(
"rep(1:3, times = {})",
["-1", "1:2", "NA", "c(1, 2, 3, 4)"][r.below(4)]
),
1 => format!("rep(1:3, each = -{n})"),
2 => format!("seq(1, 10, by = {})", ["-1", "0", "NA"][r.below(3)]),
3 => format!("seq_len({})", ["-1", "NA", "\"a\"", "c(1, 2)"][r.below(4)]),
4 => format!("matrix(1:{}, {})", n * 3 + 1, n),
5 => format!("cbind(1:{n}, 1:{})", n + 1),
6 => format!("rbind(matrix(1:4, 2), matrix(1:{}, 2))", n * 2 + 2),
7 => format!("if (c(TRUE, FALSE)) {n}"),
8 => format!(
"if ({}) 1",
["NA", "NULL", "\"a\"", "logical(0)"][r.below(4)]
),
9 => format!("{n} && c(TRUE, FALSE)"),
10 => format!("sum(\"{w}\")"),
11 => format!("(1:{n})[[{}]]", n + 3),
12 => format!("list(a = 1)${w}$z"),
13 => format!("(1:{n})${w}"),
14 => format!(
"matrix(1:4, 2)[{}]",
["3, 1", "1, 3", "1, 1, 1", "\"a\", 1"][r.below(4)]
),
15 => format!("(function(x) x)({})", ["", "1, 2", "y = 2"][r.below(3)]),
16 => format!(
"stopifnot({})",
["1 == 2", "c(TRUE, FALSE)", "is.character(1)", "NA"][r.below(4)]
),
17 => format!("match.arg(\"{w}\", c(\"alpha\", \"beta\"))"),
18 => format!("get(\"{w}_nope\")"),
19 => format!("do.call(\"{w}_nofun\", list())"),
20 => format!("lapply(1:{n}, \"{w}_nofun\")"),
21 => format!("vapply(1:{n}, function(i) \"a\", numeric(1))"),
22 => format!("vapply(1:{n}, function(i) 1:2, numeric(1))"),
23 => format!("Reduce(\"+\", list(1, \"{w}\"))"),
24 => format!("as.integer(list(1, 1:{n}))"),
25 => format!("vector(\"{w}\", {n})"),
26 => format!("{{ x <- 1:{n}; names(x) <- letters[1:{}]; x }}", n + 2),
27 => format!("{{ x <- 1:{n}; x[1:2] <- 1:{}; x }}", n + 1),
28 => "{ x <- 1:6; x[c(-1, 2)] }".to_string(),
29 => format!("{{ m <- matrix(0, 2, 2); m[, 1] <- 1:{}; m }}", n + 1),
30 => format!("{{ x <- 1:3; dim(x) <- c({n}, {n}); x }}"),
31 => format!("apply(1:{n}, 1, sum)"),
32 => format!("factorial({})", ["-1", "171", "\"a\""][r.below(3)]),
_ => format!("strtoi(\"{w}\", {})", ["99", "1", "36"][r.below(3)]),
}))
}
#[derive(Clone, Copy)]
enum Mode {
Arith,
Numfmt,
Vectors,
Seqrep,
Vecmath,
Sortops,
Strings,
Strproc,
Sprintf,
Logical,
Ifelse,
Control,
Funcs,
Apply,
Lists,
Matrix,
Types,
Setops,
Rounding,
Bitops,
Factor,
Trig,
Mathfn,
Pmaxmin,
Linalg,
Stringx,
Listx,
Predicates,
Numedge,
Strx2,
Listx2,
Indexing,
Replace,
Switch,
Strx3,
Regexflags,
Factorx,
Deparsex,
Fmtx,
Seqx2,
Combinator,
Arrays,
Stat2,
Deparsefn,
Bindlabels,
Dimnames,
Ordering,
Missing,
S3methods,
Catargs,
Pastex,
Formatsci,
Parens,
Seqfmt,
Typepred,
Factorsub,
Factorops,
Conditions,
Calling,
Restarts,
Strwidth,
Collate,
Optsfmt,
Condtext,
Bitw,
Sysframes,
Visibility,
Arrelem,
Withx,
Rapplyx,
Numtype,
Pastecls,
Unlistx,
Strx,
Assignx,
Tablex,
Regexx,
Cutx,
Applyx,
Errtext2,
}
const ALL_MODES: &[Mode] = &[
Mode::Arith,
Mode::Numfmt,
Mode::Vectors,
Mode::Seqrep,
Mode::Vecmath,
Mode::Sortops,
Mode::Strings,
Mode::Strproc,
Mode::Sprintf,
Mode::Logical,
Mode::Ifelse,
Mode::Control,
Mode::Funcs,
Mode::Apply,
Mode::Lists,
Mode::Matrix,
Mode::Types,
Mode::Setops,
Mode::Rounding,
Mode::Bitops,
Mode::Factor,
Mode::Trig,
Mode::Mathfn,
Mode::Pmaxmin,
Mode::Linalg,
Mode::Stringx,
Mode::Listx,
Mode::Predicates,
Mode::Numedge,
Mode::Strx2,
Mode::Listx2,
Mode::Indexing,
Mode::Replace,
Mode::Switch,
Mode::Strx3,
Mode::Regexflags,
Mode::Factorx,
Mode::Deparsex,
Mode::Fmtx,
Mode::Seqx2,
Mode::Combinator,
Mode::Arrays,
Mode::Stat2,
Mode::Deparsefn,
Mode::Bindlabels,
Mode::Dimnames,
Mode::Ordering,
Mode::Missing,
Mode::S3methods,
Mode::Catargs,
Mode::Pastex,
Mode::Formatsci,
Mode::Parens,
Mode::Seqfmt,
Mode::Typepred,
Mode::Factorsub,
Mode::Factorops,
Mode::Conditions,
Mode::Calling,
Mode::Restarts,
Mode::Strwidth,
Mode::Collate,
Mode::Optsfmt,
Mode::Condtext,
Mode::Bitw,
Mode::Sysframes,
Mode::Visibility,
Mode::Arrelem,
Mode::Withx,
Mode::Rapplyx,
Mode::Numtype,
Mode::Pastecls,
Mode::Unlistx,
Mode::Strx,
Mode::Assignx,
Mode::Tablex,
Mode::Regexx,
Mode::Cutx,
Mode::Applyx,
Mode::Errtext2,
];
fn gen_case(seed: u64, mode: Mode) -> Vec<String> {
match mode {
Mode::Arith => gen_arith(seed),
Mode::Numfmt => gen_numfmt(seed),
Mode::Vectors => gen_vectors(seed),
Mode::Seqrep => gen_seqrep(seed),
Mode::Vecmath => gen_vecmath(seed),
Mode::Sortops => gen_sortops(seed),
Mode::Strings => gen_strings(seed),
Mode::Strproc => gen_strproc(seed),
Mode::Sprintf => gen_sprintf(seed),
Mode::Logical => gen_logical(seed),
Mode::Ifelse => gen_ifelse(seed),
Mode::Control => gen_control(seed),
Mode::Funcs => gen_funcs(seed),
Mode::Apply => gen_apply(seed),
Mode::Lists => gen_lists(seed),
Mode::Matrix => gen_matrix(seed),
Mode::Types => gen_types(seed),
Mode::Setops => gen_setops(seed),
Mode::Rounding => gen_rounding(seed),
Mode::Bitops => gen_bitops(seed),
Mode::Factor => gen_factor(seed),
Mode::Trig => gen_trig(seed),
Mode::Mathfn => gen_mathfn(seed),
Mode::Pmaxmin => gen_pmaxmin(seed),
Mode::Linalg => gen_linalg(seed),
Mode::Stringx => gen_stringx(seed),
Mode::Listx => gen_listx(seed),
Mode::Predicates => gen_predicates(seed),
Mode::Numedge => gen_numedge(seed),
Mode::Strx2 => gen_strx2(seed),
Mode::Listx2 => gen_listx2(seed),
Mode::Indexing => gen_indexing(seed),
Mode::Replace => gen_replace(seed),
Mode::Switch => gen_switch(seed),
Mode::Strx3 => gen_strx3(seed),
Mode::Regexflags => gen_regexflags(seed),
Mode::Factorx => gen_factorx(seed),
Mode::Deparsex => gen_deparsex(seed),
Mode::Fmtx => gen_fmtx(seed),
Mode::Seqx2 => gen_seqx2(seed),
Mode::Combinator => gen_combinator(seed),
Mode::Arrays => gen_arrays(seed),
Mode::Stat2 => gen_stat2(seed),
Mode::Deparsefn => gen_deparsefn(seed),
Mode::Bindlabels => gen_bindlabels(seed),
Mode::Dimnames => gen_dimnames(seed),
Mode::Ordering => gen_ordering(seed),
Mode::Missing => gen_missing(seed),
Mode::S3methods => gen_s3methods(seed),
Mode::Catargs => gen_catargs(seed),
Mode::Pastex => gen_pastex(seed),
Mode::Formatsci => gen_formatsci(seed),
Mode::Parens => gen_parens(seed),
Mode::Seqfmt => gen_seqfmt(seed),
Mode::Typepred => gen_typepred(seed),
Mode::Factorsub => gen_factorsub(seed),
Mode::Factorops => gen_factorops(seed),
Mode::Conditions => gen_conditions(seed),
Mode::Calling => gen_calling(seed),
Mode::Restarts => gen_restarts(seed),
Mode::Strwidth => gen_strwidth(seed),
Mode::Collate => gen_collate(seed),
Mode::Optsfmt => gen_optsfmt(seed),
Mode::Condtext => gen_condtext(seed),
Mode::Bitw => gen_bitw(seed),
Mode::Sysframes => gen_sysframes(seed),
Mode::Visibility => gen_visibility(seed),
Mode::Arrelem => gen_arrelem(seed),
Mode::Withx => gen_withx(seed),
Mode::Rapplyx => gen_rapplyx(seed),
Mode::Numtype => gen_numtype(seed),
Mode::Pastecls => gen_pastecls(seed),
Mode::Unlistx => gen_unlistx(seed),
Mode::Strx => gen_strx(seed),
Mode::Assignx => gen_assignx(seed),
Mode::Tablex => gen_tablex(seed),
Mode::Regexx => gen_regexx(seed),
Mode::Cutx => gen_cutx(seed),
Mode::Applyx => gen_applyx(seed),
Mode::Errtext2 => gen_errtext2(seed),
}
}
fn gen_deparsefn(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let body = match r.below(10) {
0 => format!("x {} {}", r.pick(&["+", "-", "*", "/", "^"]), ii(r)),
1 => format!("if (x > {}) x else {}", si(r), si(r)),
2 => format!(
"{{\n y <- x * {}\n if (y > {}) y else {}\n y\n}}",
ii(r),
si(r),
si(r)
),
3 => format!("{{\n for (i in 1:{}) x <- x + i\n x\n}}", r.range(1, 5)),
4 => format!("{{\n while (x > {}) x <- x - 1\n x\n}}", ii(r)),
5 => format!("(x + {}) * {}", si(r), ii(r)),
6 => format!("c(a = {}, b = \"{}\")", ff(r), ww(r)),
7 => "function(y) x + y".to_string(),
8 => format!(
"{{\n if (x) {{\n {}\n }} else {{\n {}\n }}\n}}",
ii(r),
ii(r)
),
_ => format!("x[[{}]]$k", r.range(1, 3)),
};
let params = match r.below(4) {
0 => "x".to_string(),
1 => format!("x, y = {}", ii(r)),
2 => format!("x, y = c({}, {}), z = \"{}\"", ff(r), ff(r), ww(r)),
_ => "x, ...".to_string(),
};
let show = match r.below(3) {
0 => "print(f)",
1 => "print(deparse(f))",
_ => "print(format(f))",
};
vec![format!("f <- function({params}) {body}"), show.to_string()]
}
fn gen_bindlabels(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let f = r.pick(&["rbind", "cbind"]);
let setup = vec![
format!("x <- c({}, {}, {})", si(r), si(r), si(r)),
format!("y <- c({}, {}, {})", si(r), si(r), si(r)),
];
let call = match r.below(9) {
0 => format!("{f}(x, y)"),
1 => format!("{f}(x, x)"),
2 => format!("{f}(a = x, y)"),
3 => format!("{f}(x, c({}, {}, {}))", si(r), si(r), si(r)),
4 => format!("{f}(x, y, deparse.level = 0)"),
5 => format!("{f}(x, y, deparse.level = 2)"),
6 => format!("{f}(x + 0, y)"),
7 => format!("{f}({f}(x, y), x)"),
_ => format!("{f}(x)"),
};
let mut out = setup;
out.push(format!("print({call})"));
out
}
fn gen_dimnames(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let mut out = vec![format!(
"m <- matrix(1:6, nrow = 2{})",
if r.below(2) == 0 {
", byrow = TRUE"
} else {
""
}
)];
match r.below(8) {
0 => {
out.push("dimnames(m) <- list(c(\"r1\", \"r2\"), c(\"c1\", \"c2\", \"c3\"))".into());
out.push("print(m)".into());
}
1 => {
out.push("rownames(m) <- c(\"p\", \"q\")".into());
out.push("print(m)".into());
out.push("print(dimnames(m))".into());
}
2 => {
out.push("colnames(m) <- c(\"i\", \"j\", \"k\")".into());
out.push("print(m)".into());
out.push("print(colnames(m))".into());
}
3 => {
out.push("dimnames(m) <- list(c(\"r1\", \"r2\"), c(\"c1\", \"c2\", \"c3\"))".into());
out.push(format!("print(apply(m, {}, sum))", r.range(1, 2)));
}
4 => {
out.push("dimnames(m) <- list(c(\"r1\", \"r2\"), c(\"c1\", \"c2\", \"c3\"))".into());
out.push(format!("print(apply(m, {}, range))", r.range(1, 2)));
}
5 => {
out.push("rownames(m) <- c(\"p\", \"q\")".into());
out.push("rownames(m) <- NULL".into());
out.push("print(m)".into());
}
6 => {
out.push("dimnames(m) <- list(c(\"r1\", \"r2\"), c(\"c1\", \"c2\", \"c3\"))".into());
out.push("print(m[\"r1\", ])".into());
out.push("print(m[, \"c2\"])".into());
}
_ => {
out.push("dimnames(m) <- list(NULL, c(\"c1\", \"c2\", \"c3\"))".into());
out.push("print(m)".into());
}
}
out
}
fn gen_ordering(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let v = format!("c({}, NA, {}, {})", si(r), si(r), si(r));
let s = format!("c(\"{}\", NA, \"{}\")", ww(r), ww(r));
one(match r.below(10) {
0 => format!("print(sort({v}))"),
1 => format!("print(sort({v}, na.last = TRUE))"),
2 => format!("print(sort({v}, na.last = FALSE))"),
3 => format!("print(order({v}))"),
4 => format!("print(order({v}, na.last = FALSE))"),
5 => format!("print(order({v}, decreasing = TRUE))"),
6 => format!("print(sort({s}, na.last = TRUE))"),
7 => format!(
"print(order(c({a}, {a}, {b}), c({c}, {d}, {d})))",
a = ii(r),
b = ii(r),
c = ii(r),
d = ii(r)
),
8 => format!(
"print(sort(c({a}, {a}, {b}), decreasing = TRUE))",
a = ii(r),
b = ii(r)
),
_ => format!(
"print(order(c({a}, {a}, {b}), decreasing = TRUE))",
a = ii(r),
b = ii(r)
),
})
}
fn gen_missing(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let f = r.pick(&[
"mean", "median", "sum", "prod", "max", "min", "var", "sd", "range",
]);
let v = match r.below(6) {
0 => format!("c({}, NA)", ff(r)),
1 => format!("c({}, NaN)", ff(r)),
2 => "c(NA, NaN)".to_string(),
3 => "c(NaN, NA)".to_string(),
4 => format!("c({}, NA, NaN, {})", ff(r), ff(r)),
_ => format!("c({}, {}, NA)", ff(r), ff(r)),
};
one(if r.below(2) == 0 {
format!("print({f}({v}))")
} else {
format!("print({f}({v}, na.rm = TRUE))")
})
}
fn gen_s3methods(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let body = match r.below(3) {
0 => format!("c({}, {})", ii(r), ii(r)),
1 => format!("list({}, \"{}\")", ii(r), ww(r)),
_ => format!("\"{}\"", ww(r)),
};
let mut out = vec![format!("obj <- structure({body}, class = \"kk\")")];
match r.below(6) {
0 => {
out.push("print.kk <- function(x, ...) cat(\"<kk>\\n\")".into());
out.push("print(obj)".into());
out.push("obj".into());
}
1 => {
out.push(format!("format.kk <- function(x, ...) \"{}\"", ww(r)));
out.push("print(format(obj))".into());
}
2 => {
out.push(format!("as.character.kk <- function(x, ...) \"{}\"", ww(r)));
out.push("print(as.character(obj))".into());
}
3 => {
out.push(format!("length.kk <- function(x) {}L", r.range(1, 9)));
out.push("print(length(obj))".into());
}
4 => out.push("print(obj)".into()),
_ => out.push("obj".into()),
}
out
}
fn gen_catargs(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
one(match r.below(10) {
0 => format!("cat(NULL, \"{}\")", ww(r)),
1 => format!("cat(character(0), \"{}\", \"\\n\")", ww(r)),
2 => format!("cat(\"{}\", NULL, \"{}\", \"\\n\")", ww(r), ww(r)),
3 => format!("cat(list({}), \"\\n\")", ii(r)),
4 => "cat(list())".to_string(),
5 => format!("cat({}, {}, sep = \"\")", ii(r), ii(r)),
6 => format!("cat(c(\"{}\", \"{}\"), sep = \"\\n\")", ww(r), ww(r)),
7 => format!("cat(\"{}\", list({}))", ww(r), ii(r)),
8 => format!("cat({}:{}, \"\\n\")", ii(r), r.range(3, 8)),
_ => format!("cat(NULL, NULL, \"{}\")", ww(r)),
})
}
fn gen_pastex(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
one(match r.below(9) {
0 => format!("print(paste(\"{}\", NULL, \"{}\"))", ww(r), ww(r)),
1 => format!("print(paste(\"{}\", character(0), \"{}\"))", ww(r), ww(r)),
2 => format!("print(paste0(\"{}\", NULL))", ww(r)),
3 => "print(paste(NULL))".to_string(),
4 => format!("print(paste(NULL, collapse = \"{}\"))", ww(r)),
5 => format!("print(paste(1:{}, 1:{}))", r.range(2, 3), r.range(4, 6)),
6 => format!(
"print(paste(\"{}\", 1:{}, sep = \"-\"))",
ww(r),
r.range(1, 4)
),
7 => format!("print(paste(c(\"{}\", NA), \"{}\"))", ww(r), ww(r)),
_ => format!(
"print(paste(c(\"{}\", \"{}\"), collapse = \"{}\"))",
ww(r),
ww(r),
r.pick(&["+", "", ", "])
),
})
}
fn gen_formatsci(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let big = [
"1e6", "1e5", "123456", "1234567", "1e-4", "1e-10", "0.0001", "100000",
];
let v = r.pick(&big);
one(match r.below(9) {
0 => format!("print(format({v}))"),
1 => format!("print(format({v}, big.mark = \",\"))"),
2 => format!("print(format({v}, nsmall = {}))", r.range(1, 4)),
3 => format!("print(format({v}, digits = {}))", r.range(1, 5)),
4 => format!("print(format({v}, scientific = FALSE))"),
5 => format!("print(format({v}, scientific = TRUE))"),
6 => format!("print(format(c({v}, {})))", ii(r)),
7 => format!("print(format({v}, width = {}))", r.range(1, 12)),
_ => format!("print(format(c({v}, NA, Inf)))"),
})
}
fn gen_parens(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
one(match r.below(7) {
0 => format!("(x <- {})", ii(r)),
1 => format!("x <- {}\n(x)", ii(r)),
2 => format!("(invisible({}))", ii(r)),
3 => format!("print(({} + {}) * {})", ii(r), ii(r), ii(r)),
4 => format!("f <- function() invisible({})\n(f())", ii(r)),
5 => format!("(({}))", ii(r)),
_ => format!("x <- c({}, {})\n(x[1])", ii(r), ii(r)),
})
}
fn gen_seqfmt(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
one(match r.below(9) {
0 => format!(
"print(seq(along.with = c({}, {}, {})))",
ii(r),
ii(r),
ii(r)
),
1 => format!(
"print(seq({}, {}, length.out = {}))",
ii(r),
r.range(5, 20),
r.range(2, 5)
),
2 => format!(
"print(seq({}, {}, by = {}))",
ii(r),
r.range(5, 20),
r.range(2, 4)
),
3 => format!("print(seq_len({}))", r.range(0, 5)),
4 => format!(
"print(sprintf(\"%*d\", {}, {}))",
r.range(1, 8),
r.range(1, 999)
),
5 => format!(
"print(sprintf(\"%-*d|\", {}, {}))",
r.range(1, 8),
r.range(1, 999)
),
6 => format!("print(sprintf(\"%.*f\", {}, {}))", r.range(0, 5), ff(r)),
7 => format!("print(sprintf(\"%*s|\", {}, \"{}\"))", r.range(1, 9), ww(r)),
_ => format!("print(seq({}))", r.range(0, 6)),
})
}
fn gen_typepred(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let f = r.pick(&[
"is.numeric",
"is.double",
"is.integer",
"is.character",
"is.logical",
"is.vector",
"is.list",
"is.null",
]);
let v = match r.below(8) {
0 => format!("{}L", ii(r)),
1 => ff(r).to_string(),
2 => format!("\"{}\"", ww(r)),
3 => format!("factor(c(\"{}\", \"{}\"))", ww(r), ww(r)),
4 => "TRUE".to_string(),
5 => "NULL".to_string(),
6 => format!("list({})", ii(r)),
_ => format!("1:{}", r.range(2, 5)),
};
one(match r.below(3) {
0 => format!("print({f}({v}))"),
1 => format!("print(class({v}))"),
_ => format!("print(c(class({v}), typeof({v})))"),
})
}
fn mode_name(m: Mode) -> &'static str {
match m {
Mode::Arith => "arith",
Mode::Numfmt => "numfmt",
Mode::Vectors => "vectors",
Mode::Seqrep => "seqrep",
Mode::Vecmath => "vecmath",
Mode::Sortops => "sortops",
Mode::Strings => "strings",
Mode::Strproc => "strproc",
Mode::Sprintf => "sprintf",
Mode::Logical => "logical",
Mode::Ifelse => "ifelse",
Mode::Control => "control",
Mode::Funcs => "funcs",
Mode::Apply => "apply",
Mode::Lists => "lists",
Mode::Matrix => "matrix",
Mode::Types => "types",
Mode::Setops => "setops",
Mode::Rounding => "rounding",
Mode::Bitops => "bitops",
Mode::Factor => "factor",
Mode::Trig => "trig",
Mode::Mathfn => "mathfn",
Mode::Pmaxmin => "pmaxmin",
Mode::Linalg => "linalg",
Mode::Stringx => "stringx",
Mode::Listx => "listx",
Mode::Predicates => "predicates",
Mode::Numedge => "numedge",
Mode::Strx2 => "strx2",
Mode::Listx2 => "listx2",
Mode::Indexing => "indexing",
Mode::Replace => "replace",
Mode::Switch => "switch",
Mode::Strx3 => "strx3",
Mode::Regexflags => "regexflags",
Mode::Factorx => "factorx",
Mode::Deparsex => "deparsex",
Mode::Fmtx => "fmtx",
Mode::Seqx2 => "seqx2",
Mode::Combinator => "combinator",
Mode::Arrays => "arrays",
Mode::Stat2 => "stat2",
Mode::Deparsefn => "deparsefn",
Mode::Bindlabels => "bindlabels",
Mode::Dimnames => "dimnames",
Mode::Ordering => "ordering",
Mode::Missing => "missing",
Mode::S3methods => "s3methods",
Mode::Catargs => "catargs",
Mode::Pastex => "pastex",
Mode::Formatsci => "formatsci",
Mode::Parens => "parens",
Mode::Seqfmt => "seqfmt",
Mode::Typepred => "typepred",
Mode::Factorsub => "factorsub",
Mode::Factorops => "factorops",
Mode::Conditions => "conditions",
Mode::Calling => "calling",
Mode::Restarts => "restarts",
Mode::Strwidth => "strwidth",
Mode::Collate => "collate",
Mode::Optsfmt => "optsfmt",
Mode::Condtext => "condtext",
Mode::Bitw => "bitw",
Mode::Sysframes => "sysframes",
Mode::Visibility => "visibility",
Mode::Arrelem => "arrelem",
Mode::Withx => "withx",
Mode::Rapplyx => "rapplyx",
Mode::Numtype => "numtype",
Mode::Pastecls => "pastecls",
Mode::Unlistx => "unlistx",
Mode::Strx => "strx",
Mode::Assignx => "assignx",
Mode::Tablex => "tablex",
Mode::Regexx => "regexx",
Mode::Cutx => "cutx",
Mode::Applyx => "applyx",
Mode::Errtext2 => "errtext2",
}
}
fn mode_from_name(s: &str) -> Option<Mode> {
ALL_MODES.iter().copied().find(|&m| mode_name(m) == s)
}
fn build_program(stmts: &[String]) -> String {
stmts.join("\n")
}
fn diverges(script: &str, bin: &Path, timeout: Duration) -> bool {
let o = run_oracle(script, timeout);
if o.timed_out {
return false;
}
let r = run_ours(script, bin, timeout);
if r.exit == -999 || r.exit == -998 || r.timed_out || o.exit == -999 || o.exit == -998 {
return false;
}
differs(&o, &r)
}
fn minimize(stmts: Vec<String>, bin: &Path, timeout: Duration) -> Vec<String> {
let mut cur = stmts;
loop {
let mut removed = false;
let mut i = 0;
while i < cur.len() {
let mut cand = cur.clone();
cand.remove(i);
if !cand.is_empty() && diverges(&build_program(&cand), bin, timeout) {
cur = cand;
removed = true;
} else {
i += 1;
}
}
if !removed {
break;
}
}
cur
}
fn signature(program: &str) -> String {
let body = program
.lines()
.map(|l| l.trim())
.rfind(|l| !l.is_empty())
.unwrap_or("")
.to_string();
let mut s = body;
for (pat, rep) in [
(r"[0-9]+\.[0-9]+([eE][-+]?[0-9]+)?", "F"),
(r"[0-9]+[eE][-+]?[0-9]+", "F"),
(r"-?[0-9]+", "N"),
("\"[^\"]*\"", "W"),
("'[^']*'", "W"),
] {
s = regex_lite_replace(&s, pat, rep);
}
s
}
fn case_marker(i: usize) -> String {
format!("\n@@CASE {i}\n")
}
const BATCH_END: &str = "\n@@END\n";
fn batch_program<'a>(cases: impl Iterator<Item = &'a [String]>) -> String {
let mut p = String::new();
for (i, stmts) in cases.enumerate() {
p.push_str(&format!("cat(\"\\n@@CASE {i}\\n\")\n"));
p.push_str("tryCatch({\n");
for s in stmts {
p.push_str(&format!(
".rl_v <- withVisible({{\n{s}\n}}); if (.rl_v$visible) print(.rl_v$value)\n"
));
}
p.push_str("}, error = function(e) cat(\"Error:\", conditionMessage(e), \"\\n\"))\n");
p.push_str("rm(list = ls(all.names = TRUE))\noptions(digits = 7, scipen = 0, warn = 0)\n");
}
p.push_str("cat(\"\\n@@END\\n\")\n");
p
}
fn split_batch(out: &[u8], n: usize) -> Option<Vec<&[u8]>> {
fn find(hay: &[u8], needle: &[u8], from: usize) -> Option<usize> {
hay.get(from..)?
.windows(needle.len())
.position(|w| w == needle)
.map(|p| p + from)
}
let mut segs = Vec::with_capacity(n);
let mut pos = find(out, case_marker(0).as_bytes(), 0)? + case_marker(0).len();
for i in 0..n {
let next = if i + 1 < n {
case_marker(i + 1)
} else {
BATCH_END.to_string()
};
let end = find(out, next.as_bytes(), pos)?;
segs.push(&out[pos..end]);
pos = end + next.len();
}
Some(segs)
}
fn regex_lite_replace(s: &str, pat: &str, rep: &str) -> String {
match regex::Regex::new(pat) {
Ok(re) => re.replace_all(s, rep).into_owned(),
Err(_) => s.to_string(),
}
}
struct Args {
count: u64,
base_seed: u64,
once: bool,
timeout_ms: u64,
out_path: PathBuf,
max_report: usize,
jobs: usize,
mode: Option<Mode>,
verify: usize,
baseline: Option<PathBuf>,
batch: u64,
}
fn parse_args() -> Args {
let mut count = 2000u64;
let mut base_seed = 1u64;
let mut once = false;
let mut timeout_ms = 10000u64;
let mut max_report = 200usize;
let mut mode: Option<Mode> = None;
let mut verify = 1usize;
let mut batch = 1u64;
let mut baseline: Option<PathBuf> = None;
let mut jobs = std::thread::available_parallelism()
.map(|n| n.get())
.unwrap_or(4);
let mut out_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("target")
.join("parity-fuzz")
.join("divergences.txt");
let argv: Vec<String> = std::env::args().skip(1).collect();
let mut i = 0;
while i < argv.len() {
match argv[i].as_str() {
"--count" | "-c" => {
i += 1;
count = argv.get(i).and_then(|s| s.parse().ok()).unwrap_or(count);
}
"--seed" | "-s" => {
i += 1;
base_seed = argv
.get(i)
.and_then(|s| s.parse().ok())
.unwrap_or(base_seed);
}
"--once" => once = true,
"--timeout-ms" => {
i += 1;
timeout_ms = argv
.get(i)
.and_then(|s| s.parse().ok())
.unwrap_or(timeout_ms);
}
"--out" | "-o" => {
i += 1;
if let Some(p) = argv.get(i) {
out_path = PathBuf::from(p);
}
}
"--max-report" => {
i += 1;
max_report = argv
.get(i)
.and_then(|s| s.parse().ok())
.unwrap_or(max_report);
}
"--jobs" | "-j" => {
i += 1;
jobs = argv
.get(i)
.and_then(|s| s.parse().ok())
.filter(|&j| j >= 1)
.unwrap_or(jobs);
}
"--mode" | "-m" => {
i += 1;
match argv.get(i).and_then(|s| mode_from_name(s)) {
Some(m) => mode = Some(m),
None => {
eprintln!(
"unknown --mode '{}'",
argv.get(i).map(|s| s.as_str()).unwrap_or("")
);
std::process::exit(2);
}
}
}
a if a.starts_with("--") && mode_from_name(&a[2..]).is_some() => {
mode = Some(mode_from_name(&a[2..]).unwrap());
}
"--verify" => {
i += 1;
verify = argv
.get(i)
.and_then(|s| s.parse().ok())
.filter(|&k| k >= 1)
.unwrap_or(verify);
}
"--baseline" => {
i += 1;
baseline = argv.get(i).map(PathBuf::from);
}
"--batch" | "-b" => {
i += 1;
batch = argv
.get(i)
.and_then(|s| s.parse().ok())
.filter(|&k| k >= 1)
.unwrap_or(batch);
}
"--stderr" => {
CMP_STDERR.store(true, Ordering::Relaxed);
}
"--help" | "-h" => {
let modes: Vec<&str> = ALL_MODES.iter().copied().map(mode_name).collect();
eprintln!(
"parity-fuzz — differential R/rlang parity fuzzer\n\
\n\
--count N number of cases (default 2000)\n\
--seed N base seed; case i uses seed+i (default 1)\n\
--mode M one of: {}\n\
(each also accepted as a `--<mode>` shorthand; default: all\n\
modes, round-robin by case index)\n\
--stderr also require the diagnostics to match\n\
--once run a single case (seed) and print both outputs\n\
--timeout-ms N per-interpreter wall-clock timeout (default 10000)\n\
--out PATH divergence corpus file\n\
--max-report N stop after N divergences (default 200)\n\
--jobs N parallel workers (default = CPU count)\n\
--verify K require K consecutive divergences to report (default 1)\n\
--batch K run K cases per interpreter launch as a pre-filter;\n\
only cases whose output differs are re-run alone\n\
(default 1 = one launch per case)\n\
--baseline FILE allowlist of known-gap signatures; only a NEW\n\
divergence fails the run (exit 1)\n\
\n\
env RLANG_FUZZ_RSCRIPT=PATH the reference Rscript to compare against.\n\
The oracle is part of the result; every run prints it.",
modes.join(", ")
);
std::process::exit(0);
}
_ => {}
}
i += 1;
}
Args {
count,
base_seed,
once,
timeout_ms,
out_path,
max_report,
jobs,
mode,
verify,
baseline,
batch,
}
}
fn mode_for(idx: u64, pinned: Option<Mode>) -> Mode {
match pinned {
Some(m) => m,
None => ALL_MODES[(idx as usize) % ALL_MODES.len()],
}
}
fn main() {
let args = parse_args();
let bin = ours_bin();
let timeout = Duration::from_millis(args.timeout_ms);
let _ = std::fs::create_dir_all(ours_home());
if !bin.exists() {
eprintln!(
"rlang binary not found at {}; run `cargo build` first",
bin.display()
);
std::process::exit(2);
}
if args.once {
let mode = mode_for(args.base_seed, args.mode);
let stmts = gen_case(args.base_seed, mode);
let script = build_program(&stmts);
let o = run_oracle(&script, timeout);
let r = run_ours(&script, &bin, timeout);
if o.timed_out || o.exit == -999 || o.exit == -998 {
eprintln!("parity-fuzz: the oracle did not answer this case — nothing to compare");
std::process::exit(2);
}
let diverged = differs(&o, &r);
println!("seed : {}", args.base_seed);
println!("mode : {}", mode_name(mode));
let (show, o, r) = if diverged && stmts.len() > 1 {
let m = minimize(stmts, &bin, timeout);
let ms = build_program(&m);
let mo = run_oracle(&ms, timeout);
let mr = run_ours(&ms, &bin, timeout);
(ms, mo, mr)
} else {
(script, o, r)
};
println!("program:\n {}", show.replace('\n', "\n "));
println!("--- R exit={} timeout={} ---", o.exit, o.timed_out);
let _ = std::io::stdout().write_all(&o.stdout);
println!("--- rlang exit={} timeout={} ---", r.exit, r.timed_out);
let _ = std::io::stdout().write_all(&r.stdout);
println!("--- {} ---", if diverged { "DIVERGE" } else { "match" });
std::process::exit(if diverged { 1 } else { 0 });
}
use std::sync::atomic::AtomicU64;
use std::sync::Mutex;
let next = AtomicU64::new(0);
let checked = AtomicU64::new(0);
let timeouts = AtomicU64::new(0);
let drained = AtomicU64::new(0);
let silent = AtomicU64::new(0);
let compared = AtomicU64::new(0);
let stop = AtomicBool::new(false);
let divergences: Mutex<Vec<(u64, String)>> = Mutex::new(Vec::new());
let start = Instant::now();
eprintln!(
"fuzzing {} cases across {} workers (mode {})…",
args.count,
args.jobs,
args.mode.map(mode_name).unwrap_or("all"),
);
let judge = |idx: u64| {
let seed = args.base_seed.wrapping_add(idx);
let mode = mode_for(idx, args.mode);
let stmts = gen_case(seed, mode);
let script = build_program(&stmts);
let o = run_oracle(&script, timeout);
let r = run_ours(&script, &bin, timeout);
let done = checked.fetch_add(1, Ordering::Relaxed) + 1;
if o.timed_out || r.timed_out {
timeouts.fetch_add(1, Ordering::Relaxed);
}
if o.timed_out || o.exit == -999 || o.exit == -998 {
drained.fetch_add(1, Ordering::Relaxed);
} else if no_signal(&o, &r) {
silent.fetch_add(1, Ordering::Relaxed);
} else {
compared.fetch_add(1, Ordering::Relaxed);
}
if !o.timed_out && differs(&o, &r) {
let minimal = minimize(stmts, &bin, timeout);
let mscript = build_program(&minimal);
let mo = run_oracle(&mscript, timeout);
let mr = run_ours(&mscript, &bin, timeout);
let mut confirmed = differs(&mo, &mr);
for _ in 1..args.verify.max(1) {
if !confirmed {
break;
}
confirmed = diverges(&mscript, &bin, timeout);
}
if !confirmed {
return; }
let err_of = |o: &RunOut| -> String {
if CMP_STDERR.load(Ordering::Relaxed) {
format!(
"\n stderr: {}",
render(&norm_stderr(&o.stderr)).replace('\n', "\n ")
)
} else {
String::new()
}
};
let rec = format!(
"==== seed {seed} (mode {}) ====\n\
program:\n {}\n\
R : exit={} timeout={}{}\n{}\n\
rlang : exit={} timeout={}{}\n{}\n",
mode_name(mode),
mscript.replace('\n', "\n "),
mo.exit,
mo.timed_out,
err_of(&mo),
render(&mo.stdout),
mr.exit,
mr.timed_out,
err_of(&mr),
render(&mr.stdout),
);
let mut d = divergences.lock().unwrap();
d.push((seed, rec));
if d.len() >= args.max_report {
stop.store(true, Ordering::Relaxed);
}
}
if done % 500 == 0 {
let n = divergences.lock().unwrap().len();
eprintln!(
" {done}/{} checked, {n} divergences, {:.0}/s",
args.count,
done as f64 / start.elapsed().as_secs_f64().max(0.001)
);
}
};
let prefilter = |first: u64, last: u64| -> Vec<u64> {
let cases: Vec<(u64, Mode, Vec<String>)> = (first..last)
.map(|idx| {
let mode = mode_for(idx, args.mode);
(idx, mode, gen_case(args.base_seed.wrapping_add(idx), mode))
})
.collect();
let script = batch_program(cases.iter().map(|(_, _, s)| s.as_slice()));
let batch_timeout = timeout * cases.len() as u32;
let file = args
.out_path
.parent()
.map(|d| d.join("batches"))
.unwrap_or_else(|| PathBuf::from("."))
.join(format!("run-{}-{first}.R", std::process::id()));
if let Some(dir) = file.parent() {
let _ = std::fs::create_dir_all(dir);
}
let _ = std::fs::write(&file, &script);
let o = run_file(&file, None, batch_timeout);
let r = run_file(&file, Some(&bin), batch_timeout);
let _ = std::fs::remove_file(&file);
let n = cases.len();
let (so, sr) = match (split_batch(&o.stdout, n), split_batch(&r.stdout, n)) {
(Some(a), Some(b)) => (a, b),
_ => {
let tail = |o: &RunOut| {
String::from_utf8_lossy(&o.stderr)
.lines()
.rfind(|l| !l.trim().is_empty())
.unwrap_or("")
.to_string()
};
eprintln!(
" batch {first}..{last} not attributable (R exit={} {:?}; rlang exit={} {:?}); \
re-running its cases one by one",
o.exit,
tail(&o),
r.exit,
tail(&r)
);
let dir = args.out_path.parent().map(|d| d.join("batches"));
if let Some(dir) = dir {
let _ = std::fs::create_dir_all(&dir);
let _ = std::fs::write(dir.join(format!("{first}.R")), &script);
let _ = std::fs::write(dir.join(format!("{first}.R.out")), &o.stdout);
let _ = std::fs::write(dir.join(format!("{first}.rlang.out")), &r.stdout);
}
return cases.iter().map(|(i, _, _)| *i).collect();
}
};
let mut suspects = Vec::new();
for (k, (idx, _, _)) in cases.iter().enumerate() {
if so[k] != sr[k] {
suspects.push(*idx);
continue;
}
let done = checked.fetch_add(1, Ordering::Relaxed) + 1;
if so[k].iter().all(|b| b.is_ascii_whitespace()) {
silent.fetch_add(1, Ordering::Relaxed);
} else {
compared.fetch_add(1, Ordering::Relaxed);
}
if done % 500 == 0 {
eprintln!(" {done}/{} checked", args.count);
}
}
suspects
};
std::thread::scope(|scope| {
for _ in 0..args.jobs {
scope.spawn(|| loop {
if stop.load(Ordering::Relaxed) {
break;
}
let first = next.fetch_add(args.batch, Ordering::Relaxed);
if first >= args.count {
break;
}
let last = (first + args.batch).min(args.count);
if args.batch > 1 {
for idx in prefilter(first, last) {
judge(idx);
}
} else {
judge(first);
}
});
}
});
let checked = checked.load(Ordering::Relaxed);
let timeouts = timeouts.load(Ordering::Relaxed);
let drained = drained.load(Ordering::Relaxed);
let silent = silent.load(Ordering::Relaxed);
let compared = compared.load(Ordering::Relaxed);
let mut divergences: Vec<(u64, String)> = divergences.into_inner().unwrap();
divergences.sort_by_key(|(seed, _)| *seed);
let divergences: Vec<String> = divergences.into_iter().map(|(_, r)| r).collect();
let elapsed = start.elapsed();
let sig_of = |rec: &str| -> String {
let prog = rec
.split("program:\n")
.nth(1)
.and_then(|s| s.split("\nR :").next())
.unwrap_or(rec);
signature(prog)
};
let allowed: std::collections::HashSet<String> = match &args.baseline {
Some(bp) => std::fs::read_to_string(bp)
.unwrap_or_default()
.lines()
.map(|l| l.trim().to_string())
.filter(|l| !l.is_empty() && !l.starts_with('#'))
.collect(),
None => std::collections::HashSet::new(),
};
let mut new_records: Vec<&String> = Vec::new();
let mut new_sigs: std::collections::BTreeSet<String> = std::collections::BTreeSet::new();
let mut known = 0usize;
for rec in &divergences {
let sig = sig_of(rec);
if args.baseline.is_some() && allowed.contains(&sig) {
known += 1;
} else {
new_records.push(rec);
new_sigs.insert(sig);
}
}
let oracle = oracle_id();
println!(
"\nfuzzed {checked} cases in {:.1}s ({:.0}/s)\n\
oracle : {}\n\
compared : {compared} (drained {drained} / no-signal {silent})\n\
divergences : {} ({} known / {} new)\n\
timeouts : {}",
elapsed.as_secs_f64(),
checked as f64 / elapsed.as_secs_f64().max(0.001),
oracle,
divergences.len(),
known,
new_records.len(),
timeouts,
);
if !divergences.is_empty() {
if let Some(parent) = args.out_path.parent() {
let _ = std::fs::create_dir_all(parent);
}
if let Ok(mut f) = std::fs::File::create(&args.out_path) {
let _ = writeln!(f, "# oracle: {oracle}");
for d in &divergences {
let _ = writeln!(f, "{d}");
}
println!(
"wrote {} divergences to {}",
divergences.len(),
args.out_path.display()
);
}
}
if compared == 0 {
eprintln!(
"parity-fuzz: nothing was compared — {checked} case(s) generated, \
{drained} drained, {silent} with no output on either side. \
A run that compares nothing cannot pass."
);
std::process::exit(2);
}
if !new_records.is_empty() {
println!(
"\n--- {} NEW gap signature(s) (add to baseline once triaged) ---",
new_sigs.len()
);
for s in &new_sigs {
println!("{s}");
}
println!(
"\n--- first {} new divergence record(s) ---",
new_records.len().min(5)
);
for d in new_records.iter().take(5) {
println!("{d}");
}
std::process::exit(1);
}
if known > 0 {
println!("all {known} divergences are known (in baseline) — OK");
}
}