use std::io::Write;
use std::path::{Path, PathBuf};
use std::process::Command;
use std::time::Duration;
use texrs::parity::Oracle;
fn main() -> std::process::ExitCode {
let args: Vec<String> = std::env::args().skip(1).collect();
let cfg = match Config::parse(&args) {
Ok(c) => c,
Err(e) => {
eprintln!("{e}");
return std::process::ExitCode::from(2);
}
};
if cfg.help {
print!("{USAGE}");
return std::process::ExitCode::SUCCESS;
}
let oracle = match texrs::parity::oracle(&repo()) {
Ok(o) => o,
Err(e) => {
eprintln!("parity-fuzz: {e}");
return std::process::ExitCode::from(2);
}
};
println!(
"oracle: tex {} · {} program(s) × {} probes · seed {}",
oracle.version, cfg.programs, cfg.probes, cfg.seed
);
let Ok(dir) = scratch_dir() else {
eprintln!("parity-fuzz: cannot make a scratch directory");
return std::process::ExitCode::from(2);
};
let mut diverged = 0usize;
for i in 0..cfg.programs {
let index = match cfg.once {
true => cfg.seed,
false => cfg.seed.wrapping_add(i as u64),
};
let probes = generate(index, cfg.probes);
if !diverges(&probes, &oracle, &dir, cfg.timeout) {
continue;
}
diverged += 1;
let minimal = minimize(&probes, &oracle, &dir, cfg.timeout);
let source = document(&minimal);
let (want, got) = run_both(&source, &oracle, &dir, cfg.timeout);
println!(
"\nDIVERGES program {index}, minimized to {} probe(s)\n tex : {want}\n texrs : {got}\n{}",
minimal.len(),
indent(&source)
);
}
let _ = std::fs::remove_dir_all(&dir);
match diverged {
0 => {
println!("\nPARITY: {} program(s) agree with tex.", cfg.programs);
std::process::ExitCode::SUCCESS
}
n => {
println!("\n{n}/{} program(s) diverge from tex", cfg.programs);
std::process::ExitCode::from(u8::try_from(n.min(250)).unwrap_or(250))
}
}
}
const USAGE: &str = "\
usage: parity-fuzz [OPTIONS]
--seed N first program index (default 1)
--programs N how many to generate (default 50)
--probes N constructs packed into each one (default 40)
--once run only the program named by --seed
--timeout SECS per-engine limit for one program (default 20)
-h, --help print this
";
struct Config {
seed: u64,
programs: usize,
probes: usize,
once: bool,
timeout: Duration,
help: bool,
}
impl Config {
fn parse(args: &[String]) -> Result<Self, String> {
let mut cfg = Config {
seed: 1,
programs: 50,
probes: 40,
once: false,
timeout: Duration::from_secs(20),
help: false,
};
let mut i = 0;
while i < args.len() {
let arg = args[i].as_str();
i += 1;
let mut value = |name: &str| -> Result<String, String> {
let v = args
.get(i)
.cloned()
.ok_or_else(|| format!("parity-fuzz: {name} needs a value"))?;
i += 1;
Ok(v)
};
match arg {
"-h" | "--help" => cfg.help = true,
"--once" => cfg.once = true,
"--seed" => cfg.seed = value("--seed")?.parse().map_err(|_| "bad --seed")?,
"--programs" => {
cfg.programs = value("--programs")?.parse().map_err(|_| "bad --programs")?
}
"--probes" => {
cfg.probes = value("--probes")?.parse().map_err(|_| "bad --probes")?
}
"--timeout" => {
let secs: u64 = value("--timeout")?.parse().map_err(|_| "bad --timeout")?;
cfg.timeout = Duration::from_secs(secs);
}
other => return Err(format!("parity-fuzz: unknown option: {other}")),
}
}
if cfg.once {
cfg.programs = 1;
}
Ok(cfg)
}
}
fn repo() -> PathBuf {
PathBuf::from(env!("CARGO_MANIFEST_DIR"))
}
fn scratch_dir() -> std::io::Result<PathBuf> {
let dir = std::env::temp_dir().join(format!("texrs-parity-fuzz-{}", std::process::id()));
std::fs::create_dir_all(&dir)?;
Ok(dir)
}
struct Rng(u64);
impl Rng {
fn new(seed: u64) -> Self {
Rng(seed.wrapping_add(1) & 0xFFFF_FFFF)
}
fn next(&mut self, m: usize) -> usize {
self.0 = (self.0.wrapping_mul(1_664_525).wrapping_add(1_013_904_223)) & 0xFFFF_FFFF;
((self.0 >> 16) as usize) % m.max(1)
}
fn pick<'a, T>(&mut self, xs: &'a [T]) -> &'a T {
&xs[self.next(xs.len())]
}
fn word<'a>(&mut self, xs: &[&'a str]) -> &'a str {
xs[self.next(xs.len())]
}
}
fn reg(rng: &mut Rng) -> usize {
1 + rng.next(9)
}
fn letters(mut id: usize) -> String {
let mut out = String::new();
loop {
out.push((b'a' + (id % 26) as u8) as char);
id /= 26;
if id == 0 {
return out;
}
}
}
const PROBE_KINDS: usize = 62;
const INT_PARAMS: &[&str] = &[
"pretolerance",
"tolerance",
"linepenalty",
"hyphenpenalty",
"exhyphenpenalty",
"clubpenalty",
"widowpenalty",
"displaywidowpenalty",
"brokenpenalty",
"binoppenalty",
"relpenalty",
"predisplaypenalty",
"postdisplaypenalty",
"interlinepenalty",
"doublehyphendemerits",
"finalhyphendemerits",
"adjdemerits",
"delimiterfactor",
"looseness",
"hbadness",
"vbadness",
"maxdeadcycles",
"hangafter",
"floatingpenalty",
"fam",
"defaulthyphenchar",
"defaultskewchar",
"language",
"lefthyphenmin",
"righthyphenmin",
"holdinginserts",
"uchyph",
"showboxbreadth",
"showboxdepth",
"outputpenalty",
];
const DIMEN_PARAMS: &[&str] = &[
"parindent",
"mathsurround",
"lineskiplimit",
"hsize",
"vsize",
"maxdepth",
"splitmaxdepth",
"boxmaxdepth",
"hfuzz",
"vfuzz",
"delimitershortfall",
"nulldelimiterspace",
"scriptspace",
"predisplaysize",
"displaywidth",
"displayindent",
"overfullrule",
"hangindent",
"hoffset",
"voffset",
"emergencystretch",
];
const GLUE_PARAMS: &[&str] = &[
"lineskip",
"baselineskip",
"parskip",
"abovedisplayskip",
"belowdisplayskip",
"abovedisplayshortskip",
"belowdisplayshortskip",
"leftskip",
"rightskip",
"topskip",
"splittopskip",
"tabskip",
"spaceskip",
"xspaceskip",
"parfillskip",
];
const WORDS: &[&str] = &[
"ALPHA", "BETA", "GAMMA", "DELTA", "EPS", "ZETA", "ETA", "THETA",
];
fn probe(rng: &mut Rng, id: usize) -> String {
let w = rng.pick(WORDS);
let r = reg(rng);
let m = format!("\\fzm{}", letters(id));
let h = format!("\\fzh{}", letters(id));
match rng.next(PROBE_KINDS) {
0 => format!("\\count{r}={n} \\message{{p{id}:\\the\\count{r} }}", n = rng.next(2000)),
1 => format!(
"\\count{r}={a} \\advance\\count{r} by {b} \\multiply\\count{r} by {c} \\message{{p{id}:\\the\\count{r} }}",
a = rng.next(200),
b = rng.next(100),
c = 1 + rng.next(9)
),
2 => format!(
"\\count{r}={a} \\divide\\count{r} by {d} \\message{{p{id}:\\the\\count{r} }}",
a = rng.next(1000),
d = 1 + rng.next(9)
),
3 => format!(
"\\count{r}={a} \\message{{p{id}:\\ifnum\\count{r}>{b} BIG\\else SMALL\\fi }}",
a = rng.next(50),
b = rng.next(50)
),
4 => format!(
"\\count{r}={a} \\message{{p{id}:\\ifodd\\count{r} ODD\\else EVEN\\fi }}",
a = rng.next(50)
),
5 => format!(
"\\count{r}={a} \\message{{p{id}:\\ifcase\\count{r} Z\\or O\\or T\\else M\\fi }}",
a = rng.next(5)
),
6 => format!("\\def{m}#1{{{w}-#1}}\\message{{p{id}:{m}{{{x}}} }}", x = rng.pick(WORDS)),
7 => format!(
"\\def{m}{{{w}}}\\message{{p{id}:{m} }}{{\\def{m}{{{x}}}\\message{{p{id}i:{m} }}}}\\message{{p{id}o:{m} }}",
x = rng.pick(WORDS)
),
8 => format!(
"\\count{r}={a} \\edef{m}{{\\the\\count{r} }}\\count{r}={b} \\message{{p{id}:{m}\\the\\count{r} }}",
a = rng.next(100),
b = rng.next(100)
),
9 => format!(
"\\def{m}{{{w}}}\\message{{p{id}:\\string{m} \\number{n} \\csname fzm{name}\\endcsname }}",
n = rng.next(1000),
name = letters(id)
),
10 => format!("\\uppercase{{\\message{{p{id}:{w} abc 12}}}}\\lowercase{{\\message{{P{id}:{w} ABC}}}}"),
11 => format!(
"\\def{m}{{\\message{{p{id}:AFTER\\the\\count{r} }}}}\\afterassignment{m}\\count{r}={a} \\message{{p{id}:SET\\the\\count{r} }}",
a = rng.next(100)
),
12 => format!(
"\\def{m}{{\\futurelet{h}{h}z}}\\def{h}z{{\\message{{p{id}:\\meaning{h} }}}}{m}{x}",
x = rng.pick(&["\\relax", "\\par", "{}", "\\count1=0 "])
),
13 => format!("\\def{m}#1#2.{{{w}#2#1}}\\message{{p{id}:\\meaning{m} }}\\message{{p{id}:{m} x y.}}"),
14 => format!(
"\\def{h}{{{w}}}\\def{m}{{\\expandafter\\def\\expandafter{h}\\expandafter{{X{h}}}}}{m}\\message{{p{id}:\\meaning{h} }}"
),
15 => format!(
"\\def{m}#1#2{{\\if#1#2T\\else F\\fi \\ifcat#1#2T\\else F\\fi \\ifx#1#2T\\else F\\fi}}\\message{{p{id}:{m} {a}{b} }}",
a = rng.pick(&["a", "A", "1", "\\relax ", "@"]),
b = rng.pick(&["a", "b", "1", "\\relax ", "@"])
),
16 => format!(
"\\dimen{r}={a}pt \\message{{p{id}:\\ifdim\\dimen{r}>{b}pt GT\\else LE\\fi \\ifdim\\dimen{r}={b}pt EQ\\fi }}",
a = rng.next(30),
b = rng.next(30)
),
17 => format!(
"\\dimen{r}={a}.{f}pt \\multiply\\dimen{r} by {c} \\advance\\dimen{r} by -{b}pt \\divide\\dimen{r} by {d} \\message{{p{id}:\\the\\dimen{r} }}",
a = rng.next(100),
f = rng.next(1000),
b = rng.next(50),
c = 1 + rng.next(9),
d = 1 + rng.next(9)
),
18 => format!(
"\\skip{r}={a}pt plus {b}fil minus {c}pt \\advance\\skip{r} by {c}pt plus {a}fil \\message{{p{id}:\\the\\skip{r} }}",
a = rng.next(20),
b = rng.next(20),
c = rng.next(20)
),
19 => format!(
"\\toks{r}={{{w}#{x}}}\\edef{m}{{\\the\\toks{r}}}\\message{{p{id}:\\the\\toks{r} \\meaning{m} }}",
x = rng.next(9)
),
20 => format!("\\message{{p{id}:\\romannumeral{n} \\number-{n} \\number\"{n:X} \\number'{n:o} }}", n = rng.next(4000)),
21 => format!(
"\\def{m}{{\\message{{p{id}:AG}}}}{{\\aftergroup{m}\\message{{p{id}:IN}}}}\\message{{p{id}:OUT}}"
),
22 => format!(
"{{\\catcode`\\@=11 \\message{{p{id}:\\the\\catcode`\\@ \\string @x}}}}\\message{{p{id}:\\the\\catcode`\\@ }}"
),
23 => format!(
"\\edef{m}{{\\noexpand{h}{w}\\string{h}}}\\message{{p{id}:\\meaning{m} }}"
),
24 => format!(
"\\count{r}={a} \\message{{p{id}:\\ifcase\\count{r} A\\or B\\or\\ifcase\\count{r} x\\or y\\or Z\\fi\\else E\\fi }}",
a = rng.next(5) as i32 - 1
),
25 => format!(
"{{\\escapechar={e} \\message{{p{id}:\\string{h} \\meaning{m} }}}}",
e = rng.pick(&["`\\!", "-1", "`\\A", "256"])
),
26 => format!(
"\\lccode`\\{u}=`\\{l} \\uccode`\\{l}=`\\{u} \\lowercase{{\\message{{p{id}:{u}{l}{u} }}}}\\uppercase{{\\message{{P{id}:{u}{l}{u} }}}}",
u = rng.pick(&["X", "Y", "Z"]),
l = rng.pick(&["x", "y", "z"])
),
27 => format!(
"\\count{r}=1 {{\\global\\advance\\count{r} by {a} \\count{r}=7 \\global\\count{r}=\\count{r} }}\\message{{p{id}:\\the\\count{r} }}",
a = rng.next(9)
),
28 => format!(
"\\let{h}={a}\\def{m}{{{a}}}\\message{{p{id}:\\ifx{h}{m}S\\else D\\fi \\ifx{h}{a}S\\else D\\fi \\meaning{h} }}",
a = rng.pick(&["\\relax", "\\par", "\\undefinedprobe", "A", "\\count"])
),
29 => format!(
"\\chardef{h}={n} \\countdef{m}={r} {m}={n} \\message{{p{id}:\\number{h} \\the{m} \\meaning{h} \\meaning{m} }}",
n = rng.next(256)
),
30 => format!(
"\\expandafter\\ifx\\csname unprobe{n}\\endcsname\\relax \\message{{p{id}:UNDEF}}\\fi \\message{{p{id}:\\expandafter\\meaning\\csname unprobe{n}\\endcsname }}",
n = letters(id)
),
31 => format!(
"\\def{m}#1{{\\ifx#1\\relax END\\else[#1]\\expandafter{m}\\fi}}\\message{{p{id}:{m} {w}\\relax }}"
),
32 => format!(
"\\def{m}#1#{{\\message{{p{id}:#1|}}\\def{h}}}{m} {w}x{{Q}}\\message{{p{id}:\\meaning{h} }}"
),
33 => format!(
"{{\\endlinechar={e} \\message{{p{id}:\\the\\endlinechar}}}}\\message{{p{id}:\\the\\endlinechar}}",
e = rng.pick(&["-1", "`\\A", "13"])
),
34 => format!(
"\\count{r}={a} \\message{{p{id}:\\number\\count{r} \\ifnum\\count{r}<0 NEG\\fi \\ifnum-\\count{r}<{b} LT\\fi }}",
a = rng.next(40) as i32 - 20,
b = rng.next(10)
),
35 => {
let p = rng.word(INT_PARAMS);
format!(
"\\{p}={a} \\advance\\{p} by {b} \\multiply\\{p} by {c} \\message{{p{id}:\\the\\{p} \\number\\{p} }}",
a = rng.next(3000) as i32 - 1000,
b = rng.next(100),
c = 1 + rng.next(5)
)
}
36 => {
let p = rng.word(DIMEN_PARAMS);
format!(
"\\{p}={a}.{f}pt \\advance\\{p} by {b}pt \\multiply\\{p} by {c} \\message{{p{id}:\\the\\{p} \\number\\{p} }}",
a = rng.next(100),
f = rng.next(1000),
b = rng.next(20),
c = 1 + rng.next(5)
)
}
37 => {
let p = rng.word(GLUE_PARAMS);
format!(
"\\{p}={a}pt plus {b}{fil} minus {c}pt \\advance\\{p} by {c}pt \\message{{p{id}:\\the\\{p} }}",
a = rng.next(30),
b = rng.next(30),
c = rng.next(30),
fil = rng.word(&["pt", "fil", "fill", "filll"])
)
}
38 => {
let p = rng.word(&["thinmuskip", "medmuskip", "thickmuskip"]);
format!(
"\\{p}={a}mu plus {b}{fil} minus {c}mu \\message{{p{id}:\\the\\{p} }}",
a = rng.next(30),
b = rng.next(30),
c = rng.next(30),
fil = rng.word(&["mu", "fil", "fill"])
)
}
39 => {
let p = rng.word(&["everypar", "everymath", "everydisplay", "everyhbox", "everyvbox", "everyjob", "everycr", "errhelp", "output"]);
format!(
"\\{p}={{{w}#{x}\\relax}}\\message{{p{id}:\\the\\{p} \\meaning\\{p} }}{{\\{p}={{}}\\message{{p{id}i:\\the\\{p}}}}}\\message{{p{id}o:\\the\\{p} }}",
x = rng.next(9)
)
}
40 => {
let cat = rng.pick(&[1, 2, 3, 4, 6, 7, 8, 10, 11, 12, 13]);
format!(
"{{\\catcode`\\!={cat} \\message{{p{id}:\\meaning!}}}}\\message{{p{id}:\\meaning!}}"
)
}
41 => {
let c = rng.word(&["\\relax", "\\par", "\\ ", "\\/", "\\-", "\\@", "\\:", "\\<", "\\(", "\\)", "\\[", "\\]"]);
let e = rng.word(&["`\\\\", "`\\!", "-1", "0", "`\\a", "`\\ "]);
format!(
"{{\\escapechar={e} \\message{{p{id}:\\string{c} \\meaning{c}}}}}"
)
}
42 => {
let c = rng.word(&["a", "A", "0", "\\a", "\\\\", "\\ ", "\\{", "\\}", "\\#", "\\%", "^^A", "^^?", "^^7f", "\"", "'"]);
format!("\\catcode`\\^=7 \\message{{p{id}:\\number`{c} \\number`{c}\\relax x}}")
}
43 => {
let v = rng.word(&["2147483647", "-2147483647", "1000000000", "65536", "46341", "-46341", "1"]);
let op = rng.word(&["multiply", "divide"]);
let by = rng.word(&["2", "3", "0", "-1", "46341", "2147483647", "65536"]);
format!(
"\\count{r}={v} \\{op}\\count{r} by {by} \\message{{p{id}:\\the\\count{r} }}"
)
}
44 => {
let v = rng.word(&["16383pt", "16383.99998pt", "-16383pt", "8192pt", "1sp", "10000pt"]);
let op = rng.word(&["multiply", "divide", "advance"]);
let by = match op {
"advance" => rng.word(&["1pt", "16383pt", "-16383pt", "1sp"]),
_ => rng.word(&["2", "3", "0", "-1", "65536", "7"]),
};
let kind = rng.word(&["dimen", "skip"]);
format!(
"\\{kind}{r}={v} \\{op}\\{kind}{r} by {by} \\message{{p{id}:\\the\\{kind}{r} }}"
)
}
45 => {
let t = rng.word(&["16384pt", "16383.999999pt", "16384.0pt", "1073741824sp", "1073741823sp", "99999pt", "1000000in", "2000mm", "300000cm", "1000000bp"]);
format!("\\dimen{r}={t} \\message{{p{id}:\\the\\dimen{r} }}")
}
46 => {
let table = rng.word(&["uccode", "lccode", "sfcode", "mathcode", "delcode", "catcode"]);
let v = rng.word(&["0", "1", "65", "255", "256", "1000", "32768", "32769", "-1", "16777215", "16777216", "15", "16"]);
format!(
"\\{table}`\\!={v} \\message{{p{id}:\\the\\{table}`\\!}}\\uccode`\\a=`\\Q \\lccode`\\a=`\\z \\uppercase{{\\message{{P{id}:abAB}}}}\\lowercase{{\\message{{p{id}:abAB}}}}"
)
}
47 => format!(
"{{\\uccode`\\b=`\\Y \\uppercase{{\\message{{p{id}:ab}}}}}}\\uppercase{{\\message{{p{id}:ab}}}}\\uppercase{{\\def{m}{{ab\\message{{p{id}:x}}}}}}\\message{{p{id}:\\meaning{m} }}"
),
48 => {
let a = rng.word(&[
"\\def{h}{}",
"\\let{h}=\\relax",
"\\count1=5 ",
"\\advance\\count1 by 1 ",
"\\toks1={}",
"\\chardef{h}=65 ",
"\\global\\count1=3 ",
"\\relax\\count1=1 ",
"\\catcode`\\@=12 ",
"\\uccode`\\a=`\\A ",
"\\dimen1=1pt ",
"\\skip1=1pt ",
"\\tolerance=100 ",
"\\everypar={}",
]);
let a = a.replace("{h}", &h);
format!(
"\\def{m}{{\\message{{p{id}:AFTER}}}}\\afterassignment{m}{a}\\message{{p{id}:NEXT}}\\afterassignment{m}\\afterassignment\\relax{a}\\message{{p{id}:END}}"
)
}
49 => {
let open = rng.word(&["{", "\\begingroup "]);
let close = if open == "{" { "}" } else { "\\endgroup " };
format!(
"\\def{m}{{\\message{{p{id}:A}}}}\\def{h}{{\\message{{p{id}:B}}}}{open}\\aftergroup{m}{{\\aftergroup{h}\\aftergroup{m}}}\\aftergroup{h}\\message{{p{id}:IN}}{close}\\message{{p{id}:OUT}}"
)
}
50 => {
let n = rng.next(30);
format!(
"\\def{m}#1{{[#1]}}\\expandafter\\message\\expandafter{{\\romannumeral{n} \\number{n}{m}{{{w}}}}}\\expandafter\\expandafter\\expandafter\\message\\expandafter\\expandafter\\expandafter{{\\csname relax\\endcsname {w}}}"
)
}
51 => format!(
"\\def{m}{{{w}}}\\edef{h}{{\\expandafter\\noexpand\\csname fzq{name}\\endcsname\\noexpand{m}\\noexpand\\noexpand{m}\\expandafter\\noexpand{m}}}\\message{{p{id}:\\meaning{h} }}",
name = letters(id)
),
52 => format!(
"\\def{m}{{{w}}}\\message{{p{id}:\\noexpand{m}\\expandafter\\noexpand\\expandafter{m}\\noexpand\\csname relax\\endcsname\\noexpand}}\\message{{p{id}:\\ifx\\noexpand{m}{m}T\\else F\\fi \\if\\noexpand{m}\\relax T\\else F\\fi \\ifcat\\noexpand{m}\\relax T\\else F\\fi}}"
),
53 => {
let n = rng.word(&["-1", "256", "300", "32767", "255", "0", "32768"]);
let k = rng.word(&["count", "dimen", "skip", "toks", "muskip"]);
let body = match k {
"toks" => "{}",
"muskip" => "1mu",
"dimen" => "1pt",
"skip" => "1pt",
_ => "1",
};
format!(
"\\{k}{n}={body} \\message{{p{id}:\\the\\{k}{n} }}\\{k}def{m}={n} \\message{{p{id}:\\meaning{m} }}"
)
}
54 => {
let n = rng.word(&["\"7FFF", "\"8000", "\"8001", "\"FFFF", "\"10000", "\"1000", "0", "32768", "-1"]);
format!(
"\\mathchardef{m}={n} \\message{{p{id}:\\meaning{m} \\number{m} \\the{m} }}\\chardef{h}={n} \\message{{p{id}:\\meaning{h} \\number{h} }}"
)
}
55 => {
let t = rng.word(&[
"\"FF", "\"ff", "'777", "'8", "\"G", "--5", "-+-5", "+-+7", "5.5", "\"7FFFFFFF", "\"80000000", "'17777777777", "'20000000000", "2147483648", "-2147483648", "\\relax5", " 12 ", "007", "`a", "`ab",
]);
format!("\\message{{p{id}:\\number{t}x \\romannumeral{t}x}}")
}
56 => {
let name = rng.word(&["a b", " ", "", "\\string\\x", "12", "{", "a\\relax"]);
let name = if name.contains('{') { "a" } else { name };
format!(
"\\expandafter\\def\\csname {name}\\endcsname{{{w}}}\\expandafter\\message\\expandafter{{\\csname {name}\\endcsname \\expandafter\\string\\csname {name}\\endcsname}}"
)
}
57 => {
let a = rng.word(&["\\count{r} ", "\\dimen{r} ", "\\skip{r} ", "-\\count{r} ", "-\\dimen{r} ", "--\\skip{r} ", "\\catcode`\\a ", "\\hoffset ", "\\voffset "]);
let into = rng.word(&["count", "dimen", "skip"]);
let a = a.replace("{r}", &r.to_string());
format!(
"\\count{r}={x} \\dimen{r}={y}pt \\skip{r}={z}pt plus 1fil \\{into}{s}={a}\\message{{p{id}:\\the\\{into}{s} }}",
x = rng.next(100),
y = rng.next(100),
z = rng.next(100),
s = 1 + rng.next(9)
)
}
58 => format!(
"\\count{r}={a} \\dimen{r}=\\count{r}pt \\skip{r}=\\count{r}\\dimen{r} \\count{s}=\\dimen{r} \\message{{p{id}:\\the\\dimen{r} \\the\\skip{r} \\the\\count{s} }}",
a = rng.next(40) as i32 - 20,
s = 1 + rng.next(9)
),
59 => format!(
"\\toks{r}={{{w}}}\\toks{s}={{\\the\\toks{r}\\the\\toks{r} #}}\\edef{m}{{\\the\\toks{s}}}\\message{{p{id}:\\the\\toks{s} \\meaning{m} }}\\toks{t}=\\toks{r} \\message{{p{id}:\\the\\toks{t}}}",
s = 1 + rng.next(9),
t = 1 + rng.next(9)
),
60 => {
let l = rng.word(&["\\hfuzz=1pt", "\\count1=7", "\\toks1={a}", "\\catcode`\\a=11 ", "\\def\\x{}", "\\let\\x=\\relax"]);
format!(
"{{{l} \\global\\advance\\count{r} by 1 }}\\begingroup\\count{r}=9 {{\\count{r}=\\count{r}\\advance\\count{r} by -3 \\global\\count{s}=\\count{r}}}\\endgroup\\message{{p{id}:\\the\\count{r},\\the\\count{s}}}",
s = 1 + rng.next(9)
)
}
61 => {
let k = rng.word(&["\\skip", "\\muskip"]);
let u = if k == "\\skip" { "pt" } else { "mu" };
format!(
"{k}{r}=1{u} plus 2fil minus 3fill {k}{s}={a}{u} plus {b}{u} \\advance{k}{r} by {k}{s} \\multiply{k}{r} by {c} \\divide{k}{r} by {d} \\message{{p{id}:\\the{k}{r}}}",
s = 1 + rng.next(9),
a = rng.next(20),
b = rng.next(20),
c = 1 + rng.next(9),
d = 1 + rng.next(9)
)
}
_ => unreachable!("probe kind out of range"),
}
}
fn generate(index: u64, count: usize) -> Vec<String> {
let mut rng = Rng::new(index);
(0..count).map(|id| probe(&mut rng, id)).collect()
}
fn document(probes: &[String]) -> String {
let mut src = String::from(
"\\catcode`\\{=1 \\catcode`\\}=2 \\catcode`\\#=6 \\errorcontextlines=5 \\newlinechar=-1\n",
);
for p in probes {
src.push_str(p);
src.push('\n');
}
src.push_str("\\end\n");
src
}
fn run_both(source: &str, oracle: &Oracle, dir: &Path, timeout: Duration) -> (String, String) {
let path = dir.join("case.tex");
if std::fs::write(&path, source).is_err() {
return ("<unwritable>".into(), "<unwritable>".into());
}
let want = run_with_timeout(
Command::new(&oracle.program)
.arg("-interaction=nonstopmode")
.arg("case.tex")
.env("max_print_line", "8000")
.current_dir(dir),
timeout,
);
let got = run_with_timeout(
Command::new(texrs_binary()).arg(&path).current_dir(dir),
timeout,
);
(
texrs::parity::messages_of(&want),
texrs::parity::messages_of(&got),
)
}
fn texrs_binary() -> PathBuf {
std::env::current_exe()
.ok()
.and_then(|p| p.parent().map(|d| d.join("texrs")))
.unwrap_or_else(|| PathBuf::from("texrs"))
}
fn run_with_timeout(cmd: &mut Command, timeout: Duration) -> String {
use std::process::Stdio;
let Ok(mut child) = cmd.stdout(Stdio::piped()).stderr(Stdio::null()).spawn() else {
return "<unstartable>".into();
};
let start = std::time::Instant::now();
loop {
match child.try_wait() {
Ok(Some(_)) => break,
Ok(None) if start.elapsed() > timeout => {
let _ = child.kill();
return "<timeout>".into();
}
Ok(None) => std::thread::sleep(Duration::from_millis(10)),
Err(_) => return "<unwaitable>".into(),
}
}
let out = child
.wait_with_output()
.map(|o| o.stdout)
.unwrap_or_default();
String::from_utf8_lossy(&out).into_owned()
}
fn diverges(probes: &[String], oracle: &Oracle, dir: &Path, timeout: Duration) -> bool {
let (want, got) = run_both(&document(probes), oracle, dir, timeout);
want != got
}
fn minimize(probes: &[String], oracle: &Oracle, dir: &Path, timeout: Duration) -> Vec<String> {
for p in probes {
let one = vec![p.clone()];
if diverges(&one, oracle, dir, timeout) {
return one;
}
}
let mut cur = probes.to_vec();
let mut i = 0;
while i < cur.len() && cur.len() > 1 {
let mut trial = cur.clone();
trial.remove(i);
match diverges(&trial, oracle, dir, timeout) {
true => cur = trial,
false => i += 1,
}
}
cur
}
fn indent(source: &str) -> String {
source
.lines()
.map(|l| format!(" {l}\n"))
.collect::<String>()
}
#[allow(dead_code)]
fn flush() {
let _ = std::io::stdout().flush();
}