use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant};
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 pick<'a, T>(&mut self, xs: &'a [T]) -> &'a T {
let i = self.below(xs.len());
&xs[i]
}
}
fn ours_bin() -> PathBuf {
if let Ok(p) = std::env::var("PHPLANG_FUZZ_OURS") {
return PathBuf::from(p);
}
if let Ok(exe) = std::env::current_exe() {
if let Some(dir) = exe.parent() {
let cand = dir.join("php");
if cand.exists() {
return cand;
}
}
}
PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("target")
.join("debug")
.join("php")
}
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("PHPLANG_FUZZ_PHP") {
if !Path::new(&p).exists() {
eprintln!("parity-fuzz: PHPLANG_FUZZ_PHP={p}: no such file");
std::process::exit(2);
}
return p;
}
for p in [
"/opt/homebrew/bin/php",
"/usr/local/bin/php",
"/usr/bin/php",
] {
if Path::new(p).exists() {
return p.to_string();
}
}
"php".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| {
String::from_utf8_lossy(&o.stdout)
.lines()
.next()
.unwrap_or("")
.trim()
.to_string()
})
.filter(|s| !s.is_empty())
.unwrap_or_else(|| "unknown".to_string());
format!("{path} ({ver})")
}
struct RunOut {
stdout: Vec<u8>,
stderr: Vec<u8>,
exit: i32,
timed_out: bool,
infra_fail: bool,
}
fn render(bytes: &[u8]) -> String {
String::from_utf8_lossy(bytes)
.trim_end_matches('\n')
.to_string()
}
fn differs(a: &RunOut, b: &RunOut) -> bool {
a.stdout != b.stdout || a.stderr != b.stderr || a.exit != b.exit
}
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 infra(-999),
};
let out_pipe = child.stdout.take();
let err_pipe = child.stderr.take();
let out_thread = std::thread::spawn(move || drain(out_pipe));
let err_thread = std::thread::spawn(move || drain(err_pipe));
let start = Instant::now();
loop {
match child.try_wait() {
Ok(Some(status)) => {
return RunOut {
stdout: out_thread.join().unwrap_or_default(),
stderr: err_thread.join().unwrap_or_default(),
exit: status.code().unwrap_or(-1),
timed_out: false,
infra_fail: false,
};
}
Ok(None) => {
if start.elapsed() >= timeout {
let _ = child.kill();
let _ = child.wait();
let _ = out_thread.join();
let _ = err_thread.join();
return RunOut {
stdout: Vec::new(),
stderr: Vec::new(),
exit: -1,
timed_out: true,
infra_fail: false,
};
}
std::thread::sleep(Duration::from_millis(2));
}
Err(_) => {
let _ = out_thread.join();
let _ = err_thread.join();
return infra(-998);
}
}
}
}
fn drain(pipe: Option<impl std::io::Read>) -> Vec<u8> {
let mut buf = Vec::new();
if let Some(mut p) = pipe {
let _ = p.read_to_end(&mut buf);
}
buf
}
fn infra(exit: i32) -> RunOut {
RunOut {
stdout: Vec::new(),
stderr: Vec::new(),
exit,
timed_out: false,
infra_fail: true,
}
}
fn run_oracle(script: &str, timeout: Duration) -> RunOut {
let mut cmd = Command::new(oracle_path());
cmd.args(["-r", script]);
run_with_timeout(cmd, timeout)
}
fn run_ours(script: &str, bin: &Path, timeout: Duration) -> RunOut {
let mut cmd = Command::new(bin);
cmd.args(["-r", script]);
run_with_timeout(cmd, timeout)
}
const INTS: &[&str] = &[
"0", "1", "2", "7", "10", "-3", "-7", "42", "100", "-1", "5", "9", "-2",
];
const FLOATS: &[&str] = &[
"0.1", "0.2", "1.5", "3.14", "2.0", "-1.5", "10.0", "0.0", "100.25", "-0.5", "1.0", "0.3",
];
const WORDS: &[&str] = &[
"foo", "bar", "baz", "hello", "world", "abc", "PHP", "Lang", "x",
];
fn ii<'a>(r: &mut Rng) -> &'a str {
r.pick(INTS)
}
fn ff<'a>(r: &mut Rng) -> &'a str {
r.pick(FLOATS)
}
fn ww<'a>(r: &mut Rng) -> &'a str {
r.pick(WORDS)
}
fn gen_arith(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let ops = ["+", "-", "*"];
let (a, b, c) = (ii(r), ii(r), ii(r));
let (o1, o2) = (r.pick(&ops), r.pick(&ops));
vec![format!("echo {a} {o1} {b} {o2} {c};")]
}
fn gen_intdiv(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let (a, b) = (ii(r), r.pick(&["3", "-3", "2", "-2", "7", "-7", "4", "5"]));
match r.below(3) {
0 => vec![format!("echo {a} % {b};")],
1 => vec![format!("echo intdiv({a}, {b});")],
_ => vec![format!("echo {a} / {b};")],
}
}
fn gen_floatfmt(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
match r.below(4) {
0 => vec![format!("echo {} + {};", ff(r), ff(r))],
1 => vec![format!("echo {} * {};", ff(r), ff(r))],
2 => vec![format!(
"echo {} / {};",
ii(r),
r.pick(&["3", "7", "9", "4"])
)],
_ => vec![format!("echo {};", ff(r))],
}
}
fn gen_pow(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let (a, b) = (
r.pick(&["2", "3", "5", "10", "-2"]),
r.pick(&["0", "1", "2", "3", "4"]),
);
vec![format!("echo {a} ** {b};")]
}
fn gen_concat(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
match r.below(4) {
0 => vec![format!("echo \"{}\" . {};", ww(r), ii(r))],
1 => vec![format!("echo \"{}\" + {};", ii(r), ii(r))], 2 => vec![format!("echo {} . {};", ii(r), ff(r))],
_ => vec![format!("echo \"{}\" . \"{}\";", ww(r), ww(r))],
}
}
fn gen_compare(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let ops = ["==", "===", "!=", "<", ">", "<=", ">="];
let lhs = *r.pick(&[
"1", "0", "\"1\"", "\"0\"", "\"a\"", "1.0", "\"1.0\"", "10", "\"10\"",
]);
let rhs = *r.pick(&[
"1", "0", "\"1\"", "\"0\"", "\"a\"", "1.0", "\"1.0\"", "2", "\"2\"",
]);
let op = r.pick(&ops);
vec![format!("echo ({lhs} {op} {rhs}) ? \"T\" : \"F\";")]
}
fn gen_ternary(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
match r.below(3) {
0 => vec![format!(
"$x = {}; echo $x ?: \"empty\";",
r.pick(&["0", "5", "\"\"", "\"hi\""])
)],
1 => vec![format!("echo {} > {} ? \"a\" : \"b\";", ii(r), ii(r))],
_ => vec![format!(
"$x = {}; echo $x ?? \"nil\";",
r.pick(&["null", "0", "7"])
)],
}
}
fn gen_strfns(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let w = ww(r);
match r.below(8) {
0 => vec![format!("echo strlen(\"{w}\");")],
1 => vec![format!("echo strtoupper(\"{w}\");")],
2 => vec![format!("echo ucfirst(\"{w}\");")],
3 => vec![format!("echo strrev(\"{w}\");")],
4 => vec![format!("echo str_repeat(\"{w}\", {});", r.below(4))],
5 => vec![format!(
"echo substr(\"{w}\", {}, {});",
r.below(3),
1 + r.below(3)
)],
6 => vec![format!("echo str_pad(\"{w}\", {}, \"-\");", 4 + r.below(4))],
_ => vec![format!(
"echo strpos(\"hello\", \"{}\") === false ? \"no\" : \"yes\";",
r.pick(&["l", "z", "e"])
)],
}
}
fn gen_arrays(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let arr = format!("[{}, {}, {}]", ii(r), ii(r), ii(r));
match r.below(8) {
0 => vec![format!("echo count({arr});")],
1 => vec![format!("echo array_sum({arr});")],
2 => vec![format!("echo implode(\",\", {arr});")],
3 => vec![format!("echo implode(\",\", array_reverse({arr}));")],
4 => vec![format!("echo in_array({}, {arr}) ? \"y\" : \"n\";", ii(r))],
5 => vec![format!("echo array_product({arr});")],
6 => vec![format!(
"$n = [{}, [{}, {}], [[{}]]]; \
echo count($n), '|', count($n, COUNT_RECURSIVE), '|', count($n, COUNT_NORMAL);",
ii(r),
ii(r),
ii(r),
ii(r)
)],
_ => vec![format!(
"try {{ echo count({arr}, {}); }} catch (Throwable $e) {{ \
echo get_class($e), '|', $e->getMessage(); }}",
r.pick(&["0", "1", "2", "99", "-1"])
)],
}
}
fn gen_sorting(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let arr = format!("[{}, {}, {}, {}]", ii(r), ii(r), ii(r), ii(r));
match r.below(2) {
0 => vec![format!("$a = {arr}; sort($a); echo implode(\",\", $a);")],
_ => vec![format!("$a = {arr}; rsort($a); echo implode(\",\", $a);")],
}
}
fn gen_assoc(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let m = format!("[\"{}\" => {}, \"{}\" => {}]", ww(r), ii(r), ww(r), ii(r));
match r.below(3) {
0 => vec![format!(
"$m = {m}; $t = 0; foreach ($m as $k => $v) {{ $t += $v; }} echo $t;"
)],
1 => vec![format!("echo implode(\",\", array_keys({m}));")],
_ => vec![format!(
"echo array_key_exists(\"{}\", {m}) ? \"y\" : \"n\";",
ww(r)
)],
}
}
fn gen_printf(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
match r.below(4) {
0 => vec![format!("echo sprintf(\"%d\", {});", ii(r))],
1 => vec![format!(
"echo sprintf(\"%s-%d\", \"{}\", {});",
ww(r),
ii(r)
)],
2 => vec![format!("echo sprintf(\"%b\", {});", r.below(16))],
_ => vec![format!("echo number_format({}, {});", ff(r), r.below(3))],
}
}
fn gen_control(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
match r.below(3) {
0 => {
let n = ii(r);
vec![format!(
"$n = {n}; switch ($n) {{ case 1: echo \"one\"; break; case 2: echo \"two\"; break; default: echo \"other\"; }}"
)]
}
1 => {
let n = r.pick(&["1", "2", "3", "4"]);
vec![format!(
"echo match({n}) {{ 1 => \"a\", 2, 3 => \"b\", default => \"z\" }};"
)]
}
_ => {
let n = r.pick(&["0", "3", "6", "9"]);
vec![format!(
"$n = {n}; echo ($n % 2 == 0) ? \"even\" : \"odd\";"
)]
}
}
}
fn gen_loops(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let n = r.pick(&["3", "4", "5", "6"]);
match r.below(2) {
0 => vec![format!(
"$s = 0; for ($i = 1; $i <= {n}; $i++) {{ $s += $i; }} echo $s;"
)],
_ => vec![format!(
"$s = 1; $i = 1; while ($i <= {n}) {{ $s *= $i; $i++; }} echo $s;"
)],
}
}
fn gen_funcs(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let n = r.pick(&["0", "1", "5", "6"]);
match r.below(2) {
0 => vec![format!(
"function f($n) {{ if ($n <= 1) {{ return 1; }} return $n * f($n - 1); }} echo f({n});"
)],
_ => vec![format!(
"function g($a, $b) {{ return $a + $b; }} echo g({}, {});",
ii(r),
ii(r)
)],
}
}
fn gen_typeconv(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let v = *r.pick(&["5", "5.7", "\"12abc\"", "\"3.9\"", "\"\"", "0", "\"42\""]);
match r.below(4) {
0 => vec![format!("echo intval({v});")],
1 => vec![format!("var_dump(is_numeric({v}));")],
2 => vec![format!("echo gettype({v});")],
_ => vec![format!("echo (int){v} + 0;")],
}
}
fn gen_mathfns(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
match r.below(6) {
0 => vec![format!("echo abs({});", ii(r))],
1 => vec![format!("echo max({}, {}, {});", ii(r), ii(r), ii(r))],
2 => vec![format!("echo min({}, {});", ii(r), ii(r))],
3 => vec![format!("echo floor({});", ff(r))],
4 => vec![format!("echo ceil({});", ff(r))],
_ => vec![format!("echo round({}, {});", ff(r), r.below(3))],
}
}
fn gen_stricttypes(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let decl = *r.pick(&[
"declare(strict_types=1);",
"declare(strict_types=0);",
"",
"declare(ticks=1);",
]);
let ty = *r.pick(&["int", "float", "string", "bool", "?int", "?string"]);
let val = *r.pick(&[
"5", "-3", "0", "5.0", "5.5", "\"5\"", "\"5.5\"", "\"5abc\"", "\"abc\"", "\"\"", "true",
"false", "null", "[1]",
]);
let body = match r.below(3) {
0 => format!("function f({ty} $x): {ty} {{ return $x; }}"),
1 => format!("function f({ty} $x): string {{ return $x; }}"),
_ => format!("function f({ty} $x) {{ var_dump($x); }}"),
};
vec![format!(
"{decl} {body} try {{ var_dump(f({val})); }} \
catch (Throwable $e) {{ echo get_class($e), \"|\", $e->getMessage(), \"|\"; }}"
)]
}
fn gen_declaresyntax(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
match r.below(9) {
0 => vec!["declare(strict_types=1); echo \"ok\";".to_string()],
1 => vec!["echo \"before\"; declare(strict_types=1);".to_string()],
2 => vec!["declare(ticks=1); declare(strict_types=1); echo \"ok\";".to_string()],
8 => vec![format!(
"declare(strict_types={}); declare(strict_types={}); \
function f(int $x) {{ var_dump($x); }} \
try {{ f(\"5\"); }} catch (Throwable $e) {{ echo get_class($e); }}",
r.below(2),
r.below(2)
)],
3 => vec!["declare(strict_types=1) { echo \"in\"; }".to_string()],
4 => vec!["declare(ticks=1) { echo \"in\"; }".to_string()],
5 => vec![format!(
"declare(strict_types={}); echo \"ok\";",
r.pick(&["2", "-1", "0", "1"])
)],
6 => vec!["declare(strict_types=$x); echo \"ok\";".to_string()],
_ => vec!["declare(encoding='UTF-8'); echo \"ok\";".to_string()],
}
}
fn gen_exitdie(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let word = *r.pick(&["exit", "die"]);
let arg = *r.pick(&[
"",
"()",
"(0)",
"(3)",
"(255)",
"(256)",
"(300)",
"(-1)",
"(true)",
"(false)",
"(2.0)",
"(2.9)",
"(null)",
"(\"bye\")",
"(\"7\")",
"([1])",
]);
match r.below(4) {
0 => vec![format!("echo \"[\"; {word}{arg}; echo \"]\";")],
1 => vec![format!(
"function f() {{ echo \"in\"; {word}{arg}; echo \"after\"; }} \
echo \"[\"; f(); echo \"]\";"
)],
2 => vec![format!(
"echo \"[\"; try {{ {word}{arg}; }} catch (Throwable $e) {{ echo \"C\"; }} \
finally {{ echo \"F\"; }} echo \"]\";"
)],
_ => vec![format!(
"ob_start(); echo \"[\"; \
array_map(function ($x) {{ if ($x == 2) {{ {word}{arg}; }} echo $x; }}, [1, 2, 3]); \
echo \"]\";"
)],
}
}
fn num_leaf<'a>(r: &mut Rng) -> &'a str {
if r.below(3) == 0 {
ff(r)
} else {
ii(r)
}
}
fn gen_exprtree(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let ops = ["+", "-", "*"];
let arith = |r: &mut Rng| {
let n = 2 + r.below(4); let mut e = num_leaf(r).to_string();
for _ in 1..n {
e = format!("{e} {} {}", r.pick(&ops), num_leaf(r));
}
e
};
if r.below(2) == 0 {
let cmp = ["<", ">", "<=", ">=", "==", "!="];
vec![format!(
"var_dump({} {} {});",
arith(r),
r.pick(&cmp),
arith(r)
)]
} else {
vec![format!("echo {};", arith(r))]
}
}
fn gen_unary(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
match r.below(6) {
0 => vec![format!("echo - - {};", ii(r))],
1 => vec![format!(
"echo -{} ** {};",
r.pick(&["2", "3", "4"]),
r.pick(&["2", "3"])
)],
2 => vec![format!(
"echo !!{};",
r.pick(&["0", "1", "5", "\"\"", "\"a\""])
)],
3 => vec![format!("echo -{} * -{};", ii(r), ii(r))],
4 => vec![format!("echo {} - -{};", ii(r), ii(r))],
_ => vec![format!("var_dump(!({} > {}));", ii(r), ii(r))],
}
}
const SPRINTF_SPECS: &[&str] = &[
"%d", "%5d", "%-5d", "%05d", "%+d", "%x", "%X", "%o", "%b", "%c", "%e", "%.2f", "%8.3f",
"%-8.2f", "%+.1f", "%s", "%10s", "%-10s", "%%", "%'*8d", "%1\\$d", "%g",
];
fn gen_sprintf_rich(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let spec = r.pick(SPRINTF_SPECS);
let arg = if spec.contains('f') || spec.contains('e') || spec.contains('g') {
ff(r)
} else if spec.contains('s') {
return vec![format!("echo sprintf(\"[{spec}]\", \"{}\");", ww(r))];
} else if spec.contains('c') {
return vec![format!("echo sprintf(\"{spec}\", {});", 65 + r.below(26))];
} else if *spec == "%%" {
return vec!["echo sprintf(\"100%%\");".to_string()];
} else {
ii(r)
};
vec![format!("echo sprintf(\"[{spec}]\", {arg});")]
}
fn gen_numedge(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let vals = [
"0.1 + 0.2",
"1 / 3",
"2 / 3",
"10 / 7",
"9223372036854775807 + 1",
"9223372036854775807 * 2",
"1.0e100",
"1.5e-10",
"0.0001",
"123456789012345",
"1234567890.12345",
"1e20",
"-0.0",
"100000000000000.0",
"3.0 / 2.0",
"7 % 3",
"-7 % 3",
"7 % -3",
"2 ** 63",
"2 ** 64",
];
vec![format!("echo {};", r.pick(&vals))]
}
fn gen_stredge(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let w = ww(r);
match r.below(9) {
0 => vec![format!("echo substr(\"{w}\", -{});", 1 + r.below(3))],
1 => vec![format!(
"echo substr(\"hello\", {}, -{});",
r.below(2),
1 + r.below(2)
)],
2 => vec![format!(
"echo str_pad(\"{w}\", {}, \"ab\", {});",
6 + r.below(3),
r.below(3)
)],
3 => vec![format!(
"echo str_replace(\"{}\", \"X\", \"{w}{w}\");",
&w[..1]
)],
4 => vec![format!("echo ucwords(\"{} {}\");", ww(r), ww(r))],
5 => vec![format!("echo strrev(\"{w}\");")],
6 => vec![format!(
"echo wordwrap(\"{w} {w} {w}\", {}, \"\\n\", true);",
4 + r.below(6)
)],
7 => vec![format!("echo str_repeat(\"{}\", {});", &w[..1], r.below(6))],
_ => vec![format!("var_dump(strpos(\"{w}\", \"{}\"));", &w[..1])],
}
}
fn gen_arraypipe(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let arr = format!("[{}, {}, {}, {}, {}]", ii(r), ii(r), ii(r), ii(r), ii(r));
match r.below(8) {
0 => vec![format!(
"echo implode(\",\", array_slice({arr}, {}, {}));",
r.below(3),
1 + r.below(3)
)],
1 => vec![format!(
"echo implode(\",\", array_slice({arr}, -{}));",
1 + r.below(3)
)],
2 => vec![format!("echo array_sum(array_map(\"abs\", {arr}));")],
3 => vec![format!("echo implode(\",\", array_merge([1, 2], {arr}));")],
4 => vec!["echo implode(\",\", array_unique([1, 1, 2, 2, 3]));".to_string()],
5 => vec![format!("echo count(array_filter({arr}));")],
6 => vec![format!(
"function dbl($x) {{ return $x * 2; }} echo implode(\",\", array_map(\"dbl\", {arr}));"
)],
_ => vec![format!(
"echo implode(\",\", array_reverse(array_slice({arr}, 1)));"
)],
}
}
fn gen_multi(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
match r.below(5) {
0 => vec![
"$a = [];".into(),
format!(
"for ($i = 0; $i < {}; $i++) {{ $a[] = $i * $i; }}",
3 + r.below(4)
),
"echo implode(\",\", $a);".into(),
],
1 => vec![
format!("$s = \"\"; $n = {};", 3 + r.below(4)),
"for ($i = 1; $i <= $n; $i++) { $s .= $i; }".into(),
"echo $s;".into(),
],
2 => vec![
format!("$m = [\"a\" => {}, \"b\" => {}];", ii(r), ii(r)),
"$m[\"c\"] = $m[\"a\"] + $m[\"b\"];".into(),
"echo $m[\"c\"];".into(),
],
3 => vec![
format!("$x = {};", ii(r)),
format!("$x += {}; $x *= 2; $x -= {};", ii(r), ii(r)),
"echo $x;".into(),
],
_ => vec![
format!(
"$t = 0; foreach ([{}, {}, {}] as $v) {{ if ($v % 2 == 0) {{ $t += $v; }} }}",
ii(r),
ii(r),
ii(r)
),
"echo $t;".into(),
],
}
}
fn gen_bitwise(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
match r.below(9) {
0 => vec![format!("echo {} & {};", ii(r), ii(r))],
1 => vec![format!("echo {} | {};", ii(r), ii(r))],
2 => vec![format!("echo {} ^ {};", ii(r), ii(r))],
3 => vec![format!("echo {} << {};", ii(r), r.below(40))],
4 => vec![format!("echo {} >> {};", ii(r), r.below(40))],
5 => vec![format!("echo ~{};", ii(r))],
6 => vec![format!(
"echo {} & {} + {} | {};",
ii(r),
ii(r),
ii(r),
ii(r)
)],
7 => vec![format!(
"echo {} << {} + {} ^ {};",
ii(r),
r.below(4),
ii(r),
ii(r)
)],
_ => vec![format!(
"$n = {}; $n &= {}; $n |= {}; $n ^= {}; $n <<= {}; echo $n;",
ii(r),
ii(r),
ii(r),
ii(r),
r.below(4)
)],
}
}
fn gen_spaceship(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
match r.below(3) {
0 => vec![format!("echo {} <=> {};", ii(r), ii(r))],
1 => vec![format!("echo {} <=> {};", ff(r), ff(r))],
_ => vec![format!("echo \"{}\" <=> \"{}\";", ww(r), ww(r))],
}
}
fn gen_stroffset(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let w = ww(r);
match r.below(4) {
0 => vec![format!("echo \"{w}\"[{}];", r.below(5))],
1 => vec![format!("$s = \"{w}\"; echo $s[-{}];", 1 + r.below(3))],
2 => vec![format!(
"$s = \"{w}\"; var_dump(isset($s[{}]));",
r.below(8)
)],
_ => vec![format!("$s = \"{w}\"; echo $s[0], $s[strlen($s) - 1];")],
}
}
fn gen_coalesce(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
match r.below(4) {
0 => vec![format!(
"$x = {}; echo $x ?? \"def\";",
r.pick(&["null", "5", "\"\"", "0", "\"hi\""])
)],
1 => vec![format!(
"$x = {}; $x ??= 7; echo $x;",
r.pick(&["null", "3", "0"])
)],
2 => {
vec!["$a = ['k' => 1]; echo $a['missing'] ?? 'miss', '|', $a['k'] ?? 'no';".to_string()]
}
_ => vec![format!(
"echo {} ?: \"z\";",
r.pick(&["0", "5", "\"\"", "\"hi\"", "null"])
)],
}
}
const SW: &[&str] = &[
"hello",
"World",
"abcABC",
"FooBar",
"mixedCase",
"aaabbb",
"level",
];
fn gen_str2(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let s = *r.pick(SW);
match r.below(16) {
0 => vec![format!("echo substr_count(\"{s}xx{s}\", \"{s}\");")],
1 => vec![format!("echo ucwords(\"{s} and {s}\");")],
2 => vec![format!("echo lcfirst(\"{s}\");")],
3 => vec!["echo str_word_count(\"one two three four\");".to_string()],
4 => vec![format!("echo strrpos(\"{s}{s}\", \"{}\");", &s[..1])],
5 => vec![format!(
"echo stripos(\"{s}\", \"{}\");",
&s[..1].to_uppercase()
)],
6 => vec!["echo addslashes(\"a'b\\\"c\");".to_string()],
7 => vec![format!("echo strtr(\"{s}\", \"lo\", \"LO\");")],
8 => vec![format!(
"echo wordwrap(\"the quick brown fox\", {}, \"|\", true);",
4 + r.below(8)
)],
9 => vec![format!(
"echo strncasecmp(\"{s}\", \"{}\", {}) <=> 0;",
s.to_uppercase(),
1 + r.below(5)
)],
10 => vec![format!(
"echo str_ireplace(\"{}\", \"X\", \"{s}\");",
&s[..1].to_uppercase()
)],
11 => vec![format!("echo strpbrk(\"{s}\", \"lo\");")],
12 => vec![format!("echo strspn(\"{s}\", \"{}\");", s)],
13 => vec![format!(
"echo levenshtein(\"{s}\", \"{}x\");",
&s[..s.len().saturating_sub(1)]
)],
14 => vec!["echo nl2br(\"a\\nb\");".to_string()],
_ => vec!["echo quotemeta(\"a.b*c\");".to_string()],
}
}
fn gen_arr2(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let mut list = || {
let n = 3 + r.below(4);
(0..n)
.map(|_| (r.below(20)).to_string())
.collect::<Vec<_>>()
.join(", ")
};
let l = list();
match r.below(15) {
0 => vec![format!(
"echo json_encode(array_chunk([{l}], {}));",
1 + r.below(3)
)],
1 => vec![format!(
"echo json_encode(array_pad([{l}], {}, 0));",
1 + r.below(6)
)],
2 => vec![format!(
"echo json_encode(array_slice([{l}], {}, {}));",
r.below(3),
1 + r.below(3)
)],
3 => vec![format!(
"echo json_encode(array_count_values([{}]));",
"1, 2, 2, 3, 3, 3"
)],
4 => vec![format!(
"echo json_encode(array_flip([{}]));",
"\"a\", \"b\", \"c\""
)],
5 => vec![format!(
"echo array_key_first([{l}]), \"|\", array_key_last([{l}]);"
)],
6 => vec![format!("echo array_is_list([{l}]) ? \"y\" : \"n\";")],
7 => vec![format!(
"echo in_array({}, [{l}]) ? \"y\" : \"n\";",
r.below(20)
)],
8 => vec![format!(
"$a = [{l}]; echo array_search({}, $a) === false ? \"no\" : \"yes\";",
r.below(20)
)],
9 => vec![format!("$a = [{l}]; sort($a); echo implode(\",\", $a);")],
10 => vec![format!("$a = [{l}]; rsort($a); echo implode(\",\", $a);")],
11 => vec![format!(
"$a = [{l}]; usort($a, fn($x, $y) => $x - $y); echo implode(\",\", $a);"
)],
12 => vec![format!(
"echo json_encode(array_fill_keys([\"a\", \"b\"], {}));",
r.below(9)
)],
13 => vec![
"echo json_encode(array_diff_key([\"a\" => 1, \"b\" => 2], [\"a\" => 9]));".to_string(),
],
_ => vec![format!(
"$a = [{l}]; echo array_sum($a), \"|\", array_product([1, 2, 3]);"
)],
}
}
fn gen_math2(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let n = r.below(1000);
let neg = r.below(200) as i64 - 100;
match r.below(16) {
0 => vec![format!("echo dechex({n}), \"|\", hexdec(dechex({n}));")],
1 => vec![format!("echo decbin({n}), \"|\", bindec(decbin({n}));")],
2 => vec![format!("echo decoct({n}), \"|\", octdec(decoct({n}));")],
3 => vec![format!("echo base_convert(\"{n}\", 10, 16);")],
4 => vec![format!("echo abs({neg}), \"|\", abs({neg}.5);")],
5 => vec![format!(
"echo intdiv({}, {});",
n as i64 - 500,
1 + r.below(9)
)],
6 => vec![format!(
"echo {} % {};",
n as i64 - 500,
(r.below(9) as i64) - 4
)],
7 => vec![format!(
"echo max({n}, {neg}, {}), \"|\", min({n}, {neg}, {});",
r.below(1000),
r.below(1000)
)],
8 => vec![format!(
"printf(\"%.4f\", fmod({}, {}));",
n,
1 + r.below(7)
)],
9 => vec![format!(
"echo gmp_strval(gmp_add(\"{n}00000000000000000000\", \"{}\"));",
r.below(1000)
)],
10 => vec![format!(
"echo gmp_strval(gmp_mul(\"{n}\", \"{}\"));",
r.below(100000)
)],
11 => vec![format!(
"echo gmp_strval(gmp_pow(\"{}\", {}));",
2 + r.below(5),
5 + r.below(20)
)],
12 => vec![format!(
"echo gmp_strval(gmp_gcd(\"{}\", \"{}\"));",
n * 6,
n.max(1) * 4
)],
13 => vec![format!(
"echo gmp_strval(gmp_mod(\"{}\", \"{}\"));",
n,
1 + r.below(97)
)],
14 => vec![format!(
"echo str_pad(strval(round({n}.{:03}, 2)), 1);",
r.below(1000)
)],
_ => vec![format!("echo ({} <=> {});", n, r.below(1000))],
}
}
fn gen_refs(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let x = r.below(50);
let y = r.below(50);
match r.below(8) {
0 => vec![format!("$a = {x}; $b = &$a; $b = {y}; echo $a, \"|\", $b;")],
1 => vec![format!("$a = {x}; $b = &$a; $a += {y}; echo $b;")],
2 => vec![format!(
"$a = [{}, {}, {}]; foreach ($a as &$v) {{ $v *= 2; }} unset($v); echo implode(\",\", $a);",
x, y, r.below(50)
)],
3 => vec![format!(
"function inc(&$n) {{ $n++; }} $c = {x}; inc($c); inc($c); echo $c;"
)],
4 => vec![format!(
"function swap(&$p, &$q) {{ $t = $p; $p = $q; $q = $t; }} $a = {x}; $b = {y}; swap($a, $b); echo $a, \"|\", $b;"
)],
5 => vec![format!(
"$a = [{x}, {y}]; $b = &$a[0]; $b = {}; echo implode(',', $a);",
r.below(50)
)],
6 => vec![format!(
"$a = ['k' => {x}, 'j' => {y}]; $b = &$a['k']; $b = {}; echo json_encode($a);",
r.below(50)
)],
_ => vec![format!(
"$a = [[{x}], [{y}]]; $b = &$a[0][0]; $b = {}; echo json_encode($a);",
r.below(50)
)],
}
}
fn gen_closures(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let n = r.below(20);
let list = format!(
"[{}, {}, {}, {}]",
r.below(20),
r.below(20),
r.below(20),
r.below(20)
);
match r.below(7) {
0 => vec![format!(
"$f = fn($x) => $x * {n}; echo $f({});",
r.below(10)
)],
1 => vec![format!(
"$b = {n}; $f = function ($x) use ($b) {{ return $x + $b; }}; echo $f({});",
r.below(10)
)],
2 => vec![format!(
"echo implode(\",\", array_map(fn($x) => $x + 1, {list}));"
)],
3 => vec![format!(
"echo implode(\",\", array_filter({list}, fn($x) => $x % 2 == 0));"
)],
4 => vec![format!(
"echo array_reduce({list}, fn($c, $x) => $c + $x, 0);"
)],
5 => vec![format!(
"$mk = fn($b) => fn($x) => $x + $b; $add = $mk({n}); echo $add({});",
r.below(10)
)],
_ => vec![format!("echo (fn($x) => $x <=> {n})({});", r.below(20))],
}
}
fn gen_exc(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
match r.below(6) {
0 => vec![
"try { throw new Exception(\"e\"); } catch (Exception $x) { echo $x->getMessage(); }".into(),
],
1 => vec!["try { echo \"a\"; } finally { echo \"b\"; }".into()],
2 => vec![
"function g() { try { throw new RuntimeException(\"x\"); } catch (Exception $e) { return \"R\"; } finally { echo \"F\"; } } echo g();".into(),
],
3 => vec![
"try { throw new TypeError(\"t\"); } catch (Exception $e) { echo \"exc\"; } catch (Error $e) { echo \"err\"; }".into(),
],
4 => vec![
"try { echo match({}) { 1 => \"a\" }; } catch (\\UnhandledMatchError $e) { echo \"unhandled\"; }"
.replace("{}", &(2 + r.below(5)).to_string()),
],
_ => vec![
"$v = null; try { $r = $v ?? throw new Exception(\"c\"); } catch (Exception $e) { echo $e->getMessage(); }".into(),
],
}
}
fn gen_typejug2(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let vals = [
"0",
"1",
"-5",
"3.14",
"\"42\"",
"\"3.5abc\"",
"\"\"",
"\"0\"",
"true",
"false",
"null",
"\"10\"",
];
let comps = [
"[1, [2, 3]]",
"[[1, 2], [3, 4]]",
"['a' => 1, 'b' => [2, 3]]",
"[1, ['k' => ['z' => 2]]]",
"[]",
"[[]]",
"[1.0, [2.5]]",
"[true, [false, null]]",
"['it\\'s', ['a\\\\b']]",
"(object)['x' => 1]",
"(object)['x' => [1, 2]]",
"['k' => (object)['n' => [5]]]",
"[1, [2, [3, [4]]]]",
];
let v = *r.pick(&vals);
let c = *r.pick(&comps);
match r.below(15) {
0 => vec![format!("var_dump((int){v});")],
1 => vec![format!("var_dump((float){v});")],
2 => vec![format!("var_dump((bool){v});")],
3 => vec![format!("echo gettype({v});")],
4 => vec![format!("var_dump(is_numeric({v}));")],
5 => vec![format!("echo intval({v});")],
6 => vec![format!("echo var_export({v}, true);")],
7 => vec![format!("echo json_encode({v});")],
8 => vec![format!("var_dump({v} == {});", r.pick(&vals))],
9 => vec![format!("echo var_export({c}, true);")],
10 => vec![format!("var_export({c});")],
11 => vec![format!("var_dump({c});")],
12 => vec![format!("echo json_encode({c});")],
13 => vec![format!("echo print_r({c}, true);")],
_ => vec![format!("echo serialize({c});")],
}
}
fn gen_range(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
match r.below(6) {
0 => {
let (a, b, s) = (r.below(10), 10 + r.below(20), 1 + r.below(4));
vec![format!("echo implode(\",\", range({a}, {b}, {s}));")]
}
1 => {
let (a, b, s) = (20 + r.below(20), r.below(10), 1 + r.below(4));
vec![format!("echo implode(\",\", range({a}, {b}, {s}));")]
}
2 => {
let lo = (b'a' + r.below(10) as u8) as char;
let hi = (b'p' + r.below(10) as u8) as char;
vec![format!(
"echo implode(\",\", range(\"{lo}\", \"{hi}\", {}));",
1 + r.below(3)
)]
}
3 => vec![format!(
"echo implode(\",\", range({}, {}));",
(r.below(20) as i64) - 10,
r.below(20)
)],
4 => vec![format!(
"echo count(range({}, {}, {}));",
r.below(5),
50 + r.below(50),
1 + r.below(7)
)],
_ => {
let lo = (b'A' + r.below(6) as u8) as char;
let hi = (b'T' + r.below(6) as u8) as char;
vec![format!("echo implode(\"\", range(\"{lo}\", \"{hi}\"));")]
}
}
}
fn gen_datefmt(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let tss = [
0i64, 946684800, 1234567890, 1600000000, 1700000000, 1000000, 1609459200,
];
let ts = *r.pick(&tss);
let fmts = [
"Y-m-d H:i:s",
"D, d M Y",
"l N w z",
"H:i:s A",
"y/n/j",
"W F t S",
"U G a",
];
let f = *r.pick(&fmts);
match r.below(3) {
0 => vec![format!("echo date(\"{f}\", {ts});")],
1 => vec![format!("echo gmdate(\"{f}\", {ts});")],
_ => vec![format!(
"echo date(\"{f}\", {ts}), \"|\", date(\"{f}\", {});",
ts + 86400 * (1 + r.below(400)) as i64
)],
}
}
fn gen_printf2(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let n = (r.below(2000) as i64) - 1000;
let f = r.below(100000) as f64 / 100.0;
match r.below(9) {
0 => vec![format!(
"printf(\"%b|%o|%x|%X\", {}, {}, {}, {});",
n.unsigned_abs(),
n.unsigned_abs(),
n.unsigned_abs(),
n.unsigned_abs()
)],
1 => vec![format!("printf(\"%e|%E\", {f}, {f});")],
2 => vec![format!("printf(\"%+d|%+d\", {}, {});", n.abs(), -n.abs())],
3 => vec![format!(
"printf(\"%0{}.{}f\", {f});",
4 + r.below(6),
r.below(5)
)],
4 => vec![format!(
"printf(\"%'*{}s\", \"{}\");",
4 + r.below(8),
r.pick(SW)
)],
5 => vec![format!(
"printf('%1$s %2$s %1$s', \"{}\", \"{}\");",
r.pick(SW),
r.pick(SW)
)],
6 => vec![format!("printf(\"%-{}d|\", {});", 4 + r.below(6), n)],
7 => vec![format!(
"echo number_format({}.{:03}, {}, \".\", \",\");",
r.below(9999999),
r.below(1000),
r.below(4)
)],
_ => vec![format!("printf(\"%g|%G\", {}, {});", f, f * 1000.0)],
}
}
fn gen_arr3(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let list = |r: &mut Rng| {
let n = 3 + r.below(4);
(0..n)
.map(|_| (r.below(15)).to_string())
.collect::<Vec<_>>()
.join(", ")
};
let three = |r: &mut Rng| format!("{}, {}, {}", r.below(15), r.below(15), r.below(15));
let l = list(r);
match r.below(11) {
0 => vec![format!("echo implode(\",\", array_reverse([{l}]));")],
1 => vec![format!(
"echo implode(\",\", array_unique([{}]));",
"1, 2, 2, 3, 1, 4, 4"
)],
2 => vec![format!(
"echo json_encode(array_combine([\"a\", \"b\", \"c\"], [{}]));",
three(r)
)],
3 => vec![format!(
"echo implode(\",\", array_merge([{l}], [{}]));",
list(r)
)],
4 => vec![format!("echo implode(\",\", array_keys([{l}]));")],
5 => vec![format!("echo implode(\",\", array_values([{l}]));")],
6 => vec![format!(
"echo implode(\",\", array_map(fn($x) => $x * $x, [{l}]));"
)],
7 => vec![format!(
"$a = [{l}]; echo implode(\",\", array_map(null, $a, $a)[0]);"
)],
8 => vec![format!(
"echo array_sum(array_map(fn($x) => $x + 1, [{l}]));"
)],
9 => vec![format!(
"echo implode(\",\", array_intersect([{l}], [{}]));",
list(r)
)],
_ => vec![format!(
"echo implode(\",\", array_diff([{l}], [{}]));",
list(r)
)],
}
}
fn gen_rounding(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let whole = r.below(100000);
let frac = r.below(1000);
let sign = if r.below(2) == 0 { "" } else { "-" };
let places = r.below(4) as i64;
let v = format!("{sign}{whole}.{frac:03}5");
match r.below(6) {
0 => vec![format!("echo round({v}, {places});")],
1 => vec![format!("echo number_format({v}, {places});")],
2 => vec![format!("echo number_format({v}, {places}, \".\", \",\");")],
3 => vec![format!("echo round({sign}{whole}.{frac:03}, {places});")],
4 => vec![format!("echo round({v}, {});", -(1 + r.below(3) as i64))],
_ => vec![format!(
"printf(\"%.{}f\", round({v}, {places}));",
r.below(4)
)],
}
}
fn gen_dynprop(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let p = *r.pick(&["x", "y", "value", "n"]);
let v = ii(r);
match r.below(8) {
0 => vec![format!(
"class C {{}} $c = new C; $c->{p} = {v}; echo $c->{p};"
)],
1 => vec![format!(
"class C {{ public ${p}; }} $c = new C; $c->{p} = {v}; echo $c->{p};"
)],
2 => vec![format!(
"#[AllowDynamicProperties] class C {{}} $c = new C; $c->{p} = {v}; echo $c->{p};"
)],
3 => vec![format!(
"#[AllowDynamicProperties] class P {{}} class C extends P {{}} \
$c = new C; $c->{p} = {v}; echo $c->{p};"
)],
4 => vec![format!(
"class P {{ public ${p} = 0; }} class C extends P {{}} \
$c = new C; $c->{p} = {v}; echo $c->{p};"
)],
5 => vec![format!("$o = new stdClass; $o->{p} = {v}; echo $o->{p};")],
6 => vec![format!(
"class C {{}} $c = new C; $c->{p} = {v}; $c->{p} = {}; echo $c->{p};",
ii(r)
)],
_ => vec![format!(
"class C {{}} $c = new C; $c->{p} {}= {v}; echo $c->{p};",
r.pick(&["+", ".", "*"])
)],
}
}
fn gen_attributes(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let n = ii(r);
match r.below(6) {
0 => vec![format!("#[Attr] class C {{ public $v = {n}; }} echo (new C)->v;")],
1 => vec![format!(
"class C {{ #[Attr] public $v = {n}; #[Attr] public function m() {{ return $this->v; }} }} \
echo (new C)->m();"
)],
2 => vec![format!(
"#[Attr(1, [2, 3])] function f(#[Attr] $x) {{ return $x; }} echo f({n});"
)],
3 => vec![format!(
"#[A] #[B] class C {{}} #[C] class D {{ const K = {n}; }} echo D::K;"
)],
4 => vec!["enum E { #[Attr] case A; #[Attr] case B; } echo E::A->name, count(E::cases());".to_string()],
_ => vec![format!(
"#[\\Ns\\Attr] interface I {{}} #[Attr] class C implements I {{}} \
echo (new C) instanceof I ? \"y{n}\" : \"n{n}\";"
)],
}
}
fn gen_errlevel(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let lvl = *r.pick(&[
"0",
"E_ALL",
"E_ALL & ~E_WARNING",
"E_ALL & ~E_DEPRECATED",
"E_ERROR",
"E_WARNING | E_DEPRECATED",
]);
match r.below(6) {
0 => vec!["echo error_reporting();".to_string()],
1 => vec![format!(
"var_dump(error_reporting({lvl})); echo error_reporting();"
)],
2 => vec![format!(
"error_reporting({lvl}); echo $undef; echo \"end\";"
)],
3 => vec![format!(
"error_reporting({lvl}); class C {{}} $c = new C; $c->p = 1; echo \"end\";"
)],
4 => vec![
"var_dump(ini_get(\"error_reporting\")); ini_set(\"error_reporting\", \"0\"); \
echo $undef; var_dump(ini_get(\"error_reporting\"));"
.to_string(),
],
_ => vec![format!(
"echo \"a\"; error_reporting({lvl}); $v = {}; echo \"${{v}}\";",
ii(r)
)],
}
}
fn gen_libargerr(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let call = *r.pick(&[
"range(9, 10, 2)",
"range(1, 2, 5)",
"range('a', 'b', 9)",
"array_chunk([1, 2], 0)",
"array_combine([1, 2], [1])",
"str_repeat('ab', -1)",
"substr_count('aa', '')",
"chunk_split('aa', 0)",
"mb_str_split('ab', 0)",
"mb_substr_count('aa', '')",
"hash('nope', 'x')",
"hash_hmac('nope', 'x', 'k')",
"random_bytes(0)",
"bcdiv('1', '0')",
"bcmod('1', '0')",
"bcsqrt('-1')",
"gmp_div_q('1', '0')",
"gmp_mod('1', '0')",
]);
match r.below(4) {
0 => vec![format!(
"try {{ {call}; }} catch (Throwable $e) {{ \
echo get_class($e), \"|\", $e->getMessage(); }}"
)],
1 => vec![format!(
"try {{ {call}; }} catch (Throwable $e) {{ \
echo $e->getLine(), \"|\", $e->getTraceAsString(); }}"
)],
2 => vec![format!("function f() {{ return {call}; }} f();")],
_ => vec![format!("{call};")],
}
}
const BAD_PATTERNS: &[&str] = &[
"''",
"' '",
"'abc'",
"'1a1'",
"'/a/Z'",
"'/a/gg'",
"'/abc'",
"'{abc'",
"'(a(b)'",
"'/[a'",
"'/ab[cd'",
"'/(a'",
"'/((a)'",
"'/a)'",
"'/(a))'",
"'/*a'.'/'",
"'/a**'.'/'",
"'/a|*'.'/'",
"'/a{2,1}/'",
"'/ab{5,3}c/'",
"'/{2}/'",
"'/x{1,2}{3}/'",
"'/(?'.'/'",
];
const GOOD_PATTERNS: &[&str] = &[
"'/a/'",
"'//'",
"'/a\\\\//'",
"'/a\\\\\\\\/'",
"'{a}'",
"'(a)'",
"'[a]'",
"'<a>'",
"'#a#'",
"'~a~'",
"'/a{x}/'",
"'/a{,3}/'",
"'/a{2,}/'",
"'/[a)]/'",
"'/[]a]/'",
"'/\\\\(/'",
"'/a*?/'",
"'/a*+/'",
"'/(a)(b)/'",
"'/a/imsxuADJSUX'",
"'/A/i'",
"'/^ab$/'",
"'/a|b/'",
];
fn gen_pregerr(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let bad = *r.pick(BAD_PATTERNS);
let bad2 = *r.pick(BAD_PATTERNS);
let good = *r.pick(GOOD_PATTERNS);
let subj = ww(r);
let st = r#"echo "|", preg_last_error(), ":", preg_last_error_msg(), "|";"#;
match r.below(8) {
0 => vec![format!(
"var_dump(preg_match({bad}, '{subj}')); {st} {st} preg_quote('a'); {st} \
var_dump(preg_match({good}, '{subj}')); {st}"
)],
1 => vec![format!(
"var_dump(preg_match({bad}, '{subj}')); {st} \
var_dump(preg_match_all({bad2}, '{subj}', $m)); {st} \
var_dump(preg_replace({bad}, 'z', '{subj}')); {st} \
var_dump(preg_split({bad2}, '{subj}')); {st} \
var_dump(preg_grep({bad}, ['{subj}'])); {st}"
)],
2 => vec![format!(
"preg_match({bad}, '{subj}'); {st} \
var_dump(preg_match('/zzzzz/', '{subj}')); {st} \
var_dump(preg_match({good}, '{subj}')); {st}"
)],
3 => vec![format!(
"var_dump(preg_match({good}, '{subj}', $m), $m); {st} \
var_dump(preg_split({good}, '{subj}')); {st}"
)],
4 => vec![format!(
"var_dump(@preg_match({bad}, '{subj}')); {st} \
error_reporting(E_ALL & ~E_WARNING); \
var_dump(preg_match({bad2}, '{subj}')); {st} \
error_reporting(E_ALL); var_dump(preg_match({bad}, '{subj}')); {st}"
)],
5 => vec![format!(
"var_dump(preg_replace([{good}, {bad}], 'z', '{subj}')); {st} \
var_dump(preg_replace([{good}], 'z', '{subj}')); {st}"
)],
6 => vec![format!(
"function f($p) {{ return preg_match($p, '{subj}'); }} \
var_dump(f({bad})); {st} var_dump(f({good})); {st}"
)],
_ => vec![format!(
"foreach ([{bad}, {good}, {bad2}] as $p) {{ \
var_dump(@preg_match($p, '{subj}')); {st} }}"
)],
}
}
const FANCY_PATTERNS: &[&str] = &[
"'/foo(?=bar)/'",
"'/foo(?!bar)/'",
"'/(?<=a)b/'",
"'/(?<!a)b/'",
"'/(?<=\\d)[a-z]/'",
"'/^(?=.*a)(?=.*1).{3,}$/'",
"'/\\b(?!x)\\w+/'",
"'/(?<=,)\\s*/'",
"'/(?=[A-Z])/'",
"'/(?<=\\w)(?=\\d)/'",
"'/(\\d)(?=(\\d{3})+$)/'",
"'/(\\w)\\1/'",
"'/(\\w+) \\1/'",
"'/(a|b)c\\1/'",
"'/(?<w>\\w+)-(?P=w)/'",
"'/(?<k>[a-z]+)=(?<v>\\d+)/'",
"'/(?<h>\\d\\d):(?<m>\\d\\d)/'",
"'/(?P<x>a)(b)(?P<y>c)?/'",
"'/(?>a+)b/'",
"'/a++b/'",
"'/(?>\\w+)\\d/'",
"'/x(?i)y/'",
"'/(?:(a)|(b))\\2?/'",
"'/a(?=b)/i'",
"'/^(?=\\w)/m'",
"'/(?<=a) b /x'",
"'/<(.+)>(?=<)/U'",
"'/a.(?=c)/s'",
"'/a(?=a)/A'",
];
const FANCY_SUBJECTS: &[&str] = &[
"foobar",
"foobaz",
"ab",
"cb",
"1a",
"a1c",
"xy why",
"abba",
"the the",
"aca",
"hi-hi",
"k=12",
"09:45",
"abc",
"aaab",
"aaa1",
"a, b",
"fooBarBaz",
"a1b2",
"1234567",
"xY",
"<a><b>",
];
fn gen_pregfancy(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let p = *r.pick(FANCY_PATTERNS);
let p2 = *r.pick(FANCY_PATTERNS);
let s = *r.pick(FANCY_SUBJECTS);
let s2 = *r.pick(FANCY_SUBJECTS);
let st = r#"echo "|", preg_last_error(), "|";"#;
match r.below(8) {
0 => vec![format!(
"var_dump(preg_match({p}, '{s}', $m), $m); {st} \
var_dump(preg_match({p}, '{s2}', $m2), $m2); {st}"
)],
1 => vec![format!(
"var_dump(preg_match_all({p}, '{s}', $m), $m); {st} \
var_dump(preg_match_all({p}, '{s}', $n, PREG_SET_ORDER), $n); {st}"
)],
2 => vec![format!(
"var_dump(preg_replace({p}, 'X', '{s}')); {st} \
var_dump(preg_replace({p}, '[$1]', '{s}')); {st} \
var_dump(preg_replace({p}, '<\\1>', '{s}')); {st} \
var_dump(preg_replace({p}, '${{0}}!', '{s}')); {st}"
)],
3 => vec![format!(
"var_dump(preg_replace({p}, 'X', '{s}', 1)); {st} \
var_dump(preg_replace({p}, 'X', '{s}', 2)); {st} \
var_dump(preg_replace({p}, 'X', '{s}', 0)); {st}"
)],
4 => vec![format!(
"var_dump(preg_replace_callback({p}, function($m) {{ return json_encode($m); }}, \
'{s}')); {st}"
)],
5 => vec![format!(
"var_dump(preg_split({p}, '{s}')); {st} \
var_dump(preg_split({p}, '{s}', -1, PREG_SPLIT_NO_EMPTY)); {st} \
var_dump(preg_split({p}, '{s}', -1, PREG_SPLIT_DELIM_CAPTURE)); {st} \
var_dump(preg_split({p}, '{s}', 2)); {st}"
)],
6 => vec![format!(
"var_dump(preg_grep({p}, ['{s}', '{s2}', ''])); {st} \
var_dump(preg_grep({p}, ['{s}', '{s2}'], PREG_GREP_INVERT)); {st}"
)],
_ => vec![format!(
"var_dump(preg_match({p}, '{s}', $a), $a); {st} \
var_dump(preg_match({p2}, '{s2}', $b), $b); {st} \
var_dump(preg_match({p}, '{s2}', $c), $c); {st}"
)],
}
}
const OFFSET_MB: &[(&str, &str)] = &[
("'/b/'", "éb"),
("'/b/u'", "éb"),
("'/(c)/'", "éàc"),
("'/(c)/u'", "éàc"),
("'/(?<g>x)/'", "日本x"),
("'/(?<g>x)/u'", "日本x"),
("'/z(q)?(w)/'", "€zw"),
("'/z(q)?(w)/u'", "€zw"),
];
fn gen_pregoffset(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let p = *r.pick(FANCY_PATTERNS);
let s = *r.pick(FANCY_SUBJECTS);
let s2 = *r.pick(FANCY_SUBJECTS);
let (mp, ms) = *r.pick(OFFSET_MB);
let st = r#"echo "|", preg_last_error(), "|";"#;
match r.below(8) {
0 => vec![format!(
"var_dump(preg_match({p}, '{s}', $m), $m); {st} \
var_dump(preg_match({p}, '{s}', $n, PREG_OFFSET_CAPTURE), $n); {st}"
)],
1 => vec![format!(
"var_dump(preg_match({mp}, '{ms}', $m, PREG_OFFSET_CAPTURE), $m); {st} \
var_dump(preg_match_all({mp}, '{ms}', $n, PREG_OFFSET_CAPTURE), $n); {st}"
)],
2 => vec![format!(
"var_dump(preg_match_all({p}, '{s}', $m, PREG_PATTERN_ORDER|PREG_OFFSET_CAPTURE), $m); \
{st} var_dump(preg_match_all({p}, '{s}', $n, PREG_SET_ORDER|PREG_OFFSET_CAPTURE), $n); \
{st}"
)],
3 => vec![format!(
"var_dump(preg_replace_callback({p}, function($m) {{ return json_encode($m); }}, \
'{s}', -1, $c, PREG_OFFSET_CAPTURE)); var_dump($c); {st}"
)],
4 => vec![format!(
"var_dump(preg_match({p}, '{s}', $m, PREG_OFFSET_CAPTURE, 1), $m); {st} \
var_dump(preg_match({p}, '{s}', $n, PREG_OFFSET_CAPTURE, 2), $n); {st} \
var_dump(preg_match({p}, '{s}', $a, 0, strlen('{s}')), $a); {st} \
var_dump(preg_match({p}, '{s}', $b, 0, strlen('{s}') + 1), $b); {st} \
var_dump(preg_match({p}, '{s}', $c, PREG_OFFSET_CAPTURE, -2), $c); {st} \
var_dump(preg_match_all({p}, '{s}', $d, PREG_PATTERN_ORDER, 1), $d); {st} \
var_dump(preg_match_all({p}, '{s}', $e, PREG_PATTERN_ORDER, strlen('{s}') + 1)); {st}"
)],
5 => vec![format!(
"var_dump(preg_match({p}, '{s}', $m, PREG_OFFSET_CAPTURE), $m); {st} \
var_dump(preg_match('/\\bzzqq\\b/', '{s}', $m, PREG_OFFSET_CAPTURE), $m); {st}"
)],
6 => vec![format!(
"var_dump(preg_match('/(?<a>\\w)(?<b>\\d)?/', '{s}', $m, PREG_OFFSET_CAPTURE), $m); \
{st} var_dump(preg_match_all('/(?<a>\\w)(?<b>\\d)?/', '{s2}', $n, \
PREG_OFFSET_CAPTURE), $n); {st}"
)],
_ => vec![format!(
"var_dump(preg_match({p}, '{s2}', $m, PREG_OFFSET_CAPTURE|PREG_UNMATCHED_AS_NULL), $m); \
{st} var_dump(preg_match({p}, '{s2}', $n, PREG_OFFSET_CAPTURE), $n); {st}"
)],
}
}
fn gen_destructure(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let a = ii(r);
let b = ii(r);
let c = ii(r);
let w = ww(r);
match r.below(13) {
0 => vec![format!(
"$a = [[{a},{b}],[{b},{c}]]; \
foreach ($a as [$x,$y]) {{ echo $x, '-', $y, ';'; }} echo '|'; \
foreach ($a as list($x,$y)) {{ echo $x, '=', $y, ';'; }} echo \"|\\n\";"
)],
1 => vec![format!(
"$a = [['k'=>{a},'j'=>{b}],['k'=>{c},'j'=>{a}]]; \
foreach ($a as ['j'=>$v,'k'=>$u]) {{ echo $u, '/', $v, ';'; }} echo \"|\\n\";"
)],
2 => vec![format!(
"$a = ['p'=>[{a},{b}], 'q'=>[{b},{c}]]; \
foreach ($a as $k => [$x,$y]) {{ echo $k, ':', $x, ',', $y, ';'; }} echo \"|\\n\";"
)],
3 => vec![format!(
"$a = [[{a},[{b},{c}]],[{c},[{a},{b}]]]; \
foreach ($a as [$p,[$q,$s]]) {{ echo $p, $q, $s, ';'; }} echo \"|\\n\";"
)],
4 => vec![format!(
"$a = [[{a},{b},{c}]]; \
foreach ($a as [, $second]) {{ echo $second, ';'; }} echo '|'; \
foreach ($a as [, , $third]) {{ echo $third, ';'; }} echo \"|\\n\";"
)],
5 => vec![format!(
"$a = [[{a}],[{a},{b}],[]]; \
foreach ($a as [$x,$y]) {{ var_dump($x, $y); }} echo \"|\\n\";"
)],
6 => vec![format!(
"$a = [['k'=>{a}],['k'=>{b},'j'=>{c}]]; \
foreach ($a as ['k'=>$u,'j'=>$v]) {{ var_dump($u, $v); }} echo \"|\\n\";"
)],
7 => vec![format!(
"$a = [[{a},{b}], '{w}', {c}]; \
foreach ($a as [$x,$y]) {{ var_dump($x, $y); }} echo \"|\\n\";"
)],
8 => vec![format!(
"$a = [{a},{b}]; [&$x,$y] = $a; $x = {c}; \
echo implode(',', $a), '|', $y, \"|\\n\";"
)],
9 => vec![format!(
"$a = [{a},{b}]; list(&$x,$y) = $a; $x = {c}; \
echo implode(',', $a), '|', $y, \"|\\n\";"
)],
10 => vec![format!(
"$a = [[{a},{b}],[{b},{c}]]; \
foreach ($a as [&$x,$y]) {{ $x = {c}; }} unset($x); \
echo json_encode($a), \"|\\n\";"
)],
11 => vec![format!(
"$a = [{a},{b},{c}]; [&$x,,&$z] = $a; $x = {b}; $z = {a}; \
echo implode(',', $a), \"|\\n\";"
)],
_ => vec![format!(
"$a = [['k'=>{a},'j'=>{b}]]; \
foreach ($a as ['k'=>&$u]) {{ $u = {c}; }} unset($u); \
echo json_encode($a), '|'; \
$n = [[{a},[{b}]]]; \
foreach ($n as [$p,[&$q]]) {{ $q = {c}; }} unset($q); \
echo json_encode($n), \"|\\n\";"
)],
}
}
fn gen_nsconst(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let v = ii(r);
let v2 = ii(r);
let w = ww(r);
match r.below(12) {
0 => vec![format!(
"define('Foo\\BAR', {v}); echo Foo\\BAR, '|', \\Foo\\BAR, '|', \
constant('Foo\\BAR'), \"|\\n\";"
)],
1 => vec![format!(
"define('A\\B\\C', {v}); var_dump(defined('A\\B\\C'), A\\B\\C, \\A\\B\\C); \
var_dump(defined('C'));"
)],
2 => vec![format!(
"define('BAR', {v}); define('Foo\\BAR', {v2}); \
var_dump(BAR, Foo\\BAR, \\BAR, \\Foo\\BAR);"
)],
3 => vec![format!(
"try {{ echo Foo\\NOPE_{w}; }} catch (Error $e) {{ echo get_class($e), ':', \
$e->getMessage(), \"|\\n\"; }}"
)],
4 => vec![format!(
"try {{ echo \\NOPE_{w}; }} catch (Error $e) {{ echo get_class($e), ':', \
$e->getMessage(), \"|\\n\"; }} \
try {{ echo NOPE_{w}; }} catch (Error $e) {{ echo $e->getMessage(), \"|\\n\"; }}"
)],
5 => vec![format!(
"define('N\\X', {v}); define('N\\Y', {v2}); \
var_dump(N\\X + N\\Y, [N\\X, \\N\\Y], N\\X <=> N\\Y);"
)],
6 => vec![format!("const K_{w} = {v}; echo K_{w};")],
7 => vec![format!(
"const A_{w} = {v}, B_{w} = {v2}; echo A_{w}, '|', B_{w};"
)],
8 => vec![format!(
"const C_{w} = {v}; const D_{w} = C_{w} * 2; const E_{w} = [{v}, {v2}]; \
var_dump(D_{w}, E_{w}[1], C_{w} . 'x');"
)],
9 => vec![format!(
"var_dump(defined('F_{w}')); const F_{w} = {v}; \
var_dump(defined('F_{w}'), F_{w}, constant('F_{w}'));"
)],
10 => vec![format!(
"const G_{w} = {v}; const G_{w} = {v2}; echo G_{w};"
)],
_ => vec![format!(
"define('H_{w}', {v}); const H_{w} = {v2}; echo H_{w}, '|'; \
const I_{w} = {v}; var_dump(define('I_{w}', {v2})); echo I_{w};"
)],
}
}
fn gen_propmagic(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let magic = *r.pick(&[
"",
"public function __get($n) { echo \"[G$n]\"; return $this->bag[$n] ?? \"g\"; }",
"public function __set($n, $v) { echo \"[S$n]\"; $this->bag[$n] = $v; }",
"public function __get($n) { echo \"[G$n]\"; return $this->bag[$n] ?? \"g\"; } \
public function __set($n, $v) { echo \"[S$n]\"; $this->bag[$n] = $v; }",
"public function __isset($n) { echo \"[I$n]\"; return isset($this->bag[$n]); } \
public function __unset($n) { echo \"[U$n]\"; unset($this->bag[$n]); }",
"public function __get($n) { echo \"[G$n]\"; return $this->bag[$n] ?? \"g\"; } \
public function __set($n, $v) { echo \"[S$n]\"; $this->bag[$n] = $v; } \
public function __isset($n) { echo \"[I$n]\"; return isset($this->bag[$n]); } \
public function __unset($n) { echo \"[U$n]\"; unset($this->bag[$n]); }",
]);
let vis = *r.pick(&["public", "protected", "private"]);
let v = ii(r);
let cls = format!("class C {{ {vis} $p = 1; private $bag = []; {magic} }} $c = new C;");
let undeclared = format!("class D {{ private $bag = []; {magic} }} $d = new D;");
match r.below(8) {
0 => vec![format!(
"{cls} try {{ $c->p = {v}; echo \"|\", $c->p, \"|\"; unset($c->p); \
echo \"|\", $c->p, \"|\"; }} catch (Throwable $e) {{ \
echo get_class($e), \"|\", $e->getMessage(); }}"
)],
1 => vec![format!(
"{undeclared} $d->q = {v}; echo \"|\", $d->q, \"|\"; unset($d->q); \
echo \"|\", $d->q, \"|\";"
)],
2 => vec![format!(
"{cls} var_dump(isset($c->p)); var_dump(empty($c->p)); \
var_dump($c->p ?? 'D'); var_dump(@$c->p);"
)],
3 => vec![format!(
"{undeclared} var_dump(isset($d->q)); var_dump(empty($d->q)); \
var_dump($d->q ?? 'D'); var_dump(@$d->q);"
)],
4 => vec![format!(
"{undeclared} $d->q = {v}; var_dump(isset($d->q)); var_dump(empty($d->q)); \
var_dump($d->q ?? 'D');"
)],
5 => vec![format!(
"{undeclared} $d->q = {v}; unset($d->q); var_dump(isset($d->q)); \
var_dump($d->q ?? 'D'); echo \"|\", @$d->q, \"|\";"
)],
6 => vec![format!(
"class C {{ {vis} $p = 1; private $bag = []; {magic} \
public function go($v) {{ $this->p = $v; unset($this->bag); \
return $this->p; }} }} \
$c = new C; echo $c->go({v});"
)],
_ => vec![format!(
"{undeclared} try {{ $d->q {}= {v}; echo \"|\", $d->q, \"|\"; $d->q++; \
echo \"|\", $d->q, \"|\"; }} catch (Throwable $e) {{ \
echo get_class($e), \"|\", $e->getMessage(); }}",
r.pick(&["+", ".", "*"])
)],
}
}
const INI_SETTINGS: &[(&str, &str)] = &[
("memory_limit", "256M"),
("date.timezone", "America/New_York"),
("precision", "7"),
("serialize_precision", "17"),
("display_errors", "0"),
("max_execution_time", "30"),
("default_charset", "ISO-8859-1"),
("zend.assertions", "0"),
("pcre.backtrack_limit", "500000"),
("date.default_latitude", "51.5"),
("unserialize_max_depth", "2048"),
("default_socket_timeout", "10"),
("arg_separator.output", ";"),
("html_errors", "1"),
("log_errors", "0"),
("error_reporting", "0"),
("post_max_size", "16M"),
("output_buffering", "4096"),
("max_input_vars", "2000"),
("expose_php", "0"),
("allow_url_fopen", "0"),
("zend.multibyte", "1"),
("no.such.setting", "1"),
];
fn gen_ini(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let (name, val) = *r.pick(INI_SETTINGS);
match r.below(4) {
0 => vec![format!("var_dump(ini_get('{name}'));")],
1 => vec![format!(
"var_dump(ini_set('{name}', '{val}')); var_dump(ini_get('{name}'));"
)],
2 => vec![format!(
"$old = ini_get('{name}'); var_dump($old); ini_set('{name}', '{val}'); \
var_dump(ini_get('{name}')); ini_set('{name}', $old); \
var_dump(ini_get('{name}') === $old);"
)],
_ => vec![format!(
"var_dump(ini_get('{name}') === false); var_dump(ini_set('{name}', '{val}') === false);"
)],
}
}
const JUGGLE_OPERANDS: &[&str] = &[
"5",
"\"5\"",
"\" 5 \"",
"\"5.\"",
"\".5\"",
"\"-5\"",
"\"5e3\"",
"\"1e400\"",
"2.5",
"true",
"false",
"null",
"0",
"\"5g\"",
"\"5.5g\"",
"\"-5g\"",
"\".5g\"",
"\"0x1A\"",
"\"1_000\"",
"\"5e\"",
"\"5 x\"",
"\"g\"",
"\"\"",
"\" \"",
"\"INF\"",
"\"NAN\"",
"\"abc\"",
"[1]",
"[]",
];
const JUGGLE_BINOPS: &[&str] = &["+", "-", "*", "/", "%", "**", "|", "&", "^", "<<", ">>"];
fn gen_numjuggle(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let a = *r.pick(JUGGLE_OPERANDS);
let b = *r.pick(JUGGLE_OPERANDS);
let op = *r.pick(JUGGLE_BINOPS);
let show = "catch (Throwable $e) { echo get_class($e), \"|\", $e->getMessage(), \"|\"; }";
match r.below(7) {
0 => vec![format!("try {{ var_dump({a} {op} {b}); }} {show}")],
1 => vec![format!(
"try {{ $x = {a}; $x {op}= {b}; var_dump($x); }} {show}"
)],
2 => vec![format!(
"try {{ var_dump(-({a})); }} {show} try {{ var_dump(+({a})); }} {show}"
)],
3 => vec![format!(
"try {{ $x = {a}; $x++; var_dump($x); $x--; var_dump($x); }} {show}"
)],
4 => vec![format!(
"error_reporting(E_ALL & ~E_WARNING); try {{ var_dump({a} {op} {b}); }} {show} \
error_reporting(E_ALL); try {{ var_dump(@({a} {op} {b})); }} {show}"
)],
5 => vec![format!(
"function f($p, $q) {{ return $p {op} $q; }} try {{ var_dump(f({a}, {b})); }} {show}"
)],
_ => vec![format!(
"try {{ var_dump(({a} {op} {b}) {op} {a}); }} {show} \
try {{ var_dump({a} {op} ({b} {op} {b})); }} {show}"
)],
}
}
fn gen_jsondecode(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let doc = *r.pick(&[
r#"{"a":1}"#,
r#"{"0":1,"a":2}"#,
r#"{}"#,
r#"{"a":{"b":1}}"#,
r#"{"a":[{"x":1},{"y":2}]}"#,
r#"[{"a":1},{"b":2}]"#,
r#"{"a":{"b":1},"c":{"d":2}}"#,
r#"{"a":null,"b":true,"c":1.5}"#,
r#"[1,{"a":2},3]"#,
]);
let assoc = *r.pick(&["", ", true", ", false", ", null"]);
match r.below(4) {
0 => vec![format!("var_dump(json_decode('{doc}'{assoc}));")],
1 => vec![format!(
"var_dump(json_decode('{doc}', null, 512, JSON_OBJECT_AS_ARRAY));"
)],
2 => vec![format!("echo json_encode(json_decode('{doc}'{assoc}));")],
_ => vec![format!(
"$v = json_decode('{doc}'{assoc}); echo gettype($v), '|', \
json_last_error(), '|', is_object($v) ? get_class($v) : count((array)$v);"
)],
}
}
fn gen_htmlent(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let raw = *r.pick(&[
"a&<>\\\"'z",
"caf\u{00e9}",
"\u{20AC}\u{03B1}\u{2665}",
"<b class=\\\"x\\\">t</b>",
"5 < 6 > 7",
"\u{00A0}\u{00FF}\u{2260}",
"",
"plain text",
]);
let enc = *r.pick(&["htmlspecialchars", "htmlentities"]);
let dec = *r.pick(&["htmlspecialchars_decode", "html_entity_decode"]);
let flags = *r.pick(&["", ", ENT_QUOTES", ", ENT_COMPAT", ", ENT_NOQUOTES"]);
match r.below(4) {
0 => vec![format!("var_dump({enc}(\"{raw}\"{flags}));")],
1 => vec![format!("var_dump({dec}({enc}(\"{raw}\"){flags}));")],
2 => vec![format!(
"var_dump({dec}(\"<éé&''"é&nope;&\"{flags}));"
)],
_ => vec![format!(
"echo count(get_html_translation_table(HTML_ENTITIES{flags})), '|', \
count(get_html_translation_table(HTML_SPECIALCHARS{flags}));"
)],
}
}
fn gen_striptags(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let doc = *r.pick(&[
"<b>x</b><i>y</i>",
"<p>T <b class=\\\"x\\\">bold</b></p>",
"<br/>a<br />b",
"<a href=\\\"x>y\\\">link</a>",
"<!-- c --> visible",
"<!-- <b>x</b> --> y",
"<?php echo 1; ?>after",
"<?xml version=\\\"1.0\\\"?><a>x</a>",
"<!DOCTYPE html><p>x</p>",
"a < b and c > d",
"unclosed <b",
"<<b>>x",
"<B CLASS=y>x</B>",
"</b>x",
"<>x",
]);
let allow = *r.pick(&[
"",
", \"<b>\"",
", \"<b><i>\"",
", \"<a>\"",
", \"<br>\"",
", \"<p>\"",
", [\"b\", \"i\"]",
", null",
]);
vec![format!("var_dump(strip_tags(\"{doc}\"{allow}));")]
}
fn gen_compact(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let init = *r.pick(&[
"$a = 1;",
"$a = null;",
"$a = 1; unset($a);",
"$a = false;",
"$a = '';",
"$a = [1, 2];",
"",
]);
let names = *r.pick(&[
"'a'",
"'a', 'b'",
"['a', 'b']",
"['a'], 'b'",
"''",
"1",
"'a', [2]",
"true",
"null",
"['a', ['b']]",
]);
match r.below(3) {
0 => vec![format!("{init} var_dump(compact({names}));")],
1 => vec![format!("{init} echo count(compact({names}));")],
_ => vec![format!(
"{init} $b = 2; echo json_encode(compact({names}));"
)],
}
}
fn gen_callform(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
const DECL: &str = "class C { public $b = 10; public function m($v) { return $v * 2; } \
public static function s($v) { return $v * 3; } \
public function __invoke($v) { return $v + 1; } } $c = new C;";
let form = *r.pick(&["[$c, 'm']", "['C', 's']", "'C::s'", "$c", "'strrev'"]);
match r.below(6) {
0 => vec![format!("{DECL} $f = {form}; var_dump($f(4));")],
1 => vec![format!("{DECL} var_dump(array_map({form}, [1, 2]));")],
2 => vec![format!("{DECL} var_dump(call_user_func({form}, 5));")],
3 => vec![format!(
"{DECL} var_dump(is_callable({form}), Closure::fromCallable({form})(6));"
)],
4 => vec![format!(
"{DECL} var_dump(array_filter([1, 2, 3], fn($v) => call_user_func({form}, $v) > 3));"
)],
_ => vec![format!(
"{DECL} $x = [3, 1, 2]; usort($x, fn($p, $q) => \
call_user_func({form}, $p) <=> call_user_func({form}, $q)); var_dump($x);"
)],
}
}
fn gen_parseurl(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let url = *r.pick(&[
"https://user:pw@host:8080/path?q=1#frag",
"http://h/p",
"/just/path",
"mailto:a@b.c",
"//host/p",
"host:80",
"file:///c:/x",
"::",
]);
let comp = *r.pick(&[
"PHP_URL_SCHEME",
"PHP_URL_HOST",
"PHP_URL_PORT",
"PHP_URL_USER",
"PHP_URL_PASS",
"PHP_URL_PATH",
"PHP_URL_QUERY",
"PHP_URL_FRAGMENT",
"-1",
"-2",
"8",
"9",
]);
vec![format!(
"try {{ var_dump(parse_url(\"{url}\", {comp})); }} \
catch (Throwable $e) {{ echo get_class($e), ': ', $e->getMessage(), \"\\n\"; }}"
)]
}
fn gen_sscanf(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let input = *r.pick(&[
"42 foo",
"ff 10 0x1F",
"12:34:56",
"abc123",
" 42",
"1e3",
"a b",
"hello5",
"SN/2350001",
"12abc",
"3.14 abc",
"[abc]",
"-17",
"017",
"0x1F",
"00x10",
"+5",
"a1b2",
"XYZ",
"abcdef",
"50%",
"",
" ",
"99999999999999999999",
"1e+",
".",
"]ab",
"a-b",
]);
let fmt = *r.pick(&[
"%d %s",
"%x %o %i",
"%d:%d:%d",
"%[a-c]",
"%[^0-9]",
"%[]a]",
"%[a-]",
"%d",
"%s",
"%c",
"%c%c%c",
"%2c",
"%5s",
"%f",
"%e",
"%u",
"%o",
"%i",
"%*c%c",
"%3s%3s",
"%s%n",
"%ld %hd %Lf",
"%d%%",
"SN/%d",
"%d%s",
"%d %d %d",
"age %d name %s",
"[%[a-c]]",
"%[a-z]%d%[a-z]%d",
"x%d",
" ",
]);
let byref = r.below(2) == 0;
if byref {
vec![format!(
"$a = $b = $c = 'UNSET'; \
var_dump(sscanf(\"{input}\", \"{fmt}\", $a, $b, $c), $a, $b, $c);"
)]
} else {
vec![format!("var_dump(sscanf(\"{input}\", \"{fmt}\"));")]
}
}
fn gen_cslashes(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let subject = *r.pick(&[
"foo[bar]",
"zoo['.']",
"a..b",
"x",
"hello",
"\\n\\t\\x07",
"A1z9",
" padded ",
"XYZhi",
"aqz",
"!hi!",
"",
]);
let list = *r.pick(&[
"A..Z",
"A..z",
"a..z",
"z..A",
"..z",
"a..",
"a..b..c",
"z..a",
"0..9",
"!..#",
"",
"abc",
".",
"\\n\\t\\x07",
]);
let call = *r.pick(&["addcslashes", "trim", "ltrim", "rtrim"]);
vec![
format!("var_dump({call}(\"{subject}\", \"{list}\"));"),
format!("var_dump(stripcslashes(\"{subject}\"));"),
format!("var_dump(str_word_count(\"{subject}\", 0, \"{list}\"));"),
]
}
fn gen_strtok_counts(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let subject = *r.pick(&[
"a b c",
" a b ",
"a;b.c",
"abc",
"",
"aab",
"hello world",
" ",
]);
let delims = *r.pick(&[" ", ";.", "", "x", "abc", " \\t"]);
let mode = *r.pick(&["0", "1", "2", "3", "5", "-1"]);
vec![
format!(
"var_dump(strtok(\"{subject}\", \"{delims}\"), strtok(\"{delims}\"), \
strtok(\"{delims}\"), strtok(\"{delims}\"));"
),
format!(
"try {{ $c = count_chars(\"{subject}\", {mode}); \
var_dump(is_array($c) ? count($c) : $c); }} \
catch (Throwable $e) {{ echo get_class($e), ': ', $e->getMessage(), \"\\n\"; }}"
),
]
}
fn gen_substrx(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let subject = *r.pick(&[
"\"Hello\"",
"[\"ab\", \"cd\"]",
"[\"hello\", \"world\"]",
"[\"k\" => \"abc\"]",
"[\"abcd\", \"efgh\"]",
"[]",
"\"\"",
]);
let replace = *r.pick(&["\"Z\"", "[\"X\", \"Y\"]", "[\"X\"]", "\"\"", "[]"]);
let from = *r.pick(&["0", "1", "-2", "10", "[1, 0]", "[1, 2]", "[]"]);
let length = *r.pick(&["1", "-1", "0", "100", "[2, 1]", "null", ""]);
let call = if length.is_empty() {
format!("substr_replace({subject}, {replace}, {from})")
} else {
format!("substr_replace({subject}, {replace}, {from}, {length})")
};
let hay = *r.pick(&["\"Hello\"", "\"Hello World\"", "\"abc\"", "\"a\"", "\"\""]);
let needle = *r.pick(&[
"\"hello\"",
"\"world\"",
"\"abz\"",
"\"ABD\"",
"\"\"",
"\"abcdef\"",
]);
let off = *r.pick(&["0", "3", "6", "-3", "5"]);
let len2 = *r.pick(&["null", "5", "2", "0", "-1", "3"]);
let ci = *r.pick(&["true", "false"]);
vec![
format!(
"try {{ var_dump({call}); }} \
catch (Throwable $e) {{ echo get_class($e), ': ', $e->getMessage(), \"\\n\"; }}"
),
format!(
"try {{ var_dump(substr_compare({hay}, {needle}, {off}, {len2}, {ci})); }} \
catch (Throwable $e) {{ echo get_class($e), ': ', $e->getMessage(), \"\\n\"; }}"
),
]
}
fn gen_arrayfold(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let base = *r.pick(&[
"[\"a\" => [\"b\" => 1, \"c\" => 2]]",
"[\"a\" => 1]",
"[\"a\" => [\"x\"]]",
"[1, 2, 3]",
"[]",
]);
let over = *r.pick(&[
"[\"a\" => [\"b\" => 9]]",
"[\"a\" => [\"b\" => 2]]",
"[\"a\" => \"s\"]",
"[9]",
"[]",
]);
let fold = *r.pick(&[
"[1, \"a\"]",
"[1, \"2abc\"]",
"[1, [2]]",
"[2, \"a\"]",
"[]",
"[1, null, true, false]",
"[1, \"1e3\"]",
"[1, new stdClass]",
"[PHP_INT_MAX, 1]",
"[1, 2.5]",
]);
let fname = *r.pick(&["array_sum", "array_product"]);
let nested = *r.pick(&["[1, [2, [3]]]", "[\"x\" => 1]", "[]", "[1, 2]"]);
vec![
format!("var_dump(array_replace_recursive({base}, {over}));"),
format!("var_dump({fname}({fold}));"),
format!(
"$a = {nested}; \
var_dump(array_walk_recursive($a, function (&$v, $k) {{ $v = \"$k:$v\"; }}), $a);"
),
]
}
#[derive(Clone, Copy)]
struct Mode {
name: &'static str,
gen: fn(u64) -> Vec<String>,
}
const MODES: &[Mode] = &[
Mode {
name: "sscanf",
gen: gen_sscanf,
},
Mode {
name: "cslashes",
gen: gen_cslashes,
},
Mode {
name: "strtokcounts",
gen: gen_strtok_counts,
},
Mode {
name: "substrx",
gen: gen_substrx,
},
Mode {
name: "arrayfold",
gen: gen_arrayfold,
},
Mode {
name: "jsondecode",
gen: gen_jsondecode,
},
Mode {
name: "htmlent",
gen: gen_htmlent,
},
Mode {
name: "striptags",
gen: gen_striptags,
},
Mode {
name: "compact",
gen: gen_compact,
},
Mode {
name: "callform",
gen: gen_callform,
},
Mode {
name: "parseurl",
gen: gen_parseurl,
},
Mode {
name: "pregoffset",
gen: gen_pregoffset,
},
Mode {
name: "destructure",
gen: gen_destructure,
},
Mode {
name: "nsconst",
gen: gen_nsconst,
},
Mode {
name: "numjuggle",
gen: gen_numjuggle,
},
Mode {
name: "arith",
gen: gen_arith,
},
Mode {
name: "intdiv",
gen: gen_intdiv,
},
Mode {
name: "floatfmt",
gen: gen_floatfmt,
},
Mode {
name: "pow",
gen: gen_pow,
},
Mode {
name: "concat",
gen: gen_concat,
},
Mode {
name: "compare",
gen: gen_compare,
},
Mode {
name: "ternary",
gen: gen_ternary,
},
Mode {
name: "strfns",
gen: gen_strfns,
},
Mode {
name: "arrays",
gen: gen_arrays,
},
Mode {
name: "sorting",
gen: gen_sorting,
},
Mode {
name: "assoc",
gen: gen_assoc,
},
Mode {
name: "printf",
gen: gen_printf,
},
Mode {
name: "control",
gen: gen_control,
},
Mode {
name: "loops",
gen: gen_loops,
},
Mode {
name: "funcs",
gen: gen_funcs,
},
Mode {
name: "typeconv",
gen: gen_typeconv,
},
Mode {
name: "mathfns",
gen: gen_mathfns,
},
Mode {
name: "exprtree",
gen: gen_exprtree,
},
Mode {
name: "unary",
gen: gen_unary,
},
Mode {
name: "sprintf_rich",
gen: gen_sprintf_rich,
},
Mode {
name: "numedge",
gen: gen_numedge,
},
Mode {
name: "stredge",
gen: gen_stredge,
},
Mode {
name: "arraypipe",
gen: gen_arraypipe,
},
Mode {
name: "multi",
gen: gen_multi,
},
Mode {
name: "bitwise",
gen: gen_bitwise,
},
Mode {
name: "spaceship",
gen: gen_spaceship,
},
Mode {
name: "stroffset",
gen: gen_stroffset,
},
Mode {
name: "coalesce",
gen: gen_coalesce,
},
Mode {
name: "str2",
gen: gen_str2,
},
Mode {
name: "arr2",
gen: gen_arr2,
},
Mode {
name: "math2",
gen: gen_math2,
},
Mode {
name: "refs",
gen: gen_refs,
},
Mode {
name: "closures",
gen: gen_closures,
},
Mode {
name: "exc",
gen: gen_exc,
},
Mode {
name: "typejug2",
gen: gen_typejug2,
},
Mode {
name: "range",
gen: gen_range,
},
Mode {
name: "datefmt",
gen: gen_datefmt,
},
Mode {
name: "printf2",
gen: gen_printf2,
},
Mode {
name: "arr3",
gen: gen_arr3,
},
Mode {
name: "rounding",
gen: gen_rounding,
},
Mode {
name: "dynprop",
gen: gen_dynprop,
},
Mode {
name: "attributes",
gen: gen_attributes,
},
Mode {
name: "errlevel",
gen: gen_errlevel,
},
Mode {
name: "libargerr",
gen: gen_libargerr,
},
Mode {
name: "pregerr",
gen: gen_pregerr,
},
Mode {
name: "pregfancy",
gen: gen_pregfancy,
},
Mode {
name: "propmagic",
gen: gen_propmagic,
},
Mode {
name: "ini",
gen: gen_ini,
},
Mode {
name: "stricttypes",
gen: gen_stricttypes,
},
Mode {
name: "declaresyntax",
gen: gen_declaresyntax,
},
Mode {
name: "exitdie",
gen: gen_exitdie,
},
];
fn build_program(stmts: &[String]) -> String {
stmts.join("\n")
}
fn case_for(base: u64, i: u64) -> (Mode, Vec<String>) {
let case_seed = {
let mut z = base ^ i.wrapping_mul(0x9E37_79B9_7F4A_7C15);
z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
z ^ (z >> 31)
};
let mode = MODES[(case_seed >> 7) as usize % MODES.len()];
(mode, (mode.gen)(case_seed))
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
enum Skip {
OracleTimeout,
OracleInfra,
OursTimeout,
OursInfra,
}
impl Skip {
fn label(self) -> &'static str {
match self {
Skip::OracleTimeout => "oracle timed out",
Skip::OracleInfra => "oracle failed to run",
Skip::OursTimeout => "ours timed out",
Skip::OursInfra => "ours failed to run",
}
}
}
enum Verdict {
Same,
Diverged(Box<(RunOut, RunOut)>),
Skipped(Skip),
Barren,
}
fn judge(script: &str, bin: &Path, timeout: Duration) -> Verdict {
let o = run_oracle(script, timeout);
if o.timed_out {
return Verdict::Skipped(Skip::OracleTimeout);
}
if o.infra_fail {
return Verdict::Skipped(Skip::OracleInfra);
}
let r = run_ours(script, bin, timeout);
if r.timed_out {
return Verdict::Skipped(Skip::OursTimeout);
}
if r.infra_fail {
return Verdict::Skipped(Skip::OursInfra);
}
if differs(&o, &r) {
return Verdict::Diverged(Box::new((o, r)));
}
if o.stdout.is_empty() {
return Verdict::Barren;
}
Verdict::Same
}
fn diverges(script: &str, bin: &Path, timeout: Duration) -> Option<(RunOut, RunOut)> {
let o = run_oracle(script, timeout);
if o.timed_out || o.infra_fail {
return None;
}
let r = run_ours(script, bin, timeout);
if r.timed_out || r.infra_fail {
return None;
}
if differs(&o, &r) {
Some((o, r))
} else {
None
}
}
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).is_some() {
cur = cand;
removed = true;
} else {
i += 1;
}
}
if !removed {
break;
}
}
cur
}
fn signature(mode: &str, program: &str) -> String {
let line = program
.lines()
.rfind(|l| !l.trim().is_empty())
.unwrap_or("");
let mut out = String::with_capacity(line.len());
let bytes = line.as_bytes();
let mut i = 0;
while i < bytes.len() {
let c = bytes[i];
if c == b'"' || c == b'\'' {
let q = c;
out.push('W');
i += 1;
while i < bytes.len() && bytes[i] != q {
i += 1;
}
i += 1; } else if c.is_ascii_digit() {
out.push('N');
while i < bytes.len() && (bytes[i].is_ascii_digit() || bytes[i] == b'.') {
i += 1;
}
} else {
out.push(c as char);
i += 1;
}
}
format!("[{mode}] {out}")
}
#[derive(Debug)]
struct Divergence {
seed: u64,
mode: &'static str,
program: String,
oracle_out: String,
oracle_err: String,
oracle_exit: i32,
ours_out: String,
ours_err: String,
ours_exit: i32,
signature: String,
}
struct Args {
count: u64,
base_seed: u64,
jobs: usize,
timeout: Duration,
once: Option<u64>,
mode: Option<String>,
show: usize,
}
fn parse_args() -> Args {
let mut a = Args {
count: 2000,
base_seed: 0,
jobs: std::thread::available_parallelism()
.map(|n| n.get().min(8))
.unwrap_or(4),
timeout: Duration::from_millis(5000),
once: None,
mode: None,
show: 10,
};
let argv: Vec<String> = std::env::args().skip(1).collect();
let mut it = argv.iter();
while let Some(arg) = it.next() {
match arg.as_str() {
"--count" => a.count = it.next().and_then(|s| s.parse().ok()).unwrap_or(a.count),
"--seed" => a.base_seed = it.next().and_then(|s| s.parse().ok()).unwrap_or(0),
"--jobs" => {
a.jobs = it
.next()
.and_then(|s| s.parse().ok())
.unwrap_or(a.jobs)
.max(1)
}
"--timeout" => {
a.timeout = it
.next()
.and_then(|s| s.parse().ok())
.map(Duration::from_millis)
.unwrap_or(a.timeout)
}
"--once" => a.once = Some(1),
"--mode" => a.mode = it.next().cloned(),
"--show" => a.show = it.next().and_then(|s| s.parse().ok()).unwrap_or(a.show),
"-h" | "--help" => {
println!("parity-fuzz [--count N] [--seed S] [--jobs J] [--timeout MS] [--mode NAME] [--once --seed S] [--show N]");
std::process::exit(0);
}
other => {
eprintln!("parity-fuzz: unknown arg {other}");
std::process::exit(2);
}
}
}
a
}
fn main() {
let args = parse_args();
let bin = ours_bin();
if !bin.exists() {
eprintln!(
"parity-fuzz: phplang binary not found at {} (run `cargo build` first)",
bin.display()
);
std::process::exit(2);
}
if args.once.is_some() {
let (mode, stmts) = case_for(args.base_seed, 0);
let prog = build_program(&stmts);
let o = run_oracle(&prog, args.timeout);
let r = run_ours(&prog, &bin, args.timeout);
println!("seed : {}", args.base_seed);
println!("mode : {}", mode.name);
println!("prog : {prog}");
println!(
"oracle: exit={} out={:?} err={:?}",
o.exit,
render(&o.stdout),
render(&o.stderr)
);
println!(
"ours : exit={} out={:?} err={:?}",
r.exit,
render(&r.stdout),
render(&r.stderr)
);
println!("differ: {}", differs(&o, &r));
return;
}
let mode_filter = args.mode.clone();
if let Some(m) = &mode_filter {
if !MODES.iter().any(|md| md.name == m) {
eprintln!("parity-fuzz: unknown mode {m}");
std::process::exit(2);
}
}
eprintln!("parity-fuzz: oracle = {}", oracle_id());
eprintln!("parity-fuzz: ours = {}", bin.display());
eprintln!(
"parity-fuzz: {} cases, {} jobs, base seed {}",
args.count, args.jobs, args.base_seed
);
let next = Arc::new(AtomicUsize::new(0));
let divergences = Arc::new(Mutex::new(Vec::<Divergence>::new()));
let ran = Arc::new(AtomicUsize::new(0));
let start = Instant::now();
let barren: Arc<Mutex<Vec<&'static str>>> = Arc::new(Mutex::new(Vec::new()));
let skipped: Arc<Mutex<Vec<(&'static str, Skip)>>> = Arc::new(Mutex::new(Vec::new()));
let scored = Arc::new(AtomicUsize::new(0));
let mut handles = Vec::new();
for _ in 0..args.jobs {
let next = Arc::clone(&next);
let divergences = Arc::clone(&divergences);
let ran = Arc::clone(&ran);
let barren = Arc::clone(&barren);
let scored = Arc::clone(&scored);
let skipped = Arc::clone(&skipped);
let bin = bin.clone();
let timeout = args.timeout;
let base = args.base_seed;
let count = args.count;
let mode_filter = mode_filter.clone();
handles.push(std::thread::spawn(move || loop {
let i = next.fetch_add(1, Ordering::Relaxed) as u64;
if i >= count {
break;
}
let (mode, stmts) = case_for(base, i);
if let Some(m) = &mode_filter {
if mode.name != m {
continue;
}
}
ran.fetch_add(1, Ordering::Relaxed);
let prog = build_program(&stmts);
let verdict = judge(&prog, &bin, timeout);
let (o, r) = match verdict {
Verdict::Same => {
scored.fetch_add(1, Ordering::Relaxed);
continue;
}
Verdict::Barren => {
barren.lock().unwrap().push(mode.name);
continue;
}
Verdict::Skipped(why) => {
skipped.lock().unwrap().push((mode.name, why));
continue;
}
Verdict::Diverged(pair) => *pair,
};
{
let min = minimize(stmts.clone(), &bin, timeout);
let min_prog = build_program(&min);
let om = run_oracle(&min_prog, timeout);
let rm = run_ours(&min_prog, &bin, timeout);
let (o, r) = if differs(&om, &rm) { (om, rm) } else { (o, r) };
let sig = signature(mode.name, &min_prog);
divergences.lock().unwrap().push(Divergence {
seed: {
i
},
mode: mode.name,
program: min_prog,
oracle_out: render(&o.stdout),
oracle_err: render(&o.stderr),
oracle_exit: o.exit,
ours_out: render(&r.stdout),
ours_err: render(&r.stderr),
ours_exit: r.exit,
signature: sig,
});
}
}));
}
let mut dead_workers = 0usize;
for h in handles {
if h.join().is_err() {
dead_workers += 1;
}
}
let mut divs = Arc::try_unwrap(divergences).unwrap().into_inner().unwrap();
divs.sort_by(|a, b| a.signature.cmp(&b.signature).then(a.seed.cmp(&b.seed)));
let ran = ran.load(Ordering::Relaxed);
let elapsed = start.elapsed();
let mut classes: Vec<(&str, usize, &Divergence)> = Vec::new();
for d in &divs {
match classes.iter_mut().find(|(s, _, _)| *s == d.signature) {
Some((_, n, _)) => *n += 1,
None => classes.push((&d.signature, 1, d)),
}
}
let barren = Arc::try_unwrap(barren).unwrap().into_inner().unwrap();
let skipped = Arc::try_unwrap(skipped).unwrap().into_inner().unwrap();
println!("\n=== parity-fuzz summary ===");
println!("ran : {ran} cases in {:.1}s", elapsed.as_secs_f64());
println!(
"compared : {} (both sides produced a verdict)",
ran.saturating_sub(skipped.len())
);
println!(
"divergences: {} ({} distinct gap classes)",
divs.len(),
classes.len()
);
println!("skipped : {}", skipped.len());
for why in [
Skip::OracleTimeout,
Skip::OracleInfra,
Skip::OursTimeout,
Skip::OursInfra,
] {
let n = skipped.iter().filter(|(_, w)| *w == why).count();
if n > 0 {
println!(" {n:>6} {}", why.label());
let mut by_mode: Vec<(&str, usize)> = Vec::new();
for (m, _) in skipped.iter().filter(|(_, w)| *w == why) {
match by_mode.iter_mut().find(|(name, _)| name == m) {
Some((_, c)) => *c += 1,
None => by_mode.push((m, 1)),
}
}
by_mode.sort_by_key(|c| std::cmp::Reverse(c.1));
for (m, n) in by_mode.iter().take(5) {
println!(" {n:>5}x {m}");
}
}
}
println!(
"barren : {} (agreed, but the reference produced no stdout — \
proves nothing)",
barren.len()
);
if !barren.is_empty() {
let mut by_mode: Vec<(&str, usize)> = Vec::new();
for m in &barren {
match by_mode.iter_mut().find(|(name, _)| name == m) {
Some((_, n)) => *n += 1,
None => by_mode.push((m, 1)),
}
}
by_mode.sort_by(|a, b| b.1.cmp(&a.1).then(a.0.cmp(b.0)));
let ran_by_mode = |name: &str| {
(0..args.count)
.filter(|i| case_for(args.base_seed, *i).0.name == name)
.count()
};
println!(" barren by mode (share of that mode's cases):");
for (name, n) in by_mode {
let total = ran_by_mode(name);
let pct = if total == 0 {
0.0
} else {
100.0 * n as f64 / total as f64
};
println!(" {name:<12} {n:>5} of {total:<6} ({pct:.1}%)");
}
}
let scored = scored.load(Ordering::Relaxed);
println!("scored : {scored} (agreed on a non-empty reference output)");
let missing = ran
.saturating_sub(scored)
.saturating_sub(barren.len())
.saturating_sub(skipped.len())
.saturating_sub(divs.len());
if missing > 0 || dead_workers > 0 {
println!("unaccounted: {missing} cases, {dead_workers} workers died");
}
let compared = ran.saturating_sub(skipped.len());
let mut faults: Vec<String> = Vec::new();
if !divs.is_empty() {
faults.push(format!("{} divergences", divs.len()));
}
if ran == 0 {
faults.push("no cases ran".into());
} else if scored == 0 {
faults.push("no case produced a usable comparison".into());
}
if compared == 0 && ran > 0 {
faults.push("every case that ran was skipped".into());
}
if !skipped.is_empty() {
faults.push(format!("{} skipped", skipped.len()));
}
if !barren.is_empty() {
faults.push(format!("{} barren", barren.len()));
}
if missing > 0 || dead_workers > 0 {
faults.push(format!(
"{missing} unaccounted, {dead_workers} dead workers"
));
}
if !divs.is_empty() {
let n = args.show.min(divs.len());
println!("\n--- first {n} divergences ---");
for d in divs.iter().take(n) {
println!("\n[seed {}] mode={}", d.seed, d.mode);
println!(" prog : {}", d.program.replace('\n', " ⏎ "));
println!(
" oracle: exit={} out={:?} err={:?}",
d.oracle_exit, d.oracle_out, d.oracle_err
);
println!(
" ours : exit={} out={:?} err={:?}",
d.ours_exit, d.ours_out, d.ours_err
);
}
println!("\n--- gap classes (by frequency) ---");
let mut sorted = classes.clone();
sorted.sort_by_key(|c| std::cmp::Reverse(c.1));
for (sig, n, ex) in sorted {
println!(" {n:>4}x {sig}");
println!(
" e.g. oracle={:?}/{:?}/{} ours={:?}/{:?}/{}",
ex.oracle_out,
ex.oracle_err,
ex.oracle_exit,
ex.ours_out,
ex.ours_err,
ex.ours_exit
);
}
let dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("target")
.join("parity-fuzz");
let _ = std::fs::create_dir_all(&dir);
let path = dir.join(format!("divergences-{}.txt", std::process::id()));
let mut report = String::new();
report.push_str(&format!("oracle: {}\n", oracle_id()));
report.push_str(&format!(
"ran {ran} cases, {} divergences, {} classes\n\n",
divs.len(),
classes.len()
));
for d in &divs {
report.push_str(&format!(
"[seed {}] mode={} sig={}\n",
d.seed, d.mode, d.signature
));
report.push_str(&format!(" prog : {}\n", d.program.replace('\n', " ; ")));
report.push_str(&format!(
" oracle: exit={} out={:?} err={:?}\n",
d.oracle_exit, d.oracle_out, d.oracle_err
));
report.push_str(&format!(
" ours : exit={} out={:?} err={:?}\n\n",
d.ours_exit, d.ours_out, d.ours_err
));
}
use std::io::Write;
if let Ok(mut f) = std::fs::File::create(&path) {
let _ = f.write_all(report.as_bytes());
println!("\nfull report: {}", path.display());
}
}
if faults.is_empty() {
println!(
"\n{scored} cases compared clean — phplang matches {} on this corpus.",
oracle_path()
);
return;
}
println!("\nRUN NOT CLEAN: {}", faults.join("; "));
std::process::exit(1);
}