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);
}
if !is_reference_php(&p) {
eprintln!(
"parity-fuzz: PHPLANG_FUZZ_PHP={p} is not a reference PHP \
(`--version` must print a `PHP …` banner that is not phplang's)"
);
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 is_reference_php(path: &str) -> bool {
Command::new(path)
.arg("--version")
.output()
.ok()
.map(|o| {
let banner = String::from_utf8_lossy(&o.stdout);
banner.starts_with("PHP ") && !banner.contains("phplang")
})
.unwrap_or(false)
}
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_funcargs(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
if r.below(6) == 0 {
let f = *r.pick(&["func_get_args()", "func_num_args()", "func_get_arg(0)"]);
return vec![format!("var_dump({f});")];
}
let params = *r.pick(&[
"$a",
"$a, $b",
"$a, $b = 5",
"$a = 1, $b = 2, $c = 3",
"...$r",
"$a, ...$r",
"&$a",
"$a, $b, $c",
]);
let mutate = *r.pick(&[
"",
"$a = 99;",
"$a = 99; $b = 88;",
"unset($a);",
"$r[0] = 77;",
"$a++;",
]);
let report = *r.pick(&[
"return func_get_args();",
"return func_num_args();",
"return func_get_arg(0);",
"return func_get_arg(2);",
"return func_get_arg(-1);",
"return [func_num_args(), func_get_args()];",
]);
let call = *r.pick(&[
"f(1)",
"f(1, 2)",
"f(1, 2, 3)",
"f()",
"f(b: 2, a: 1)",
"f(9, c: 7)",
"f(...[1, 2, 3])",
"f(1, ...[2, 3])",
]);
let prog = match r.below(3) {
0 => format!("function f({params}) {{ {mutate} {report} }} var_dump({call});"),
1 => format!(
"class C {{ function f({params}) {{ {mutate} {report} }} }} \
$o = new C; var_dump($o->{call});"
),
_ => format!("$f = function({params}) {{ {mutate} {report} }}; var_dump($f({call}));"),
};
vec![format!(
"try {{ {prog} }} catch (Throwable $e) {{ echo get_class($e), \"|\", $e->getMessage(); }}"
)]
}
fn gen_extractflags(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let pre = *r.pick(&["", "$x = 1;", "$x = 1; $z = 2;", "$p_x = 0;"]);
let arr = *r.pick(&[
"[\"x\" => 2]",
"[\"x\" => 2, \"z\" => 3]",
"[\"1bad\" => 2, \"ok\" => 3]",
"[5 => 1, \"ok\" => 2]",
"[\"this\" => 5]",
"[]",
"[\"x\" => 2, \"y\" => 4, \"z\" => 6]",
]);
let flags = *r.pick(&[
"",
", EXTR_OVERWRITE",
", EXTR_SKIP",
", EXTR_PREFIX_SAME, \"p\"",
", EXTR_PREFIX_ALL, \"p\"",
", EXTR_PREFIX_INVALID, \"p\"",
", EXTR_PREFIX_IF_EXISTS, \"p\"",
", EXTR_IF_EXISTS",
", EXTR_REFS",
", EXTR_SKIP | EXTR_REFS",
", 999",
", -1",
", EXTR_PREFIX_ALL",
", EXTR_PREFIX_ALL, \"1\"",
", EXTR_PREFIX_ALL, \"\"",
]);
let after = *r.pick(&["", "$x = 9;", "$p_x = 9;"]);
let seen = "foreach ([\"x\", \"y\", \"z\", \"ok\", \"p_x\", \"p_z\", \"p_ok\", \"p_5\", \"_x\", \"p_1bad\", \"p_this\"] as $k) { echo $k, \"=\", isset($$k) ? var_export($$k, true) : \"-\", \"|\"; }";
vec![format!(
"function t() {{ {pre} $a = {arr}; $n = extract($a{flags}); \
var_dump($n); {after} var_dump($a); {seen} }} \
try {{ t(); }} catch (Throwable $e) {{ echo get_class($e), \"|\", $e->getMessage(); }}"
)]
}
fn gen_calleeforms(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let subject = *r.pick(&[
"$n = [1];",
"$n = false;",
"$n = null;",
"$n = 5;",
"$n = \"nope\";",
"$n = \"Nope::m\";",
"$n = new stdClass;",
"$n = [new stdClass, \"nope\"];",
"$n = [1, 2, 3];",
"class C { function m($x) { return $x * 2; } } $n = new C;",
"$n = function ($x) { return $x; };",
"$n = \"strtoupper\";",
]);
let call = *r.pick(&[
"$n->m(f())",
"$n?->m(f())",
"$n(f())",
"undefinedfn(f())",
"Nope::m(f())",
"new Nope(f())",
"C::nope(f())",
"$n->m(f(), f())",
"$n->m(x: f())",
"undefinedfn(x: f())",
"new Nope(x: f())",
"$n->m()",
"undefinedfn()",
"new Nope()",
]);
vec![format!(
"function f() {{ echo \"F\"; return 1; }} {subject} \
try {{ var_dump({call}); }} \
catch (Throwable $e) {{ echo get_class($e), \"|\", $e->getMessage(); }}"
)]
}
fn gen_fcc(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let decl = *r.pick(&[
"class C { function m($a, $b = 5) { return \"$a/$b\"; } \
static function s($a, $b = 5) { return \"s$a/$b\"; } }",
"class C { private function m($a, $b = 5) { return \"p$a/$b\"; } \
private static function s($a, $b = 5) { return \"ps$a/$b\"; } }",
"class C { protected function m($a, $b = 5) { return \"q$a/$b\"; } \
static function s($a, $b = 5) { return \"s$a/$b\"; } }",
"class C { function __call($n, $x) { return \"call:$n:\" . count($x); } \
static function __callStatic($n, $x) { return \"cs:$n:\" . count($x); } }",
]);
const USER_CALLS: &[&str] = &[
"$f(1)",
"$f(1, 2)",
"$f(a: 1)",
"$f(b: 2, a: 1)",
"$f(1, b: 2)",
"\"built\"",
];
const BUILTIN_CALLS: &[&str] = &["$f(\"Ab\")", "\"built\""];
let (callee, calls): (&str, &[&str]) = *r.pick(&[
("strtoupper(...)", BUILTIN_CALLS),
("$name(...)", BUILTIN_CALLS),
("nosuchfunction(...)", BUILTIN_CALLS),
("(new C)->m(...)", USER_CALLS),
("(new C)->nope(...)", USER_CALLS),
("C::s(...)", USER_CALLS),
("C::nope(...)", USER_CALLS),
("Nope::m(...)", USER_CALLS),
("$scalar->m(...)", USER_CALLS),
("$scalar::s(...)", USER_CALLS),
("$fn(...)", USER_CALLS),
("mk()->m(...)", USER_CALLS),
]);
let call = *r.pick(calls);
vec![format!(
"{decl} function mk() {{ echo \"MK\"; return new C; }} \
$scalar = \"C\"; $name = \"strtolower\"; \
$fn = function ($a, $b = 5) {{ return \"f$a/$b\"; }}; \
try {{ $f = {callee}; var_dump({call}); }} \
catch (Throwable $e) {{ echo get_class($e), \"|\", $e->getMessage(); }}"
)]
}
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_builtinargs(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
const FNS: &[(&str, &str, usize)] = &[
("strtolower", "string", 1),
("strrev", "string", 1),
("str_repeat", "times", 2),
("substr", "offset", 2),
("implode", "separator", 1),
("array_slice", "offset", 2),
("str_pad", "pad_string", 3),
("in_array", "strict", 3),
("number_format", "decimals", 2),
("explode", "limit", 3),
("array_keys", "strict", 3),
("count", "mode", 2),
("str_replace", "subject", 3),
("array_search", "needle", 1),
("array_fill", "count", 2),
("htmlspecialchars", "double_encode", 4),
("ucwords", "separators", 2),
("sprintf", "format", 1),
("array_map", "callback", 1),
("array_filter", "callback", 2),
("str_word_count", "format", 2),
("substr_count", "length", 4),
];
const VALS: &[&str] = &[
"\"ab\"", "\"a\"", "1", "0", "2", "[1, 2]", "[]", "true", "null", "$arr",
];
const CALLBACKS: &[&str] = &[
"\"strtoupper\"",
"\"nofunc\"",
"null",
"1",
"[1, 2]",
"[\"C\"]",
"[\"C\", \"nope\"]",
"[\"C\", \"m\"]",
"[\"C\", \"s\"]",
"[$o, \"m\"]",
"[$o, \"p\"]",
"\"C::m\"",
"\"C::s\"",
"fn($v) => $v",
"$o",
];
const DECL: &str = "class C { public function m($v = 1) { return $v; } \
private function p($v = 1) { return $v; } \
public static function s($v = 1) { return $v; } } \
$arr = [3, 1, 2]; $o = new C();";
let (func, pname, ppos) = *r.pick(FNS);
let takes_callback = matches!(func, "array_map" | "array_filter");
let npos = r.below(5);
let mut args: Vec<String> = Vec::new();
for i in 0..npos {
let at_callback = takes_callback && (i + 1 == if func == "array_map" { 1 } else { 2 });
args.push(if at_callback {
(*r.pick(CALLBACKS)).to_string()
} else {
(*r.pick(VALS)).to_string()
});
}
match r.below(4) {
0 => {}
1 => args.push(format!("{pname}: {}", r.pick(VALS))),
2 => args.push(format!("nosuch: {}", r.pick(VALS))),
_ => {
let _ = ppos;
args.push(format!("{pname}: {}", r.pick(VALS)));
}
}
let call = format!("{func}({})", args.join(", "));
match r.below(4) {
0 => vec![format!(
"{DECL} try {{ var_dump({call}); }} catch (Throwable $e) {{ \
echo get_class($e), \"|\", $e->getMessage(); }}"
)],
1 => vec![format!(
"{DECL} try {{ {call}; }} catch (Throwable $e) {{ \
echo $e->getLine(), \"|\", $e->getTraceAsString(); }}"
)],
2 => vec![format!(
"{DECL} function f() {{ global $arr, $o; return {call}; }} var_dump(f());"
)],
_ => vec![format!("{DECL} var_dump({call});")],
}
}
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_mbx(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let subject = *r.pick(&[
"\" h\u{e9}llo \"",
"\"\u{3000}x\u{a0}\u{2003}\"",
"\"\\0 a \\0\"",
"\"xxh\u{e9}xx\"",
"\"\u{65e5}\u{672c}\u{8a9e}abc\"",
"\"Hello World\"",
"\"\"",
"\"a/b/c\"",
"\"h\u{c9}LLo\"",
]);
let chars = *r.pick(&["null", "\"x\"", "\" \"", "\"\u{e9}h\"", "\"a-b\"", "\"\""]);
let needle = *r.pick(&[
"\"l\"",
"\"/\"",
"\"\u{e9}\"",
"\"LL\"",
"\"\"",
"\"zz\"",
"\"\u{672c}\"",
]);
let before = *r.pick(&["true", "false"]);
let start = *r.pick(&["0", "1", "3", "-2", "-100", "100"]);
let width = *r.pick(&["0", "3", "5", "8", "-1", "-3", "100"]);
let marker = *r.pick(&["\"\"", "\"...\"", "\"\u{2026}\"", "\".\""]);
let map = *r.pick(&[
"[0x80, 0x10ffff, 0, 0xffffff]",
"[0x61, 0x62, 1, 0xff]",
"[0x61, 0x7a, 0x100, 0xff]",
"[0x61, 0x62, 0, 0xff, 0x6c, 0x6c, 5, 0xffff]",
"[0x80, 0xff, 0, 0xff]",
"[0, 0x7f, -1, 0xffff]",
]);
let entities = *r.pick(&[
"\"é日a\"",
"\"abc\"",
"\"bxc yd\"",
"\"a&#+97;&# 97;\"",
"\"a&b&#;&#x;&#\"",
"\"lqk\"",
]);
let guard = |call: String| {
format!(
"try {{ var_dump({call}); }} \
catch (Throwable $e) {{ echo get_class($e), ': ', $e->getMessage(), \"\\n\"; }}"
)
};
vec![
guard(format!("mb_trim({subject}, {chars})")),
guard(format!("mb_ltrim({subject}, {chars})")),
guard(format!("mb_rtrim({subject}, {chars})")),
guard(format!("mb_strstr({subject}, {needle}, {before})")),
guard(format!("mb_stristr({subject}, {needle}, {before})")),
guard(format!("mb_strrchr({subject}, {needle}, {before})")),
guard(format!("mb_strrichr({subject}, {needle}, {before})")),
guard(format!(
"mb_strimwidth({subject}, {start}, {width}, {marker})"
)),
guard(format!(
"mb_encode_numericentity({subject}, {map}, 'UTF-8', {before})"
)),
guard(format!("mb_decode_numericentity({entities}, {map})")),
]
}
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);"
),
]
}
fn gen_heredoc(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let n = ii(r);
let w = ww(r);
match r.below(7) {
0 => vec![format!(
"$n = {n}; $a = [\"k\" => \"{w}\"]; $o = new stdClass; $o->p = \"{w}\";\n\
$s = <<<EOT\nsimple $n, sub $a[k], prop $o->p, braced {{$a[\"k\"]}}\nEOT;\n\
var_dump($s);"
)],
1 => {
let esc = *r.pick(&[
"\\t|\\n|\\\\",
"\\$n",
"\\x41\\101",
"\\\"|\\'",
"\\u{48}",
"\\e",
"\\q",
]);
vec![format!(
"$n = {n};\n$s = <<<EOT\n{esc}\nEOT;\nvar_dump($s);"
)]
}
2 => {
let body = *r.pick(&["$n {$n}", "\\n \\\\ \\t", "a$n\\x41", "{$n}"]);
vec![format!(
"$n = {n};\n$s = <<<'EOT'\n{body}\nEOT;\nvar_dump($s);"
)]
}
3 => {
let (body_indent, close_indent) = *r.pick(&[
(" ", " "),
(" ", " "),
(" ", " "),
("\t", "\t"),
("", " "),
(" ", ""),
]);
vec![format!(
"$s = <<<EOT\n{body_indent}one\n{body_indent}two\n\n{close_indent}EOT;\n\
var_dump($s);"
)]
}
4 => {
let tail = *r.pick(&["EOT;", "EOT . \"z\";", "EOT , \"z\");", "EOTX\nEOT;"]);
let open = if tail.starts_with("EOT ,") {
"$s = implode(\"-\", array(<<<EOT\nbody\n"
} else {
"$s = <<<EOT\nbody\n"
};
vec![format!("{open}{tail}\nvar_dump($s);")]
}
5 => {
let body = *r.pick(&["", "\n", "a\n", "\n\n"]);
vec![format!("$s = <<<EOT\n{body}EOT;\nvar_dump($s);")]
}
_ => {
let form = *r.pick(&[
"$s = <<<\"EOT\"\nv$n\nEOT;\nvar_dump($s);",
"$s = <<< EOT\nv$n\nEOT;\nvar_dump($s);",
"$s = <<<_e1\nv$n\n_e1;\nvar_dump($s);",
"$s = <<<EOT\nv$n\n",
"$s = <<<9BAD\nv\n9BAD;\nvar_dump($s);",
]);
vec![format!("$n = {n};\n{form}")]
}
}
}
fn gen_nullsafechain(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let decl = "class B { public $v = 7; public $n = null; function m($x = 1) { return $x * 2; } } \
class A { public $b; public $z = null; function __construct() { $this->b = new B(); } }";
let chain = *r.pick(&[
"$r?->a->b",
"$r?->a->b->c",
"$r?->a[\"k\"]",
"$r?->m()->x",
"$r?->a->b->c()",
"$r?->b?->v",
"$r?->b->v",
"$r?->b->m(3)",
"$r?->z?->v->w",
"$r?->b->n?->v->w",
"$r?->b->n->v",
]);
let recv = *r.pick(&["null", "new A()", "(new A())->z"]);
match r.below(4) {
0 => vec![format!("{decl} $r = {recv}; var_dump({chain});")],
1 => vec![format!(
"{decl} $r = {recv}; echo \"[\"; var_dump({chain}); echo \"]\";"
)],
2 => vec![format!(
"{decl} function f() {{ echo \"F\"; return 1; }} $r = {recv}; \
var_dump($r?->a->m(f()));"
)],
_ => {
let q = *r.pick(&["isset(%)", "empty(%)", "% ?? \"D\"", "@%"]);
vec![format!(
"{decl} $r = {recv}; var_dump({});",
q.replace('%', chain)
)]
}
}
}
fn gen_matcherr(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let subject = *r.pick(&[
"null",
"true",
"false",
"5",
"-0.0",
"1.0",
"1e100",
"NAN",
"PHP_INT_MAX",
"\"hi\"",
"\"\"",
"\"0\"",
"str_repeat(\"ab\", 30)",
"[1, 2]",
"[]",
"new stdClass",
"new ArrayObject([])",
"(fn() => 1)",
]);
let arms = *r.pick(&[
"999999 => 1",
"1 => \"a\", 2 => \"b\"",
"\"x\" => 1",
"null => \"n\"",
]);
match r.below(3) {
0 => vec![format!(
"try {{ echo match ({subject}) {{ {arms} }}; }} \
catch (\\UnhandledMatchError $e) {{ echo get_class($e), \"|\", $e->getMessage(); }}"
)],
1 => vec![format!("echo match ({subject}) {{ {arms} }};")],
_ => vec![format!(
"echo \"[\", match ({subject}) {{ {arms}, default => \"D\" }}, \"]\";"
)],
}
}
fn gen_ifaceconst(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let v = ii(r);
let shape = *r.pick(&[
"interface I { const K = %; } class C implements I {}",
"interface I { const K = %; } interface J extends I {} class C implements J {}",
"interface I { const K = %; } class P implements I {} class C extends P {}",
"interface I { const K = 1; } class P implements I {} class C extends P { const K = %; }",
"interface I { const K = 1; } class C implements I { const K = %; }",
"interface I { const K = %; } trait T {} class C implements I { use T; }",
"interface I { const K = 1; } class C {} const K = %;",
"abstract class I { const K = %; } class C extends I {}",
]);
let decl = shape.replace('%', v);
let read = *r.pick(&[
"C::K",
"I::K",
"constant(\"C::K\")",
"defined(\"C::K\")",
"(new C())->r()",
]);
let body = if read == "(new C())->r()" {
let via = *r.pick(&["self::K", "static::K", "C::K", "$this::K"]);
format!(
"{decl} class D {{}} function mk() {{ return null; }} \
try {{ echo (function () {{ return {via}; }})->call(new C()); }} \
catch (\\Throwable $e) {{ echo get_class($e), \": \", $e->getMessage(); }}"
)
} else {
format!(
"{decl} try {{ var_dump({read}); }} \
catch (\\Throwable $e) {{ echo get_class($e), \": \", $e->getMessage(); }}"
)
};
vec![body]
}
fn gen_generators(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let n = *r.pick(&["0", "1", "3"]);
match r.below(6) {
0 => vec![format!(
"function g() {{ for ($i = 0; $i < {n}; $i++) {{ yield $i => $i * 2; }} return \"R\"; }} \
$x = g(); foreach ($x as $k => $v) {{ echo \"$k=$v,\"; }} var_dump($x->getReturn());"
)],
1 => vec![
"function g() { yield 1; yield from [10, 20]; yield from h(); yield 2; } \
function h() { yield \"a\" => 5; } \
foreach (g() as $k => $v) { echo \"$k=$v,\"; }"
.to_string(),
],
2 => vec![
"function g() { $x = yield 1; echo \"got:\", var_export($x, true), \",\"; \
$y = yield 2; echo \"got:\", var_export($y, true), \",\"; } \
$g = g(); echo $g->current(), \",\", $g->send(\"A\"), \",\"; $g->send(\"B\"); \
var_dump($g->valid());"
.to_string(),
],
3 => vec![
"function g() { echo \"body,\"; yield 1; } echo \"before,\"; $g = g(); \
echo \"made,\"; var_dump($g->key()); echo \"|\"; var_dump(iterator_to_array($g));"
.to_string(),
],
4 => vec![format!(
"function g() {{ try {{ yield 1; yield 2; }} finally {{ echo \"F,\"; }} }} \
foreach (g() as $v) {{ echo $v, \",\"; if ($v >= {n}) break; }} echo \"done\";"
)],
_ => vec![
"function g() { yield 1; throw new RuntimeException(\"boom\"); } \
try { foreach (g() as $v) { echo $v; } } \
catch (\\Throwable $e) { echo get_class($e), \":\", $e->getMessage(); } \
var_dump((function () { yield; })() instanceof Generator);"
.to_string(),
],
}
}
fn gen_enums(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let backed = *r.pick(&["string", "int"]);
let (a, b) = if backed == "int" {
("1", "2")
} else {
("\"a\"", "\"b\"")
};
let probe = *r.pick(&[a, b, "\"z\"", "9", "null"]);
match r.below(5) {
0 => vec![format!(
"enum E: {backed} {{ case A = {a}; case B = {b}; }} \
var_dump(E::tryFrom({probe})); \
try {{ var_dump(E::from({probe})); }} \
catch (\\Throwable $e) {{ echo get_class($e), \": \", $e->getMessage(); }}"
)],
1 => vec![format!(
"enum E: {backed} {{ case A = {a}; case B = {b}; }} \
print_r(E::cases()); var_dump(E::A === E::A, E::A == E::B, E::A instanceof E);"
)],
2 => vec![
"enum P { case X; case Y; } var_dump(P::X); echo P::X->name; \
var_dump(P::X instanceof UnitEnum, P::X instanceof BackedEnum);"
.to_string(),
],
3 => vec![format!(
"interface HasLabel {{ const PFX = \"p:\"; public function label(): string; }} \
enum E: {backed} implements HasLabel {{ case A = {a}; \
const DEFAULT = self::A; \
public function label(): string {{ return self::PFX . $this->name; }} }} \
echo E::A->label(), \"|\", E::DEFAULT->name, \"|\", E::PFX;"
)],
_ => vec![format!(
"enum E: {backed} {{ case A = {a}; }} \
try {{ $x = new E(); }} catch (\\Throwable $e) {{ echo get_class($e), \"|\"; }} \
var_dump(json_encode([E::A]), E::A->value, isset(E::A->name));"
)],
}
}
fn gen_traits(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
match r.below(5) {
0 => vec![
"trait T { public function hi() { return static::class . \"-\" . self::class; } } \
class C { use T; } class D extends C {} echo (new C())->hi(), \"|\", (new D())->hi();"
.to_string(),
],
1 => {
let clause = *r.pick(&[
"A::f insteadof B; B::f as g;",
"B::f insteadof A;",
"A::f insteadof B;",
"",
]);
vec![format!(
"trait A {{ public function f() {{ return \"A\"; }} }} \
trait B {{ public function f() {{ return \"B\"; }} }} \
class C {{ use A, B {{ {clause} }} }} \
$c = new C(); echo $c->f(); if (method_exists($c, \"g\")) {{ echo $c->g(); }}"
)]
}
2 => vec![
"trait T { public static $n = 0; public static function bump() { return ++static::$n; } \
abstract public function need(): string; } \
class C { use T; public function need(): string { return \"N\"; } } \
class D { use T; public function need(): string { return \"M\"; } } \
echo C::bump(), C::bump(), D::bump(), (new C())->need();"
.to_string(),
],
3 => vec![
"trait T { public function f() { return \"T\"; } } \
class C { use T; public function f() { return \"C\"; } } \
class P { public function f() { return \"P\"; } } class Q extends P { use T; } \
echo (new C())->f(), (new Q())->f();"
.to_string(),
],
_ => vec![
"trait T { public function f() { return \"T\"; } } \
class C { use T { f as protected p; } public function q() { return $this->p(); } } \
$c = new C(); echo $c->q(); \
try { echo $c->p(); } catch (\\Throwable $e) { echo \"|\", get_class($e), \": \", $e->getMessage(); }"
.to_string(),
],
}
}
fn gen_variadic(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let spread = *r.pick(&[
"[1, 2]",
"[]",
"[\"b\" => 2, \"a\" => 1]",
"[\"nope\" => 1]",
"[1, \"b\" => 2]",
"\"str\"",
"null",
"(function () { yield 1; yield 2; })()",
"new ArrayIterator([3, 4])",
]);
match r.below(5) {
0 => vec![format!(
"function f(...$xs) {{ return count($xs) . \":\" . implode(\",\", $xs); }} \
try {{ echo f(...{spread}); }} \
catch (\\Throwable $e) {{ echo get_class($e), \": \", $e->getMessage(); }}"
)],
1 => vec![format!(
"function f($a = \"x\", $b = \"y\") {{ return \"$a|$b\"; }} \
try {{ echo f(...{spread}); }} \
catch (\\Throwable $e) {{ echo get_class($e), \": \", $e->getMessage(); }}"
)],
2 => vec![format!(
"try {{ var_dump([0, ...{spread}, 9]); }} \
catch (\\Throwable $e) {{ echo get_class($e), \": \", $e->getMessage(); }}"
)],
3 => vec![
"function f(int ...$xs) { return array_sum($xs); } \
try { echo f(1, 2, \"3\"); } catch (\\Throwable $e) { echo get_class($e), \": \", $e->getMessage(); } \
echo \"|\"; \
function g($first, ...$rest) { return $first . \"/\" . implode(\",\", $rest); } echo g(1, 2, 3);"
.to_string(),
],
_ => vec![format!(
"function f(&...$xs) {{ return count($xs); }} \
try {{ $a = 1; echo f($a); }} \
catch (\\Throwable $e) {{ echo get_class($e), \": \", $e->getMessage(); }} \
echo \"|\", (fn(...$a) => implode(\"-\", $a))(...{spread});"
)],
}
}
fn gen_splobj(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
match r.below(5) {
0 => vec![
"class C implements ArrayAccess { private $d = [\"a\" => 1]; \
public function offsetExists($o): bool { return isset($this->d[$o]); } \
public function offsetGet($o): mixed { return $this->d[$o] ?? \"none\"; } \
public function offsetSet($o, $v): void { if ($o === null) { $this->d[] = $v; } else { $this->d[$o] = $v; } } \
public function offsetUnset($o): void { unset($this->d[$o]); } } \
$c = new C(); $c[\"b\"] = 2; $c[] = 3; \
var_dump($c[\"a\"], isset($c[\"b\"]), isset($c[\"zz\"]), $c[0]); \
unset($c[\"a\"]); var_dump($c[\"a\"], empty($c[\"b\"]));"
.to_string(),
],
1 => {
let n = *r.pick(&["0", "1", "7"]);
vec![format!(
"class C implements Countable {{ public function count(): int {{ return {n}; }} }} \
var_dump(count(new C()), (new C()) instanceof Countable); \
try {{ var_dump(count(new stdClass)); }} \
catch (\\Throwable $e) {{ echo get_class($e), \": \", $e->getMessage(); }}"
)]
}
2 => vec![
"class C implements IteratorAggregate { public function getIterator(): Iterator { return new ArrayIterator([\"x\" => 1, \"y\" => 2]); } } \
foreach (new C() as $k => $v) { echo \"$k=$v,\"; } \
var_dump(iterator_to_array(new C()));"
.to_string(),
],
3 => vec![
"class C implements Iterator { private $i = 0; private $a = [10, 20, 30]; \
public function current(): mixed { return $this->a[$this->i]; } \
public function key(): mixed { return \"k\" . $this->i; } \
public function next(): void { $this->i++; } \
public function rewind(): void { echo \"R,\"; $this->i = 0; } \
public function valid(): bool { return $this->i < count($this->a); } } \
$c = new C(); foreach ($c as $k => $v) { echo \"$k=$v,\"; } \
foreach ($c as $v) { echo $v, \",\"; break; }"
.to_string(),
],
_ => {
let ret = *r.pick(&["\"S\"", "\"\"", "(string) 5"]);
vec![format!(
"class C {{ public function __toString(): string {{ return {ret}; }} }} \
$c = new C(); echo $c, \"|\", \"x{{$c}}y\", \"|\"; \
var_dump((string) $c, $c instanceof Stringable, strlen($c), $c == \"S\");"
)]
}
}
}
fn gen_altsyntax(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let n = ii(r);
let m = ii(r);
let body = *r.pick(&[
"echo \"b\";",
"echo $i;",
"$t .= \"x\";",
"if ($i > 0): echo \"p\"; else: echo \"q\"; endif;",
"?>raw<?php ",
"echo \"a\"; ?>|<?php echo \"z\";",
]);
let shape = *r.pick(&[
"if (#N): echo \"t\"; endif;",
"if (#N): echo \"t\"; else: echo \"f\"; endif;",
"if (#N): echo \"t\"; elseif (#M): echo \"e\"; else: echo \"f\"; endif;",
"if (#N): if (#M): echo \"in\"; endif; echo \"out\"; endif;",
"for ($i = 0; $i < 3; $i++): #B endfor;",
"$i = 0; while ($i < 3): #B $i++; endwhile;",
"foreach ([#N, #M] as $i): #B endforeach;",
"foreach ([\"k\" => #N] as $k => $i): echo \"$k=$i\"; endforeach;",
"switch (#N): case #M: echo \"m\"; break; case #N: echo \"n\"; break; default: echo \"d\"; endswitch;",
"switch (#N): default: echo \"d\"; endswitch;",
"declare(ticks=1): echo \"tick\"; enddeclare;",
"if (#N): ?>YES<?php else: ?>NO<?php endif;",
"for ($i = 0; $i < 2; $i++): if ($i): continue; endif; echo $i; endfor;",
"$i = 0; while (true): $i++; if ($i > 2): break; endif; echo $i; endwhile;",
]);
let prog = shape.replace("#N", n).replace("#M", m).replace("#B", body);
vec![format!("$t = \"\"; {prog} echo \"|\", $t, \"|\";")]
}
fn gen_printexpr(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let a = *r.pick(&[
"true", "false", "1", "0", "\"\"", "\"s\"", "null", "[]", "2",
]);
let b = *r.pick(&["true", "false", "1", "0", "\"\"", "\"s\"", "null", "3"]);
let shape = *r.pick(&[
"$x = #A and #B; var_dump($x);",
"$x = #A or #B; var_dump($x);",
"$x = #A xor #B; var_dump($x);",
"var_dump(#A and #B, #A or #B, #A xor #B);",
"var_dump(#A xor #B xor #A);",
"var_dump(#A or #B and #A);",
"$x = 1; $y = $x == 1 and #B; var_dump($x, $y);",
"$r = print \"p\"; var_dump($r);",
"var_dump(print \"p\");",
"echo print(\"p\"), \"|\";",
"print #A; echo \"|\";",
"#A or print \"o\"; echo \"|\";",
"$x = #A and print \"a\"; var_dump($x);",
"var_dump(#A ? print \"y\" : print \"n\");",
"print print \"n\"; echo \"|\";",
"function f($v) { echo \"f\"; return $v; } var_dump(f(#A) and f(#B));",
"function f($v) { echo \"f\"; return $v; } var_dump(f(#A) or f(#B));",
"function f($v) { echo \"f\"; return $v; } var_dump(f(#A) xor f(#B));",
"$a = #A; $a = #B and #A; var_dump($a);",
"var_dump(#A && #B or #A);",
]);
vec![shape.replace("#A", a).replace("#B", b)]
}
fn gen_reflect(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let subject = *r.pick(&[
"(function () { yield 1; })()",
"(function () { return 1; })",
"(fn() => 1)",
"new C()",
"new D()",
"E::A",
"[1, 2]",
"\"C\"",
"17",
"null",
]);
let q = *r.pick(&[
"var_dump(is_object($v));",
"var_dump(gettype($v));",
"var_dump(get_debug_type($v));",
"try { var_dump(get_class($v)); } catch (\\Throwable $e) { echo get_class($e), \": \", $e->getMessage(); }",
"try { var_dump(get_object_vars($v)); } catch (\\Throwable $e) { echo get_class($e), \": \", $e->getMessage(); }",
"var_dump($v instanceof Generator, $v instanceof Closure);",
"var_dump($v instanceof Traversable, $v instanceof Iterator);",
"var_dump($v instanceof I, $v instanceof C, $v instanceof UnitEnum);",
"var_dump(is_a($v, \"Closure\"), is_a($v, \"Generator\"), is_a($v, \"C\"));",
"var_dump(is_subclass_of($v, \"Iterator\"), is_subclass_of($v, \"C\"));",
"var_dump(method_exists($v, \"current\"), method_exists($v, \"bindTo\"), method_exists($v, \"go\"));",
"var_dump(is_callable($v), is_iterable($v), is_countable($v), is_scalar($v));",
"try { echo strlen($v); } catch (\\Throwable $e) { echo get_class($e), \": \", $e->getMessage(); }",
"try { echo $v + 1; } catch (\\Throwable $e) { echo get_class($e), \": \", $e->getMessage(); }",
"try { var_dump($v::class); } catch (\\Throwable $e) { echo get_class($e), \": \", $e->getMessage(); }",
"var_dump($v == $v);",
"$w = $v; var_dump($v === $w);",
]);
let names = *r.pick(&[
"\"C\"",
"\"D\"",
"\"I\"",
"\"T\"",
"\"E\"",
"\"Closure\"",
"\"Generator\"",
"\"Traversable\"",
"\"Iterator\"",
"\"Countable\"",
"\"Ghost\"",
"\"stdClass\"",
]);
let extra = r.pick(&[
"",
"echo \"|\", (int)class_exists(#N), (int)interface_exists(#N), (int)trait_exists(#N), (int)enum_exists(#N);",
"echo \"|\"; var_dump(class_implements(#N));",
"echo \"|\"; var_dump(class_uses(#N));",
"echo \"|\"; var_dump(class_parents(#N));",
])
.replace("#N", names);
vec![format!(
"interface I {{}} trait T {{}} enum E {{ case A; }} \
class C implements I {{ use T; public $p = 1; function go() {{}} }} \
class D extends C {{}} \
$v = {subject}; {q} {extra}"
)]
}
fn gen_issetform(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let operand = *r.pick(&[
"$a",
"$a[0]",
"$a[9]",
"$a[\"k\"]",
"$u",
"$o->p",
"$o->q",
"$o?->p",
"C::$s",
"C::$s[0]",
"$$name",
"f()",
"f()[0]",
"f2()->p",
"$o->m()",
"C::sm()",
"new C",
"1 + 1",
"\"s\"",
"K",
"C::KK",
"$c()",
"$a[f()]",
]);
let form = *r.pick(&["isset(#O)", "empty(#O)", "isset($a, #O)", "isset(#O, $a)"]);
let call = form.replace("#O", operand);
vec![format!(
"define(\"K\", 1); \
class C {{ const KK = 2; public static $s = [5]; public $p = 1; \
function m() {{ return 1; }} static function sm() {{ return 1; }} }} \
function f() {{ echo \"F\"; return [7]; }} \
function f2() {{ echo \"G\"; return new C(); }} \
$a = [1, \"k\" => 2]; $o = new C(); $name = \"a\"; $c = fn() => 1; \
echo \"start|\"; var_dump({call});"
)]
}
fn gen_callorder(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let recv = *r.pick(&[
"null", "5", "\"s\"", "[1]", "true", "false", "1.5", "new C()", "$g", "$c",
]);
let call = *r.pick(&[
"$r->m(f())",
"$r->m(f(), f())",
"$r->go(f())",
"$r?->m(f())",
"$r->m(x: f())",
"$r->m(...[f()])",
]);
let wrap = r.pick(&[
"try { #C; } catch (\\Throwable $e) { echo \"|\", get_class($e), \": \", $e->getMessage(); }",
"#C;",
"echo @#C;",
])
.replace("#C", call);
vec![format!(
"class C {{ function go($x = 0) {{ echo \"GO\"; return $x; }} }} \
function f() {{ echo \"F\"; return 1; }} \
$g = (function () {{ yield 1; }})(); $c = fn() => 1; \
$r = {recv}; echo \"start|\"; {wrap}"
)]
}
fn gen_cloning(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let subject = *r.pick(&[
"new P()",
"new Q()",
"new R(1)",
"$arr",
"5",
"null",
"\"s\"",
"$cl",
"$gen",
"new stdClass",
"E::A",
]);
let after = *r.pick(&[
"var_dump($a == $b, $a === $b);",
"$b->n = 9; var_dump($a->n ?? \"none\", $b->n ?? \"none\");",
"$b->list[] = 3; var_dump($a->list ?? \"none\", $b->list ?? \"none\");",
"$b->inner->k = 9; var_dump($a->inner->k ?? \"none\");",
"var_dump(get_object_vars($b));",
"try { $b->ro = 5; } catch (\\Throwable $e) { echo get_class($e), \": \", $e->getMessage(); }",
"var_dump(get_class($b));",
]);
vec![format!(
"class Inner {{ public $k = 1; }} \
class P {{ public $n = 1; public $list = [1, 2]; public $inner; \
function __construct() {{ $this->inner = new Inner(); }} }} \
class Q extends P {{ public $n = 2; function __clone() {{ echo \"CL\"; $this->n++; }} }} \
class R {{ function __construct(public readonly int $ro) {{}} }} \
enum E {{ case A; }} \
$arr = [1, 2]; $cl = fn() => 1; $gen = (function () {{ yield 1; }})(); \
$a = {subject}; \
try {{ $b = clone $a; }} catch (\\Throwable $e) {{ echo get_class($e), \": \", $e->getMessage(); return; }} \
{after}"
)]
}
fn gen_magiccall(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let call = *r.pick(&[
"$o->missing()",
"$o->missing(1, \"a\")",
"$o->declared()",
"$o->missing(...[1, 2])",
"$o->missing(k: 1)",
"M::missing()",
"M::missing(1, 2)",
"M::declaredStatic()",
"N::missing()",
"$o->privateOne()",
"call_user_func([$o, \"missing\"], 1)",
"call_user_func(\"M::missing\", 1)",
"array_map([$o, \"missing\"], [1, 2])",
"is_callable([$o, \"missing\"])",
"method_exists($o, \"missing\")",
"$o(3)",
]);
let cls = *r.pick(&["M", "N"]);
vec![format!(
"class M {{ \
function __call($n, $a) {{ echo \"C:$n/\", count($a), \"|\"; return $n; }} \
static function __callStatic($n, $a) {{ echo \"S:$n/\", count($a), \"|\"; return $n; }} \
function __invoke($x) {{ return $x * 2; }} \
function declared() {{ return \"D\"; }} \
static function declaredStatic() {{ return \"DS\"; }} \
private function privateOne() {{ return \"P\"; }} }} \
class N {{}} \
$o = new {cls}(); \
try {{ var_dump({call}); }} catch (\\Throwable $e) {{ echo get_class($e), \": \", $e->getMessage(); }}"
)]
}
fn gen_parse_error(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let bases = [
"$a = f ( 1 , 2 ) ;",
"$a = [ 1 , 2 , 3 ] ;",
"$a = [ 'k' => 1 , 'j' => [ 2 , 3 ] ] ;",
"$a = array ( 1 , 2 ) ;",
"echo 1 , 2 ;",
"return 1 ;",
"function f ( $a , $b = 1 ) { return $a ; }",
"function f ( int $a , string ... $r ) : int { return 1 ; }",
"class A { public $a = 1 ; const X = 2 ; function m ( $p ) { return $p ; } }",
"class A extends B implements C , D { }",
"interface I { function m ( ) ; }",
"enum E { case A ; case B ; }",
"enum E : int { case A = 1 ; }",
"trait T { public $t ; }",
"$f = function ( $a ) use ( $b , $c ) { return 1 ; } ;",
"$f = fn ( $a ) => $a ;",
"foreach ( $a as $k => $v ) { echo $v ; }",
"for ( $i = 0 ; $i < 3 ; $i ++ ) { echo $i ; }",
"while ( $a ) { break ; }",
"do { $a ++ ; } while ( $a < 3 ) ;",
"if ( $a ) { echo 1 ; } else { echo 2 ; }",
"switch ( $a ) { case 1 : echo 1 ; break ; default : echo 2 ; }",
"try { f ( ) ; } catch ( E $e ) { echo 1 ; } finally { echo 2 ; }",
"$x = match ( $a ) { 1 , 2 => 'a' , default => 'b' } ;",
"$x = new A ( 1 , 2 ) ;",
"$x = $a -> m ( 1 , 2 ) ;",
"$x = A :: m ( 1 ) ;",
"$x = $a [ 1 ] [ 2 ] ;",
"global $a , $b ;",
"static $a = 1 , $b = 2 ;",
"const A = 1 , B = 2 ;",
"unset ( $a , $b ) ;",
"isset ( $a , $b ) ;",
"$x = isset ( $a ) ;",
"$x = empty ( $a ) ;",
"declare ( ticks = 1 ) ;",
"namespace A ;",
"use A \\ B ;",
"list ( $a , $b ) = $c ;",
"[ $a , [ $b ] ] = $c ;",
"goto a ;",
"$x = $a ? 1 : 2 ;",
"$x = $a ?? 2 ;",
"abstract class A { abstract function m ( ) ; }",
];
let stray = ["1", "$z", "'s'", "2.5"];
let mut tokens: Vec<&str> = r.pick(&bases).split(' ').collect();
let at = r.below(tokens.len() + 1);
tokens.insert(at, r.pick(&stray));
vec![tokens.join(" ")]
}
fn gen_fnmatch_flags(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let tokens = [
"a",
"b",
"c",
".",
"/",
"*",
"?",
"[ab]",
"[!a]",
"[a-c]",
"[^b]",
"[[:alpha:]]",
"[[:digit:]]",
"[.]",
"[/]",
"\\\\*",
"\\\\.",
"\\\\\\\\",
"[",
"[a",
"]",
"-",
"[a-]",
"[]a]",
];
let subject_tokens = ["a", "b", "c", ".", "/", "*", "1", "-", "[", "\\\\"];
let mut pattern = String::new();
for _ in 0..1 + r.below(5) {
pattern.push_str(r.pick(&tokens));
}
let mut subject = String::new();
for _ in 0..r.below(6) {
subject.push_str(r.pick(&subject_tokens));
}
let mut flags = 0;
for bit in [1, 2, 4, 16] {
if r.below(2) == 0 {
flags |= bit;
}
}
vec![format!(
"var_dump(fnmatch(\"{pattern}\", \"{subject}\", {flags}));"
)]
}
fn gen_gmp_ops(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let operands = [
"0",
"1",
"-1",
"2",
"-2",
"7",
"-7",
"12",
"-18",
"97",
"100",
"255",
"\"0x1f\"",
"\"0b101\"",
"\"010\"",
"\"-0xff\"",
"\" 42 \"",
"\"12x\"",
"\"\"",
"\"+3\"",
"\"9223372036854775807\"",
"\"-9223372036854775808\"",
"\"18446744073709551617\"",
"\"123456789012345678901234567890\"",
];
let a = *r.pick(&operands);
let b = *r.pick(&operands);
let small = *r.pick(&["0", "1", "2", "3", "5", "-1", "63", "64"]);
let mode = *r.pick(&[
"GMP_ROUND_ZERO",
"GMP_ROUND_PLUSINF",
"GMP_ROUND_MINUSINF",
"3",
]);
let call = match r.below(10) {
0 => format!(
"{}({a}, {b}, {mode})",
r.pick(&["gmp_div_q", "gmp_div_r", "gmp_div_qr"])
),
1 => format!(
"{}({a}, {b})",
r.pick(&[
"gmp_add",
"gmp_sub",
"gmp_mul",
"gmp_mod",
"gmp_gcd",
"gmp_lcm",
"gmp_and",
"gmp_or",
"gmp_xor",
"gmp_cmp",
"gmp_gcdext",
"gmp_invert",
"gmp_jacobi",
"gmp_kronecker",
"gmp_hamdist",
])
),
2 => format!(
"{}({a})",
r.pick(&[
"gmp_abs",
"gmp_neg",
"gmp_com",
"gmp_sign",
"gmp_sqrt",
"gmp_sqrtrem",
"gmp_perfect_square",
"gmp_perfect_power",
"gmp_popcount",
"gmp_intval",
"gmp_prob_prime",
"gmp_nextprime",
])
),
3 => format!(
"gmp_strval({a}, {})",
r.pick(&["2", "8", "16", "36", "62", "-16", "-36", "1", "37", "-37", "0"])
),
4 => format!(
"gmp_init({a}, {})",
r.pick(&["0", "2", "8", "10", "16", "36", "62", "1", "63"])
),
5 => format!("gmp_pow({a}, {small})"),
6 => format!("gmp_powm({a}, {small}, {b})"),
7 => format!(
"{}({a}, {small})",
r.pick(&[
"gmp_root",
"gmp_rootrem",
"gmp_binomial",
"gmp_testbit",
"gmp_scan0",
"gmp_scan1"
])
),
8 => format!("gmp_fact({small})"),
_ => format!("gmp_legendre({a}, {b})"),
};
vec![format!(
"try {{ $r = {call}; echo is_array($r) ? implode(',', array_map('strval', $r)) : var_export(is_object($r) ? (string)$r : $r, true); }} \
catch (Throwable $e) {{ echo get_class($e), ': ', $e->getMessage(); }} echo \"\\n\";"
)]
}
fn gen_hash_algos(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let algo = *r.pick(&[
"md4",
"md5",
"sha1",
"sha224",
"sha256",
"sha384",
"sha512",
"sha512/224",
"sha512/256",
"sha3-224",
"sha3-256",
"sha3-384",
"sha3-512",
"adler32",
"crc32",
"crc32b",
"crc32c",
"fnv132",
"fnv1a32",
"fnv164",
"fnv1a64",
"joaat",
"nope",
]);
let len = *r.pick(&[
0, 1, 3, 55, 56, 63, 64, 65, 71, 72, 73, 103, 104, 135, 136, 137, 143, 144, 200, 257,
]);
let fill = *r.pick(&["a", "xyz", "0", "~"]);
let key_len = *r.pick(&[0, 1, 32, 64, 65, 128, 129, 300]);
let guard =
"try { {} } catch (Throwable $e) { echo get_class($e), ': ', $e->getMessage(), \"\\n\"; }";
let body = format!(
"$d = substr(str_repeat(\"{fill}\", {len}), 0, {len}); $k = str_repeat(\"k\", {key_len}); \
echo hash(\"{algo}\", $d), \"\\n\"; echo hash_hmac(\"{algo}\", $d, $k), \"\\n\"; \
echo hash_pbkdf2(\"{algo}\", $d, \"salt\", 2, 24), \"\\n\";"
);
vec![guard.replace("{}", &body)]
}
fn gen_ctype_args(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let func = *r.pick(&[
"ctype_alnum",
"ctype_alpha",
"ctype_cntrl",
"ctype_digit",
"ctype_graph",
"ctype_lower",
"ctype_print",
"ctype_punct",
"ctype_space",
"ctype_upper",
"ctype_xdigit",
]);
let value = *r.pick(&[
"48", "65", "97", "-129", "256", "1000", "-200", "0", "32", "9", "127", "\"a\"", "\"12\"",
"\"\"", "\" \\t\"", "null", "true", "false", "1.5", "[]", "\"A1\"", "\"!\"",
]);
vec![format!("var_dump({func}({value}));")]
}
fn gen_var_export(seed: u64) -> Vec<String> {
let r = &mut Rng::seed(seed);
let leaves = [
"PHP_INT_MIN",
"PHP_INT_MAX",
"-PHP_INT_MAX - 1",
"0",
"-0.0",
"1.0",
"0.1 + 0.2",
"1e100",
"-1.5e-7",
"NAN",
"INF",
"-INF",
"true",
"false",
"null",
"\"\"",
"\"a\\0b\"",
"\"\\0\"",
"\"it's\"",
"\"back\\\\slash\"",
"\"multi\\nline\"",
"\"\\r\\t\"",
"\"é\"",
];
let keys = [
"0",
"7",
"-3",
"\"k\"",
"\"a\\0b\"",
"\"it's\"",
"\"p\\\\q\"",
"\"\"",
"\"12\"",
"PHP_INT_MIN",
];
let mut parts = Vec::new();
for _ in 0..1 + r.below(4) {
let leaf = r.pick(&leaves);
parts.push(match r.below(3) {
0 => leaf.to_string(),
1 => format!("{} => {leaf}", r.pick(&keys)),
_ => format!("{} => [{leaf}, {}]", r.pick(&keys), r.pick(&leaves)),
});
}
let list = parts.join(", ");
vec![
format!("var_export([{list}]); echo \"\\n\";"),
format!("var_export((object)[{list}]); echo \"\\n\";"),
]
}
#[derive(Clone, Copy)]
struct Mode {
name: &'static str,
gen: fn(u64) -> Vec<String>,
}
const MODES: &[Mode] = &[
Mode {
name: "mbx",
gen: gen_mbx,
},
Mode {
name: "funcargs",
gen: gen_funcargs,
},
Mode {
name: "extractflags",
gen: gen_extractflags,
},
Mode {
name: "calleeforms",
gen: gen_calleeforms,
},
Mode {
name: "fcc",
gen: gen_fcc,
},
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: "builtinargs",
gen: gen_builtinargs,
},
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,
},
Mode {
name: "heredoc",
gen: gen_heredoc,
},
Mode {
name: "nullsafechain",
gen: gen_nullsafechain,
},
Mode {
name: "matcherr",
gen: gen_matcherr,
},
Mode {
name: "ifaceconst",
gen: gen_ifaceconst,
},
Mode {
name: "generators",
gen: gen_generators,
},
Mode {
name: "enums",
gen: gen_enums,
},
Mode {
name: "traits",
gen: gen_traits,
},
Mode {
name: "variadic",
gen: gen_variadic,
},
Mode {
name: "splobj",
gen: gen_splobj,
},
Mode {
name: "altsyntax",
gen: gen_altsyntax,
},
Mode {
name: "printexpr",
gen: gen_printexpr,
},
Mode {
name: "reflect",
gen: gen_reflect,
},
Mode {
name: "issetform",
gen: gen_issetform,
},
Mode {
name: "callorder",
gen: gen_callorder,
},
Mode {
name: "cloning",
gen: gen_cloning,
},
Mode {
name: "magiccall",
gen: gen_magiccall,
},
Mode {
name: "fnmatchflags",
gen: gen_fnmatch_flags,
},
Mode {
name: "gmpops",
gen: gen_gmp_ops,
},
Mode {
name: "hashalgos",
gen: gen_hash_algos,
},
Mode {
name: "ctypeargs",
gen: gen_ctype_args,
},
Mode {
name: "varexport",
gen: gen_var_export,
},
Mode {
name: "parseerr",
gen: gen_parse_error,
},
];
fn build_program(stmts: &[String]) -> String {
stmts.join("\n")
}
fn case_seed(base: u64, i: u64) -> u64 {
let mut z = base ^ i.wrapping_mul(0x9E37_79B9_7F4A_7C15);
z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
z ^ (z >> 31)
}
fn case_from_seed(seed: u64, only: Option<Mode>) -> (Mode, Vec<String>) {
let mode = only.unwrap_or(MODES[(seed >> 7) as usize % MODES.len()]);
(mode, (mode.gen)(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 [--mode NAME]] [--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);
}
let forced = match &args.mode {
Some(m) => match MODES.iter().find(|md| md.name == m) {
Some(md) => Some(*md),
None => {
eprintln!("parity-fuzz: unknown mode {m}");
std::process::exit(2);
}
},
None => None,
};
if args.once.is_some() {
let (mode, stmts) = case_from_seed(args.base_seed, forced);
let prog = build_program(&stmts);
let o = run_oracle(&prog, args.timeout);
let r = run_ours(&prog, &bin, args.timeout);
println!("oracle bin: {}", oracle_id());
println!("ours bin: {}", bin.display());
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;
}
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 scored_modes: Arc<Mutex<Vec<&'static str>>> = Arc::new(Mutex::new(Vec::new()));
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 scored_modes = Arc::clone(&scored_modes);
let skipped = Arc::clone(&skipped);
let bin = bin.clone();
let timeout = args.timeout;
let base = args.base_seed;
let count = args.count;
handles.push(std::thread::spawn(move || loop {
let i = next.fetch_add(1, Ordering::Relaxed) as u64;
if i >= count {
break;
}
let seed = case_seed(base, i);
let (mode, stmts) = case_from_seed(seed, forced);
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);
scored_modes.lock().unwrap().push(mode.name);
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,
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();
let scored_modes = Arc::try_unwrap(scored_modes).unwrap().into_inner().unwrap();
let ran_by_mode = |name: &str| {
(0..args.count)
.filter(|i| {
forced.map_or_else(
|| case_from_seed(case_seed(args.base_seed, *i), None).0.name,
|m| m.name,
) == name
})
.count()
};
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)));
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 mut rows: Vec<(&str, usize, usize, usize)> = Vec::new();
for m in MODES {
let handed = ran_by_mode(m.name);
if handed == 0 {
continue;
}
let ok = scored_modes.iter().filter(|n| **n == m.name).count();
let found = divs.iter().filter(|d| d.mode == m.name).count();
rows.push((m.name, handed, ok, found));
}
rows.sort_by(|a, b| {
let ra = a.2 as f64 / a.1 as f64;
let rb = b.2 as f64 / b.1 as f64;
ra.partial_cmp(&rb).unwrap().then(a.0.cmp(b.0))
});
println!(" scored by mode (of the cases the mode was handed), worst first:");
for (name, handed, ok, found) in rows {
let pct = 100.0 * ok as f64 / handed as f64;
println!(" {name:<14} {ok:>5} of {handed:<6} ({pct:5.1}%) {found} divergences");
}
}
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);
}