use std::io::Read as _;
use std::io::Write as _;
use std::path::{Path, PathBuf};
use std::process::{Command, Stdio};
use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use std::sync::Mutex;
use std::time::{Duration, Instant};
struct Rng(u64);
impl Rng {
fn new(seed: u64) -> Self {
Rng(seed ^ 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: u64) -> u64 {
if n == 0 {
0
} else {
self.next_u64() % n
}
}
}
fn pick<'a, T>(rng: &mut Rng, xs: &'a [T]) -> &'a T {
&xs[rng.below(xs.len() as u64) as usize]
}
fn ours_bin() -> PathBuf {
if let Ok(p) = std::env::var("CARGO_BIN_EXE_python") {
return PathBuf::from(p);
}
if let Some(d) = std::env::current_exe()
.ok()
.and_then(|p| p.parent().map(|d| d.to_path_buf()))
{
let cand = d.join("python");
if cand.exists() {
return cand;
}
}
PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("target")
.join("debug")
.join("python")
}
fn resolve_oracle() -> String {
if let Ok(p) = std::env::var("PYTHONRS_FUZZ_PYTHON") {
if version_of(&p).is_none() {
eprintln!("parity-fuzz: PYTHONRS_FUZZ_PYTHON={p}: not a usable python");
std::process::exit(2);
}
return p;
}
for p in [
"python3",
"/usr/bin/python3",
"/opt/homebrew/bin/python3",
"python",
] {
if version_of(p).is_some() {
return p.to_string();
}
}
eprintln!("parity-fuzz: no reference python3 found; set PYTHONRS_FUZZ_PYTHON");
std::process::exit(2);
}
fn version_of(prog: &str) -> Option<String> {
let o = Command::new(prog).arg("--version").output().ok()?;
if !o.status.success() && o.stdout.is_empty() && o.stderr.is_empty() {
return None;
}
let mut s = String::from_utf8_lossy(&o.stdout).trim().to_string();
if s.is_empty() {
s = String::from_utf8_lossy(&o.stderr).trim().to_string();
}
if s.is_empty() {
None
} else {
Some(s)
}
}
fn oracle_id(oracle: &str) -> String {
let v = version_of(oracle).unwrap_or_else(|| "unknown".to_string());
format!("{oracle} ({v})")
}
static CMP_STDERR: AtomicBool = AtomicBool::new(false);
struct RunOut {
stdout: Vec<u8>,
stderr: Vec<u8>,
exit: i32,
timed_out: bool,
}
fn render(bytes: &[u8]) -> String {
let text = String::from_utf8_lossy(bytes);
let text = text.trim_end_matches('\n');
if std::str::from_utf8(bytes).is_err() {
let hex: Vec<String> = bytes.iter().map(|b| format!("{b:02x}")).collect();
return format!("{text}\n (hex) {}", hex.join(" "));
}
text.to_string()
}
fn norm_stderr(s: &[u8]) -> Vec<u8> {
let text = String::from_utf8_lossy(s);
let last = text
.lines()
.map(|l| l.trim())
.rfind(|l| !l.is_empty())
.unwrap_or("")
.to_lowercase();
last.into_bytes()
}
fn differs(oracle: &RunOut, ours: &RunOut) -> bool {
if (oracle.exit == 0) != (ours.exit == 0) {
return true;
}
if oracle.stdout != ours.stdout {
return true;
}
if CMP_STDERR.load(Ordering::Relaxed)
&& norm_stderr(&oracle.stderr) != norm_stderr(&ours.stderr)
{
return true;
}
false
}
fn run_prog(
prog: &Path,
src: &str,
timeout: Duration,
oracle_env: bool,
hash_seed: &str,
) -> RunOut {
let mut cmd = Command::new(prog);
cmd.arg("-c")
.arg(src)
.env("PYTHONHASHSEED", hash_seed)
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped());
if oracle_env {
cmd.env("PYTHONDONTWRITEBYTECODE", "1");
}
let mut child = match cmd.spawn() {
Ok(c) => c,
Err(_) => {
return RunOut {
stdout: Vec::new(),
stderr: Vec::new(),
exit: -1,
timed_out: false,
}
}
};
let mut out_h = child.stdout.take().map(|mut o| {
std::thread::spawn(move || {
let mut b = Vec::new();
let _ = o.read_to_end(&mut b);
b
})
});
let mut err_h = child.stderr.take().map(|mut e| {
std::thread::spawn(move || {
let mut b = Vec::new();
let _ = e.read_to_end(&mut b);
b
})
});
let deadline = Instant::now() + timeout;
let mut timed_out = false;
let exit;
loop {
match child.try_wait() {
Ok(Some(status)) => {
exit = status.code().unwrap_or(-1);
break;
}
Ok(None) => {
if Instant::now() >= deadline {
let _ = child.kill();
let s = child.wait().ok();
exit = s.and_then(|s| s.code()).unwrap_or(-1);
timed_out = true;
break;
}
std::thread::sleep(Duration::from_millis(2));
}
Err(_) => {
exit = -1;
break;
}
}
}
let stdout = out_h.take().and_then(|h| h.join().ok()).unwrap_or_default();
let stderr = err_h.take().and_then(|h| h.join().ok()).unwrap_or_default();
RunOut {
stdout,
stderr,
exit,
timed_out,
}
}
fn build_program(stmts: &[String]) -> String {
stmts.join("\n")
}
const INTS: &[&str] = &[
"0", "1", "2", "3", "5", "7", "10", "-1", "-3", "-7", "42", "100", "-100", "1000",
];
const POSINTS: &[&str] = &["1", "2", "3", "4", "5", "6", "8", "10"];
const FLOATS: &[&str] = &[
"0.1", "0.2", "0.5", "1.5", "2.0", "3.14", "10.0", "-1.5", "100.0", "0.0", "2.5", "1e3", "1e-3",
];
const STRS: &[&str] = &[
"'hello'",
"'World'",
"'abc'",
"'Python'",
"''",
"'a'",
"'foo bar'",
"' pad '",
"'AbC'",
];
const WORDS: &[&str] = &["'a'", "'b'", "'c'", "'x'", "'y'", "'z'", "'ab'", "'cd'"];
fn gen_arith(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let a = pick(r, INTS);
let b = pick(r, INTS);
let c = pick(r, INTS);
let exp = pick(r, &["2", "3", "0", "-1"]);
let op = pick(r, &["+", "-", "*", "//", "%"]);
let e = match r.below(6) {
0 => format!("{a} {op} {b}"),
1 => format!("{a} + {b} * {c}"),
2 => format!("({a} + {b}) * {c}"),
3 => format!("-{a} ** {exp}"),
4 => format!("{a} // {b} + {c} % {b}"),
_ => format!("{a} {op} {b} {op} {c}"),
};
vec![format!("print({e})")]
}
fn gen_bignum(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
match r.below(3) {
0 => {
let n = 16 + r.below(240);
vec![format!("print(2 ** {n})")]
}
1 => {
let n = 8 + r.below(80);
vec![format!("print(10 ** {n})")]
}
_ => {
let n = 10 + r.below(40);
vec![
"f = 1".into(),
format!("for i in range(1, {n}): f *= i"),
"print(f)".into(),
]
}
}
}
fn gen_floatfmt(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let a = pick(r, FLOATS);
let b = pick(r, FLOATS);
let k = r.below(6);
let e = match r.below(7) {
0 => "0.1 + 0.2".to_string(),
1 => format!("{a} / {b}"),
2 => format!("{a} * {b}"),
3 => format!("round({a} / {b}, {k})"),
4 => format!("{} ** 0.5", pick(r, POSINTS)),
5 => format!("{a} + {b}"),
_ => a.to_string(),
};
vec![format!("print({e})")]
}
fn gen_strings(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let s = pick(r, STRS);
let n = r.below(4);
let e = match r.below(5) {
0 => format!("{s}[{}]", r.below(3)),
1 => format!("{s} * {n}"),
2 => format!("{s} + {}", pick(r, STRS)),
3 => format!("{} in {s}", pick(r, WORDS)),
_ => format!("len({s})"),
};
vec![format!("print({e})")]
}
fn gen_fstring(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let x = pick(r, FLOATS);
let n = pick(r, INTS);
let s = pick(r, STRS);
let e = match r.below(6) {
0 => format!("f\"{{{x}}}\""),
1 => format!("f\"{{{x}:.2f}}\""),
2 => format!("f\"{{{s}!r}}\""),
3 => format!("f\"{{{n}:05d}}\""),
4 => format!("f\"[{{{n}}}][{{{x}}}]\""),
_ => format!("f\"{{{n} + {}}}\"", pick(r, INTS)),
};
vec![format!("print({e})")]
}
fn gen_slice(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let seq = pick(
r,
&[
"'abcdefg'",
"[1, 2, 3, 4, 5]",
"(10, 20, 30, 40)",
"'Python3'",
],
);
let idx = &["", "0", "1", "2", "-1", "-2", "3", "5"];
let a = pick(r, idx);
let b = pick(r, idx);
let step = pick(r, &["", "1", "2", "-1", "-2"]);
let e = if step.is_empty() {
format!("{seq}[{a}:{b}]")
} else {
format!("{seq}[{a}:{b}:{step}]")
};
vec![format!("print({e})")]
}
fn gen_seqtail(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let bounds = &[
"", "0", "1", "2", "3", "-1", "-2", "-3", "5", "7", "-7", "100", "-100",
];
let a = pick(r, bounds);
let b = pick(r, bounds);
let steps = &["", "1", "2", "3", "-1", "-2", "-3"];
let step = pick(r, steps);
let sl = |a: &str, b: &str, step: &str| -> String {
if step.is_empty() {
format!("{a}:{b}")
} else {
format!("{a}:{b}:{step}")
}
};
let k = pick(r, &["0", "1", "2", "3", "-1", "-2", "5", "-5"]);
let n = pick(r, &["0", "1", "2", "3", "4"]);
match r.below(20) {
0 => {
let seq = pick(
r,
&[
"[10, 20, 30, 40, 50, 60]",
"(0, 1, 2, 3, 4, 5, 6)",
"'abcdefghij'",
"range(10)",
"range(2, 20, 3)",
],
);
vec![format!("print(({seq})[{}])", sl(a, b, step))]
}
1 => {
let rhs = pick(
r,
&[
"[]",
"[99]",
"[7, 8, 9]",
"[1, 2, 3, 4, 5]",
"range(3)",
"'xy'",
"(100, 200)",
],
);
vec![
"x = [0, 1, 2, 3, 4]".into(),
format!("x[{a}:{b}] = {rhs}"),
"print(x)".into(),
]
}
2 => {
let rhs = pick(
r,
&["[100, 200, 300]", "[9]", "range(2)", "[1, 2, 3, 4, 5, 6]"],
);
let st = pick(r, &["2", "3", "-1", "-2"]);
vec![
"x = list(range(6))".into(),
"try:".into(),
format!(" x[{}] = {rhs}", sl(a, b, st)),
" print(x)".into(),
"except Exception as e:".into(),
" print(type(e).__name__)".into(),
]
}
3 => {
vec![
"x = list(range(8))".into(),
format!("del x[{}]", sl(a, b, step)),
"print(x)".into(),
]
}
4 => {
let av = pick(r, &["0", "1", "2", "-1", "-2", "3", "5"]);
let bv = pick(r, &["6", "4", "3", "-1", "10", "2"]);
let sv = pick(r, &["1", "2", "-1"]);
let mut prog = vec![
"class Idx:".into(),
" def __init__(self, v): self.v = v".into(),
" def __index__(self): return self.v".into(),
"s = [0, 1, 2, 3, 4, 5]".into(),
];
match r.below(4) {
0 => prog.push(format!("print(s[Idx({av}):Idx({bv}):Idx({sv})])")),
1 => prog.push(format!("print('abcdef'[Idx({av}):Idx({bv})])")),
2 => {
prog.push(format!("s[Idx({av}):Idx({bv})] = [7, 8]"));
prog.push("print(s)".into());
}
_ => {
prog.push(format!("del s[Idx({av}):Idx({bv})]"));
prog.push("print(s)".into());
}
}
prog
}
5 => {
let e = match r.below(5) {
0 => format!("x.insert({k}, 99); print(x)"),
1 => "x.append(99); print(x)".to_string(),
2 => format!("x.extend(range({n})); print(x)"),
3 => "y = x.copy(); y.append(0); print(x, y)".to_string(),
_ => "x.clear(); print(x)".to_string(),
};
vec!["x = [1, 2, 3, 4]".into(), e]
}
6 => {
let v = pick(r, &["1", "2", "3", "9"]);
match r.below(2) {
0 => vec![
"x = [1, 2, 2, 3, 2]".into(),
"try:".into(),
format!(" x.remove({v}); print(x)"),
"except ValueError as e:".into(),
" print('ValueError')".into(),
],
_ => vec![format!("print([1, 2, 2, 3, 2].count({v}))")],
}
}
7 => {
let v = pick(r, &["1", "2", "3", "9"]);
let start = pick(r, &["0", "1", "2", "-3"]);
let stop = pick(r, &["3", "5", "-1", "100"]);
let call = match r.below(3) {
0 => format!("x.index({v})"),
1 => format!("x.index({v}, {start})"),
_ => format!("x.index({v}, {start}, {stop})"),
};
vec![
"x = [1, 2, 3, 2, 1, 2]".into(),
"try:".into(),
format!(" print({call})"),
"except ValueError:".into(),
" print('ValueError')".into(),
]
}
8 => {
let arg = pick(r, &["", "0", "1", "-1", "-2", "5", "-9"]);
vec![
"x = [10, 20, 30]".into(),
"try:".into(),
format!(" print(x.pop({arg}), x)"),
"except IndexError:".into(),
" print('IndexError')".into(),
]
}
9 => match r.below(4) {
0 => vec![
"x = [3, 1, 4, 1, 5, 9, 2]".into(),
"x.reverse(); print(x)".into(),
],
1 => vec![
"x = [3, 1, 4, 1, 5, 9, 2, 6]".into(),
"x.sort(); print(x)".into(),
],
2 => vec![
"x = [3, 1, 4, 1, 5, 9, 2, 6]".into(),
"x.sort(reverse=True); print(x)".into(),
],
_ => vec![
"x = [(1, 'a'), (0, 'b'), (1, 'c'), (0, 'd'), (2, 'e')]".into(),
"x.sort(key=lambda t: t[0]); print(x)".into(),
],
},
10 => {
vec![
"class S:".into(),
" def __init__(self): self.d = [0, 1, 2, 3, 4, 5, 6]".into(),
" def __getitem__(self, i):".into(),
" if isinstance(i, slice):".into(),
" return ('slice', i.start, i.stop, i.step)".into(),
" return self.d[i]".into(),
format!("print(S()[{}])", sl(a, b, step)),
]
}
11 => {
let which = if r.below(2) == 0 { "set" } else { "del" };
if which == "set" {
vec![
"class S:".into(),
" def __init__(self): self.d = list(range(6))".into(),
" def __setitem__(self, i, v): self.d[i] = v".into(),
" def show(self): return self.d".into(),
"s = S()".into(),
format!("s[{}] = [88, 77]", sl(a, b, "")),
"print(s.show())".into(),
]
} else {
vec![
"class S:".into(),
" def __init__(self): self.d = list(range(6))".into(),
" def __delitem__(self, i): del self.d[i]".into(),
" def show(self): return self.d".into(),
"s = S()".into(),
format!("del s[{}]", sl(a, b, step)),
"print(s.show())".into(),
]
}
}
12 => {
let v = pick(r, &["0", "2", "5", "9"]);
vec![
"class C:".into(),
" def __init__(self): self.d = [0, 2, 4, 6, 8]".into(),
" def __len__(self): return len(self.d)".into(),
" def __getitem__(self, i): return self.d[i]".into(),
"c = C()".into(),
format!("print(len(c), {v} in c)"),
]
}
13 => {
let seq = pick(r, &["[0]", "[1, 2]", "(3, 4)", "'ab'", "[9, 8, 7]"]);
match r.below(3) {
0 => vec![format!("print({seq} * {n})")],
1 => vec![format!("print({n} * {seq})")],
_ => vec![
format!("x = {seq} * {n}"),
format!("y = {n} * {seq}"),
"print(x == y, x)".into(),
],
}
}
14 => {
let e = match r.below(3) {
0 => "[1, 2] + [3, 4, 5]".to_string(),
1 => "(1, 2) + (3,)".to_string(),
_ => "'ab' + 'cde'".to_string(),
};
vec![format!("print({e})")]
}
15 => {
let av = pick(r, bounds);
let bv = pick(r, bounds);
let sv = pick(r, steps);
let ctor = if sv.is_empty() {
let a2 = if av.is_empty() { "None" } else { av };
let b2 = if bv.is_empty() { "None" } else { bv };
format!("slice({a2}, {b2})")
} else {
let a2 = if av.is_empty() { "None" } else { av };
let b2 = if bv.is_empty() { "None" } else { bv };
format!("slice({a2}, {b2}, {sv})")
};
vec![
format!("s = {ctor}"),
"print(s.start, s.stop, s.step)".into(),
"print('abcdefgh'[s])".into(),
"print(s.indices(8))".into(),
]
}
16 => {
let seq = pick(r, &["[10, 20, 30, 40]", "(1, 2, 3, 4, 5)", "'wxyz'"]);
let i = pick(r, &["-1", "-2", "-4", "0", "3", "5", "-9"]);
vec![
"try:".into(),
format!(" print(({seq})[{i}])"),
"except IndexError:".into(),
" print('IndexError')".into(),
]
}
17 => {
let seq = pick(r, &["'Python3'", "range(1, 9)", "[1, 2, 3, 4, 5]"]);
let e = match r.below(4) {
0 => format!("({seq})[::-1]"),
1 => format!("({seq})[:]"),
2 => format!("({seq})[::2]"),
_ => format!("({seq})[{}]", sl(a, b, step)),
};
vec![format!(
"print(list({e}) if not isinstance({e}, str) else {e})"
)]
}
18 => match r.below(3) {
0 => vec![
"x = [0] * 6".into(),
"x[::2] = [1, 2, 3]".into(),
"print(x)".into(),
],
1 => vec![
"x = list(range(6))".to_string(),
format!("del x[::{}]", pick(r, &["2", "3", "-2"])),
"print(x)".into(),
],
_ => vec![
"x = ['b', 'a', 'c', 'a', 'b']".into(),
"x.sort(); print(x)".into(),
"x.sort(reverse=True); print(x)".into(),
],
},
_ => {
vec![
"class Idx:".into(),
" def __init__(self, v): self.v = v".into(),
" def __index__(self): return self.v".into(),
format!("print([10, 20, 30, 40, 50][Idx({k})] if -5 <= {k} < 5 else 'oob')"),
"print(slice(Idx(1), Idx(4), Idx(2)).indices(10))".to_string(),
]
}
}
}
fn gen_listcomp(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let n = 3 + r.below(6);
let e = match r.below(4) {
0 => format!("[i * i for i in range({n})]"),
1 => format!("[i for i in range({n}) if i % 2 == 0]"),
2 => "[(i, j) for i in range(3) for j in range(2)]".to_string(),
_ => "[c.upper() for c in 'abcd' if c != 'b']".to_string(),
};
vec![format!("print({e})")]
}
fn gen_dictcomp(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let n = 3 + r.below(5);
let e = match r.below(3) {
0 => format!("{{i: i * i for i in range({n})}}"),
1 => "{c: ord(c) for c in 'abc'}".to_string(),
_ => format!("{{i: i % 2 == 0 for i in range({n})}}"),
};
vec![format!("print({e})")]
}
fn gen_setcomp(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let n = 4 + r.below(8);
let inner = match r.below(3) {
0 => format!("{{i % 3 for i in range({n})}}"),
1 => "{c for c in 'banana'}".to_string(),
_ => format!("{{i * i % 5 for i in range({n})}}"),
};
vec![format!("print(sorted({inner}))")]
}
fn gen_sorting(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let lst = pick(
r,
&[
"[3, 1, 2, 5, 4]",
"[10, -1, 7, 0]",
"['banana', 'apple', 'cherry']",
"[2.5, 1.1, 3.3]",
],
);
let e = match r.below(6) {
0 => format!("sorted({lst})"),
1 => format!("sorted({lst}, reverse=True)"),
2 => format!("sorted({lst}, key=lambda x: -x if isinstance(x, int) else x)"),
3 => format!("min({lst})"),
4 => format!("max({lst})"),
_ => format!("sorted('{}')", "dcba"),
};
vec![format!("print({e})")]
}
fn gen_formatspec(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let x = pick(r, FLOATS);
let n = pick(r, &["0", "1", "42", "255", "-7", "1000"]);
let s = pick(r, WORDS);
let e = match r.below(9) {
0 => format!("'{{:.3f}}'.format({x})"),
1 => format!("'{{:05d}}'.format({n})"),
2 => format!("'{{:>8}}'.format({s})"),
3 => format!("'{{:x}}'.format({n})"),
4 => format!("'{{:b}}'.format({n})"),
5 => format!("'{{:e}}'.format({x})"),
6 => format!("'%d %s' % ({n}, {s})"),
7 => format!("'%.2f' % {x}"),
_ => format!("'{{:+.2f}}'.format({x})"),
};
vec![format!("print({e})")]
}
fn gen_boolint(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let a = pick(r, INTS);
let b = pick(r, INTS);
let e = match r.below(6) {
0 => "True + True".to_string(),
1 => format!("{a} and {b}"),
2 => format!("{a} or {b}"),
3 => format!("not {a}"),
4 => format!("int({a} == {b})"),
_ => format!("{a} if {b} else 0"),
};
vec![format!("print({e})")]
}
fn gen_ranges(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let a = pick(r, &["0", "1", "2", "-3", "5", "10"]);
let b = pick(r, &["0", "3", "5", "-2", "10", "-5"]);
let c = pick(r, &["1", "2", "3", "-1", "-2"]);
let e = match r.below(3) {
0 => format!("list(range({a}, {b}, {c}))"),
1 => format!("sum(range({}))", pick(r, POSINTS)),
_ => format!("list(range({b}))"),
};
vec![format!("print({e})")]
}
fn gen_strmeth(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let s = pick(r, STRS);
let e = match r.below(11) {
0 => format!("{s}.upper()"),
1 => format!("{s}.lower()"),
2 => format!("{s}.split()"),
3 => "','.join(['a', 'b', 'c'])".to_string(),
4 => format!("{s}.replace('a', 'X')"),
5 => format!("{s}.strip()"),
6 => format!("{s}.find('o')"),
7 => format!("{s}.count('a')"),
8 => format!("{s}.startswith('h')"),
9 => format!("'{}'.zfill({})", "42", r.below(6)),
_ => format!("{s}.title()"),
};
vec![format!("print({e})")]
}
fn gen_comparison(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let a = pick(r, INTS);
let b = pick(r, INTS);
let c = pick(r, INTS);
let e = match r.below(5) {
0 => format!("{a} < {b} < {c}"),
1 => format!("{a} == {b}"),
2 => format!("{a} <= {b} <= {c}"),
3 => format!("(1, 2) < (1, {})", pick(r, POSINTS)),
_ => format!("{a} == float({a})"),
};
vec![format!("print({e})")]
}
fn gen_builtins(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let a = pick(r, POSINTS);
let b = pick(r, POSINTS);
let n = pick(r, &["0", "7", "42", "255", "65"]);
let x = pick(r, FLOATS);
let e = match r.below(12) {
0 => format!("divmod({}, {})", pick(r, INTS), b),
1 => format!("abs({})", pick(r, INTS)),
2 => format!("hex({n})"),
3 => format!("oct({n})"),
4 => format!("bin({n})"),
5 => format!("pow({a}, {b})"),
6 => format!("pow({a}, {b}, {})", pick(r, POSINTS)),
7 => format!("round({x}, {})", r.below(4)),
8 => "ord('A')".to_string(),
9 => format!("chr({})", 65 + r.below(20)),
10 => format!("int('{}', 2)", pick(r, &["101", "1111", "10"])),
_ => format!("sum([{a}, {b}, {n}])"),
};
vec![format!("print({e})")]
}
fn gen_ternary(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let a = pick(r, INTS);
let b = pick(r, INTS);
let cond = pick(r, &["True", "False", "1 > 0", "0", "''", "[]"]);
vec![format!("print({a} if {cond} else {b})")]
}
fn gen_augassign(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let a = pick(r, INTS);
let b = pick(r, POSINTS);
let op = pick(r, &["+=", "-=", "*=", "//=", "%=", "**="]);
vec![format!("x = {a}"), format!("x {op} {b}"), "print(x)".into()]
}
fn gen_augwith(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
match r.below(6) {
0 => {
let n = pick(r, POSINTS);
if r.below(2) == 0 {
vec![
"class C:".into(),
" def __init__(s): s.v = 0".into(),
" def __iadd__(s, o): s.v += o; return s".into(),
"c = C()".into(),
"d = c".into(),
format!("c += {n}"),
"print(d is c, c.v)".into(),
]
} else {
vec![
"class A:".into(),
" def __init__(s, x): s.x = x".into(),
" def __add__(s, o): return A(s.x + o)".into(),
format!("a = A({n})"),
"b = a".into(),
"a += 1".into(),
"print(b is a, a.x)".into(),
]
}
}
1 => {
let a = pick(r, POSINTS);
let b = pick(r, POSINTS);
let k = pick(r, &["1", "2", "3"]);
match r.below(4) {
0 => vec![
format!("l = [{a}]"),
"m = l".into(),
format!("l += [{b}]"),
"print(m is l, l)".into(),
],
1 => vec![
format!("l = [{a}, {b}]"),
"m = l".into(),
format!("l *= {k}"),
"print(m is l, l)".into(),
],
2 => vec![
"l = [1]".into(),
"l += (x for x in range(3))".into(),
"print(l)".into(),
],
_ => vec![
"b = bytearray(b'ab')".into(),
"m = b".into(),
"b += b'cd'".into(),
"print(m is b, b)".into(),
],
}
}
2 => {
let op = pick(r, &["|=", "&=", "-=", "^="]);
if r.below(2) == 0 {
vec![
"s = {1, 2, 3}".into(),
"m = s".into(),
format!("s {op} {{2, 3, 4}}"),
"print(m is s, sorted(s))".into(),
]
} else {
vec![
"d = {'a': 1}".into(),
"m = d".into(),
"d |= {'b': 2}".into(),
"print(m is d, d)".into(),
]
}
}
3 => {
let a = pick(r, INTS);
let b = pick(r, POSINTS);
match r.below(3) {
0 => vec![format!("x = {a}"), format!("x += {b}"), "print(x)".into()],
1 => vec!["s = 'a'".into(), "s += 'b'".into(), "print(s)".into()],
_ => vec![
"t = (1,)".into(),
"u = t".into(),
"t += (2,)".into(),
"print(u is t, t)".into(),
],
}
}
4 => {
let a = pick(r, SMALLINTS);
let b = pick(r, SMALLINTS);
let c = pick(r, SMALLINTS);
let mut out: Vec<String> = vec![
"n = 0".into(),
"def f(v):".into(),
" global n".into(),
" n += 1".into(),
" return v".into(),
];
if r.below(2) == 0 {
out.push(format!("print({a} < f({b}) < {c}, n)"));
} else {
out.push(format!("print({a} < {b} < f({c}), n)"));
}
out
}
_ => {
let sup = if r.below(2) == 0 { "True" } else { "False" };
if r.below(2) == 0 {
vec![
"class CM:".into(),
" def __enter__(s): return s".into(),
format!(" def __exit__(s, t, v, tb): return {sup}"),
"r = []".into(),
"try:".into(),
" with CM():".into(),
" r.append(1)".into(),
" raise ValueError('x')".into(),
" r.append(2)".into(),
"except ValueError:".into(),
" r.append(3)".into(),
"print(r)".into(),
]
} else {
vec![
"seen = []".into(),
"class CM:".into(),
" def __enter__(s): return 7".into(),
" def __exit__(s, t, v, tb):".into(),
" seen.append((t is ValueError, str(v)))".into(),
" return True".into(),
"with CM() as x:".into(),
" raise ValueError('boom')".into(),
"print(x, seen)".into(),
]
}
}
}
}
const SMALLINTS: &[&str] = &[
"0", "1", "2", "3", "4", "5", "6", "7", "-1", "-2", "-3", "10",
];
fn gen_classes(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let a = pick(r, SMALLINTS);
let b = pick(r, SMALLINTS);
let c = pick(r, SMALLINTS);
let vdef: Vec<String> = vec![
"class V:".into(),
" def __init__(self, x): self.x = x".into(),
" def __repr__(self): return 'V(' + str(self.x) + ')'".into(),
" def __eq__(self, o): return self.x == o.x".into(),
" def __lt__(self, o): return self.x < o.x".into(),
" def __add__(self, o): return V(self.x + o.x)".into(),
" def __sub__(self, o): return V(self.x - o.x)".into(),
" def __mul__(self, k): return V(self.x * k)".into(),
" def __neg__(self): return V(-self.x)".into(),
" def __abs__(self): return V(abs(self.x))".into(),
" def __len__(self): return abs(self.x)".into(),
" def __bool__(self): return self.x != 0".into(),
" def __format__(self, s): return format(self.x, s)".into(),
];
let mut out = vdef;
match r.below(8) {
0 => out.push(format!("print(V({a}) + V({b}) - V({c}))")),
1 => out.push(format!("print(V({a}) == V({b}), V({a}) < V({b}))")),
2 => out.push(format!("print(sorted([V({a}), V({b}), V({c})]))")),
3 => out.push(format!("print(-V({a}), abs(V({b})), V({a}) * 3)")),
4 => out.push(format!("print(bool(V({a})), len(V({b})))")),
5 => out.push(format!("print(V({a}) != V({b}), V({a}) != V({a}))")),
6 => out.push(format!(
"print('{{:+d}}'.format(V({a})), format(V({b}), '03d'))"
)),
_ => {
out.push("class C(V):".into());
out.push(" @property".into());
out.push(" def doubled(self): return self.x * 2".into());
out.push(" def __add__(self, o): return C(super().__add__(o).x + 1)".into());
out.push(format!("c = C({a})"));
out.push(format!("print(c.doubled, (c + V({b})).x)"));
}
}
out
}
fn gen_subclass(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
const STRS: &[&str] = &["a", "hi", "xy", "abc", "z", "cat", "Q"];
let a = pick(r, SMALLINTS);
let b = pick(r, SMALLINTS);
let c = pick(r, SMALLINTS);
let s = pick(r, STRS);
let t = {
let mut cand = pick(r, STRS);
while cand == s {
cand = pick(r, STRS);
}
cand
};
let mut out: Vec<String> = Vec::new();
match r.below(16) {
0 => {
out.push("class Stack(list):".into());
out.push(" def push(self, x): self.append(x)".into());
out.push(" def top(self): return self[-1]".into());
out.push(format!("s = Stack([{a}, {b}])"));
out.push(format!("s.push({c})"));
out.push("print(s, len(s), s.top(), s[0])".into());
out.push(format!("print({a} in s, s + [99], s.count({a}))"));
out.push("print(type(s).__name__, isinstance(s, list))".into());
}
1 => {
out.push("class DList(list):".into());
out.push(" def __init__(self, data):".into());
out.push(" super().__init__(data)".into());
out.push(" self.tag = 'd'".into());
out.push(format!("d = DList([{a}, {b}, {c}])"));
out.push("print(d, d.tag, sum(d), sorted(d, reverse=True))".into());
out.push("d.append(7); print(d, len(d))".into());
}
2 => {
out.push("class D(dict):".into());
out.push(" def __missing__(self, k): return len(k)".into());
out.push(format!("d = D({s}={a}, {t}={b})"));
out.push(format!("d['{s}'] = {c}"));
out.push(format!("print(d['{s}'], d['zzzz'], d.get('no'))"));
out.push("print(sorted(d.keys()), sorted(d.values()), len(d))".into());
out.push(format!("print('{s}' in d, type(d).__name__)"));
}
3 => {
out.push("class MyD(dict):".into());
out.push(" def total(self): return sum(self.values())".into());
out.push(format!("m = MyD({{'{s}': {a}, '{t}': {b}}})"));
out.push("print(m, m.total(), len(m))".into());
out.push(format!(
"m['{s}'] = {c}; print(m['{s}'], sorted(m.items()))"
));
}
4 => {
out.push("class U(str):".into());
out.push(" def shout(self): return self.upper() + '!'".into());
out.push(format!("u = U('{s}')"));
out.push("print(u, repr(u), u.shout(), len(u))".into());
out.push(format!("print(u + '{t}', u[0], u.startswith('{s}'[0]))"));
out.push(format!(
"print(u == '{s}', type(u).__name__, isinstance(u, str))"
));
}
5 => {
out.push("class Name(str):".into());
out.push(" def rev(self): return self[::-1]".into());
out.push(format!("n = Name('{s}{t}')"));
out.push("print(n.rev(), n.replace('a', 'Z'), n.count('a'))".into());
out.push("print(sorted(n), list(n), n * 2)".into());
}
6 => {
out.push("class C(int):".into());
out.push(" def half(self): return self // 2".into());
out.push(format!("c = C({a})"));
out.push(format!("print(c + {b}, c - {b}, c * {b})"));
out.push(format!("print(type(c + {b}).__name__, c.half())"));
out.push(format!("print(c < {b}, c == {a}, abs(C({b})), -c)"));
out.push("print(type(c).__name__, isinstance(c, int), bool(C(0)))".into());
}
7 => {
out.push("class I(int):".into());
out.push(" pass".into());
out.push(format!("i = I({b})"));
out.push("print(i // 2, i % 3, i & 6, i | 1, i ^ 3)".to_string());
out.push(format!(
"print(i + I({a}), type(i * 2).__name__, hash(i) == hash({b}))"
));
}
8 => {
out.push("class F(float):".into());
out.push(" def sq(self): return self * self".into());
let fa = pick(r, &["1.5", "2.0", "3.25", "0.5", "4.0"]);
let fb = pick(r, &["2", "0.5", "1.5", "3"]);
out.push(format!("f = F({fa})"));
out.push(format!("print(f + {fb}, f * 2, type(f + {fb}).__name__)"));
out.push("print(f.sq(), type(f).__name__, isinstance(f, float))".into());
}
9 => {
out.push("class T(tuple):".into());
out.push(" def first(self): return self[0]".into());
out.push(format!("tp = T([{a}, {b}, {c}])"));
out.push("print(tp, tp[1], len(tp), tp.first())".into());
out.push(format!("print({a} in tp, tp + ({b},), tp.count({a}))"));
out.push("print(type(tp).__name__, isinstance(tp, tuple), sorted(tp))".into());
}
10 => {
out.push("class S(set):".into());
out.push(" pass".into());
out.push(format!("ss = S([{a}, {b}, {c}, {a}])"));
out.push(format!("print(sorted(ss), len(ss), {a} in ss)"));
out.push(format!(
"print(sorted(ss | {{{b}, 99}}), sorted(ss & {{{a}, {c}}}))"
));
out.push("print(type(ss).__name__, isinstance(ss, set))".into());
}
11 => {
out.push("class Log(list):".into());
out.push(" def __init__(self, *xs):".into());
out.push(" super().__init__(xs)".into());
out.push(" self.n = 0".into());
out.push(" def add(self, x):".into());
out.push(" self.append(x); self.n += 1".into());
out.push(format!("g = Log({a}, {b})"));
out.push(format!("g.add({c}); g.add({a})"));
out.push("print(g, g.n, [x * 2 for x in g])".into());
}
12 => {
out.push("class W(str):".into());
out.push(" pass".into());
out.push(format!("w = W('{s}')"));
out.push(format!("print('{{}}!'.format(w), w in ('{s}', '{t}'))"));
out.push("print(w.upper(), w.ljust(5, '.'), len(w))".into());
}
13 => {
out.push("class C(int):".into());
out.push(" def __new__(cls, v):".into());
out.push(" return super().__new__(cls, v * 2)".into());
out.push(" def __init__(self, v):".into());
out.push(" self.orig = v".into());
out.push(format!("c = C({b})"));
out.push("print(c, c.orig, c + 1, type(c).__name__)".into());
out.push("print(isinstance(c, int), c * 2, c.orig + c)".into());
}
14 => {
out.push("class U(str):".into());
out.push(" def __new__(cls, v):".into());
out.push(" return super().__new__(cls, v.upper())".into());
out.push(format!("u = U('{s}')"));
out.push("print(u, len(u), type(u).__name__, u.lower())".into());
}
_ => {
out.push("class EL(list): pass".into());
out.push("class ED(dict): pass".into());
out.push("class ES(str): pass".into());
out.push("print(EL(), ED(), repr(ES()), len(EL()), len(ED()))".into());
out.push(format!("el = EL(); el.append({a}); el.append({b})"));
out.push("print(el, sum(el), bool(EL()), bool(el))".into());
}
}
out
}
fn gen_metatype(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
const STRS: &[&str] = &["a", "b", "hi", "tag", "x", "M", "zz"];
let a = pick(r, SMALLINTS);
let b = pick(r, SMALLINTS);
let s = pick(r, STRS);
let mut out: Vec<String> = Vec::new();
match r.below(16) {
0 => {
out.push("class C: pass".into());
out.push(format!(
"print(type({a}).__name__, type('{s}').__name__, type([]).__name__, type(C).__name__, type(C()).__name__)"
));
}
1 => {
out.push(format!(
"D = type('D', (), {{'x': {a}, 'greet': lambda self: '{s}'}})"
));
out.push("d = D()".into());
out.push(
"print(D.__name__, d.x, d.greet(), type(D).__name__, isinstance(d, D))".into(),
);
}
2 => {
out.push("class Meta(type):".into());
out.push(" def __new__(mcs, name, bases, ns):".into());
out.push(format!(" ns['tag'] = {a}"));
out.push(" return super().__new__(mcs, name, bases, ns)".into());
out.push("class C(metaclass=Meta): pass".into());
out.push("print(C.tag, type(C).__name__)".into());
}
3 => {
out.push("class Meta(type):".into());
out.push(" def __init__(cls, name, bases, ns):".into());
out.push(format!(" cls.marker = {a}"));
out.push(" super().__init__(name, bases, ns)".into());
out.push("class C(metaclass=Meta): pass".into());
out.push("class D(C): pass".into());
out.push("print(C.marker, D.marker, type(D).__name__)".into());
}
4 => {
out.push("class Meta(type):".into());
out.push(" def __call__(cls, *a, **k):".into());
out.push(" obj = super().__call__(*a, **k)".into());
out.push(format!(" obj.extra = {b}"));
out.push(" return obj".into());
out.push("class C(metaclass=Meta):".into());
out.push(" def __init__(self, v): self.v = v".into());
out.push(format!("c = C({a})"));
out.push("print(c.v, c.extra)".into());
}
5 => {
out.push("class Base:".into());
out.push(" def __init_subclass__(cls, **kw):".into());
out.push(" cls.tags = tuple(sorted(kw.items()))".into());
out.push(" super().__init_subclass__()".into());
out.push(format!("class C(Base, x={a}, y={b}): pass"));
out.push("class D(Base): pass".into());
out.push("print(C.tags, D.tags)".into());
}
6 => {
out.push("class Named:".into());
out.push(" def __set_name__(self, owner, name):".into());
out.push(" self.label = owner.__name__ + '.' + name".into());
out.push(" def __get__(self, o, ot): return self.label".into());
out.push("class Q:".into());
out.push(" field = Named()".into());
out.push("print(Q().field)".into());
}
7 => {
out.push("class A: pass".into());
out.push("class B(A): pass".into());
out.push("class C(A): pass".into());
out.push("class D(B, C): pass".into());
out.push("print([c.__name__ for c in D.__mro__])".into());
}
8 => {
out.push("class A: pass".into());
out.push("class B(A): pass".into());
out.push(
"print([x.__name__ for x in B.__bases__], [x.__name__ for x in A.__bases__])"
.into(),
);
}
9 => {
out.push("class Meta(type):".into());
out.push(" def __instancecheck__(cls, inst): return hasattr(inst, 'quack')".into());
out.push("class Duck(metaclass=Meta): pass".into());
out.push("class RealDuck:".into());
out.push(" quack = True".into());
out.push(format!(
"print(isinstance(RealDuck(), Duck), isinstance({a}, Duck))"
));
}
10 => {
out.push("class Meta(type):".into());
out.push(" def __subclasscheck__(cls, sub): return hasattr(sub, 'draw')".into());
out.push("class Drawable(metaclass=Meta): pass".into());
out.push("class Circle:".into());
out.push(" def draw(self): pass".into());
out.push("print(issubclass(Circle, Drawable), issubclass(int, Drawable))".into());
}
11 => {
out.push("class Box:".into());
out.push(" def __class_getitem__(cls, item):".into());
out.push(" return (cls.__name__, item.__name__)".into());
out.push("print(Box[int], Box[str])".into());
}
12 => {
out.push("class Meta(type):".into());
out.push(format!(" registry = {a}"));
out.push(" def describe(cls): return cls.__name__ + '!'".into());
out.push("class C(metaclass=Meta): pass".into());
out.push("print(C.registry, C.describe())".into());
}
13 => {
out.push("class A: pass".into());
out.push("class B(A): pass".into());
out.push(format!(
"print(isinstance(B(), (A, int)), issubclass(B, (int, A)), isinstance({a}, (str, int)))"
));
}
14 => {
out.push("class M(type): pass".into());
out.push("class C(metaclass=M): pass".into());
out.push(
"print(C.__class__.__name__, type(C).__name__, C().__class__.__name__)".into(),
);
}
_ => {
out.push("class Meta(type):".into());
out.push(" def __new__(mcs, name, bases, ns):".into());
out.push(" ns['base_names'] = tuple(b.__name__ for b in bases)".into());
out.push(" return super().__new__(mcs, name, bases, ns)".into());
out.push("class A(metaclass=Meta): pass".into());
out.push("class B(A): pass".into());
out.push("class C(B): pass".into());
out.push(
"print(A.base_names, B.base_names, C.base_names, issubclass(C, A), type(C).__name__)"
.into(),
);
}
}
out
}
fn gen_match(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let mut out: Vec<String> = Vec::new();
match r.below(18) {
0 => {
let s = pick(r, &["0", "1", "2", "3", "-1", "7", "99"]);
out.push(format!("match {s}:"));
out.push(" case 0:".into());
out.push(" print('zero')".into());
out.push(" case 1 | 2 | 3:".into());
out.push(" print('small')".into());
out.push(" case -1:".into());
out.push(" print('neg')".into());
out.push(" case x:".into());
out.push(" print('other', x)".into());
}
1 => {
let s = pick(r, &["0", "1", "None", "True", "False", "2", "3"]);
out.push(format!("match {s}:"));
out.push(" case None:".into());
out.push(" print('none')".into());
out.push(" case True:".into());
out.push(" print('true')".into());
out.push(" case False:".into());
out.push(" print('false')".into());
out.push(" case 0:".into());
out.push(" print('int0')".into());
out.push(" case 1:".into());
out.push(" print('int1')".into());
out.push(" case _:".into());
out.push(" print('other')".into());
}
2 => {
let n = r.below(5);
let items: Vec<String> = (0..n).map(|i| ((i * 3 + 1) % 10).to_string()).collect();
out.push(format!("match [{}]:", items.join(", ")));
out.push(" case []:".into());
out.push(" print('empty')".into());
out.push(" case [a]:".into());
out.push(" print('one', a)".into());
out.push(" case [a, b]:".into());
out.push(" print('two', a, b)".into());
out.push(" case [a, *rest]:".into());
out.push(" print('many', a, rest)".into());
}
3 => {
let a = pick(r, SMALLINTS);
let b = pick(r, SMALLINTS);
out.push(format!("match ({a}, {b}):"));
out.push(" case (0, 0):".into());
out.push(" print('origin')".into());
out.push(" case (0, y):".into());
out.push(" print('yaxis', y)".into());
out.push(" case (x, 0):".into());
out.push(" print('xaxis', x)".into());
out.push(" case (x, y):".into());
out.push(" print('pt', x, y)".into());
}
4 => {
let a = pick(r, SMALLINTS);
let b = pick(r, SMALLINTS);
out.push(format!("match {{'x': {a}, 'y': {b}}}:"));
out.push(" case {'x': 0}:".into());
out.push(" print('x0')".into());
out.push(" case {'x': xv, **rest}:".into());
out.push(" print('x', xv, rest)".into());
out.push(" case _:".into());
out.push(" print('none')".into());
}
5 => {
let a = pick(r, SMALLINTS);
let b = pick(r, SMALLINTS);
out.push("class Point:".into());
out.push(" __match_args__ = ('x', 'y')".into());
out.push(" def __init__(self, x, y):".into());
out.push(" self.x = x".into());
out.push(" self.y = y".into());
out.push(format!("match Point({a}, {b}):"));
out.push(" case Point(0, 0):".into());
out.push(" print('origin')".into());
out.push(" case Point(x, 0):".into());
out.push(" print('xaxis', x)".into());
out.push(" case Point(0, y):".into());
out.push(" print('yaxis', y)".into());
out.push(" case Point(x, y):".into());
out.push(" print('pt', x, y)".into());
}
6 => {
let a = pick(r, SMALLINTS);
let b = pick(r, SMALLINTS);
out.push("class P:".into());
out.push(" __match_args__ = ('x', 'y')".into());
out.push(" def __init__(self, x, y):".into());
out.push(" self.x = x".into());
out.push(" self.y = y".into());
out.push(format!("match P({a}, {b}):"));
out.push(" case P(x=0, y=yv):".into());
out.push(" print('x0', yv)".into());
out.push(" case P(x=xv, y=yv) if xv > yv:".into());
out.push(" print('gt', xv, yv)".into());
out.push(" case P(x=xv, y=yv):".into());
out.push(" print('pt', xv, yv)".into());
}
7 => {
let s = pick(r, &["1", "4", "7", "0", "5", "9", "2"]);
out.push(format!("match {s}:"));
out.push(" case 1 | 2 | 3:".into());
out.push(" print('low')".into());
out.push(" case 4 | 5 | 6:".into());
out.push(" print('mid')".into());
out.push(" case (7 | 8 | 9) as n:".into());
out.push(" print('high', n)".into());
out.push(" case _:".into());
out.push(" print('other')".into());
}
8 => {
let a = pick(r, SMALLINTS);
let b = pick(r, SMALLINTS);
out.push(format!("match [{a}, {b}]:"));
out.push(" case [x, y] if x == y:".into());
out.push(" print('eq', x)".into());
out.push(" case [x, y] as pair:".into());
out.push(" print('pair', x, y, len(pair))".into());
}
9 => {
let a = pick(r, SMALLINTS);
let b = pick(r, SMALLINTS);
let c = pick(r, SMALLINTS);
out.push(format!("match [{a}, [{b}, {c}]]:"));
out.push(" case [0, [y, z]]:".into());
out.push(" print('zero', y, z)".into());
out.push(" case [x, [0, z]]:".into());
out.push(" print('midzero', x, z)".into());
out.push(" case [x, [y, z]]:".into());
out.push(" print('nested', x, y, z)".into());
}
10 => {
let v = pick(r, &["0", "1", "2", "3"]);
out.push("class Color:".into());
out.push(" RED = 0".into());
out.push(" GREEN = 1".into());
out.push(" BLUE = 2".into());
out.push(format!("match {v}:"));
out.push(" case Color.RED:".into());
out.push(" print('red')".into());
out.push(" case Color.GREEN:".into());
out.push(" print('green')".into());
out.push(" case Color.BLUE:".into());
out.push(" print('blue')".into());
out.push(" case _:".into());
out.push(" print('unknown')".into());
}
11 => {
let a = pick(r, SMALLINTS);
let b = pick(r, SMALLINTS);
out.push(format!("match {{'items': [{a}, {b}]}}:"));
out.push(" case {'items': [0, y]}:".into());
out.push(" print('head0', y)".into());
out.push(" case {'items': [x, y]}:".into());
out.push(" print('two', x, y)".into());
out.push(" case _:".into());
out.push(" print('no')".into());
}
12 => {
let subj = if r.below(2) == 0 {
pick(r, SMALLINTS).to_string()
} else {
"'hi'".to_string()
};
out.push(format!("match {subj}:"));
out.push(" case int(v) if v > 0:".into());
out.push(" print('pos', v)".into());
out.push(" case int(v):".into());
out.push(" print('int', v)".into());
out.push(" case str(s):".into());
out.push(" print('str', s)".into());
out.push(" case _:".into());
out.push(" print('other')".into());
}
13 => {
out.push("class P:".into());
out.push(" __match_args__ = ('x',)".into());
out.push(" def __init__(self):".into());
out.push(" self.x = 1".into());
out.push("match P():".into());
out.push(" case P(a, b):".into());
out.push(" print(a, b)".into());
}
14 => {
let a = pick(r, SMALLINTS);
let b = pick(r, SMALLINTS);
out.push(format!("match [{a}, {b}]:"));
out.push(" case [x, x]:".into());
out.push(" print(x)".into());
}
15 => {
let a = pick(r, SMALLINTS);
out.push(format!("match {{'a': {a}}}:"));
out.push(" case {'a': x, 'a': y}:".into());
out.push(" print(x, y)".into());
}
16 => {
out.push("class P:".into());
out.push(" def __init__(self):".into());
out.push(" self.x = 1".into());
out.push("match P():".into());
out.push(" case P(x=a, x=b):".into());
out.push(" print(a, b)".into());
}
_ => {
let s = pick(r, SMALLINTS);
out.push(format!("match {s}:"));
out.push(" case [x] | y:".into());
out.push(" print('bad')".into());
out.push(" case _:".into());
out.push(" print('ok')".into());
}
}
out
}
fn gen_async(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let n = 2 + r.below(4); let mut out: Vec<String> = vec!["import asyncio".into()];
match r.below(7) {
6 => {
out.push("async def ag(n):".into());
out.push(" for i in range(n):".into());
out.push(" await asyncio.sleep(0)".into());
out.push(" if i % 2 == 0:".into());
out.push(" yield i * i".into());
out.push("async def main():".into());
out.push(format!(" return [x async for x in ag({})]", n + 2));
out.push("print(asyncio.run(main()))".into());
}
0 => {
out.push("async def sq(i):".into());
out.push(" await asyncio.sleep(0)".into());
out.push(" return i * i".into());
out.push("async def main():".into());
let calls: Vec<String> = (0..n).map(|i| format!("sq({i})")).collect();
out.push(format!(
" return await asyncio.gather({})",
calls.join(", ")
));
out.push("print(asyncio.run(main()))".into());
}
1 => {
out.push("async def w(i):".into());
out.push(" print('s', i)".into());
out.push(" await asyncio.sleep(0)".into());
out.push(" print('e', i)".into());
out.push("async def main():".into());
out.push(format!(
" ts = [asyncio.create_task(w(i)) for i in range({n})]"
));
out.push(" for t in ts:".into());
out.push(" await t".into());
out.push("asyncio.run(main())".into());
}
2 => {
out.push("class R:".into());
out.push(" def __init__(self, n):".into());
out.push(" self.n = n".into());
out.push(" self.i = 0".into());
out.push(" def __aiter__(self):".into());
out.push(" return self".into());
out.push(" async def __anext__(self):".into());
out.push(" if self.i >= self.n:".into());
out.push(" raise StopAsyncIteration".into());
out.push(" self.i += 1".into());
out.push(" await asyncio.sleep(0)".into());
out.push(" return self.i".into());
out.push("async def main():".into());
out.push(" acc = []".into());
out.push(format!(" async for x in R({n}):"));
out.push(" acc.append(x)".into());
out.push(" return acc".into());
out.push("print(asyncio.run(main()))".into());
}
3 => {
out.push("async def setter(fut, v):".into());
out.push(" await asyncio.sleep(0)".into());
out.push(" fut.set_result(v)".into());
out.push("async def main():".into());
out.push(" fut = asyncio.Future()".into());
out.push(format!(" asyncio.create_task(setter(fut, {n}))"));
out.push(" return await fut".into());
out.push("print(asyncio.run(main()))".into());
}
4 => {
out.push("async def inner(i):".into());
out.push(" await asyncio.sleep(0)".into());
out.push(" return i + 1".into());
out.push("class R:".into());
out.push(" def __init__(self, n):".into());
out.push(" self.n = n".into());
out.push(" self.i = 0".into());
out.push(" def __aiter__(self):".into());
out.push(" return self".into());
out.push(" async def __anext__(self):".into());
out.push(" if self.i >= self.n:".into());
out.push(" raise StopAsyncIteration".into());
out.push(" self.i += 1".into());
out.push(" return self.i".into());
out.push("async def main():".into());
out.push(format!(" return [await inner(x) async for x in R({n})]"));
out.push("print(asyncio.run(main()))".into());
}
_ => {
out.push("class CM:".into());
out.push(" def __init__(self, v):".into());
out.push(" self.v = v".into());
out.push(" async def __aenter__(self):".into());
out.push(" return self.v".into());
out.push(" async def __aexit__(self, *a):".into());
out.push(" return False".into());
out.push("async def main():".into());
out.push(format!(" async with CM({n}) as v:"));
out.push(" return v * 2".into());
out.push("print(asyncio.run(main()))".into());
}
}
out
}
fn gen_async2(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let n = 1 + r.below(4); let mut out: Vec<String> = vec!["import asyncio".into()];
match r.below(9) {
0 => {
out.push("async def worker():".into());
out.push(" try:".into());
out.push(" await asyncio.sleep(10)".into());
out.push(" return 'no'".into());
out.push(" except asyncio.CancelledError:".into());
out.push(" return 'caught'".into());
out.push("async def main():".into());
out.push(" t = asyncio.create_task(worker())".into());
out.push(" await asyncio.sleep(0)".into());
out.push(" c = t.cancel()".into());
out.push(" r = await t".into());
out.push(" print(c, r, t.cancelled())".into());
out.push("asyncio.run(main())".into());
}
1 => {
out.push("async def worker():".into());
out.push(" await asyncio.sleep(10)".into());
out.push(" return 'no'".into());
out.push("async def main():".into());
out.push(" t = asyncio.create_task(worker())".into());
out.push(" await asyncio.sleep(0)".into());
out.push(" t.cancel()".into());
out.push(" try:".into());
out.push(" await t".into());
out.push(" print('no-raise')".into());
out.push(" except asyncio.CancelledError:".into());
out.push(" print('cancelled', t.cancelled())".into());
out.push("asyncio.run(main())".into());
}
2 => {
out.push("async def ag(k):".into());
out.push(" for i in range(k):".into());
out.push(" await asyncio.sleep(0)".into());
out.push(" yield i".into());
out.push("async def main():".into());
out.push(format!(" g = ag({n})"));
out.push(" acc = []".into());
out.push(" try:".into());
out.push(" v = await g.asend(None)".into());
out.push(" while True:".into());
out.push(" acc.append(v)".into());
out.push(" v = await g.asend(v)".into());
out.push(" except StopAsyncIteration:".into());
out.push(" pass".into());
out.push(" print(acc)".into());
out.push("asyncio.run(main())".into());
}
3 => {
out.push("async def ag():".into());
out.push(" try:".into());
out.push(" while True:".into());
out.push(" yield 1".into());
out.push(" except ValueError:".into());
out.push(" yield 2".into());
out.push("async def main():".into());
out.push(" g = ag()".into());
out.push(" a = await g.asend(None)".into());
out.push(" b = await g.athrow(ValueError)".into());
out.push(" await g.aclose()".into());
out.push(" print(a, b)".into());
out.push("asyncio.run(main())".into());
}
4 => {
out.push("async def ag():".into());
out.push(" try:".into());
out.push(" yield 1".into());
out.push(" yield 2".into());
out.push(" finally:".into());
out.push(" pass".into());
out.push("async def main():".into());
out.push(" g = ag()".into());
out.push(" print(await g.asend(None))".into());
out.push(" await g.aclose()".into());
out.push(" print('closed')".into());
out.push("asyncio.run(main())".into());
}
5 => {
out.push("async def slow():".into());
out.push(" await asyncio.sleep(10)".into());
out.push(" return 1".into());
out.push("async def main():".into());
out.push(" try:".into());
out.push(" await asyncio.wait_for(slow(), timeout=1)".into());
out.push(" print('no')".into());
out.push(" except asyncio.TimeoutError:".into());
out.push(" print('timeout')".into());
out.push("asyncio.run(main())".into());
}
6 => {
out.push("async def fast(v):".into());
out.push(" await asyncio.sleep(0)".into());
out.push(" return v".into());
out.push("async def main():".into());
out.push(format!(
" r = await asyncio.wait_for(fast({n}), timeout=5)"
));
out.push(" print(r)".into());
out.push("asyncio.run(main())".into());
}
7 => {
out.push("async def main():".into());
out.push(" q = asyncio.Queue(2)".into());
out.push(" async def prod():".into());
out.push(format!(" for i in range({}):", n + 3));
out.push(" await q.put(i)".into());
out.push(" await q.put(-1)".into());
out.push(" async def cons():".into());
out.push(" acc = []".into());
out.push(" while True:".into());
out.push(" v = await q.get()".into());
out.push(" if v == -1:".into());
out.push(" break".into());
out.push(" acc.append(v)".into());
out.push(" await asyncio.sleep(0)".into());
out.push(" print(acc)".into());
out.push(" await asyncio.gather(prod(), cons())".into());
out.push("asyncio.run(main())".into());
}
_ => {
out.push("async def f(v, d):".into());
out.push(" await asyncio.sleep(d)".into());
out.push(" return v".into());
out.push("async def main():".into());
out.push(" t1 = asyncio.create_task(f(1, 3))".into());
out.push(" t2 = asyncio.create_task(f(2, 1))".into());
out.push(
" done, pending = await asyncio.wait([t1, t2], return_when=asyncio.FIRST_COMPLETED)"
.into(),
);
out.push(" print(len(done), len(pending))".into());
out.push(" await asyncio.wait([t1, t2])".into());
out.push("asyncio.run(main())".into());
}
}
out
}
fn gen_iterproto(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let n = 1 + r.below(5);
let probe = r.below(9) as i64;
match r.below(2) {
0 => vec![
"class S:".into(),
" def __init__(self, n): self.n = n".into(),
" def __getitem__(self, i):".into(),
" if i >= self.n: raise IndexError".into(),
" return i * i".into(),
format!("s = S({n})"),
"print(list(s))".into(),
"print(sum(s))".into(),
format!("print({probe} in s)"),
"print([x for x in s])".into(),
],
_ => vec![
"class R:".into(),
" def __init__(self, n): self.data = list(range(n))".into(),
" def __iter__(self): return iter(self.data)".into(),
" def __contains__(self, x): return x in self.data".into(),
" def __reversed__(self): return reversed(self.data)".into(),
format!("r = R({n})"),
"print(list(r))".into(),
"print(list(reversed(r)))".into(),
format!("print({probe} in r)"),
"print(sorted(r, reverse=True))".into(),
],
}
}
fn gen_generators(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let base = *pick(r, SMALLINTS);
let v1 = *pick(r, SMALLINTS);
let v2 = *pick(r, SMALLINTS);
let v3 = *pick(r, SMALLINTS);
let n = 2 + r.below(4); match r.below(10) {
0 => vec![
"def sub(base):".into(),
" a = yield base".into(),
" b = yield a + 1".into(),
" c = yield b + 1".into(),
" return a + b + c".into(),
"def deleg(base):".into(),
" r = yield from sub(base)".into(),
" print('ret', r)".into(),
format!("g = deleg({base})"),
"print(next(g))".into(),
format!("print(g.send({v1}))"),
format!("print(g.send({v2}))"),
"try:".into(),
format!(" g.send({v3})"),
"except StopIteration as e:".into(),
" print('stop', e.value)".into(),
],
1 => vec![
"def sub():".into(),
" try:".into(),
" while True:".into(),
" x = yield".into(),
" except ValueError:".into(),
" yield 'recovered'".into(),
format!(" return {v1}"),
"def deleg():".into(),
" r = yield from sub()".into(),
" print('dret', r)".into(),
"g = deleg()".into(),
"next(g)".into(),
format!("g.send({v2})"),
"print(g.throw(ValueError))".into(),
"try:".into(),
" next(g)".into(),
"except StopIteration as e:".into(),
" print('stop', e.value)".into(),
],
2 => vec![
"def sub():".into(),
" try:".into(),
" yield 1".into(),
" yield 2".into(),
" finally:".into(),
" print('sub cleanup')".into(),
"def deleg():".into(),
" yield from sub()".into(),
"g = deleg()".into(),
"print(next(g))".into(),
"g.close()".into(),
"print('closed')".into(),
],
3 => vec![
"def leaf():".into(),
" a = yield 10".into(),
" b = yield a + 1".into(),
" return b * 2".into(),
"def mid():".into(),
" r = yield from leaf()".into(),
format!(" return r + {v1}"),
"def top():".into(),
" r = yield from mid()".into(),
" print('top', r)".into(),
"g = top()".into(),
"print(next(g))".into(),
format!("print(g.send({v2}))"),
"try:".into(),
format!(" g.send({v3})"),
"except StopIteration as e:".into(),
" print('stop', e.value)".into(),
],
4 => vec![
"def g():".into(),
" total = 0".into(),
" try:".into(),
" while True:".into(),
" x = yield total".into(),
" total += x".into(),
" except ValueError:".into(),
" yield -1".into(),
"gen = g()".into(),
"print(next(gen))".into(),
format!("print(gen.send({v1}))"),
format!("print(gen.send({v2}))"),
"print(gen.throw(ValueError))".into(),
"gen.close()".into(),
"print('closed')".into(),
],
5 => vec![
"def g(n):".into(),
" for i in range(n):".into(),
" yield i".into(),
format!(" return n * {v1}"),
format!("gen = g({n})"),
"acc = []".into(),
"try:".into(),
" while True:".into(),
" acc.append(next(gen))".into(),
"except StopIteration as e:".into(),
" print(acc, e.value)".into(),
],
6 => vec![
format!("gen = (x * x for x in range({n}))"),
"print(next(gen))".into(),
"print(list(gen))".into(),
format!("print(sum(y + {v1} for y in range({n})))"),
format!("print(list(z for z in range({n}) if z % 2 == 0))"),
],
7 => vec![
"def g():".into(),
" yield -1".into(),
format!(" yield from [{v1}, {v2}]"),
format!(" yield from range({n})"),
" yield from 'ab'".into(),
format!(" r = yield from (i for i in range({v3}))"),
" print('genexp done', r)".into(),
"print(list(g()))".into(),
],
8 => vec![
"def acc():".into(),
" total = 0".into(),
" while True:".into(),
" v = yield total".into(),
" if v is None:".into(),
" break".into(),
" total += v".into(),
"gen = acc()".into(),
"next(gen)".into(),
format!("print(gen.send({v1}))"),
format!("print(gen.send({v2}))"),
format!("print(gen.send({v3}))"),
],
_ => vec![
"def g():".into(),
" try:".into(),
" yield 1".into(),
" yield 2".into(),
" finally:".into(),
" print('cleanup')".into(),
"gen = g()".into(),
"print(next(gen))".into(),
"try:".into(),
" gen.throw(RuntimeError('x'))".into(),
"except RuntimeError as e:".into(),
" print('propagated', type(e).__name__)".into(),
],
}
}
fn gen_exceptions(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let k = r.below(5) as i64;
match r.below(3) {
0 => vec![
"def risky(k):".into(),
" if k == 0: raise ValueError('bad value')".into(),
" if k == 1: return 1 // 0".into(),
" if k == 2: return [1, 2][5]".into(),
" if k == 3: raise KeyError('missing')".into(),
" return 'ok'".into(),
"try:".into(),
format!(" print('result', risky({k}))"),
"except ValueError as e:".into(),
" print('ValueError', e)".into(),
"except (IndexError, ZeroDivisionError) as e:".into(),
" print('arith/index', type(e).__name__)".into(),
"except Exception as e:".into(),
" print('other', type(e).__name__)".into(),
"finally:".into(),
" print('done')".into(),
],
1 => vec![
"def g():".into(),
" try:".into(),
format!(" if {k} < 3: raise ValueError('x')"),
" return 'clean'".into(),
" except ValueError:".into(),
" print('inner handling')".into(),
" raise".into(),
"try:".into(),
" print('got', g())".into(),
"except ValueError as e:".into(),
" print('reraised', e)".into(),
],
_ => vec![
"x = 0".into(),
"try:".into(),
format!(" x = 10 // {k}"),
"except ZeroDivisionError:".into(),
" x = -1".into(),
"else:".into(),
" x += 100".into(),
"finally:".into(),
" x += 1".into(),
"print(x)".into(),
],
}
}
fn gen_unpacking(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let a = pick(r, SMALLINTS);
let b = pick(r, SMALLINTS);
let c = pick(r, SMALLINTS);
let n = 3 + r.below(4);
match r.below(6) {
0 => vec![format!("a, *b, c = [{a}, {b}, {c}, 7, 8]\nprint(a, b, c)")],
1 => vec![format!("first, *rest = range({n})\nprint(first, rest)")],
2 => vec![format!("*init, last = [{a}, {b}, {c}]\nprint(init, last)")],
3 => vec![format!("(x, y), z = ({a}, {b}), {c}\nprint(x, y, z)")],
4 => vec![
"def f(p, q, r): return p * 100 + q * 10 + r".to_string(),
format!("args = [{a}, {b}, {c}]"),
"print(f(*args))".into(),
format!("print(*[{a}, {b}, {c}], sep='-')"),
],
_ => vec![
format!("d1 = {{'a': {a}, 'b': {b}}}"),
format!("d2 = {{'b': {c}, 'c': 9}}"),
"print({**d1, **d2})".into(),
format!("print([*[{a}, {b}], *[{c}]])"),
],
}
}
fn gen_comprehension(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let n = 3 + r.below(5);
let m = 2 + r.below(4);
let k = pick(r, POSINTS);
match r.below(6) {
0 => vec![format!("print([x * x for x in range({n})])")],
1 => vec![format!("print([x for x in range({n}) if x % {k} == 0])")],
2 => vec![format!("print(sorted({{x % {k} for x in range({n})}}))")],
3 => vec![format!("print({{x: x * x for x in range({n})}})")],
4 => vec![format!(
"print([x * y for x in range({m}) for y in range({m})])"
)],
_ => vec![format!("print(sum(x * x for x in range({n})))")],
}
}
fn gen_dictset(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let a = pick(r, SMALLINTS);
let b = pick(r, SMALLINTS);
let c = pick(r, SMALLINTS);
let d = pick(r, SMALLINTS);
match r.below(8) {
0 => vec![format!(
"print(sorted({{{a}, {b}, {c}}} | {{{b}, {c}, {d}}}))"
)],
1 => vec![format!(
"print(sorted({{{a}, {b}, {c}}} & {{{b}, {c}, {d}}}))"
)],
2 => vec![format!(
"print({{{a}, {b}}} <= {{{a}, {b}, {c}}}, {{{a}, {b}}} < {{{a}, {b}}})"
)],
3 => vec![
format!("fs = frozenset([{a}, {b}, {c}])"),
"m = {fs: 'v'}".to_string(),
format!("print(m[frozenset([{c}, {b}, {a}])])"),
"print(isinstance(fs, frozenset), isinstance(fs, set))".into(),
],
4 => vec![
format!("dd = {{{a}: 1, {b}: 2, {c}: 3}}"),
"print(sorted(dd.keys()))".into(),
"print(sorted(dd.values()))".into(),
format!("print(sorted(dd.keys() | {{{d}}}))"),
],
5 => vec![
format!("dd = {{{a}: 1, {b}: 2}}"),
"print(type(dd.keys()).__name__)".into(),
"print(len(dd.items()))".into(),
format!("print(dict.fromkeys([{a}, {b}, {c}], 0))"),
],
6 => vec![
format!("d1 = {{'a': {a}}}"),
format!("d2 = {{'b': {b}}}"),
"print(d1 | d2)".into(),
format!("d1.update(c={c})\nprint(d1)"),
],
_ => vec![format!(
"print(sorted({{{a}, {b}, {c}}}.symmetric_difference([{b}, {c}, {d}])))"
)],
}
}
fn gen_itertools(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let a = pick(r, SMALLINTS);
let b = pick(r, SMALLINTS);
let c = pick(r, SMALLINTS);
let s = pick(r, POSINTS);
match r.below(6) {
0 => vec![
format!("z = zip([{a}, {b}], [{c}, 9])"),
"print(next(z))".into(),
"print(list(z))".into(),
"print(next(z, 'end'))".into(),
],
1 => vec![format!(
"print(list(map(lambda t: t * 2, [{a}, {b}, {c}])))"
)],
2 => vec![format!(
"print(list(filter(lambda t: t > {b}, [{a}, {b}, {c}, 9])))"
)],
3 => vec![format!(
"print(list(enumerate([{a}, {b}, {c}], start={s})))"
)],
4 => vec![
format!("rv = reversed([{a}, {b}, {c}])"),
"print(next(rv))".into(),
"print(list(rv))".into(),
],
_ => vec![
"def cnt():".into(),
" i = 0".into(),
" while True:".into(),
" yield i".into(),
" i += 1".into(),
format!("print(list(zip(cnt(), [{a}, {b}, {c}])))"),
],
}
}
fn gen_complexnum(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let a = 1 + r.below(5);
let b = 1 + r.below(5);
let c = 1 + r.below(5);
let d = 1 + r.below(5);
match r.below(6) {
0 => vec![format!("print(({a}+{b}j) + ({c}+{d}j))")],
1 => vec![format!("print(({a}+{b}j) * ({c}+{d}j))")],
2 => vec![format!("print(({a}+{b}j) - ({c}+{d}j))")],
3 => vec![format!("print(complex({a}, {b}).conjugate())")],
4 => vec![format!(
"z = {a}+{b}j\nprint(z.real, z.imag, abs(z) == abs(z))"
)],
_ => vec![format!("print(({a}+{b}j) ** 2)")],
}
}
fn gen_numedge(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
const SI: &[&str] = &[
"7", "-7", "3", "-3", "10", "-10", "42", "-42", "1", "-1", "0",
];
const SD: &[&str] = &["3", "-3", "2", "-2", "4", "-4", "5", "-5"];
const FL: &[&str] = &[
"7.5", "-7.5", "2.5", "-2.5", "0.5", "-0.5", "10.25", "-10.25", "3.0", "1.5",
];
const PRIMES: &[&str] = &["7", "11", "13", "17"];
let a = pick(r, SI);
let b = pick(r, SD);
let f = pick(r, FL);
let g = pick(r, SD);
match r.below(20) {
0 => vec![
"print(float('inf'), float('-inf'), float('nan'))\n\
print(float('inf') > 1e308, float('nan') == float('nan'), float('nan') != float('nan'))\n\
print(float('inf') + 1, float('inf') - float('inf'), float('nan') + 1)".to_string()
],
1 => vec![
"print(repr(-0.0), repr(0.0), 0.0 == -0.0, repr(-0.0) == repr(0.0))\n\
print(1e308 * 10, -1e308 * 10, repr(float('inf')))\n\
print(round(-0.0), repr(round(-0.0)))".to_string()
],
2 => vec![
"print(round(0.5), round(1.5), round(2.5), round(3.5), round(-0.5), round(-1.5), round(-2.5))".to_string()
],
3 => vec![format!(
"print(round({f}), round({f}, 1), round({f}, 0), round({f}, 2))"
)],
4 => {
let n = pick(r, &["1234567", "-1234567", "15", "25", "-15", "250"]);
let d = pick(r, &["-1", "-2", "-3"]);
vec![format!("print(round({n}, {d}), round({n}))")]
}
5 => vec![
"print(round(0.125, 2), round(0.375, 2), round(2.675, 2), round(1.005, 2))".to_string()
],
6 => {
let base = pick(r, &["2", "3", "4", "5"]);
let e = pick(r, &["2", "3", "8", "10", "0"]);
vec![format!(
"print(pow({base}, {e}), {base} ** {e}, pow({base}, {e}, 1000))"
)]
}
7 => {
let base = pick(r, &["2", "3", "4", "5", "6"]);
let m = pick(r, PRIMES);
vec![format!("print(pow({base}, -1, {m}), pow({base}, -3, {m}))")]
}
8 => vec![
"print(2 ** 0.5, 4 ** 0.5, 2 ** -2, 2 ** -3, (-2) ** 2, -2 ** 2, 2 ** 3 ** 2)".to_string()
],
9 => vec![format!(
"print(divmod({a}, {b}), {a} // {b}, {a} % {b})"
)],
10 => vec![
"print(7 // 3, -7 // 3, 7 // -3, -7 // -3, 7 % 3, -7 % 3, 7 % -3, -7 % -3)".to_string()
],
11 => vec![format!(
"print(divmod({f}, {g}), {f} // {g}, {f} % {g})"
)],
12 => vec![
"print(7.5 // 2, -7.5 // 2, 7.5 % 2, -7.5 % 2, 10.5 % -3, -10.5 % 3)".to_string()
],
13 => {
let n = pick(r, &["255", "-255", "10", "-10", "4096", "0"]);
vec![format!("print(bin({n}), oct({n}), hex({n}))")]
}
14 => vec![
"print(int('ff', 16), int('-1010', 2), int('777', 8), int('0x1f', 16), int('1_000'), 0x1f, 0o17, 0b1010)".to_string()
],
15 => vec![format!(
"print(int({f}), int(-{f}), int(2.0 ** 60), float('1.5e3'), float(' 2.5 '), float('1_000'))"
)],
16 => {
let (x, y, z, w) = (1 + r.below(5), 1 + r.below(5), 1 + r.below(5), 1 + r.below(5));
vec![format!(
"print(({x}+{y}j) + ({z}+{w}j), ({x}+{y}j) * ({z}+{w}j), ({x}+{y}j) / ({z}+{w}j))"
)]
}
17 => {
let (x, y) = (1 + r.below(6), 1 + r.below(6));
vec![format!(
"z = complex({x}, -{y})\nprint(z.real, z.imag, z.conjugate(), abs(z), ({x}+{y}j) ** 2)"
)]
}
18 => {
let k = 2 + r.below(4);
vec![format!(
"class Idx:\n def __index__(self): return {k}\ni = Idx()\n\
print(bin(i), hex(i), oct(i), int(i), float(i))\n\
print([0,10,20,30,40,50,60][i], 'abcdefgh'[i], (5,6,7,8,9,10)[i], range(30)[i])"
)]
}
_ => {
let iv = pick(r, SI);
let fv = pick(r, FL);
vec![format!(
"class N:\n def __int__(self): return {iv}\nclass F:\n def __float__(self): return {fv}\nclass B:\n def __bool__(self): return {}\n\
print(int(N()), float(F()), bool(B()))\n\
print(abs({iv}), abs({fv}), -{iv}, +{fv}, abs(3+4j))\n\
print(int(True), int(False), True + 1, float(True), bool(0), bool(0.0), bool(0j))",
if r.below(2) == 0 { "True" } else { "False" }
)]
}
}
}
fn gen_exceptions2(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let excs = ["ValueError", "TypeError", "KeyError", "RuntimeError"];
let e1 = excs[r.below(excs.len() as u64) as usize];
let e2 = excs[r.below(excs.len() as u64) as usize];
match r.below(3) {
0 => vec![
"try:".into(),
" try:".into(),
format!(" raise {e1}('inner')"),
format!(" except {e1} as e:"),
format!(" raise {e2}('outer') from e"),
format!("except {e2} as t:"),
" print(type(t.__cause__).__name__, t.__suppress_context__)".into(),
],
1 => vec![
"try:".into(),
" try:".into(),
format!(" raise {e1}('a')"),
format!(" except {e1}:"),
format!(" raise {e2}('b')"),
format!("except {e2} as t:"),
" print(type(t.__context__).__name__, t.__cause__)".into(),
],
_ => vec![
"class E(Exception): pass".into(),
"try:".into(),
format!(" raise E('x') from {e1}('c')"),
"except E as e:".into(),
" print(type(e.__cause__).__name__)".into(),
],
}
}
fn gen_exceptions3(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let a = pick(r, WORDS);
let b = pick(r, WORDS);
let n = pick(r, POSINTS);
match r.below(6) {
0 => vec![
"class E(Exception): pass".into(),
format!("e = E({a})"),
"print(str(e), repr(e), e.args)".into(),
"print(isinstance(e, Exception), isinstance(e, E))".into(),
],
1 => vec![
"class E(Exception): pass".into(),
format!("e = E({a}, {b})"),
"print(str(e))".into(),
"print(repr(e))".into(),
"print(e.args)".into(),
"print(str(E()), repr(E()), E().args)".into(),
],
2 => vec![
"class E(Exception):".into(),
" def __init__(self, code):".into(),
" super().__init__('err:' + str(code))".into(),
" self.code = code".into(),
format!("e = E({n})"),
"print(str(e), e.args, e.code)".into(),
format!(
"try:\n raise E({n})\nexcept E as x:\n print('caught', x, x.code, x.args)"
),
],
3 => vec![
"class E(Exception):".into(),
" def __str__(self): return 'S:' + str(self.args)".into(),
format!("e = E({a})"),
"print(str(e), repr(e))".into(),
],
4 => vec![
"class Base(Exception): pass".into(),
"class Mid(Base): pass".into(),
"class Leaf(Mid): pass".into(),
format!("e = Leaf({a})"),
"print(isinstance(e, Base), isinstance(e, Mid), isinstance(e, Exception))".into(),
"print(str(e), e.args, type(e).__name__)".into(),
],
_ => vec![
"class MyVal(ValueError): pass".into(),
format!(
"try:\n raise MyVal({a})\nexcept ValueError as e:\n print(str(e), e.args, isinstance(e, ValueError), type(e).__name__)"
),
],
}
}
fn gen_exceptions4(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let n = pick(r, POSINTS);
let k = r.below(4) as i64;
let excs = ["ValueError", "TypeError", "KeyError", "IndexError"];
let e1 = excs[r.below(excs.len() as u64) as usize];
let e2 = excs[r.below(excs.len() as u64) as usize];
match r.below(12) {
0 => vec![
"def f(k):".into(),
" try:".into(),
" if k: return 'from_try'".into(),
" return 'no_k'".into(),
" finally:".into(),
" print('finally ran')".into(),
format!("print(f({}))", k),
],
1 => vec![
"def f():".into(),
" try:".into(),
" return 'try'".into(),
" finally:".into(),
" return 'finally'".into(),
"print(f())".into(),
],
2 => vec![
"log = []".into(),
format!("for i in range({n}):"),
" try:".into(),
format!(" if i == {k}: break"),
" log.append(i)".into(),
" finally:".into(),
" log.append('f%d' % i)".into(),
"print(log)".into(),
],
3 => vec![
"log = []".into(),
format!("for i in range({n}):"),
" try:".into(),
format!(" if i == {k}: continue"),
" log.append(i)".into(),
" finally:".into(),
" log.append('f%d' % i)".into(),
" log.append('tail%d' % i)".into(),
"print(log)".into(),
],
4 => vec![
"def f(k):".into(),
" order = []".into(),
" try:".into(),
" if k: raise ValueError('x')".into(),
" order.append('body')".into(),
" except ValueError:".into(),
" order.append('except')".into(),
" else:".into(),
" order.append('else')".into(),
" finally:".into(),
" order.append('finally')".into(),
" return order".into(),
format!("print(f({}))", k),
],
5 => vec![
"class MyErr(ValueError): pass".into(),
"def f(k):".into(),
" try:".into(),
format!(" if k == 0: raise {e1}('a')"),
" if k == 1: raise MyErr('b')".into(),
" return 'ok'".into(),
format!(" except ({e1}, TypeError) as e:"),
" return ('tuple', type(e).__name__)".into(),
" except ValueError as e:".into(),
" return ('subclass', type(e).__name__)".into(),
format!("print(f({}))", k),
],
6 => vec![
"try:".into(),
format!(" raise {e1}('boom')"),
format!(" _ = {e2}"),
format!("except {e1} as e:"),
" print('inside', type(e).__name__)".into(),
"print('e' in dir())".into(),
],
7 => vec![
"def f(k):".into(),
" try:".into(),
format!(" if k == 0: raise {e1}('a')"),
" if k == 1: return 1 // 0".into(),
" return [1][9]".into(),
" except:".into(),
" return 'caught'".into(),
format!("print(f({}))", k),
],
8 => vec![
"try:".into(),
" try:".into(),
format!(" raise {e1}('inner')"),
format!(" except {e1} as e:"),
format!(" raise {e2}('outer') from e"),
format!(" except {e1}:"),
" print('unreached')".into(),
format!("except {e2} as t:"),
" print(type(t.__cause__).__name__, t.__suppress_context__)".into(),
],
9 => vec![
"try:".into(),
" try:".into(),
format!(" raise {e1}('first')"),
format!(" except {e1}:"),
" d = {}".into(),
" d['missing']".into(),
"except KeyError as e:".into(),
" print(type(e).__name__, str(e), type(e.__context__).__name__)".into(),
],
10 => vec![
format!("d = {{'a': {n}}}"),
"try:".into(),
" d['zzz']".into(),
"except KeyError as e:".into(),
" print(str(e), repr(e), e.args)".into(),
"print(str(KeyError('k')), repr(KeyError('k')), KeyError(1, 2).args)".into(),
],
_ => vec![
"def g(k):".into(),
" try:".into(),
format!(" if k: raise {e1}('deep')"),
" return 'clean'".into(),
format!(" except {e1}:"),
" print('logging')".into(),
" raise".into(),
"try:".into(),
format!(" print('got', g({}))", k),
format!("except {e1} as e:"),
" print('reraised', type(e).__name__, e)".into(),
],
}
}
fn gen_closures(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let a = pick(r, POSINTS);
let b = pick(r, POSINTS);
let n = 2 + r.below(4);
match r.below(6) {
0 => vec![
"def make():".into(),
" count = 0".into(),
" def inc():".into(),
" nonlocal count".into(),
" count += 1".into(),
" return count".into(),
" return inc".into(),
"c = make()".into(),
"print(c(), c(), c())".into(),
],
1 => vec![
"fs = []".into(),
format!("for i in range({n}):"),
" fs.append(lambda: i)".into(),
"print([f() for f in fs])".into(),
],
2 => vec![
"fs = []".into(),
format!("for i in range({n}):"),
" fs.append(lambda i=i: i * 2)".into(),
"print([f() for f in fs])".into(),
],
3 => vec![
"def mul(factor):".into(),
" def deco(fn):".into(),
" def wrap(x): return fn(x) * factor".into(),
" return wrap".into(),
" return deco".into(),
format!("@mul({a})"),
"def f(x): return x + 1".into(),
format!("print(f({b}))"),
],
4 => vec![
"def logged(fn):".into(),
" def w(*args, **kw):".into(),
" return fn(*args, **kw)".into(),
" return w".into(),
"@logged".into(),
"def add(a, b): return a + b".into(),
format!("print(add({a}, b={b}))"),
],
_ => vec![
"def outer(x):".into(),
" def middle(y):".into(),
" def inner(z): return x + y + z".into(),
" return inner".into(),
" return middle".into(),
format!("print(outer({a})({b})(1))"),
],
}
}
fn gen_scoping(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let a = pick(r, POSINTS);
let b = pick(r, POSINTS);
let n = 2 + r.below(3); match r.below(25) {
0 => vec![
format!("x = {a}"),
"def f():".into(),
format!(" x = {b}"),
" return x".into(),
"print(f(), x)".into(),
],
1 => vec![
format!("x = {a}"),
"def f():".into(),
" return x + 1".into(),
"print(f())".into(),
],
2 => vec![
"def outer():".into(),
format!(" z = {a}"),
" def inner():".into(),
format!(" return z + {b}"),
" return inner()".into(),
"print(outer())".into(),
],
3 => vec![
"def f(v):".into(),
" return len(v) + abs(-1)".into(),
format!("print(f([0] * {a}))"),
],
4 => vec![
format!("c = {a}"),
"def f():".into(),
" global c".into(),
format!(" c += {b}"),
"f()".into(),
"print(c)".into(),
],
5 => vec![
"def f():".into(),
" global made".into(),
format!(" made = {a}"),
"f()".into(),
"print(made)".into(),
],
6 => vec![
"def make():".into(),
format!(" n = {a}"),
" def inc():".into(),
" nonlocal n".into(),
" n += 1".into(),
" return n".into(),
" return inc".into(),
"c = make()".into(),
"print(c(), c(), c())".into(),
],
7 => vec![
"def a():".into(),
format!(" x = {a}"),
" def b():".into(),
" def c():".into(),
" nonlocal x".into(),
format!(" x = {b}"),
" c()".into(),
" b()".into(),
" return x".into(),
"print(a())".into(),
],
8 => vec![
format!("fs = [lambda: i for i in range({n})]"),
"print([f() for f in fs])".into(),
],
9 => vec![
format!("fs = [lambda i=i: i for i in range({n})]"),
"print([f() for f in fs])".into(),
],
10 => vec![
format!("[i for i in range({n})]"),
"try:".into(),
" print(i)".into(),
"except NameError:".into(),
" print('unbound')".into(),
],
11 => vec![
"def f():".into(),
format!(" r = [(y := v) for v in range({n})]"),
" return (r, y)".into(),
"print(f())".into(),
],
12 => vec![
format!("x = {a}"),
"def f():".into(),
" print(x)".into(),
format!(" x = {b}"),
"f()".into(),
],
13 => vec!["def f():".into(), format!(" x += {a}"), "f()".into()],
14 => vec![
"def f(c):".into(),
format!(" if c: y = {a}"),
" return y".into(),
"print(f(0))".into(),
],
15 => vec![
"def f():".into(),
format!(" x = {a}"),
" del x".into(),
" return x".into(),
"f()".into(),
],
16 => vec![
"def f():".into(),
" def g():".into(),
" nonlocal q".into(),
format!(" q = {a}"),
" g()".into(),
"f()".into(),
],
17 => vec!["nonlocal z".into()],
18 => vec![
format!("x = {a}"),
"class C:".into(),
format!(" x = {b}"),
" def m(self):".into(),
" return x".into(),
"print(C().m(), C.x)".into(),
],
19 => vec![
format!("v = {a}"),
"class C:".into(),
format!(" v = {b}"),
format!(" got = [v for _ in range({n})]"),
"print(C.got)".into(),
],
20 => vec![
"def outer():".into(),
" def inner(): pass".into(),
" return inner".into(),
"f = outer()".into(),
"print(f.__name__, f.__qualname__, f.__module__)".into(),
],
21 => vec![
"class A:".into(),
" class B:".into(),
" def m(self): pass".into(),
"print(A.__qualname__, A.B.__qualname__, A.B.m.__qualname__)".into(),
],
22 => vec![
format!("def f(p, q={a}, r={b}): return p"),
"print(f.__defaults__)".into(),
],
23 => vec![
"def f(p, *, k): return p".into(),
"print(f.__defaults__)".into(),
],
_ => vec![
"def make():".into(),
" class Inner: pass".into(),
" return Inner".into(),
"print(make().__qualname__, make().__name__)".into(),
],
}
}
fn gen_calls(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let a = pick(r, POSINTS);
let b = pick(r, POSINTS);
let c = pick(r, POSINTS);
let d = pick(r, POSINTS);
match r.below(24) {
0 => vec![
"def f(p, q, /, r, *args, k, m=9, **kw):".into(),
" return (p, q, r, args, k, m, sorted(kw.items()))".into(),
format!("print(f({a}, {b}, {c}, 100, 200, k={d}, x=1, y=2))"),
],
1 => vec![
"def f(*args, **kw): return (args, sorted(kw.items()))".into(),
format!("print(f({a}, {b}, {c}, u={d}, v=1, w=2))"),
],
2 => vec![
"def f(a, b=2, *rest, c, d=4, **kw):".into(),
" return (a, b, rest, c, d, sorted(kw.items()))".into(),
format!("print(f({a}, {b}, 7, 8, c={c}, z=9))"),
],
3 => vec![
"def f(x, y, /, z): return (x, y, z)".into(),
format!("print(f({a}, {b}, z={c}))"),
],
4 => vec![
"def f(a, b, c, d): return (a, b, c, d)".into(),
format!("print(f(*[{a}, {b}], *({c},), {d}))"),
],
5 => vec![
"def f(a, b, c): return (a, b, c)".into(),
format!("print(f({a}, **{{'b': {b}, 'c': {c}}}))"),
],
6 => vec![
"def f(*args, **kw): return (args, sorted(kw.items()))".into(),
format!("print(f(*[{a}], *[{b}, {c}], **{{'p': 1}}, **{{'q': 2}}))"),
],
7 => vec![
"def f(v, acc=[]):".into(),
" acc.append(v)".into(),
" return list(acc)".into(),
format!("print(f({a}))"),
format!("print(f({b}))"),
format!("print(f({c}))"),
],
8 => vec![
format!("BASE = {a}"),
"def f(x, step=10): return x + step".into(),
format!("print(f(BASE), f(BASE, {b}))"),
],
9 => vec![
"def f(a, b, c): return (a, b, c)".into(),
format!("print(f(c={c}, a={a}, b={b}))"),
],
10 => vec![
"def f(a, b, c, d): return (a, b, c, d)".into(),
format!("print(f({a}, {b}, d={d}, c={c}))"),
],
11 => vec![
"f = lambda a, b=3, *c, d, **e: (a, b, c, d, sorted(e.items()))".into(),
format!("print(f({a}, {b}, 9, d={d}, z=5))"),
],
12 => vec![
"def inner(a, b, c): return a * 100 + b * 10 + c".into(),
"def outer(*args, **kw): return inner(*args, **kw)".into(),
format!("print(outer({a}, {b}, c={c}))"),
],
13 => vec![
"def f(a, *, b, c=7): return (a, b, c)".into(),
format!("print(f({a}, b={b}))"),
],
14 => vec![
"def f(a, /, **kw): return (a, sorted(kw.items()))".into(),
format!("print(f({a}, a={b}, z={c}))"),
],
15 => vec![
"def f(a, *args): return (a, args)".into(),
format!("print(f({a}))"),
],
16 => {
let params = ["a, b", "a, b, c", "a, b, c, d"][r.below(3) as usize];
let given = match r.below(2) {
0 => String::new(),
_ => a.to_string(),
};
vec![
format!("def f({params}): return 0"),
format!("print(f({given}))"),
]
}
17 => match r.below(3) {
0 => vec![
"def f(a, b): return 0".into(),
format!("print(f({a}, {b}, {c}))"),
],
1 => vec![
"def f(a, b=2): return 0".into(),
format!("print(f({a}, {b}, {c}, {d}))"),
],
_ => vec![
"def f(a): return 0".into(),
format!("print(f(*[{a}, {b}]))"),
],
},
18 => vec![
"def f(a, b): return 0".into(),
format!("print(f({a}, a={b}))"),
],
19 => vec![
"def f(a, b): return 0".into(),
format!("print(f({a}, {b}, zz={c}))"),
],
20 => vec![
"def f(a, b, /): return 0".into(),
format!("print(f({a}, b={b}))"),
],
21 => match r.below(2) {
0 => vec!["def f(a, *, k): return 0".into(), format!("print(f({a}))")],
_ => vec!["def f(*, k, m): return 0".into(), "print(f())".into()],
},
22 => match r.below(2) {
0 => vec![
"def f(a, b): return 0".into(),
format!("print(f(**{{'a': {a}}}, **{{'a': {b}, 'b': {c}}}))"),
],
_ => vec![
"def f(a): return 0".into(),
format!("print(f(a={a}, **{{'a': {b}}}))"),
],
},
_ => vec![
"def f(a, *, k=1): return 0".into(),
format!("print(f({a}, {b}, {c}))"),
],
}
}
fn gen_oop2(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let a = pick(r, SMALLINTS);
match r.below(5) {
0 => vec![
"class A:".into(),
" def who(self): return 'A'".into(),
"class B(A):".into(),
" def who(self): return 'B'".into(),
"class C(A):".into(),
" def who(self): return 'C'".into(),
"class D(B, C): pass".into(),
"print(D().who())".into(),
"print([c.__name__ for c in D.__mro__])".into(),
],
1 => vec![
"class A:".into(),
" @property".into(),
" def v(self): return 10".into(),
"class B(A):".into(),
" @property".into(),
" def v(self): return super().v + 1".into(),
"print(B().v)".into(),
],
2 => vec![
"class P:".into(),
" def __init_subclass__(cls, /, tag=None, **kw):".into(),
" cls.tag = tag".into(),
format!("class C(P, tag={a}): pass"),
"print(C.tag)".into(),
],
3 => vec![
"class Shape:".into(),
" def __init__(self, n): self.n = n".into(),
" @classmethod".into(),
" def unit(cls): return cls(1)".into(),
" @classmethod".into(),
format!(" def scaled(cls, k): return cls({a} + k)"),
"print(Shape.unit().n, Shape.scaled(3).n)".into(),
],
_ => vec![
"class A:".into(),
" x = 1".into(),
"class B:".into(),
" x = 2".into(),
" y = 3".into(),
"class C(A, B): pass".into(),
"print(C.x, C.y)".into(),
"print([k.__name__ for k in C.__mro__])".into(),
],
}
}
fn gen_strfmt2(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let a = pick(r, SMALLINTS);
let b = pick(r, SMALLINTS);
match r.below(6) {
0 => vec![format!("xs = [{a}, {b}]\nprint(f'{{xs!r}}|{{xs!s}}')")],
1 => vec![format!("d = {{'k': {a}, 'j': {b}}}\nprint(f'{{d!r}}')")],
2 => vec![format!("t = ({a}, {b})\nprint('%r %s' % (t, t))")],
3 => vec![format!("print('{{0}}-{{1}}-{{0}}'.format({a}, {b}))")],
4 => vec![
format!("v = {a}"),
format!("w = {b}"),
"print(f'{v:+05d} {w:>6d}')".into(),
],
_ => vec![format!(
"print('%d/%o/%x/%X' % ({a}, abs({b}), abs({a}), abs({b})))"
)],
}
}
const BLIT: &[&str] = &[
"b'hello'",
"b'World'",
"b'abcabc'",
"b''",
"b'a'",
"b'foo bar'",
"b'a,b,c'",
"b' pad '",
"b'AbC'",
"b'x-y-z'",
"b'ab.cd.ef'",
"b\"a'b\"",
"b'a\"b'",
"b'tab\\ther'",
"b'\\x00\\xff'",
];
const BSEP: &[&str] = &["b','", "b'-'", "b'.'", "b' '", "b'a'", "b'X'", "b'cd'"];
const BDEC: &[&str] = &["b'hello'", "b'World'", "b'abc'", "b''", "b'A,B,C'"];
fn gen_bytesops(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let b = pick(r, BLIT);
let b2 = pick(r, BLIT);
let sep = pick(r, BSEP);
let idx = pick(r, &["0", "1", "2", "-1", "-2", "3"]);
let jdx = pick(r, &["0", "1", "2", "3", "-1", "5"]);
let n = r.below(3);
let e = match r.below(26) {
0 => format!("print({b})"),
1 => format!("print(bytearray({b}))"),
2 => format!("print(repr({b}), repr(bytearray({b})))"),
3 => format!("print({b}[{idx}:{jdx}], {b}[::-1], {b}[::2])"),
4 => format!("print({b} + {b2}, bytearray({b}) + {b2})"),
5 => format!("print({b} * {n}, {n} * bytearray({b}))"),
6 => format!("print({sep} in {b}, 97 in {b}, 300 not in {b})"),
7 => format!("print({b}.split({sep}), {b}.split())"),
8 => format!("print({b}.rsplit({sep}, 1), {b}.rsplit())"),
9 => format!("print({sep}.join([b'a', b'b', b'c']), bytearray({sep}).join([{b}]))"),
10 => format!("print({b}.replace({sep}, b'YY'), {b}.replace({sep}, b'', 1))"),
11 => format!("print({b}.find({sep}), {b}.rfind({sep}), {b}.count({sep}))"),
12 => format!("print({b}.startswith({sep}), {b}.endswith({sep}))"),
13 => format!("print({b}.strip(), {b}.lstrip(), {b}.rstrip())"),
14 => "print(b'xxhelloxx'.strip(b'x'), b'--a--'.lstrip(b'-'))".to_string(),
15 => format!("print({b}.upper(), {b}.lower())"),
16 => "print(b'a\\nb\\r\\nc\\rd'.splitlines(), b'a\\nb\\n'.splitlines(True))".to_string(),
17 => format!("print({b}.partition({sep}), {b}.rpartition({sep}))"),
18 => format!("print({b}.removeprefix(b'a'), {b}.removesuffix(b'c'))"),
19 => format!("print(bytes.fromhex('48656c6c6f20'), {b}.hex())"),
20 => "print(bytes([72, 105]), bytes(3), bytearray([65, 66]))".to_string(),
21 => format!("print(list({b}), len({b}))"),
22 => {
let d = pick(r, BDEC);
format!("print({d}.decode('utf-8'), {d}.decode('ascii'))")
}
23 => {
let v = 65 + r.below(20);
format!("ba = bytearray(b'abcdef')\nba[{idx}] = {v}\nprint(ba)")
}
24 => format!("ba = bytearray(b'abcdef')\nba[{idx}:{jdx}] = b'XY'\nprint(ba)"),
_ => format!("print({b} < {b2}, {b} == bytearray({b}), {b} != {b2})"),
};
vec![e]
}
fn gen_bytestail(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
const TLIT: &[&str] = &[
"b'hello world'",
"b'Hello World'",
"b'ABC def'",
"b\"they're bill's\"",
"b'x1x y2y'",
"b'MixedCase'",
"b' spaced '",
"b'abc123'",
"b'ABC123'",
"b' '",
"b''",
];
let b = pick(r, TLIT);
let fill = pick(r, &["b'*'", "b'.'", "b'-'", "b'0'"]);
let w = pick(r, &["6", "8", "10", "3", "0"]);
const PCT: &[&str] = &[
"b'%d-%s' % (42, b'x')",
"b'%5d|%-5d|%05d' % (3, 3, 3)",
"b'%x/%X/%#o' % (255, 255, 8)",
"b'%c%c%c' % (72, 105, 33)",
"b'%b and %s' % (b'A', b'B')",
"b'%a|%r' % (b'\\xff', b'ok')",
"b'%.2f|%+.1f|% d' % (3.14159, 2.5, 7)",
"b'%(x)s-%(y)d' % {b'x': b'hi', b'y': 9}",
"b'%*d|%-*d|' % (6, 3, 6, 3)",
"b'%s' % bytearray(b'ba')",
"bytearray(b'%d.%d') % (1, 2)",
"b'%%literal%% %d' % (5,)",
];
let idx = pick(r, &["0", "1", "2", "-1", "-2", "7"]);
let e = match r.below(24) {
0 => format!("print({b}.swapcase())"),
1 => format!("print({b}.title())"),
2 => format!("print({b}.title(), bytearray({b}).title())"),
3 => format!("print({b}.center({w}, {fill}), {b}.center({w}))"),
4 => format!("print({b}.ljust({w}, {fill}), {b}.rjust({w}, {fill}))"),
5 => format!("print({b}.ljust({w}), {b}.rjust({w}))"),
6 => format!("print({b}.isalpha(), {b}.isdigit(), {b}.isalnum())"),
7 => format!("print({b}.isspace(), {b}.isupper(), {b}.islower())"),
8 => format!("print({b}.istitle(), {b}.isascii())"),
9 => format!("print(bytearray({b}).swapcase(), bytearray({b}).isupper())"),
10 => {
"t = bytes.maketrans(b'abcABC', b'xyzXYZ')\n\
print(b'aAbBcCd'.translate(t))"
.to_string()
}
11 => {
"t = bytes.maketrans(b'abc', b'xyz')\n\
print(b'aabbccd'.translate(t, b'a'), b'aabbcc'.translate(None, b'b'))"
.to_string()
}
12 => format!("print(bytearray({b}).translate(bytes.maketrans(b'lo', b'LO')))"),
13 => "print(bytes.maketrans(b'', b''))".to_string(),
14 => {
let p = pick(r, PCT);
format!("print({p})")
}
15 => {
let p = pick(r, PCT);
format!("print({p})")
}
16 => {
let p = pick(r, PCT);
format!("v = {p}\nprint(v, type(v).__name__)")
}
17 => format!("ba = bytearray(b'abcdefgh')\ndel ba[{idx}]\nprint(ba)"),
18 => {
let a = pick(r, &["1", "2", "3"]);
let c = pick(r, &["4", "5", "6", "8"]);
format!("ba = bytearray(b'abcdefgh')\ndel ba[{a}:{c}]\nprint(ba)")
}
19 => {
let k = pick(r, &["2", "3", "-1", "-2"]);
format!("ba = bytearray(b'abcdefgh')\ndel ba[::{k}]\nprint(ba)")
}
20 => "ba = bytearray(b'abcdef')\ndel ba[1:4]\ndel ba[0]\nprint(ba)".to_string(),
21 => "print(b'a\\xffb'.decode('utf-8', 'ignore'), b'a\\xffb'.decode('utf-8', 'replace'))"
.to_string(),
22 => {
"print(b'x\\x80y'.decode('ascii', 'ignore'), b'x\\x80y'.decode('ascii', errors='replace'))"
.to_string()
}
_ => "print(b'\\xe2\\x28\\xa1'.decode('utf-8', 'replace'), b'ab\\xc3'.decode('utf-8', 'ignore'))"
.to_string(),
};
vec![e]
}
fn gen_format2(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let w = pick(r, &["4", "6", "8", "10", "12"]);
let p = pick(r, &["1", "2", "3", "4"]);
let f = pick(r, &["3.14159", "2.5", "12345.678", "0.5", "-7.25"]);
let s = pick(r, WORDS);
let a = pick(r, INTS);
let b = pick(r, INTS);
let e = match r.below(15) {
0 => format!("print('{{:{{}}}}'.format({s}, {w}))"),
1 => format!("print('{{:.{{}}f}}'.format({f}, {p}))"),
2 => format!("print('{{:{{}}.{{}}f}}'.format({f}, {w}, {p}))"),
3 => format!("print('{{:>{{wd}}.{{pr}}f}}'.format({f}, wd={w}, pr={p}))"),
4 => format!("print('{{name}}'.format(name={s}))"),
5 => format!("print('{{0}}-{{1}}-{{0}}'.format({a}, {b}))"),
6 => format!("print('{{0[1]}}'.format([{a}, {b}, 9]))"),
7 => format!("print('{{d[k]}}'.format(d={{'k': {a}}}))"),
8 => format!("print('{{0.real}}|{{0.imag}}'.format(complex({a}, {b})))"),
9 => format!("print('{{:{{fill}}>{{wd}}}}'.format({s}, fill='-', wd={w}))"),
10 => format!("print('{{v:{{aa}}.{{bb}}f}}'.format(v={f}, aa={w}, bb={p}))"),
11 => format!("print('{{0:{{1}}}}'.format({s}, {w}))"),
12 => format!("print('{{:+.{{}}e}}'.format({f}, {p}))"),
13 => format!("print('{{o[0]}}/{{o[2]}}'.format(o=({a}, 0, {b})))"),
_ => format!("print('{{:^{{}}}}'.format({s}, {w}), '{{:*^{{}}}}'.format({s}, {w}))"),
};
vec![e]
}
fn gen_strformat(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
const GINTS: &[&str] = &[
"0",
"5",
"42",
"255",
"1234",
"1000000",
"1234567",
"-1234",
"-1000000",
"1234567890",
"-42",
"999",
"1000",
"65535",
];
const GFLOATS: &[&str] = &[
"1234.5",
"1234567.891",
"-1234.5",
"0.5",
"1000000.25",
"-9999.99",
"12345.678",
"0.0",
];
let gi = pick(r, GINTS);
let gi2 = pick(r, GINTS);
let gf = pick(r, GFLOATS);
let s = pick(r, WORDS);
let grp = pick(r, &[",", "_"]);
let ugrp = "_"; let w = pick(r, &["0", "6", "8", "10", "12", "15"]);
let sign = pick(r, &["", "+", "-", " "]);
let p = pick(r, &["1", "2", "3", "4"]);
let e = match r.below(34) {
0 => format!("print('{{:{grp}}}'.format({gi}))"),
1 => format!("print('{{:{grp}d}}'.format({gi}))"),
2 => format!("print('{{:0{w}{grp}d}}'.format({gi}))"),
3 => format!("print('{{:{sign}0{w}{grp}}}'.format({gi}))"),
4 => format!("print('{{:{sign}{grp}}}'.format({gi}))"),
5 => {
let t = pick(r, &["x", "X", "o", "b"]);
format!("print('{{:{ugrp}{t}}}'.format(abs({gi})))")
}
6 => {
let t = pick(r, &["x", "X", "o", "b"]);
format!("print('{{:#{ugrp}{t}}}'.format(abs({gi})))")
}
7 => {
let t = pick(r, &["x", "X", "o", "b"]);
format!("print('{{:0{w}{ugrp}{t}}}'.format(abs({gi})))")
}
8 => {
let t = pick(r, &["x", "X", "o", "b"]);
format!("print('{{:#0{w}{ugrp}{t}}}'.format(abs({gi})))")
}
9 => format!("print('{{:{grp}.{p}f}}'.format({gf}))"),
10 => format!("print('{{:0{w}{grp}.{p}f}}'.format({gf}))"),
11 => format!("print('{{:{sign}{grp}.{p}f}}'.format({gf}))"),
12 => format!("print('{{:*>{w}{grp}d}}'.format({gi}))"),
13 => {
let (v, sp) = pick(
r,
&[
("255", "#_x"),
("1234567", ",d"),
("1234.5", "012,.2f"),
("42", "+08_d"),
("'hi'", ">6"),
("3.14159", ".3g"),
],
);
format!("print(format({v}, '{sp}'))")
}
14 => "class C:\n def __format__(self, spec): return f'F<{spec}>'\nprint(format(C(), 'abc'), '{:xyz}'.format(C()))".to_string(),
15 => format!(
"print('{{a}}/{{b}}/{{a}}'.format_map({{'a': {gi}, 'b': {gi2}}}))"
),
16 => "class M:\n def __getitem__(self, k): return k * 2\nprint('{x}{yy}'.format_map(M()))".to_string(),
17 => "print('hello world'.translate(str.maketrans('lo', 'LO')))".to_string(),
18 => "print('hello'.translate(str.maketrans('el', 'ip', 'lo')))".to_string(),
19 => "print('abc'.translate({97: 'AA', 98: None, 99: 0x44}))".to_string(),
20 => format!(
"print('%{sign}0{w}d|%-8s|%.{p}f' % ({gi}, {s}, {gf}))"
),
21 => format!("print('%*.*f|%*d' % (10, {p}, {gf}, {w}, abs({gi})))"),
22 => "print('%(name)s=%(val)08.2f' % {'name': 'x', 'val': 1234.5})".to_string(),
23 => format!("print('{{0!r:>10}}|{{1!s}}|{{0!a}}'.format({s}, {gi}))"),
24 => {
let t = pick(r, &["x", "X", "o", "b", "c", "n"]);
format!("print('{{:,{t}}}'.format(abs({gi}) + 1))")
}
25 => {
let t = pick(r, &["d", "x", "o", "b", "c", ""]);
format!("print('{{:.{p}{t}}}'.format(abs({gi}) + 1))")
}
26 => {
let t = pick(r, &["d", "x", "o", "b", "c"]);
format!("print('{{:{t}}}'.format({gf}))")
}
27 => {
let t = pick(r, &["d", "x", "g", "e", "f", "c", "n"]);
format!("print('{{:{t}}}'.format({s}))")
}
28 => {
let bad = pick(r, &["+", " ", "#", "=6", ","]);
format!("print('{{:{bad}}}'.format({s}))")
}
29 => {
let n = pick(r, &["65", "97", "0x41", "8364", "-1", "1114112", "0x110000"]);
format!("print('{{:c}}'.format({n}))")
}
30 => format!("print('{{:0{w}}}|{{:*^{w}}}|{{:.>{w}s}}'.format({s}, {s}, {s}))"),
31 => {
let (v, sp) = pick(
r,
&[
("3.5", "d"),
("'hi'", "x"),
("255", ",x"),
("5", ".2d"),
("'hi'", "+"),
("[1, 2]", ">5"),
],
);
format!("print(format({v}, '{sp}'))")
}
32 => format!(
"print('%#x|%#o|%+d|% d|%r' % (abs({gi}), abs({gi2}), {gi}, abs({gi2}), {s}))"
),
_ => {
let tmpl = pick(
r,
&[
"{}{}", "{0}{1}{0}", "{n}{}{}", "{}{0}", "{0}{}", "{1}{}", "{:{}}", "{0:{1}}", "{0:{}}", ],
);
format!("print('{tmpl}'.format({gi}, {gi2}, n={gf}))")
}
};
vec![e]
}
fn gen_attr(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let n = pick(r, SMALLINTS);
let m = pick(r, SMALLINTS);
let e: String = match r.below(18) {
0 => format!(
"class C:\n def __init__(self): self.x = {n}\nc = C()\nprint(c.__dict__ is c.__dict__)\nd = c.__dict__\nc.y = {m}\nprint(sorted(d.items()))\nd['z'] = {n}\nprint(c.z, sorted(c.__dict__.keys()))"
),
1 => format!(
"class C:\n def __init__(self):\n self.a = {n}\n self.b = {m}\nc = C()\ndel c.__dict__['a']\nprint(hasattr(c, 'a'), sorted(c.__dict__.items()))"
),
2 => format!(
"class C: pass\nc = C()\nsetattr(c, 'foo', {n})\nprint(getattr(c, 'foo'), hasattr(c, 'foo'), hasattr(c, 'bar'), getattr(c, 'bar', {m}))"
),
3 => format!(
"class C:\n def __init__(self): self.a = {n}\nc = C()\nprint(vars(c) is c.__dict__)\nvars(c)['b'] = {m}\nprint(sorted(c.__dict__.items()))"
),
4 => format!(
"class F:\n def __getattr__(self, k): return 'missing:' + k\nf = F()\nf.real = {n}\nprint(f.real, f.ghost, getattr(f, 'x'))"
),
5 => format!(
"class G:\n def __getattribute__(self, k):\n if k == 'secret': return {m}\n return object.__getattribute__(self, k)\ng = G()\ng.x = {n}\nprint(g.secret, g.x, sorted(g.__dict__.items()))"
),
6 => format!(
"class S:\n def __setattr__(self, k, v): object.__setattr__(self, k, v * 2)\ns = S()\ns.a = {n}\ns.b = {m}\nprint(sorted(s.__dict__.items()))"
),
7 => format!(
"class D:\n def __delattr__(self, k):\n print('del', k)\n object.__delattr__(self, k)\nd = D()\nd.z = {n}\ndel d.z\nprint(hasattr(d, 'z'), sorted(d.__dict__.keys()))"
),
8 => format!(
"class P:\n __slots__ = ('a', 'b')\n def __init__(self): self.a = {n}\np = P()\np.b = {m}\nprint(p.a, p.b)\ntry:\n p.c = 1\nexcept AttributeError as ex:\n print('AE', 'c' in str(ex))\ntry:\n p.__dict__\nexcept AttributeError:\n print('no-dict')"
),
9 => format!(
"class Base:\n bx = {n}\n def m(self): return 1\nclass C(Base):\n cy = {m}\n def __init__(self): self.i = {n}\nc = C()\nprint([x for x in dir(c) if not x.startswith('_')])\nprint([x for x in dir(C) if not x.startswith('_')])"
),
10 => format!(
"class C:\n shared = {n}\nc = C()\nprint('shared' in c.__dict__, c.shared)\nc.shared = {m}\nprint('shared' in c.__dict__, c.shared, C.shared)\ndel c.shared\nprint('shared' in c.__dict__, c.shared)"
),
11 => format!(
"class C: pass\nc = C()\nfor name in ['p', 'q', 'r']:\n setattr(c, name, {n})\nprint(sorted(c.__dict__.keys()))\ndelattr(c, 'q')\nprint(sorted(c.__dict__.keys()), hasattr(c, 'q'))"
),
12 => format!(
"class C:\n def __init__(self):\n self.a = {n}\n self.b = {m}\nc = C()\nc.__dict__.update({{'c': {n}}})\nprint(sorted(c.__dict__.items()))\nc.__dict__.pop('a')\nprint(sorted(c.__dict__.keys()), hasattr(c, 'a'))"
),
13 => format!(
"class C:\n def __getattr__(self, k): return 'fallback:' + k\n def __getattribute__(self, k):\n if k == 'boom': raise AttributeError(k)\n return object.__getattribute__(self, k)\nc = C()\nc.real = {n}\nprint(c.real, c.boom, c.other)"
),
14 => format!(
"class C:\n def __init__(self):\n self.a = {n}\n self.b = {m}\nc = C()\nc.a = {m}\nc.d = {n}\nprint(list(c.__dict__.keys()), sorted(c.__dict__.values()))"
),
15 => format!(
"class C:\n def __init__(self):\n self.a = {n}\n self.b = {m}\n self.c = {n}\nc = C()\nprint(len(c.__dict__), 'a' in c.__dict__, 'z' in c.__dict__)\nprint(sorted(k for k in c.__dict__))"
),
16 => format!(
"class C: pass\nc = C()\nprint(c.__dict__ == {{}}, len(c.__dict__))\nc.only = {n}\nprint(sorted(c.__dict__.items()))"
),
_ => format!(
"class A:\n def __init__(self): self.base = {n}\nclass B(A):\n def __init__(self):\n super().__init__()\n self.own = {m}\nb = B()\nprint(sorted(b.__dict__.items()), hasattr(b, 'base'), hasattr(b, 'own'))"
),
};
vec![e]
}
fn gen_descriptors(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let n = pick(r, &["1", "2", "3", "5", "7", "10", "-4"]);
let m = pick(r, &["2", "3", "4", "6"]);
let e: String = match r.below(28) {
0 => "class C:\n def __init__(self): self._x = 10\n @property\n def x(self): return self._x * 2\nc = C()\nprint(c.x)"
.to_string(),
1 => format!(
"class C:\n def __init__(self): self._x = 1\n @property\n def x(self): return self._x\n @x.setter\n def x(self, v): self._x = v + {n}\nc = C()\nc.x = {m}\nprint(c.x)"
),
2 => "class C:\n def __init__(self): self._x = 5\n @property\n def x(self): return self._x\n @x.setter\n def x(self, v): self._x = v\n @x.deleter\n def x(self): self._x = -99\nc = C()\nprint(c.x)\nc.x = 7\nprint(c.x)\ndel c.x\nprint(c.x)"
.to_string(),
3 => "class C:\n @property\n def x(self): return 42\nc = C()\nprint(c.x)\ntry:\n c.x = 1\nexcept AttributeError as ex:\n print('AE', 'no setter' in str(ex) or 'has no setter' in str(ex))"
.to_string(),
4 => "class C:\n @property\n def x(self): return 1\nc = C()\ntry:\n del c.x\nexcept AttributeError as ex:\n print('AE', 'deleter' in str(ex))"
.to_string(),
5 => format!(
"class C:\n @staticmethod\n def add(a, b): return a + b\nprint(C.add({n}, {m}), C().add({n}, {m}))"
),
6 => format!(
"class C:\n @classmethod\n def make(cls, v): return cls.__name__ + ':' + str(v)\nprint(C.make({n}), C().make({m}))"
),
7 => "class A:\n @classmethod\n def who(cls): return cls.__name__\nclass B(A): pass\nprint(A.who(), B.who(), B().who())"
.to_string(),
8 => "class C:\n kind = 'K'\n @classmethod\n def tag(cls): return cls.kind\n @staticmethod\n def s(): return 'S'\nprint(C.tag(), C.s(), C().tag(), C().s())"
.to_string(),
9 => format!(
"def twice(f):\n def w(*a, **k): return f(*a, **k) * 2\n return w\n@twice\ndef g(x): return x + {n}\nprint(g({m}))"
),
10 => "def a(f):\n def w(): return 'a(' + f() + ')'\n return w\ndef b(f):\n def w(): return 'b(' + f() + ')'\n return w\n@a\n@b\ndef g(): return 'g'\nprint(g())"
.to_string(),
11 => format!(
"def rep(k):\n def d(f):\n def w(*a, **kw): return f(*a, **kw) * k\n return w\n return d\n@rep({m})\ndef g(x): return x + {n}\nprint(g({n}))"
),
12 => "def tag(c):\n c.marker = 'T'\n return c\n@tag\nclass C:\n pass\nprint(C.marker, C().marker)"
.to_string(),
13 => "def wrap(c):\n class New(c):\n extra = 'new'\n return New\n@wrap\nclass C:\n base = 'old'\nprint(C.base, C.extra)"
.to_string(),
14 => format!(
"def twice_dec(f):\n def w(*a, **kw): return f(*a, **kw) * 2\n return w\ndef add(k):\n def d(f):\n def w(*a, **kw): return f(*a, **kw) + k\n return w\n return d\n@twice_dec\n@add({m})\ndef g(x): return x\nprint(g({n}))"
),
15 => "class Named:\n def __set_name__(self, owner, name): self.name = name\n def __get__(self, obj, ot=None): return self.name\nclass C:\n a = Named()\n bb = Named()\nprint(C.a, C.bb)"
.to_string(),
16 => "class D:\n def __get__(self, obj, ot=None):\n return 'cls' if obj is None else 'inst'\nclass C:\n x = D()\nprint(C.x, C().x)"
.to_string(),
17 => format!(
"class Pos:\n def __init__(self): self.v = 0\n def __get__(self, obj, ot=None):\n return self.v if obj is not None else self\n def __set__(self, obj, val):\n if val < 0: raise ValueError('neg')\n self.v = val\nclass C:\n p = Pos()\nc = C()\nc.p = {m}\nprint(c.p)\ntry:\n c.p = {n} - 100\nexcept ValueError as ex:\n print('VE', ex)\nprint(c.p)"
),
18 => "class Log:\n def __get__(self, obj, ot=None): return 5\n def __delete__(self, obj): print('deleted')\nclass C:\n x = Log()\nc = C()\nprint(c.x)\ndel c.x"
.to_string(),
19 => "class Data:\n def __get__(self, o, t=None): return 'D-get'\n def __set__(self, o, v): pass\nclass NonData:\n def __get__(self, o, t=None): return 'ND-get'\nclass C:\n d = Data()\n nd = NonData()\nc = C()\nc.d = 'x'\nc.nd = 'y'\nprint(c.d, c.nd)"
.to_string(),
20 => "class C:\n def m(self): return 'method'\nc = C()\nprint(C.m(c), c.m())\nc.m = lambda: 'shadow'\nprint(c.m())"
.to_string(),
21 => format!(
"class Temp:\n def __init__(self, c): self.c = c\n @property\n def f(self): return self.c * 9 / 5 + 32\nt = Temp({m})\nprint(t.f)"
),
22 => "class C:\n @classmethod\n def alt(cls, v):\n obj = cls()\n obj.val = v\n return obj\nclass D(C): pass\nprint(C.alt(3).val, D.alt(4).val, type(D.alt(5)).__name__)"
.to_string(),
23 => format!(
"def deco(f):\n def w(*a, **k):\n return (len(a), sorted(k), f(*a, **k))\n return w\n@deco\ndef g(x, y, z=0): return x + y + z\nprint(g({n}, {m}, z={n}))"
),
24 => "class Const:\n def __init__(self, v): self.v = v\n def __get__(self, obj, ot=None): return self.v\n def __set__(self, obj, val): raise AttributeError('read-only')\nclass C:\n x = Const(7)\nc = C()\nprint(c.x)\ntry:\n c.x = 1\nexcept AttributeError as ex:\n print('AE', ex)"
.to_string(),
25 => "class C:\n _n = 0\n @property\n def n(self): return self._n\n @n.setter\n def n(self, v): self._n = v\nclass D(C):\n @property\n def n(self): return super().n + 1\nd = D()\nd._n = 4\nprint(d.n)"
.to_string(),
26 => "class Counter:\n def __init__(self): self.calls = 0\n def __get__(self, obj, ot=None):\n self.calls += 1\n return self.calls\nclass C:\n x = Counter()\nc = C()\nprint(c.x, c.x, c.x)"
.to_string(),
_ => format!(
"def memo(f):\n cache = []\n def w(x):\n cache.append(x)\n return f(x) + len(cache)\n return w\n@memo\ndef g(x): return x * {m}\nprint(g({n}), g({n}), g({m}))"
),
};
vec![e]
}
fn gen_conttail(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let a = pick(r, SMALLINTS);
let b = pick(r, SMALLINTS);
let c = pick(r, SMALLINTS);
let d = pick(r, SMALLINTS);
match r.below(40) {
0 => vec![format!(
"d = {{'a': {a}, 'b': {b}, 'c': {c}}}\nprint(d.get('a'), d.get('z'), d.get('z', -9))"
)],
1 => vec![format!(
"d = {{'a': {a}}}\nprint(d.setdefault('a', {b}), d.setdefault('b', {c}), d)"
)],
2 => vec![format!(
"d = {{'a': {a}, 'b': {b}}}\nprint(d.pop('a'), d.pop('z', 'def'), d)"
)],
3 => vec![format!(
"d = {{'a': {a}, 'b': {b}, 'c': {c}}}\nprint(d.popitem(), d.popitem(), d)"
)],
4 => vec![format!("d = {{'a': {a}}}\nd.update({{'b': {b}}}, c={c})\nprint(d)")],
5 => vec![format!(
"print(dict.fromkeys(['x', 'y', 'z'], {a}))\nprint(dict.fromkeys(['p', 'q']))"
)],
6 => vec![format!(
"d = {{'a': {a}, 'b': {b}}}\ne = d.copy()\ne['c'] = {c}\nprint(d, e)\nd.clear()\nprint(d)"
)],
7 => vec![format!(
"d = {{'a': {a}, 'b': {b}, 'c': {c}}}\nprint(list(d.keys()), list(d.values()))\nprint(list(d.items()))"
)],
8 => vec![format!(
"d = {{'a': {a}, 'b': {b}}}\nprint(len(d.keys()), 'a' in d.keys(), 'z' in d.keys())\nprint(type(d.keys()).__name__, type(d.values()).__name__, type(d.items()).__name__)"
)],
9 => vec![format!(
"d = {{'a': {a}, 'b': {b}, 'c': {c}}}\nprint(sorted(d.keys() & {{'a', 'c', 'x'}}))\nprint(sorted(d.keys() | {{'z'}}))\nprint(sorted(d.keys() - {{'a'}}))\nprint(sorted(d.keys() ^ {{'a', 'z'}}))"
)],
10 => vec![format!(
"d = {{'a': {a}, 'b': {b}}}\nprint(('a', {a}) in d.items(), ('a', 999) in d.items())\nprint(sorted(d.items() & {{('a', {a})}}))"
)],
11 => vec![format!(
"d1 = {{'a': {a}, 'b': {b}}}\nd2 = {{'b': {c}, 'c': {d}}}\nprint(d1 | d2)\nprint(d2 | d1)"
)],
12 => vec![format!("d1 = {{'a': {a}}}\nd1 |= {{'b': {b}, 'a': {c}}}\nprint(d1)")],
13 => vec![format!("print(sorted({{{a}, {b}}}.union([{c}], [{d}, {a}])))")],
14 => vec![format!(
"print(sorted({{{a}, {b}, {c}, {d}}}.intersection([{a}, {b}, {c}], [{b}, {c}])))"
)],
15 => vec![format!(
"print(sorted({{{a}, {b}, {c}}}.difference([{a}], [{b}])))"
)],
16 => vec![format!(
"print(sorted({{{a}, {b}, {c}}}.symmetric_difference([{b}, {c}, {d}])))"
)],
17 => vec![format!(
"s = {{{a}, {b}}}\nprint(s.issubset({{{a}, {b}, {c}}}), s.issuperset({{{a}}}), s.isdisjoint({{{c}, {d}}}))"
)],
18 => vec![format!(
"s = {{{a}, {b}}}\ns.add({c})\ns.discard({d})\ns.discard(999)\nprint(sorted(s))"
)],
19 => vec![format!(
"s = {{{a}, {b}, {c}}}\nn = len(s)\ns.pop()\nprint(len(s) == n - 1)"
)],
20 => vec![format!(
"s = {{{a}, {b}, {c}}}\ns.update([{d}], {{{a}}})\ns.difference_update([{b}])\nprint(sorted(s))"
)],
21 => vec![format!(
"s = {{{a}, {b}, {c}, {d}}}\ns.intersection_update([{a}, {b}, {c}])\ns.symmetric_difference_update([{a}, 100])\nprint(sorted(s))"
)],
22 => vec![format!(
"A = {{{a}, {b}, {c}}}\nB = {{{b}, {c}, {d}}}\nprint(sorted(A | B), sorted(A & B), sorted(A - B), sorted(A ^ B))"
)],
23 => vec![format!(
"A = {{{a}, {b}}}\nB = {{{a}, {b}, {c}}}\nprint(A <= B, A < B, B >= A, A == {{{a}, {b}}})"
)],
24 => vec![format!(
"fs = frozenset([{a}, {b}, {c}])\nprint(sorted(fs), len(fs), {a} in fs)\nprint(type(fs | {{{d}}}).__name__, type(fs & {{{a}}}).__name__)"
)],
25 => vec![format!(
"fs = frozenset([{a}, {b}])\nm = {{fs: 'v'}}\nprint(m[frozenset([{b}, {a}])], hash(fs) == hash(frozenset([{b}, {a}])))"
)],
26 => vec![format!(
"fs = frozenset([{a}])\ntry:\n fs.add({b})\nexcept AttributeError as e:\n print('AE', e)"
)],
27 => vec![format!(
"s = {{{a}, {b}}}\ns.remove({a})\nprint(sorted(s))\ntry:\n s.remove(999)\nexcept KeyError as e:\n print('KE', e)"
)],
28 => vec![format!(
"x = {a}\nprint(f'{{x=}}')\nprint(f'{{x = }}')\nprint(f'{{ x =}}')"
)],
29 => vec![format!(
"x = {a}\ny = {b}\nprint(f'{{x + y = }}')\nprint(f'{{x * y=}}')"
)],
30 => vec![format!(
"v = {a}\nprint(f'{{v=:+05d}}')\nprint(f'{{v=:>8}}')\nprint(f'{{v = :#x}}')"
)],
31 => vec![format!(
"s = {}\nprint(f'{{s=!r}}')\nprint(f'{{s=!s}}')\nprint(f'{{s = !a}}')",
pick(r, WORDS)
)],
32 => vec![format!(
"d = {{'k': {a}}}\nprint(f'{{d=}}')\nprint(f'{{d[\"k\"]=}}')"
)],
33 => vec![format!("xs = [{a}, {b}]\nprint(f'{{xs!r}}|{{xs!s}}|{{xs!a}}')")],
34 => vec![format!(
"w = {}\nx = {a}\nprint(f'{{x:>{{w}}}}')\nprint(f'{{x:0{{w}}d}}')",
pick(r, POSINTS)
)],
35 => vec![format!(
"x = {a}\ny = {b}\nprint(f'''line1 {{x}}\nline2 {{y=}}''')"
)],
36 => vec![format!(
"name = {}\nprint(f'{{name=}} and {{name!r}}')",
pick(r, WORDS)
)],
37 => {
let bl = pick(
r,
&[
"b'hello WORLD'",
"b'ABC def'",
"b'123abc'",
"b' MiXeD '",
"b''",
"b'a'",
],
);
vec![format!(
"print({bl}.capitalize(), bytearray({bl}).capitalize())"
)]
}
38 => {
let zb = pick(r, &["b'42'", "b'-42'", "b'+7'", "b'abc'", "b''", "b'0'"]);
let zw = pick(r, &["0", "2", "4", "6", "8"]);
vec![format!(
"print({zb}.zfill({zw}), bytearray({zb}).zfill({zw}))"
)]
}
_ => {
let ts = pick(r, &["0", "1", "2", "4", "8"]);
let rv = pick(r, &["b'X'", "b'yy'", "b'A,B'", "b''"]);
vec![format!(
"print(b'a\\tbc\\td\\te'.expandtabs({ts}), b'x\\ty\\nz\\tw'.expandtabs({ts}))\nclass C:\n def __bytes__(self): return {rv}\nprint(b'<%b>' % C(), b'<%s>' % C())"
)]
}
}
}
fn gen_itertail(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let a = pick(r, SMALLINTS);
let b = pick(r, SMALLINTS);
let c = pick(r, SMALLINTS);
match r.below(24) {
0 => {
let sent = pick(r, &["3", "0", "5", "-1"]);
vec![
"def mk():".into(),
" state = {'i': 0}".into(),
" def step():".into(),
" state['i'] += 1".into(),
" return state['i']".into(),
" return step".into(),
format!("it = iter(mk(), {sent})"),
"print(list(it))".into(),
"print(type(it).__name__)".into(),
"print(iter(it) is it)".into(),
]
}
1 => vec![
"buf = list('abcXdef')".into(),
"pos = {'i': 0}".into(),
"def rd():".into(),
" i = pos['i']".into(),
" pos['i'] = i + 1".into(),
" return buf[i]".into(),
"it = iter(rd, 'X')".into(),
"print(next(it))".into(),
"print(next(it))".into(),
"print(next(it))".into(),
"print(next(it, 'DONE'))".into(),
"print(next(it, 'DONE'))".into(),
],
2 => vec![
"print(list(zip()))".into(),
"print(list(zip([])))".into(),
format!("print(list(zip([{a}, {b}], [{c}])))"),
"try:".into(),
format!(" print(list(zip([{a}, {b}, {c}], [1, 2], strict=True)))"),
"except ValueError as e:".into(),
" print('ValueError')".into(),
],
3 => vec![format!(
"print(list(zip([{a}, {b}, {c}], [1, 2, 3], strict=True)))"
)],
4 => vec![
format!("it = iter([{a}, {b}])"),
"print(next(it))".into(),
"print(next(it))".into(),
"print(next(it, 'end'))".into(),
"it2 = iter([])".into(),
"try:".into(),
" next(it2)".into(),
"except StopIteration:".into(),
" print('StopIteration')".into(),
],
5 => {
let seq = pick(
r,
&[
"[3, 1, 2]",
"(5, 4, 6)",
"range(4)",
"range(2, 9, 3)",
"'abcd'",
"[]",
],
);
vec![format!("print(list(reversed({seq})))")]
}
6 => vec![
"class D:".into(),
format!(" def __init__(self): self.v = [{a}, {b}, {c}]"),
" def __len__(self): return len(self.v)".into(),
" def __getitem__(self, i): return self.v[i]".into(),
" def __reversed__(self): return iter(['R'] + self.v)".into(),
"d = D()".into(),
"print(list(reversed(d)))".into(),
],
7 => vec![
"class Seq:".into(),
format!(" def __init__(self): self.v = [{a}, {b}, {c}]"),
" def __len__(self): return len(self.v)".into(),
" def __getitem__(self, i): return self.v[i]".into(),
"print(list(reversed(Seq())))".into(),
],
8 => {
let st = pick(r, &["0", "1", "5", "-2", "100"]);
vec![format!(
"print(list(enumerate(['a', 'b', 'c', 'd'], start={st})))"
)]
}
9 => vec![format!(
"print(list(map(lambda x, y: x + y, [{a}, {b}, {c}], [10, 20])))"
)],
10 => vec![format!(
"print(list(map(lambda x, y, z: x * y + z, [{a}, {b}], [2, 3], [1, 1, 1])))"
)],
11 => vec![format!(
"print(list(filter(None, [{a}, 0, {b}, '', {c}, None, [], 'x'])))"
)],
12 => vec![
"data = [('b', 2), ('a', 2), ('c', 1), ('d', 1), ('e', 2)]".into(),
"print(sorted(data, key=lambda t: t[1]))".into(),
"print(sorted(data, key=lambda t: t[1], reverse=True))".into(),
"print(sorted('dbca'))".into(),
],
13 => vec![format!(
"print(sorted([{a}, {b}, {c}, -4, 4, -1], key=abs))"
)],
14 => vec![
"words = ['bb', 'a', 'cccc', 'ddd']".into(),
"print(min(words, key=len))".into(),
"print(max(words, key=len))".into(),
"print(min([], default='none'))".into(),
"print(max([], default=-1))".into(),
],
15 => vec![
format!("print(min({a}, {b}, {c}))"),
format!("print(max({a}, {b}, {c}))"),
format!("print(min({a}, {b}, {c}, key=abs))"),
format!("print(max({a}, {b}, {c}, key=lambda x: -x))"),
],
16 => {
let st = pick(r, &["0", "10", "-5", "100"]);
vec![
format!("print(sum([{a}, {b}, {c}], {st}))"),
format!("print(sum([{a}, {b}, {c}]))"),
"print(sum([[1], [2], [3]], []))".into(),
]
}
17 => vec![
"print(all([]))".into(),
"print(any([]))".into(),
format!("print(all([{a}, {b}, {c}]))"),
format!("print(any([0, 0, {a}]))"),
"print(all([1, 1, 0, 1]))".into(),
"print(any([0, 0, 0]))".into(),
],
18 => {
let probe = pick(r, &["2", "7", "0", "-1"]);
vec![
"class Even:".into(),
" def __contains__(self, x): return x % 2 == 0".into(),
"e = Even()".into(),
format!("print({probe} in e)"),
format!("print({probe} not in e)"),
]
}
19 => {
let probe = pick(r, &["2", "9", "0"]);
vec![
"class It:".into(),
format!(" def __iter__(self): return iter([{a}, {b}, {c}])"),
format!("print({probe} in It())"),
]
}
20 => {
let probe = pick(r, &["1", "4", "0"]);
vec![
"class G:".into(),
format!(" def __init__(self): self.v = [{a}, {b}, {c}]"),
" def __getitem__(self, i):".into(),
" if i >= len(self.v): raise IndexError".into(),
" return self.v[i]".into(),
format!("print({probe} in G())"),
]
}
21 => vec![
"g = (x * x for x in range(5))".into(),
"print(list(g))".into(),
format!("print(tuple(x for x in [{a}, {b}, {c}]))"),
"print(sorted(set([1, 2, 2, 3, 3, 3])))".into(),
"print(sorted(frozenset([3, 1, 2, 1])))".into(),
"print(dict([('a', 1), ('b', 2)]))".into(),
"print(dict(zip('xy', [1, 2])))".into(),
],
22 => {
let start = pick(r, &["0", "2", "-3", "10"]);
let stop = pick(r, &["10", "5", "-5", "20"]);
let step = pick(r, &["1", "2", "3", "-1", "-2"]);
let idx = pick(r, &["0", "1", "-1", "2"]);
let probe = pick(r, &["3", "0", "-2", "7"]);
vec![
format!("rg = range({start}, {stop}, {step})"),
"print(list(rg))".into(),
"print(len(rg))".into(),
format!("print({probe} in rg)"),
"if len(rg):".into(),
format!(" print(rg[{idx}])"),
"print(list(rg[1:4]))".into(),
"print(list(rg[::-1]))".into(),
"print(range(0, 10, 2) == range(0, 10, 2))".to_string(),
"print(range(0, 4) == range(0, 4, 1))".into(),
]
}
_ => vec![
"class L:".into(),
format!(" def __len__(self): return {}", 3 + (r.below(5) as i64)),
"print(len(L()))".into(),
format!(
"print(len(range({start}, {stop})))",
start = pick(r, &["0", "2", "5"]),
stop = pick(r, &["8", "10", "3"])
),
"it = iter(range(5))".into(),
"print(next(it))".into(),
"print(list(it))".into(),
"print(list(map(str, filter(lambda x: x > 1, [0, 1, 2, 3]))))".into(),
],
}
}
fn gen_display(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
const STREXPRS: &[&str] = &[
"'plain'",
"''",
"'a b c'",
"chr(39)", "chr(34)", "chr(39)+chr(34)", "chr(92)", "chr(10)", "chr(9)", "chr(13)", "chr(7)", "chr(0)", "chr(127)", "chr(233)", "'x'+chr(39)+'y'", "'x'+chr(34)+'y'", "'q'+chr(39)+chr(34)+'r'", "'日本'", ];
const SCALARS: &[&str] = &[
"0", "1", "-1", "42", "-100", "1000000", "True", "False", "None", "0.0", "-0.0", "0.1",
"3.14", "-1.5", "1e3", "1e-3", "2.0", "100.0", "0.1+0.2", "1/3", "2**0.5", "1e300",
];
match r.below(13) {
0 => {
let sep = pick(r, &["''", "'-'", "', '", "'::'", "' '", "'\\n'", "'|'"]);
let end = pick(r, &["''", "'!'", "'\\n'", "'.\\n'", "'END'", "'\\n\\n'"]);
let a = pick(r, SCALARS);
let b = pick(r, SCALARS);
let c = pick(r, SCALARS);
vec![
format!("print({a}, {b}, {c}, sep={sep}, end={end})"),
"print('|sentinel')".into(),
]
}
1 => vec![
"print()".into(),
"print('a', end='')".into(),
"print('b', end='')".into(),
"print()".into(),
"print()".into(),
],
2 => vec![
"import sys".into(),
"print('A')".into(),
"print('B', file=sys.stdout)".into(),
"print('C', file=sys.stderr)".into(),
"print('D', 'E', file=sys.stderr, sep='-')".into(),
"print('F')".into(),
],
3 => {
let x = pick(r, SCALARS);
vec![format!("print(repr({x}))")]
}
4 => {
let s = pick(r, STREXPRS);
match r.below(3) {
0 => vec![format!("print(repr({s}))")],
1 => vec![format!("print(ascii({s}))")],
_ => vec![format!("print(repr({s}), ascii({s}))")],
}
}
5 => {
let e = pick(
r,
&[
"(1,)",
"()",
"(1, 2, 3)",
"[]",
"[[1], [2, 3], []]",
"{}",
"b''",
"b'hi'",
"b'a\\x00\\n\\t\\\\'",
"(1, 'a', (2,), [3])",
"{'k': [1, (2, 3)]}",
"[True, False, None, 1.5]",
"frozenset()",
],
);
vec![format!("print(repr({e}))")]
}
6 => vec![
"class C:".into(),
" def __repr__(self): return 'R'".into(),
" def __str__(self): return 'S'".into(),
"print([C(), (C(),), {1: C()}])".into(),
"print({C()!r})".into(),
"print(str([C()]))".into(),
],
7 => match r.below(5) {
0 => vec!["a = [1, 2]".into(), "a.append(a)".into(), "print(a)".into()],
1 => vec!["d = {}".into(), "d['self'] = d".into(), "print(d)".into()],
2 => vec![
"a = []".into(),
"b = []".into(),
"a.append(b)".into(),
"b.append(a)".into(),
"print(a)".into(),
],
3 => vec![
"a = [1]".into(),
"d = {}".into(),
"d['x'] = a".into(),
"a.append(d)".into(),
"print(a)".into(),
"print(d)".into(),
],
_ => vec![
"a = []".into(),
"a.append(a)".into(),
"a.append(a)".into(),
"print(repr(a))".into(),
],
},
8 => match r.below(4) {
0 => vec![
"class C:".into(),
" def __repr__(self): return 'RR'".into(),
"print(str(C()), repr(C()))".into(),
],
1 => vec![
"class C:".into(),
" def __str__(self): return 'SS'".into(),
"print(str(C()))".into(),
"print(repr(C()).startswith('<__main__.C object at 0x'), repr(C()).endswith('>'))"
.into(),
],
2 => vec![
"class C:".into(),
" def __str__(self): return 'S'".into(),
" def __repr__(self): return 'R'".into(),
"print(str(C()), repr(C()))".into(),
],
_ => vec![
"class C: pass".into(),
"c = C()".into(),
"print(str(c).startswith('<__main__.C object at 0x'), str(c).endswith('>'))".into(),
"print(repr(c) == str(c))".into(),
],
},
9 => match r.below(3) {
0 => vec![
"class C:".into(),
" def __str__(self): return 'STR'".into(),
" def __repr__(self): return 'REP'".into(),
"print(format(C()), format(C(), ''))".into(),
],
1 => {
let a = pick(r, SCALARS);
vec![format!("print(format({a}), format({a}, ''))")]
}
_ => vec![
"class C:".into(),
" def __format__(self, spec): return 'FMT[' + spec + ']'".into(),
"print(format(C()), format(C(), 'abc'))".into(),
],
},
10 => {
let a = pick(r, SCALARS);
let b = pick(r, SCALARS);
let c = pick(r, STREXPRS);
vec![format!("print({a}, {b}, {c})")]
}
11 => {
let e = pick(
r,
&[
"[1, 'a', 2.5]",
"(True, None)",
"{'x': 1, 'y': [2]}",
"['it'+chr(39)+'s']",
"[b'z']",
],
);
vec![format!("print(str({e}) == repr({e}), str({e}))")]
}
_ => {
let s = pick(r, STREXPRS);
vec![
format!("v = {s}"),
"print(str(v) == v)".into(),
"print(repr(v) == repr(v))".into(),
format!("print('[', repr({s}), ']', sep='')"),
]
}
}
}
fn gen_codec(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
const CPS: &[&str] = &[
"0", "7", "9", "10", "13", "27", "31", "32", "65", "0x7e", "0x7f", "0x80", "0x85", "0xa0",
"0xad", "0xa9", "0xe9", "0x3b1", "0x2022", "0x2028", "0x2029", "0x200b", "0x200d",
"0x2060", "0xfeff", "0x2603", "0xe000", "0xf8ff", "0xfdd0", "0xfffe", "0xffff", "0x10000",
"0x1f600", "0x1f4a9", "0x100000", "0x10fffd", "0x10ffff",
];
let cp = pick(r, CPS);
let cp2 = pick(r, CPS);
const ENCS: &[&str] = &[
"'utf-8'",
"'ascii'",
"'latin-1'",
"'iso-8859-1'",
"'utf-16'",
"'utf-16-le'",
"'utf-16-be'",
"'utf-32'",
"'utf-32-le'",
"'utf-32-be'",
"'UTF-8'",
"'utf_16_le'",
"'US-ASCII'",
];
let enc = pick(r, ENCS);
const UTFENCS: &[&str] = &[
"'utf-8'",
"'utf-16'",
"'utf-16-le'",
"'utf-16-be'",
"'utf-32'",
"'utf-32-le'",
"'utf-32-be'",
];
let uenc = pick(r, UTFENCS);
const ERRS: &[&str] = &[
"'strict'",
"'ignore'",
"'replace'",
"'backslashreplace'",
"'xmlcharrefreplace'",
"'namereplace'",
];
let err = pick(r, ERRS);
const ESCS: &[&str] = &[
r#""\n\t\r\\\0\a\b\f\v""#,
r#""\x41\x7f\x80\xff\xa0""#,
r#""\u03b1\u2022
\ufeff""#,
r#""\U0001F600\U0001F4A9\U00010000""#,
r#""\101\102\103\0\7\77\377""#,
r#""\N{BULLET}\N{DEGREE SIGN}\N{GREEK SMALL LETTER ALPHA}""#,
r#""mix \x41\u03b1\N{BULLET} end""#,
r#""'quotes' and \"double\"""#,
];
let esc = pick(r, ESCS);
const BESCS: &[&str] = &[
r#"b"\x00\x7f\x80\xff\n\t\r\\""#,
r#"b"\101\102\0\7\377""#,
r#"b"hello\x00world""#,
r#"b"\xe6\x97\xa5\xe6\x9c\xac""#,
r#"b"\xc3\xa9\xc3\xa8""#,
r#"b"\xff\xfe\x41\x00""#,
r#"b"caf\xc3\xa9""#,
];
let besc = pick(r, BESCS);
const RAWS: &[&str] = &[
r#"r"\n\t\x41""#,
r#"r"\u03b1\N{X}""#,
r#"r"C:\path\to""#,
r#"rb"\x41\n""#,
];
let raw = pick(r, RAWS);
let guard = |expr: String| -> Vec<String> {
vec![
"try:".into(),
format!(" print({expr})"),
"except Exception as e:".into(),
" print(type(e).__name__)".into(),
]
};
match r.below(20) {
0 => vec![format!("print(repr(chr({cp}) + chr({cp2})))")],
1 => vec![format!("print(ascii('x' + chr({cp}) + 'y' + chr({cp2})))")],
2 => vec![format!("print(ord(chr({cp})), chr({cp}) == chr({cp}))")],
3 => vec![format!(
"c = chr({cp})\nprint(c.isprintable(), c.isascii(), c.isspace())"
)],
4 => vec![format!(
"s = 'a' + chr({cp}) + 'bc' + chr({cp2})\nprint(len(s), ord(s[1]), ord(s[-1]), s[0])"
)],
5 => guard(format!("('A' + chr({cp}) + 'z').encode({enc}, {err})")),
6 => guard(format!("('q' + chr({cp})).encode({enc}, errors={err})")),
8 => vec![format!(
"print(('A' + chr({cp}) + chr({cp2})).encode({uenc}).decode({uenc}) == 'A' + chr({cp}) + chr({cp2}))"
)],
7 => vec![format!("print(repr({esc}))")],
9 => vec![format!("print(ascii({esc}))")],
10 => guard(format!("{esc}.encode({enc}, {err})")),
11 => vec![format!("print(repr({besc}), len({besc}))")],
12 => guard(format!("repr({besc}.decode({enc}, {err}))")),
13 => guard(format!("repr({besc}.decode({enc}, errors={err}))")),
14 => vec![format!("print(repr({raw}), len({raw}))")],
15 => vec![
"print(ord('\\N{BULLET}'), ord('\\N{DEGREE SIGN}'))".into(),
"print(repr('\\N{GREEK SMALL LETTER ALPHA}\\N{SNOWMAN}'))".into(),
],
16 => vec![format!(
"print(('a' + chr({cp})).isidentifier(), chr({cp}).isidentifier(), ('x1_' + chr({cp})).isidentifier())"
)],
17 => vec![format!(
"print({besc}.hex(), {besc}.hex('-'), bytes.fromhex('48656c6c6f') == b'Hello')"
)],
18 => guard(format!(
"len(('A' + chr({cp})).encode({enc}))"
)),
_ => vec![format!(
"print(repr(chr({cp}) + 'mid' + chr({cp2}) + '\\t\\x00'))"
)],
}
}
fn gen_slots(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let v = pick(r, POSINTS);
match r.below(8) {
0 => vec![
"class C:".into(),
" __slots__ = ('a', 'b')".into(),
"c = C()".into(),
format!("c.a = {v}"),
"print(c.a, C.__slots__)".into(),
"try:".into(),
" c.z = 1".into(),
"except AttributeError as e:".into(),
" print('AE', e)".into(),
],
1 => vec![
"class C:".into(),
" __slots__ = ('a',)".into(),
"try:".into(),
" print(C().a)".into(),
"except AttributeError as e:".into(),
" print('AE', e)".into(),
],
2 => vec![
"class A:".into(),
" __slots__ = ('a',)".into(),
"class B(A):".into(),
" __slots__ = ('b',)".into(),
"class D(A):".into(),
" pass".into(),
"b = B()".into(),
format!("b.a = {v}"),
"b.b = 2".into(),
"d = D()".into(),
"d.whatever = 3".into(),
"print(b.a, b.b, hasattr(b, '__dict__'), hasattr(d, '__dict__'), d.whatever)".into(),
],
3 => vec![
"class C:".into(),
" __slots__ = 'only'".into(),
"c = C()".into(),
format!("c.only = {v}"),
"print(c.only, sorted(dir(c))[-1])".into(),
],
4 => vec![
"class C:".into(),
" __slots__ = ('a',)".into(),
"c = C()".into(),
format!("c.a = {v}"),
"del c.a".into(),
"print(hasattr(c, 'a'))".into(),
],
5 => vec![
"try:".into(),
" class C:".into(),
" __slots__ = ('a',)".into(),
" a = 1".into(),
" print('made')".into(),
"except ValueError as e:".into(),
" print('VE', e)".into(),
],
6 => vec![
"class C:".into(),
" __slots__ = ('a',)".into(),
format!(" k = {v}"),
"c = C()".into(),
"print(c.k, C.k)".into(),
],
_ => vec![
"class C:".into(),
" __slots__ = ('x', 'y')".into(),
" def __init__(s, x, y):".into(),
" s.x, s.y = x, y".into(),
" def __repr__(s):".into(),
" return f'C({s.x},{s.y})'".into(),
format!("print(C({v}, 2), sorted(C.__slots__))"),
],
}
}
fn gen_dataclass(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let a = pick(r, POSINTS);
let b = pick(r, POSINTS);
match r.below(8) {
0 => vec![
"from dataclasses import dataclass".into(),
"@dataclass".into(),
"class P:".into(),
" x: int".into(),
" y: int = 5".into(),
format!("p = P({a})"),
format!("q = P({a}, {b})"),
"print(p, q, p == P(p.x), p == q)".into(),
],
1 => vec![
"from dataclasses import dataclass".into(),
"@dataclass(order=True)".into(),
"class P:".into(),
" x: int".into(),
" y: int = 0".into(),
format!("print(P({a}) < P({b}), P({a}) <= P({a}), sorted([P({b}), P({a})]))"),
],
2 => vec![
"from dataclasses import dataclass, field".into(),
"@dataclass".into(),
"class P:".into(),
" x: int = 0".into(),
" tags: list = field(default_factory=list)".into(),
"p = P()".into(),
format!("p.tags.append({a})"),
"print(p, P().tags)".into(),
],
3 => vec![
"from dataclasses import dataclass".into(),
"@dataclass(frozen=True)".into(),
"class P:".into(),
" x: int".into(),
format!("p = P({a})"),
"try:".into(),
" p.x = 1".into(),
"except Exception as e:".into(),
" print(type(e).__name__, e)".into(),
"print(p, hash(p) == hash(P(p.x)))".into(),
],
4 => vec![
"from dataclasses import dataclass, asdict, astuple, replace".into(),
"@dataclass".into(),
"class P:".into(),
" x: int".into(),
" y: int = 1".into(),
format!("p = P({a}, {b})"),
"print(asdict(p), astuple(p), replace(p, y=9))".into(),
],
5 => vec![
"from dataclasses import dataclass, field".into(),
"@dataclass".into(),
"class P:".into(),
" x: int".into(),
" note: str = field(default='n', compare=False, repr=False)".into(),
format!("print(P({a}, 'aa') == P({a}, 'bb'), P({a}, 'aa'))"),
],
6 => vec![
"from dataclasses import dataclass, fields, MISSING".into(),
"@dataclass".into(),
"class P:".into(),
" x: int".into(),
" y: str = 'q'".into(),
"print([(f.name, f.default if f.default is not MISSING else 'MISSING') \
for f in fields(P)])"
.into(),
],
_ => vec![
"from dataclasses import dataclass".into(),
"try:".into(),
" @dataclass".into(),
" class P:".into(),
" x: int = 0".into(),
" y: int".into(),
" print('made')".into(),
"except TypeError as e:".into(),
" print('TE', e)".into(),
],
}
}
fn gen_walrus(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let n = pick(r, POSINTS);
match r.below(8) {
0 => vec![
format!("xs = list(range({n} + 3))"),
"print([y for x in xs if (y := x * 2) > 2], y)".into(),
],
1 => vec![
format!("if (n := {n} + 1) > 2:"),
" print('big', n)".into(),
"else:".into(),
" print('small', n)".into(),
],
2 => vec![
format!("xs = list(range({n} + 2))"),
"out = []".into(),
"while xs and (v := xs.pop()) >= 0:".into(),
" out.append(v)".into(),
"print(out, v)".into(),
],
3 => vec![
format!("print((z := {n}) + z, z)"),
"print([(w := i) for i in range(3)], w)".into(),
],
4 => vec![
format!("d = {{'k': {n}}}"),
"if (v := d.get('k')) is not None:".into(),
" v += 1".into(),
"print(v, d)".into(),
],
5 => vec![
"try:".into(),
" exec('[(i := x) for i in range(3)]')".into(),
"except SyntaxError as e:".into(),
" print('SE')".into(),
],
6 => vec![format!(
"print([[(t := i * j) for j in range(2)] for i in range({n} % 3 + 1)], t)"
)],
_ => vec![
"total = 0".to_string(),
format!("for i in range({n}):"),
" total += (sq := i * i)".into(),
"print(total, sq)".into(),
],
}
}
fn gen_functools(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let n = pick(r, POSINTS);
match r.below(8) {
0 => vec![
"import functools".into(),
"@functools.lru_cache(maxsize=2)".into(),
"def f(a):".into(),
" return a * a".into(),
format!("for a in ({n}, {n}, 1, 2, 3, 1):"),
" f(a)".into(),
"ci = f.cache_info()".into(),
"print(ci.hits, ci.misses, ci.maxsize, ci.currsize)".into(),
],
1 => vec![
"import functools".into(),
"@functools.cache".into(),
"def fib(k):".into(),
" return k if k < 2 else fib(k - 1) + fib(k - 2)".into(),
format!("print(fib({n} + 5), fib.cache_info().currsize)"),
],
2 => vec![
"import functools".into(),
format!("print(functools.reduce(lambda a, b: a + b, range({n} + 1)))"),
format!("print(functools.reduce(lambda a, b: a * b, range(1, {n} + 1), 1))"),
"try:".into(),
" functools.reduce(lambda a, b: a + b, [])".into(),
"except TypeError as e:".into(),
" print('TE', e)".into(),
],
3 => vec![
"import functools".into(),
format!("p = functools.partial(pow, {n})"),
"q = functools.partial(pow, exp=2)".into(),
format!("print(p(2), q(base={n}), p.args, sorted(q.keywords))"),
],
4 => vec![
"import functools".into(),
"@functools.total_ordering".into(),
"class C:".into(),
" def __init__(s, v):".into(),
" s.v = v".into(),
" def __eq__(s, o):".into(),
" return s.v == o.v".into(),
" def __lt__(s, o):".into(),
" return s.v < o.v".into(),
format!("a, b = C({n}), C({n} + 1)"),
"print(a < b, a <= b, a > b, a >= b, a == C(a.v))".into(),
],
5 => vec![
"import functools".into(),
"def base(a, b):".into(),
" 'doc of base'".into(),
" return a - b".into(),
"@functools.wraps(base)".into(),
"def wrapper(a, b):".into(),
" return base(a, b)".into(),
format!("print(wrapper.__name__, wrapper.__doc__, wrapper({n}, 1))"),
],
6 => vec![
"import functools".into(),
format!("xs = [3, 1, {n}, 2]"),
"print(sorted(xs, key=functools.cmp_to_key(lambda a, b: b - a)))".into(),
],
_ => vec![
"import functools".into(),
"@functools.singledispatch".into(),
"def show(v):".into(),
" return 'obj:' + str(v)".into(),
"@show.register".into(),
"def _(v: int):".into(),
" return 'int:' + str(v)".into(),
"@show.register".into(),
"def _(v: str):".into(),
" return 'str:' + v".into(),
format!("print(show({n}), show('a'), show([1]))"),
],
}
}
fn gen_ctxmgr(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let n = pick(r, POSINTS);
match r.below(8) {
0 => {
let swallow = if r.below(2) == 0 { "True" } else { "False" };
vec![
"class C:".into(),
" def __enter__(s):".into(),
format!(" print('in'); return {n}"),
" def __exit__(s, t, v, tb):".into(),
format!(" print('out', t.__name__ if t else None); return {swallow}"),
"try:".into(),
" with C() as v:".into(),
" print(v)".into(),
" raise ValueError('boom')".into(),
" print('fell through')".into(),
"except ValueError as e:".into(),
" print('caught', e)".into(),
]
}
1 => vec![
"class C:".into(),
" def __init__(s, n):".into(),
" s.n = n".into(),
" def __enter__(s):".into(),
" print('enter', s.n); return s.n".into(),
" def __exit__(s, *a):".into(),
" print('exit', s.n); return False".into(),
"with C(1) as a, C(2) as b:".into(),
" print(a, b)".into(),
],
2 => vec![
"import contextlib".into(),
"@contextlib.contextmanager".into(),
"def cm():".into(),
" print('before')".into(),
" try:".into(),
format!(" yield {n}"),
" finally:".into(),
" print('after')".into(),
"with cm() as v:".into(),
" print(v)".into(),
],
3 => vec![
"import contextlib".into(),
"@contextlib.contextmanager".into(),
"def cm():".into(),
" try:".into(),
" yield".into(),
" except ValueError as e:".into(),
" print('cm saw', e)".into(),
"with cm():".into(),
" raise ValueError('inner')".into(),
"print('done')".into(),
],
4 => vec![
"import contextlib".into(),
"with contextlib.suppress(ValueError, KeyError):".into(),
format!(" print({n})"),
" raise KeyError('k')".into(),
"print('after')".into(),
],
5 => vec![
"class C:".into(),
" def __enter__(s):".into(),
" return 1".into(),
" def __exit__(s, *a):".into(),
" print('exit'); return False".into(),
"def f():".into(),
" with C():".into(),
format!(" return {n}"),
"print(f())".into(),
],
6 => vec![
"import contextlib".into(),
"class R:".into(),
" def close(s):".into(),
" print('closed')".into(),
"with contextlib.closing(R()) as r:".into(),
format!(" print('body', {n})"),
],
_ => vec![
"import contextlib".into(),
"with contextlib.ExitStack() as st:".into(),
format!(" for i in range({n} % 3 + 1):"),
" st.callback(print, 'cb', i)".into(),
" print('body')".into(),
],
}
}
fn gen_stdlibexc(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let key = pick(r, &["k", "missing key", "a'b", "ünïcode", ""]);
let n = pick(r, POSINTS);
match r.below(10) {
0 => vec![
"import os".into(),
"try:".into(),
" os.environ['PYTHONRS_NOT_SET_XYZ']".into(),
"except KeyError as e:".into(),
" print(repr(str(e)), e.args, type(e).__name__)".into(),
],
1 => vec![
"import types".into(),
format!("ns = types.MappingProxyType({{'x': {n}}})"),
"try:".into(),
format!(" ns[{key:?}]"),
"except KeyError as e:".into(),
" print(repr(str(e)), e.args)".into(),
],
2 => vec![
"import struct".into(),
"try:".into(),
" struct.unpack('<I', b'ab')".into(),
"except struct.error as e:".into(),
" print(type(e).__name__, repr(str(e)), len(e.args))".into(),
],
3 => vec![
"import json".into(),
"try:".into(),
" json.loads('{\"a\": }')".into(),
"except ValueError as e:".into(),
" print(type(e).__name__, e.lineno, e.colno, e.pos)".into(),
],
4 => vec![
"import contextlib".into(),
"@contextlib.contextmanager".into(),
"def cm():".into(),
" try:".into(),
format!(" yield {n}"),
" except KeyError as e:".into(),
" print('swallowed', repr(str(e)), e.args)".into(),
"with cm() as v:".into(),
" print('body', v)".into(),
format!(" raise KeyError({key:?})"),
"print('after')".into(),
],
5 => vec![
"import contextlib".into(),
"@contextlib.contextmanager".into(),
"def cm():".into(),
" try:".into(),
" yield".into(),
" except ValueError:".into(),
format!(" raise KeyError({key:?})"),
"try:".into(),
" with cm():".into(),
format!(" raise ValueError('v{n}')"),
"except KeyError as e:".into(),
" print('translated', repr(str(e)), e.args)".into(),
],
6 => vec![
"import contextlib".into(),
"@contextlib.contextmanager".into(),
"def cm():".into(),
" print('enter')".into(),
" try:".into(),
" yield".into(),
" finally:".into(),
" print('exit')".into(),
"try:".into(),
" with cm():".into(),
format!(" raise KeyError({key:?})"),
"except KeyError as e:".into(),
" print('out', repr(str(e)), e.args)".into(),
],
7 => vec![
"import contextlib".into(),
"def g():".into(),
" a = yield 1".into(),
" print('got', a)".into(),
format!(" return {n}"),
"gen = g()".into(),
"print(next(gen))".into(),
"try:".into(),
" gen.send('s')".into(),
"except StopIteration as e:".into(),
" print('SI', e.value, e.args)".into(),
],
8 => vec![
"import contextlib".into(),
"@contextlib.contextmanager".into(),
"def cm(tag):".into(),
" print('enter', tag)".into(),
" try:".into(),
" yield tag".into(),
" finally:".into(),
" print('exit', tag)".into(),
"try:".into(),
" with contextlib.ExitStack() as st:".into(),
" a = st.enter_context(cm('a'))".into(),
" b = st.enter_context(cm('b'))".into(),
" print(a, b)".into(),
format!(" raise KeyError({key:?})"),
"except KeyError as e:".into(),
" print('out', repr(str(e)))".into(),
],
_ => vec![
"import contextlib".into(),
"def g():".into(),
" try:".into(),
format!(" yield {n}"),
" except GeneratorExit:".into(),
" print('closing')".into(),
" raise".into(),
"gen = g()".into(),
"with contextlib.closing(gen) as c:".into(),
" print(next(c))".into(),
"print('done')".into(),
],
}
}
fn gen_containertail(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let n = pick(r, &["1", "2", "3", "4"]);
let seq = pick(r, &["'abcdefg'", "[1, 2, 3, 4, 5]", "range(6)", "''", "[]"]);
let init = pick(r, &["0", "10", "-3", "1.5"]);
match r.below(16) {
0 => vec![
"import itertools as it".into(),
format!("print(list(it.accumulate({seq})))"),
format!("print(list(it.accumulate({seq}, initial={init})))"),
format!("print(list(it.accumulate([], initial={init})))"),
],
1 => vec![
"import itertools as it, operator".into(),
format!("print(list(it.accumulate([1, 2, 3], operator.mul, initial={n})))"),
"print(list(it.accumulate('abc', initial='X')))".into(),
"print(list(it.accumulate([1, 2, 3], lambda a, b: a - b)))".into(),
],
2 => vec![
"import itertools as it".into(),
format!("print(list(it.batched({seq}, {n})))"),
"print(list(it.batched([], 3)))".into(),
"try:".into(),
" print(list(it.batched('abcdefg', 3, strict=True)))".into(),
"except ValueError as e:".into(),
" print('ValueError', e)".into(),
],
3 => vec![
"import itertools as it".into(),
"print(list(it.batched('abcdef', 3, strict=True)))".into(),
"try:".into(),
" list(it.batched('ab', 0))".into(),
"except ValueError as e:".into(),
" print('ValueError', e)".into(),
],
4 => vec![
"import itertools as it".into(),
format!("c = it.count({n})"),
"print(repr(c))".into(),
"next(c); next(c)".into(),
"print(repr(c))".into(),
format!("print(repr(it.count({n}, 2)), repr(it.count()))"),
],
5 => vec![
"import itertools as it".into(),
format!("rp = it.repeat('x', {n})"),
"print(repr(rp))".into(),
"next(rp)".into(),
"print(repr(rp), repr(it.repeat([1, 2])))".into(),
],
6 => vec![
"import itertools as it".into(),
"print(list(it.islice(it.count(1.5, 0.5), 4)))".into(),
format!("print(list(it.islice(it.count({n}, -1), 3)))"),
"print(list(it.islice(it.count(2**63, 2), 3)))".into(),
],
7 => vec![
"from collections import deque".into(),
format!("d = deque([1, 2, 3]); d.insert({n}, 9); print(d)"),
"d.insert(-1, 8); print(d)".into(),
"d.insert(99, 7); print(d)".into(),
"d.insert(-99, 6); print(d)".into(),
],
8 => vec![
"from collections import deque".into(),
"d = deque([1, 2], maxlen=2)".into(),
"try:".into(),
" d.insert(1, 9)".into(),
"except IndexError as e:".into(),
" print('IndexError', e)".into(),
"print(d, d.maxlen)".into(),
],
9 => vec![
"from collections import Counter".into(),
format!("c = Counter(a=3, b=-1, c=0, d={init})"),
"print(+c)".into(),
"print(-c)".into(),
"print(c)".into(),
],
10 => vec![
"from collections import Counter".into(),
"print(+Counter(), -Counter())".into(),
"print(+Counter(x=-1), -Counter(x=1))".into(),
],
11 => vec![
"from collections import defaultdict".into(),
"d = defaultdict(list)".into(),
"print(d.default_factory)".into(),
"d['x'].append(1)".into(),
"d.default_factory = int".into(),
"print(d['y'], d.default_factory, dict(d))".into(),
"d.default_factory = None".into(),
"try:".into(),
" d['z']".into(),
"except KeyError as e:".into(),
" print('KeyError', e)".into(),
],
12 => vec![
"from collections import defaultdict".into(),
"d = defaultdict(None)".into(),
"print(d.default_factory)".into(),
format!("d = defaultdict(int, a={n})"),
"print(d.default_factory, d['a'], d['b'], dict(d))".into(),
],
13 => vec![
"from collections import OrderedDict".into(),
"o = OrderedDict(a=1, b=2, c=3)".into(),
"print(o.popitem())".into(),
"print(o.popitem(last=False))".into(),
"print(o.popitem(True))".into(),
"try:".into(),
" o.popitem()".into(),
"except KeyError as e:".into(),
" print('KeyError', e)".into(),
],
14 => vec![
"import math".into(),
format!("print(math.prod([2, 3], start={n}))"),
"print(math.prod([], start=2.5))".into(),
"print(math.prod([1.5], start=2))".into(),
"print(math.prod([], start=7), math.prod([]))".into(),
"print(math.prod([10**10, 10**10], start=3))".into(),
],
_ => vec![
"import sys".into(),
"n = sys.stdlib_module_names".into(),
"print(type(n).__name__)".into(),
"print('json' in n, 'math' in n, 'sys' in n, 'itertools' in n)".into(),
"print('__hello__' in n, 'sitecustomize' in n, 'definitely_not_a_module' in n)".into(),
"for name in ('json', 'math', 'collections'):".into(),
" print(name, __import__(name).__name__)".into(),
],
}
}
fn gen_excgroup(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
let a = pick(r, POSINTS);
let b = pick(r, POSINTS);
const LEAFS: &[&str] = &[
"ValueError",
"TypeError",
"KeyError",
"IndexError",
"ZeroDivisionError",
"OSError",
"ArithmeticError",
];
let (l1, l2) = (pick(r, LEAFS), pick(r, LEAFS));
let want = pick(r, LEAFS);
match r.below(12) {
0 => vec![
format!("eg = ExceptionGroup('g', [{l1}({a}), {l2}({b})])"),
"print(repr(eg)); print(str(eg)); print(eg.message)".into(),
"print(eg.args); print(eg.exceptions)".into(),
"print(type(eg).__name__, isinstance(eg, BaseExceptionGroup), isinstance(eg, Exception))"
.into(),
],
1 => vec![
"for expr in ['ExceptionGroup(\"g\", [])', 'ExceptionGroup(\"g\", [KeyboardInterrupt()])', 'ExceptionGroup(1, [ValueError()])', 'ExceptionGroup(\"g\", ValueError())', 'ExceptionGroup(\"g\")', 'ExceptionGroup(\"g\", [ValueError, TypeError()])']:".into(),
" try:".into(),
" eval(expr); print(expr, '-> ok')".into(),
" except BaseException as e:".into(),
" print(expr, '->', type(e).__name__ + ':', e)".into(),
],
2 => vec![
format!("for excs in [[{l1}({a})], [KeyboardInterrupt()], [{l1}({a}), SystemExit(2)]]:"),
" g = BaseExceptionGroup('b', excs)".into(),
" print(type(g).__name__, repr(g))".into(),
],
3 => vec![
format!("eg = ExceptionGroup('g', [{l1}({a}), {l2}({b})])"),
format!("m, rest = eg.split({want})"),
"print(repr(m)); print(repr(rest))".into(),
format!("print(repr(eg.subgroup({want})))"),
],
4 => vec![
format!(
"eg = ExceptionGroup('out', [{l1}({a}), ExceptionGroup('in', [{l2}({b}), {l1}({b})])])"
),
format!("m, rest = eg.split({want})"),
"print(repr(m)); print(repr(rest))".into(),
],
5 => vec![
format!("eg = ExceptionGroup('g', [{l1}({a}), {l2}({b})])"),
format!("print(repr(eg.subgroup(lambda e: isinstance(e, {want}))))"),
"print(repr(eg.derive([KeyError('d')])))".into(),
"print(repr(eg.split(lambda e: False)))".into(),
],
6 => vec![
"try:".into(),
format!(" raise ExceptionGroup('g', [{l1}({a}), {l2}({b})])"),
format!("except* {l1} as e:"),
" print('one', repr(e))".into(),
format!("except* {want} as e:"),
" print('two', repr(e))".into(),
"print('after')".into(),
],
7 => vec![
"try:".into(),
" try:".into(),
format!(" raise ExceptionGroup('g', [{l1}({a}), {l2}({b})])"),
format!(" except* {want} as e:"),
" print('handled', repr(e))".into(),
"except BaseException as outer:".into(),
" print('escaped', repr(outer))".into(),
],
8 => vec![
"try:".into(),
format!(" raise {l1}({a})"),
format!("except* {want} as e:"),
" print('wrapped', repr(e))".into(),
],
9 => vec![
"try:".into(),
" try:".into(),
format!(" raise ExceptionGroup('g', [{l1}({a}), {l2}({b})])"),
format!(" except* {l1}:"),
" raise RuntimeError('from handler')".into(),
format!(" except* {l2}:"),
" raise".into(),
"except BaseException as outer:".into(),
" print('outer', repr(outer))".into(),
],
10 => vec![
"try:".into(),
format!(" raise ExceptionGroup('g', [{l1}({a}), {l2}({b})])"),
format!("except* ({l1}, {l2}) as e:"),
" print('tuple', repr(e))".into(),
"finally:".into(),
" print('finally')".into(),
],
_ => vec![
format!(
"raise ExceptionGroup('g', [{l1}({a}), ExceptionGroup('in', [{l2}({b})])])"
),
],
}
}
fn gen_valuekey(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
const VK_INTS: &[&str] = &["0", "1", "2", "3", "4", "5"];
const HASHES: &[&str] = &["hash(self.v)", "0", "self.v % 2", "self.v // 2"];
let (a, b, c, d) = (
pick(r, VK_INTS),
pick(r, VK_INTS),
pick(r, VK_INTS),
pick(r, VK_INTS),
);
let mut out: Vec<String> = vec![
"class P:".into(),
" def __init__(self, v): self.v = v".into(),
format!(" def __hash__(self): return {}", pick(r, HASHES)),
" def __eq__(self, o): return isinstance(o, P) and self.v == o.v".into(),
" def __repr__(self): return 'P(%d)' % self.v".into(),
"def S(x): return sorted(e.v for e in x)".into(),
"def D(x): return sorted((k.v, v) for k, v in x.items())".into(),
];
match r.below(16) {
0 => {
out.push(format!("A = {{P({a}), P({b})}}"));
out.push(format!("B = {{P({b}), P({c})}}"));
out.push("print(S(A & B), S(A | B), S(A - B), S(A ^ B))".into());
out.push("print(S(B - A), len(A), len(B), S(A))".into());
}
1 => {
out.push(format!("A = {{P({a}), P({b})}}"));
out.push(format!("B = {{P({a}), P({b}), P({c})}}"));
out.push("print(A == B, A != B, A <= B, A < B, A >= B, A > B)".into());
out.push(format!(
"print(A == {{P({a}), P({b})}}, {{P({a})}} == {{P({a})}})"
));
}
2 => {
out.push(format!("A = {{P({a}), P({b})}}"));
out.push(format!(
"print(A.issubset({{P({a}), P({b}), P({c})}}), A.issubset([P({a}), P({b})]))"
));
out.push(format!(
"print(A.issuperset([P({a})]), A.isdisjoint({{P({c})}}), A.isdisjoint([P({a})]))"
));
}
3 => {
out.push(format!("A = {{P({a}), P({b})}}"));
out.push(format!("A |= {{P({b}), P({c})}}"));
out.push("print(S(A), len(A))".into());
out.push(format!("A &= {{P({b}), P({c}), P({d})}}"));
out.push("print(S(A))".into());
out.push(format!("A -= {{P({c})}}"));
out.push("print(S(A))".into());
out.push(format!("A ^= {{P({a}), P({b})}}"));
out.push("print(S(A))".into());
}
4 => {
out.push(format!("A = {{P({a}), P({b})}}"));
out.push(format!("print(S(A.union([P({c})])), S(A.intersection({{P({b})}})), S(A.difference([P({a})])))"));
out.push(format!(
"print(S(A.symmetric_difference({{P({b}), P({c})}})), S(A))"
));
out.push(format!(
"print(S(A.union({{P({c})}}, [P({d})])), S(A.intersection(A, [P({a})])))"
));
}
5 => {
out.push(format!("A = {{P({a})}}"));
out.push(format!("A.update({{P({b})}}, [P({c})])"));
out.push("print(S(A))".into());
out.push(format!("A.intersection_update({{P({b}), P({c}), P({a})}})"));
out.push("print(S(A))".into());
out.push(format!("A.difference_update([P({b})])"));
out.push("print(S(A))".into());
out.push(format!("A.symmetric_difference_update({{P({c}), P({d})}})"));
out.push("print(S(A))".into());
out.push(format!("A.update([P({a}), P({a})])"));
out.push("print(S(A), len(A))".into());
}
6 => {
out.push(format!("d1 = {{P({a}): 'x', P({b}): 'y'}}"));
out.push(format!("d2 = {{P({b}): 'Y', P({c}): 'Z'}}"));
out.push("print(D(d1 | d2), D(d2 | d1))".into());
out.push("d3 = dict(d1)".into());
out.push("d3.update(d2)".into());
out.push("print(D(d3), len(d3))".into());
out.push("d4 = dict(d1)".into());
out.push(format!("d4.update([(P({c}), 'q'), (P({a}), 'r')])"));
out.push("print(D(d4), len(d4))".into());
out.push("print(d1 == dict(d1), d1 == d2)".into());
}
7 => {
out.push(format!("d1 = {{P({a}): 1, P({b}): 2}}"));
out.push(format!(
"print(S(d1.keys() & {{P({b}), P({c})}}), S(d1.keys() | {{P({c})}}))"
));
out.push(format!(
"print(S(d1.keys() - {{P({a})}}), S(d1.keys() ^ {{P({a}), P({c})}}))"
));
out.push(format!(
"print(sorted(k.v for k in d1), d1.keys() == {{P({a}), P({b})}})"
));
}
8 => {
out.push(format!("F = frozenset({{P({a}), P({b})}})"));
out.push(format!("G = frozenset({{P({b}), P({c})}})"));
out.push("print(S(F & G), S(F | G), S(F - G), S(F ^ G))".into());
out.push(format!(
"print(F == frozenset({{P({a}), P({b})}}), F == G, F <= (F | G))"
));
out.push(format!(
"print(S({{P({c})}} | F), type(F & G).__name__, len({{F, frozenset(F)}}))"
));
}
9 => {
if r.below(2) == 0 {
out.push("import enum".into());
out.push("class Col(enum.Enum):".into());
out.push(" R = 1".into());
out.push(" G = 2".into());
out.push(" B = 3".into());
out.push("X = {Col.R, Col.G}".into());
out.push("Y = {Col.G, Col.B}".into());
out.push("N = lambda s: sorted(e.name for e in s)".into());
out.push("print(N(X & Y), N(X | Y), N(X - Y), N(X ^ Y))".into());
out.push(
"print(X == {Col.R, Col.G}, X.issubset({Col.R, Col.G, Col.B}), X.isdisjoint({Col.B}))"
.into(),
);
out.push("m = {Col.R: 1}".into());
out.push("m.update({Col.R: 2, Col.G: 3})".into());
out.push("print(sorted((k.name, v) for k, v in m.items()), len(m))".into());
} else {
out.push("from decimal import Decimal as Dc".into());
out.push(format!("X = {{Dc('{a}.5'), Dc('{b}.5')}}"));
out.push(format!("Y = {{Dc('{b}.5'), Dc('{c}.5')}}"));
out.push("N = lambda s: sorted(str(e) for e in s)".into());
out.push("print(N(X & Y), N(X | Y), N(X - Y), N(X ^ Y))".into());
out.push(format!(
"print(X == {{Dc('{a}.5'), Dc('{b}.5')}}, X.isdisjoint({{Dc('{c}.5')}}))"
));
out.push(format!("m = {{Dc('{a}.5'): 1}}"));
out.push(format!("m.update({{Dc('{a}.5'): 2}})"));
out.push("print(sorted((str(k), v) for k, v in m.items()), len(m))".into());
}
}
10 => {
out.push(format!("A = {{P({a}), {b}}}"));
out.push(format!("B = {{P({b}), {a}}}"));
out.push("T = lambda s: sorted(repr(e) for e in s)".into());
out.push("print(T(A & B), T(A | B), T(A - B))".into());
out.push(format!(
"print({{{a}}}.issubset([P({a})]), {{{a}}}.isdisjoint([P({a})]))"
));
out.push(format!(
"print({{P({a})}}.isdisjoint([{a}]), len({{P({a}), {a}}}))"
));
}
11 => {
out.push(format!("A = {{P({a}), P({a}), P({b})}}"));
out.push("print(len(A), S(A))".into());
out.push(format!("B = set([P(x) for x in ({a}, {b}, {c})])"));
out.push("print(len(B), S(B))".into());
out.push("print(S(A | set()), S(set() | A), len(A & set()), S(A - set()))".into());
out.push("C2 = A.copy()".into());
out.push(format!("C2.add(P({a}))"));
out.push("print(len(C2), len(A), S(C2))".into());
out.push(format!("print(S(A.union(*[[P({c})], [P({d})]])))"));
}
12 => {
out.push(format!("d = {{(P({a}),): 'x', (P({b}), P({c})): 'y'}}"));
out.push(format!("print(d[(P({a}),)], d[(P({b}), P({c}))])"));
out.push(format!("d[(P({a}),)] = 'z'"));
out.push("print(len(d), sorted(d.values()))".into());
out.push(format!(
"print((P({a}),) in d, (P({d}),) in d, d.get((P({a}),), 'no'))"
));
out.push(format!(
"print(d == {{(P({a}),): 'z', (P({b}), P({c})): 'y'}})"
));
}
13 => {
out.push(format!(
"d = {{((P({a}),),): 1, P({a}): 2, ((P({b}),),): 3}}"
));
out.push(format!("print(len(d), d[((P({a}),),)], d[P({a})])"));
out.push(format!("print(hash((P({a}),)) == hash((P({a}),)))"));
out.push(format!(
"print(hash(((P({a}),),)) == hash(((P({a}),),)), hash(frozenset([P({a})])) == hash(frozenset([P({a})])))"
));
out.push(format!(
"print(len({{(P({a}), P({a})), (P({a}), P({a}))}}), (P({a}), P({a})) == (P({a}), P({a})))"
));
}
14 => {
out.push(format!("d = {{frozenset([P({a}), P({b})]): 'f'}}"));
out.push(format!("print(d[frozenset([P({b}), P({a})])], len(d))"));
out.push(format!("d[frozenset([P({a}), P({b})])] = 'g'"));
out.push("print(len(d), sorted(d.values()))".into());
out.push(format!(
"print({{frozenset([P({a})])}} == {{frozenset([P({a})])}}, len({{frozenset([P({a})]), frozenset([P({a})])}}))"
));
out.push(format!(
"print(len({{(frozenset([P({c})]),): 1, (frozenset([P({c})]),): 2}}))"
));
}
_ => {
out.push(format!("A = {{(P({a}),), (P({b}),)}}"));
out.push(format!("B = {{(P({b}),), (P({c}),)}}"));
out.push("T = lambda s: sorted(e[0].v for e in s)".into());
out.push("print(T(A & B), T(A | B), T(A - B), T(A ^ B))".into());
out.push(format!(
"print(A == {{(P({a}),), (P({b}),)}}, A <= (A | B))"
));
out.push(format!("A.add((P({a}),))"));
out.push(format!("A.update([(P({d}),)])"));
out.push("print(len(A), T(A))".into());
}
}
out
}
fn gen_hashval(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
const INTS: &[&str] = &[
"0",
"1",
"-1",
"2",
"-2",
"7",
"-7",
"255",
"-255",
"2**61-1",
"-(2**61-1)",
"2**61",
"-(2**61)",
"2**61+1",
"2**62",
"-(2**62)",
"2**63-1",
"2**63",
"-(2**63)",
"2**64",
"-(2**64)",
"2**64+7",
"2**70+12345",
"-(2**70+12345)",
"2**128",
"-(2**128)",
"10**30",
"-(10**30)",
"2**61*3+5",
"-(2**61*3+5)",
];
const FLOATS: &[&str] = &[
"0.0",
"-0.0",
"1.0",
"-1.0",
"0.5",
"-0.5",
"2.5",
"-2.5",
"0.1",
"3.14",
"-3.14",
"1e300",
"-1e300",
"1e-300",
"2.0**60",
"2.0**61",
"2.0**62",
"float('inf')",
"float('-inf')",
"1.5e16",
"float(2**53)",
"1/3",
"-(1/3)",
];
const OTHERS: &[&str] = &[
"None",
"True",
"False",
"1+2j",
"3-4j",
"complex(0,1)",
"complex(2.5,-0.5)",
"''",
"'a'",
"'abc'",
"'hello world'",
"'\\u00e9'",
"'\\u65e5'",
"b''",
"b'a'",
"b'abc'",
];
let atom = |r: &mut Rng| -> String {
match r.below(3) {
0 => (*pick(r, INTS)).to_string(),
1 => (*pick(r, FLOATS)).to_string(),
_ => (*pick(r, OTHERS)).to_string(),
}
};
let mut out = Vec::new();
match seed % 7 {
0 => {
for _ in 0..6 {
let a = pick(r, INTS);
out.push(format!("print(hash({a}))"));
}
}
1 => {
for _ in 0..4 {
let a = pick(r, FLOATS);
out.push(format!("print(hash({a}))"));
}
let n = pick(r, INTS);
out.push(format!(
"print(hash({n}), hash(float({n})) if abs({n}) < 2**52 else hash({n}))"
));
}
2 => {
for _ in 0..6 {
let a = pick(r, OTHERS);
out.push(format!("print(hash({a}))"));
}
}
3 => {
out.push("print(hash(()))".into());
for _ in 0..4 {
let a = atom(r);
let b = atom(r);
out.push(format!("print(hash(({a},)), hash(({a}, {b})))"));
}
}
4 => {
let a = atom(r);
let b = atom(r);
let c = atom(r);
out.push(format!("print(hash(({a}, {b}, {c})))"));
out.push(format!("print(hash((({a}, {b}), {c})))"));
out.push(format!("print(hash(({a}, ({b}, ({c},)))))"));
out.push(format!("print(hash(({a},) * 4))"));
out.push(format!("print(hash(({a}, {b}) + ({c},)))"));
}
5 => {
out.push("print(hash(frozenset()))".into());
let a = atom(r);
let b = atom(r);
let c = atom(r);
out.push(format!("print(hash(frozenset([{a}])))"));
out.push(format!(
"print(hash(frozenset([{a}, {b}])), hash(frozenset([{b}, {a}])))"
));
out.push(format!("print(hash(frozenset([{a}, {b}, {c}])))"));
out.push(format!("print(hash((frozenset([{a}, {b}]), {c})))"));
}
_ => {
let n = pick(r, INTS);
out.push(format!("v = {n}"));
out.push("print(hash(v), hash(-v), hash(v) == hash(v + 0))".into());
let f = pick(r, FLOATS);
out.push(format!("w = {f}"));
out.push("print(hash(w), hash(-w) if w == w else 0)".into());
out.push("print(hash(0.0) == hash(-0.0) == hash(0) == hash(False))".into());
out.push("print(hash(1) == hash(1.0) == hash(True) == hash(1+0j))".into());
out.push("print(len({1, 1.0, True}), len({0, 0.0, False, -0.0}))".into());
}
}
out
}
fn gen_regex(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
const SUBJ: &[(&str, &str)] = &[
("'abcabc'", "b"),
("'a\u{e9}b'", "b"),
("'a\u{65e5}b'", "b"),
("'a\u{1f600}b'", "b"),
("'\u{e9}b\u{65e5}\u{672c}'", "b"),
("'na\u{ef}ve caf\u{e9} \u{65e5}\u{672c} b'", "b"),
("'\u{3b1}\u{3b2}b\u{3b3} \u{1f600}\u{e9}'", "b"),
("'x\u{1f600}\u{e9}\u{65e5}b\u{65e5}\u{e9}\u{1f600}'", "b"),
];
let (s, lit) = *pick(r, SUBJ);
let mut out: Vec<String> = vec!["import re".into(), format!("s = {s}")];
match r.below(10) {
0 => {
out.push(format!("m = re.search(r'{lit}', s)"));
out.push("print(m.start(), m.end(), m.span())".into());
out.push("print(repr(m), m.group())".into());
out.push("print(s[m.start():m.end()] == m.group(), len(s))".into());
}
1 => {
out.push("print([m.span() for m in re.finditer(r'.', s)])".into());
out.push("print([m.start() for m in re.finditer(r'.', s, re.S)])".into());
out.push("print([s[m.start():m.end()] for m in re.finditer(r'.', s)])".into());
}
2 => {
out.push(format!("m = re.search(r'(?P<g>{lit})(.)?', s)"));
out.push("print(m.span(), m.span(1), m.span(2), m.span('g'))".into());
out.push("print(m.start('g'), m.end('g'), m.groupdict())".into());
out.push("print(m.lastindex, m.groups())".into());
}
3 => {
out.push("p = re.compile(r'.')".into());
out.push("print([p.search(s, i).span() for i in range(len(s))])".into());
out.push("print([p.match(s, i).group() for i in range(len(s))])".into());
out.push("print(p.search(s, 1, 2).span(), p.match(s, len(s)) is None)".into());
}
4 => {
out.push("p = re.compile(r'.')".into());
out.push("m = p.search(s)".into());
out.push("print(m.pos, m.endpos, m.string == s)".into());
out.push("m2 = p.search(s, 1)".into());
out.push("print(m2.pos, m2.endpos, m2.span())".into());
}
5 => {
out.push("print([m.span() for m in re.finditer(r'', s)])".into());
out.push(format!(
"print([m.span() for m in re.finditer(r'(?={lit})', s)])"
));
out.push("print(len([1 for _ in re.finditer(r'', s)]), len(s) + 1)".into());
}
6 => {
out.push(format!(
"print(re.sub(r'{lit}', lambda m: '<%d:%d>' % (m.start(), m.end()), s))"
));
out.push("print(re.subn(r'.', lambda m: str(m.start()), s, count=2))".into());
}
7 => {
out.push(format!("print(re.split(r'{lit}', s), re.findall(r'.', s))"));
out.push(format!(
"print(re.sub(r'{lit}', 'ZZ', s), re.subn(r'.', '-', s))"
));
out.push(format!("print(re.split(r'({lit})', s, maxsplit=1))"));
}
8 => {
out.push("print(re.fullmatch(r'.+', s).span(), re.match(r'.', s).span())".into());
out.push("print(re.fullmatch(r'.', s), re.match(r'.+', s).end() == len(s))".into());
out.push(
"print(re.match(r'(.)(.)', s).span(2) if re.match(r'(.)(.)', s) else None)".into(),
);
}
_ => {
out.push(format!("p = re.compile(r'({lit})')"));
out.push("print([m.span(1) for m in p.finditer(s)], p.findall(s))".into());
out.push("print(p.search(s).span(), p.split(s), p.sub('#', s))".into());
out.push("print(p.subn('#', s), [m.end() for m in p.finditer(s)])".into());
}
}
out
}
fn gen_suggest(seed: u64) -> Vec<String> {
let r = &mut Rng::new(seed);
const TYPOS: &[(&str, &str)] = &[
("value", "valu"),
("value", "vlaue"),
("value", "Value"),
("value", "valuee"),
("counter", "countr"),
("counter", "cuonter"),
("payload", "payolad"),
("payload", "paylod"),
("name", "nme"),
("name", "namme"),
("total_count", "total_cout"),
("total_count", "totl_count"),
("x", "qqqqqqqq"),
("data", "zzzz"),
];
let (good, typo) = pick(r, TYPOS);
const BUILTIN_TYPOS: &[&str] = &[
"st",
"lenght",
"leng",
"prnt",
"rang",
"sortd",
"strr",
"dictt",
"flat",
"isinstnce",
"enumrate",
"revrsed",
"ValuError",
"TypError",
"KeyErrror",
];
let bad_builtin = pick(r, BUILTIN_TYPOS);
match r.below(8) {
0 => vec![format!("{good} = 1"), typo.to_string()],
1 => vec![bad_builtin.to_string()],
2 => vec![format!("{bad_builtin}([1, 2])")],
3 => vec![
"def f():".into(),
format!(" {good} = 1"),
format!(" return {typo}"),
"f()".into(),
],
4 => vec![
"class C:".into(),
" def __init__(s):".into(),
format!(" s.{good} = 1"),
format!("C().{typo}"),
],
5 => vec![
"class C:".into(),
format!(" def {good}(s):"),
" return 1".into(),
format!("C().{typo}()"),
],
6 => vec!["x = [1]".to_string(), format!("x.{typo}")],
_ => vec![
format!("{good} = 1"),
"try:".into(),
format!(" {typo}"),
"except NameError as e:".into(),
" print(str(e))".into(),
" print(e.args)".into(),
"x = [1]".to_string(),
"try:".into(),
format!(" x.{typo}"),
"except AttributeError as e:".into(),
" print(str(e))".into(),
],
}
}
#[derive(Clone, Copy)]
enum Mode {
Mixed,
Arith,
Bignum,
Floatfmt,
Strings,
Fstring,
Slice,
Listcomp,
Dictcomp,
Setcomp,
Sorting,
Formatspec,
Boolint,
Ranges,
Strmeth,
Comparison,
Builtins,
Ternary,
Augassign,
Classes,
Iterproto,
Generators,
Exceptions,
Unpacking,
Comprehension,
Dictset,
Itertools,
Complexnum,
Numedge,
Exceptions2,
Exceptions3,
Exceptions4,
Closures,
Oop2,
Strfmt2,
Bytesops,
Bytestail,
Format2,
Strformat,
Async,
Async2,
Augwith,
Descriptors,
Attr,
Calls,
Match,
Conttail,
Itertail,
Metatype,
Seqtail,
Display,
Scoping,
Codec,
Subclass,
Slots,
Dataclass,
Walrus,
Functools,
Ctxmgr,
Excgroup,
Suggest,
Valuekey,
Regex,
Hashval,
Stdlibexc,
Containertail,
}
const REAL_MODES: &[Mode] = &[
Mode::Arith,
Mode::Bignum,
Mode::Floatfmt,
Mode::Strings,
Mode::Fstring,
Mode::Slice,
Mode::Listcomp,
Mode::Dictcomp,
Mode::Setcomp,
Mode::Sorting,
Mode::Formatspec,
Mode::Boolint,
Mode::Ranges,
Mode::Strmeth,
Mode::Comparison,
Mode::Builtins,
Mode::Ternary,
Mode::Augassign,
Mode::Classes,
Mode::Iterproto,
Mode::Generators,
Mode::Exceptions,
Mode::Unpacking,
Mode::Comprehension,
Mode::Dictset,
Mode::Itertools,
Mode::Complexnum,
Mode::Numedge,
Mode::Exceptions2,
Mode::Exceptions3,
Mode::Exceptions4,
Mode::Closures,
Mode::Oop2,
Mode::Strfmt2,
Mode::Bytesops,
Mode::Bytestail,
Mode::Format2,
Mode::Strformat,
Mode::Async,
Mode::Async2,
Mode::Augwith,
Mode::Descriptors,
Mode::Attr,
Mode::Calls,
Mode::Match,
Mode::Conttail,
Mode::Itertail,
Mode::Metatype,
Mode::Seqtail,
Mode::Display,
Mode::Scoping,
Mode::Codec,
Mode::Subclass,
Mode::Slots,
Mode::Dataclass,
Mode::Walrus,
Mode::Functools,
Mode::Ctxmgr,
Mode::Excgroup,
Mode::Suggest,
Mode::Valuekey,
Mode::Regex,
Mode::Hashval,
Mode::Stdlibexc,
Mode::Containertail,
];
fn gen_case(seed: u64, mode: Mode) -> Vec<String> {
match mode {
Mode::Mixed => {
let m = REAL_MODES[(seed % REAL_MODES.len() as u64) as usize];
gen_case(seed, m)
}
Mode::Arith => gen_arith(seed),
Mode::Bignum => gen_bignum(seed),
Mode::Floatfmt => gen_floatfmt(seed),
Mode::Strings => gen_strings(seed),
Mode::Fstring => gen_fstring(seed),
Mode::Slice => gen_slice(seed),
Mode::Listcomp => gen_listcomp(seed),
Mode::Dictcomp => gen_dictcomp(seed),
Mode::Setcomp => gen_setcomp(seed),
Mode::Sorting => gen_sorting(seed),
Mode::Formatspec => gen_formatspec(seed),
Mode::Boolint => gen_boolint(seed),
Mode::Ranges => gen_ranges(seed),
Mode::Strmeth => gen_strmeth(seed),
Mode::Comparison => gen_comparison(seed),
Mode::Builtins => gen_builtins(seed),
Mode::Ternary => gen_ternary(seed),
Mode::Augassign => gen_augassign(seed),
Mode::Classes => gen_classes(seed),
Mode::Iterproto => gen_iterproto(seed),
Mode::Generators => gen_generators(seed),
Mode::Exceptions => gen_exceptions(seed),
Mode::Unpacking => gen_unpacking(seed),
Mode::Comprehension => gen_comprehension(seed),
Mode::Dictset => gen_dictset(seed),
Mode::Itertools => gen_itertools(seed),
Mode::Complexnum => gen_complexnum(seed),
Mode::Numedge => gen_numedge(seed),
Mode::Exceptions2 => gen_exceptions2(seed),
Mode::Exceptions3 => gen_exceptions3(seed),
Mode::Exceptions4 => gen_exceptions4(seed),
Mode::Closures => gen_closures(seed),
Mode::Oop2 => gen_oop2(seed),
Mode::Strfmt2 => gen_strfmt2(seed),
Mode::Bytesops => gen_bytesops(seed),
Mode::Bytestail => gen_bytestail(seed),
Mode::Format2 => gen_format2(seed),
Mode::Strformat => gen_strformat(seed),
Mode::Async => gen_async(seed),
Mode::Async2 => gen_async2(seed),
Mode::Augwith => gen_augwith(seed),
Mode::Descriptors => gen_descriptors(seed),
Mode::Attr => gen_attr(seed),
Mode::Calls => gen_calls(seed),
Mode::Match => gen_match(seed),
Mode::Conttail => gen_conttail(seed),
Mode::Itertail => gen_itertail(seed),
Mode::Metatype => gen_metatype(seed),
Mode::Seqtail => gen_seqtail(seed),
Mode::Display => gen_display(seed),
Mode::Scoping => gen_scoping(seed),
Mode::Codec => gen_codec(seed),
Mode::Subclass => gen_subclass(seed),
Mode::Slots => gen_slots(seed),
Mode::Dataclass => gen_dataclass(seed),
Mode::Walrus => gen_walrus(seed),
Mode::Functools => gen_functools(seed),
Mode::Ctxmgr => gen_ctxmgr(seed),
Mode::Excgroup => gen_excgroup(seed),
Mode::Suggest => gen_suggest(seed),
Mode::Valuekey => gen_valuekey(seed),
Mode::Regex => gen_regex(seed),
Mode::Hashval => gen_hashval(seed),
Mode::Stdlibexc => gen_stdlibexc(seed),
Mode::Containertail => gen_containertail(seed),
}
}
fn mode_name(m: Mode) -> &'static str {
match m {
Mode::Mixed => "mixed",
Mode::Arith => "arith",
Mode::Bignum => "bignum",
Mode::Floatfmt => "floatfmt",
Mode::Strings => "strings",
Mode::Fstring => "fstring",
Mode::Slice => "slice",
Mode::Listcomp => "listcomp",
Mode::Dictcomp => "dictcomp",
Mode::Setcomp => "setcomp",
Mode::Sorting => "sorting",
Mode::Formatspec => "formatspec",
Mode::Boolint => "boolint",
Mode::Ranges => "ranges",
Mode::Strmeth => "strmeth",
Mode::Comparison => "comparison",
Mode::Builtins => "builtins",
Mode::Ternary => "ternary",
Mode::Augassign => "augassign",
Mode::Classes => "classes",
Mode::Iterproto => "iterproto",
Mode::Generators => "generators",
Mode::Exceptions => "exceptions",
Mode::Unpacking => "unpacking",
Mode::Comprehension => "comprehension",
Mode::Dictset => "dictset",
Mode::Itertools => "itertools",
Mode::Complexnum => "complexnum",
Mode::Numedge => "numedge",
Mode::Exceptions2 => "exceptions2",
Mode::Exceptions3 => "exceptions3",
Mode::Exceptions4 => "exceptions4",
Mode::Closures => "closures",
Mode::Oop2 => "oop2",
Mode::Strfmt2 => "strfmt2",
Mode::Bytesops => "bytesops",
Mode::Bytestail => "bytestail",
Mode::Format2 => "format2",
Mode::Strformat => "strformat",
Mode::Async => "async",
Mode::Async2 => "async2",
Mode::Augwith => "augwith",
Mode::Descriptors => "descriptors",
Mode::Attr => "attr",
Mode::Calls => "calls",
Mode::Match => "match",
Mode::Conttail => "conttail",
Mode::Itertail => "itertail",
Mode::Metatype => "metatype",
Mode::Seqtail => "seqtail",
Mode::Display => "display",
Mode::Scoping => "scoping",
Mode::Codec => "codec",
Mode::Subclass => "subclass",
Mode::Slots => "slots",
Mode::Dataclass => "dataclass",
Mode::Walrus => "walrus",
Mode::Functools => "functools",
Mode::Ctxmgr => "ctxmgr",
Mode::Excgroup => "excgroup",
Mode::Suggest => "suggest",
Mode::Valuekey => "valuekey",
Mode::Regex => "regex",
Mode::Hashval => "hashval",
Mode::Stdlibexc => "stdlibexc",
Mode::Containertail => "containertail",
}
}
fn mode_from_name(s: &str) -> Option<Mode> {
const ALL: &[Mode] = &[
Mode::Mixed,
Mode::Arith,
Mode::Bignum,
Mode::Floatfmt,
Mode::Strings,
Mode::Fstring,
Mode::Slice,
Mode::Listcomp,
Mode::Dictcomp,
Mode::Setcomp,
Mode::Sorting,
Mode::Formatspec,
Mode::Boolint,
Mode::Ranges,
Mode::Strmeth,
Mode::Comparison,
Mode::Builtins,
Mode::Ternary,
Mode::Augassign,
Mode::Classes,
Mode::Iterproto,
Mode::Generators,
Mode::Exceptions,
Mode::Unpacking,
Mode::Comprehension,
Mode::Dictset,
Mode::Itertools,
Mode::Complexnum,
Mode::Numedge,
Mode::Exceptions2,
Mode::Exceptions3,
Mode::Exceptions4,
Mode::Closures,
Mode::Oop2,
Mode::Strfmt2,
Mode::Bytesops,
Mode::Bytestail,
Mode::Format2,
Mode::Strformat,
Mode::Async,
Mode::Async2,
Mode::Augwith,
Mode::Descriptors,
Mode::Attr,
Mode::Calls,
Mode::Match,
Mode::Conttail,
Mode::Itertail,
Mode::Metatype,
Mode::Seqtail,
Mode::Display,
Mode::Scoping,
Mode::Codec,
Mode::Subclass,
Mode::Slots,
Mode::Dataclass,
Mode::Walrus,
Mode::Functools,
Mode::Ctxmgr,
Mode::Excgroup,
Mode::Suggest,
Mode::Valuekey,
Mode::Regex,
Mode::Hashval,
Mode::Stdlibexc,
Mode::Containertail,
];
ALL.iter().copied().find(|&m| mode_name(m) == s)
}
fn hash_seed_for(seed: u64) -> String {
if seed % 4 == 0 {
"0".to_string()
} else {
(seed % 4_294_967_296).to_string()
}
}
fn diverges(script: &str, bin: &Path, oracle: &str, timeout: Duration, hash_seed: &str) -> bool {
let o = run_prog(Path::new(oracle), script, timeout, true, hash_seed);
let r = run_prog(bin, script, timeout, false, hash_seed);
!o.timed_out && differs(&o, &r)
}
fn minimize(
stmts: Vec<String>,
bin: &Path,
oracle: &str,
timeout: Duration,
hash_seed: &str,
) -> Vec<String> {
let mut cur = stmts;
let mut changed = true;
while changed && cur.len() > 1 {
changed = false;
for i in 0..cur.len() {
let mut cand = cur.clone();
cand.remove(i);
if cand.is_empty() {
continue;
}
if diverges(&build_program(&cand), bin, oracle, timeout, hash_seed) {
cur = cand;
changed = true;
break;
}
}
}
cur
}
fn signature(program: &str) -> String {
let body = program
.lines()
.map(|l| l.trim())
.rfind(|l| !l.is_empty())
.unwrap_or("")
.to_string();
mask_words(&mask_numbers(&body))
}
fn mask_words(s: &str) -> String {
let bytes: Vec<char> = s.chars().collect();
let mut out = String::new();
let mut i = 0;
while i < bytes.len() {
let c = bytes[i];
if c == '\'' || c == '"' {
let quote = c;
i += 1;
while i < bytes.len() && bytes[i] != quote {
i += 1;
}
i += 1; out.push('W');
} else {
out.push(c);
i += 1;
}
}
out
}
fn mask_numbers(s: &str) -> String {
let chars: Vec<char> = s.chars().collect();
let mut out = String::new();
let mut i = 0;
while i < chars.len() {
let c = chars[i];
let prev_alnum = out
.chars()
.last()
.map(|p| p.is_alphanumeric() || p == '_')
.unwrap_or(false);
if c.is_ascii_digit() && !prev_alnum {
while i < chars.len() && (chars[i].is_ascii_digit() || chars[i] == '.') {
i += 1;
}
out.push('N');
} else {
out.push(c);
i += 1;
}
}
out
}
struct Args {
count: u64,
base_seed: u64,
once: bool,
timeout_ms: u64,
out_path: PathBuf,
max_report: usize,
jobs: usize,
mode: Mode,
verify: usize,
baseline: Option<PathBuf>,
}
fn parse_args() -> Args {
let mut count = 2000u64;
let mut base_seed = 1u64;
let mut once = false;
let mut timeout_ms = 5000u64;
let mut max_report = 200usize;
let mut mode = Mode::Mixed;
let mut verify = 1usize;
let mut baseline: Option<PathBuf> = None;
let mut jobs = std::thread::available_parallelism()
.map(|n| n.get())
.unwrap_or(4);
let mut out_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("target")
.join("parity-fuzz")
.join(format!("divergences-{}.txt", std::process::id()));
let argv: Vec<String> = std::env::args().skip(1).collect();
let mut i = 0;
while i < argv.len() {
match argv[i].as_str() {
"--count" | "-c" => {
i += 1;
count = argv.get(i).and_then(|s| s.parse().ok()).unwrap_or(count);
}
"--seed" | "-s" => {
i += 1;
base_seed = argv
.get(i)
.and_then(|s| s.parse().ok())
.unwrap_or(base_seed);
}
"--once" => once = true,
"--timeout-ms" => {
i += 1;
timeout_ms = argv
.get(i)
.and_then(|s| s.parse().ok())
.unwrap_or(timeout_ms);
}
"--out" | "-o" => {
i += 1;
if let Some(p) = argv.get(i) {
out_path = PathBuf::from(p);
}
}
"--max-report" => {
i += 1;
max_report = argv
.get(i)
.and_then(|s| s.parse().ok())
.unwrap_or(max_report);
}
"--jobs" | "-j" => {
i += 1;
jobs = argv
.get(i)
.and_then(|s| s.parse().ok())
.filter(|&j| j >= 1)
.unwrap_or(jobs);
}
"--mode" | "-m" => {
i += 1;
match argv.get(i).and_then(|s| mode_from_name(s)) {
Some(m) => mode = m,
None => {
eprintln!(
"unknown --mode '{}'",
argv.get(i).map(|s| s.as_str()).unwrap_or("")
);
std::process::exit(2);
}
}
}
a if a.starts_with("--") && mode_from_name(&a[2..]).is_some() => {
mode = mode_from_name(&a[2..]).unwrap();
}
"--verify" => {
i += 1;
verify = argv
.get(i)
.and_then(|s| s.parse().ok())
.filter(|&k| k >= 1)
.unwrap_or(verify);
}
"--baseline" => {
i += 1;
baseline = argv.get(i).map(PathBuf::from);
}
"--stderr" => {
CMP_STDERR.store(true, Ordering::Relaxed);
}
"--help" | "-h" => {
print_help();
std::process::exit(0);
}
_ => {}
}
i += 1;
}
Args {
count,
base_seed,
once,
timeout_ms,
out_path,
max_report,
jobs,
mode,
verify,
baseline,
}
}
fn print_help() {
eprintln!(
"parity-fuzz — differential python3/pythonrs parity fuzzer\n\
\n\
--count N number of cases (default 2000)\n\
--seed N base seed; case i uses seed+i (default 1)\n\
--mode M mixed (default; rotates all modes), arith, bignum,\n\
floatfmt, strings, fstring, slice, listcomp, dictcomp,\n\
setcomp, sorting, formatspec, boolint, ranges, strmeth,\n\
comparison, builtins, ternary, augassign, async, …\n\
(each also accepted as a `--<mode>` shorthand)\n\
--stderr also require the normalized error line to match\n\
--once run a single case (seed) and print both outputs\n\
--timeout-ms N per-process wall-clock timeout (default 5000)\n\
--out PATH divergence corpus file\n\
--max-report N stop after N divergences (default 200)\n\
--jobs N parallel workers (default = CPU count)\n\
--verify K require K consecutive divergences to report (default 1)\n\
--baseline FILE allowlist of known-gap signatures; only a NEW\n\
divergence (not in FILE) fails the run (exit 1)\n\
\n\
env PYTHONRS_FUZZ_PYTHON=PATH the reference CPython to compare against\n\
(HARD ERROR if set but unusable). Every run prints the oracle it used."
);
}
fn main() {
let args = parse_args();
let bin = ours_bin();
let oracle = resolve_oracle();
let timeout = Duration::from_millis(args.timeout_ms);
if !bin.exists() {
eprintln!(
"pythonrs `python` binary not found at {}; run `cargo build` first",
bin.display()
);
std::process::exit(2);
}
if args.once {
let stmts = gen_case(args.base_seed, args.mode);
let script = build_program(&stmts);
let hseed = hash_seed_for(args.base_seed);
let o = run_prog(Path::new(&oracle), &script, timeout, true, &hseed);
let r = run_prog(&bin, &script, timeout, false, &hseed);
let diverged = !o.timed_out && differs(&o, &r);
println!("seed : {}", args.base_seed);
println!("mode : {}", mode_name(args.mode));
println!("hashseed: {hseed}");
let (show, o, r) = if diverged && stmts.len() > 1 {
let m = minimize(stmts, &bin, &oracle, timeout, &hseed);
let ms = build_program(&m);
let mo = run_prog(Path::new(&oracle), &ms, timeout, true, &hseed);
let mr = run_prog(&bin, &ms, timeout, false, &hseed);
(ms, mo, mr)
} else {
(script, o, r)
};
println!("program:\n {}", show.replace('\n', "\n "));
println!("--- python3 exit={} timeout={} ---", o.exit, o.timed_out);
let _ = std::io::stdout().write_all(&o.stdout);
println!("--- pythonrs exit={} timeout={} ---", r.exit, r.timed_out);
let _ = std::io::stdout().write_all(&r.stdout);
println!("--- {} ---", if diverged { "DIVERGE" } else { "match" });
std::process::exit(if diverged { 1 } else { 0 });
}
let next = AtomicU64::new(0);
let checked = AtomicU64::new(0);
let timeouts = AtomicU64::new(0);
let barren = AtomicU64::new(0);
let stop = AtomicBool::new(false);
let divergences: Mutex<Vec<(u64, String)>> = Mutex::new(Vec::new());
let start = Instant::now();
eprintln!("oracle: {}", oracle_id(&oracle));
eprintln!("ours : {}", bin.display());
eprintln!(
"fuzzing {} cases ({}) across {} workers…",
args.count,
mode_name(args.mode),
args.jobs
);
std::thread::scope(|scope| {
for _ in 0..args.jobs {
scope.spawn(|| loop {
if stop.load(Ordering::Relaxed) {
break;
}
let idx = next.fetch_add(1, Ordering::Relaxed);
if idx >= args.count {
break;
}
let seed = args.base_seed.wrapping_add(idx);
let stmts = gen_case(seed, args.mode);
let script = build_program(&stmts);
let hseed = hash_seed_for(seed);
let o = run_prog(Path::new(&oracle), &script, timeout, true, &hseed);
let r = run_prog(&bin, &script, timeout, false, &hseed);
let done = checked.fetch_add(1, Ordering::Relaxed) + 1;
if o.timed_out || r.timed_out {
timeouts.fetch_add(1, Ordering::Relaxed);
}
if o.timed_out || o.exit != 0 || o.stdout.is_empty() {
barren.fetch_add(1, Ordering::Relaxed);
}
if !o.timed_out && differs(&o, &r) {
let minimal = minimize(stmts, &bin, &oracle, timeout, &hseed);
let mscript = build_program(&minimal);
let mo = run_prog(Path::new(&oracle), &mscript, timeout, true, &hseed);
let mr = run_prog(&bin, &mscript, timeout, false, &hseed);
let mut confirmed = differs(&mo, &mr);
for _ in 1..args.verify.max(1) {
if !confirmed {
break;
}
confirmed = diverges(&mscript, &bin, &oracle, timeout, &hseed);
}
if !confirmed {
continue;
}
let err_of = |o: &RunOut| -> String {
if CMP_STDERR.load(Ordering::Relaxed) {
format!(
"\n stderr: {}",
render(&norm_stderr(&o.stderr)).replace('\n', "\n ")
)
} else {
String::new()
}
};
let rec = format!(
"==== seed {seed} ====\n\
program:\n {}\n\
python3 : exit={} timeout={}{}\n{}\n\
pythonrs : exit={} timeout={}{}\n{}\n",
mscript.replace('\n', "\n "),
mo.exit,
mo.timed_out,
err_of(&mo),
render(&mo.stdout),
mr.exit,
mr.timed_out,
err_of(&mr),
render(&mr.stdout),
);
let mut d = divergences.lock().unwrap();
d.push((seed, rec));
if d.len() >= args.max_report {
stop.store(true, Ordering::Relaxed);
}
}
if done % 500 == 0 {
let n = divergences.lock().unwrap().len();
eprintln!(
" {done}/{} checked, {n} divergences, {:.0}/s",
args.count,
done as f64 / start.elapsed().as_secs_f64().max(0.001)
);
}
});
}
});
let checked = checked.load(Ordering::Relaxed);
let timeouts = timeouts.load(Ordering::Relaxed);
let barren = barren.load(Ordering::Relaxed);
let mut divergences: Vec<(u64, String)> = divergences.into_inner().unwrap();
divergences.sort_by_key(|(seed, _)| *seed);
let divergences: Vec<String> = divergences.into_iter().map(|(_, r)| r).collect();
let elapsed = start.elapsed();
let sig_of = |rec: &str| -> String {
let prog = rec
.split("program:\n")
.nth(1)
.and_then(|s| s.split("\npython3").next())
.unwrap_or(rec);
signature(prog)
};
let allowed: std::collections::HashSet<String> = match &args.baseline {
Some(bp) => std::fs::read_to_string(bp)
.unwrap_or_default()
.lines()
.map(|l| l.trim().to_string())
.filter(|l| !l.is_empty() && !l.starts_with('#'))
.collect(),
None => std::collections::HashSet::new(),
};
let mut new_records: Vec<&String> = Vec::new();
let mut new_sigs: std::collections::BTreeSet<String> = std::collections::BTreeSet::new();
let mut known = 0usize;
for rec in &divergences {
let sig = sig_of(rec);
if args.baseline.is_some() && allowed.contains(&sig) {
known += 1;
} else {
new_records.push(rec);
new_sigs.insert(sig);
}
}
let oracle = oracle_id(&oracle);
println!(
"\nfuzzed {checked} cases in {:.1}s ({:.0}/s)\n\
oracle : {}\n\
divergences : {} ({} known / {} new)\n\
timeouts : {}\n\
barren : {} (oracle timed out, exited non-zero, or printed nothing — measured nothing)\n\
productive : {}",
elapsed.as_secs_f64(),
checked as f64 / elapsed.as_secs_f64().max(0.001),
oracle,
divergences.len(),
known,
new_records.len(),
timeouts,
barren,
checked.saturating_sub(barren),
);
if !divergences.is_empty() {
if let Some(parent) = args.out_path.parent() {
let _ = std::fs::create_dir_all(parent);
}
if let Ok(mut f) = std::fs::File::create(&args.out_path) {
let _ = writeln!(f, "# oracle: {oracle}");
for d in &divergences {
let _ = writeln!(f, "{d}");
}
println!(
"wrote {} divergences to {}",
divergences.len(),
args.out_path.display()
);
}
}
if !new_records.is_empty() {
println!(
"\n--- {} NEW gap signature(s) (add to baseline once triaged) ---",
new_sigs.len()
);
for s in &new_sigs {
println!("{s}");
}
println!(
"\n--- first {} new divergence record(s) ---",
new_records.len().min(5)
);
for d in new_records.iter().take(5) {
println!("{d}");
}
std::process::exit(1);
}
if known > 0 {
println!("all {known} divergences are known (in baseline) — OK");
}
let shortfall = args.count.saturating_sub(checked);
let productive = checked.saturating_sub(barren);
if shortfall > 0 || productive == 0 {
println!(
"\nFAILED: {shortfall} of {} case(s) never ran and {productive} produced a comparable \
answer — this run measured nothing, it is not a pass",
args.count
);
std::process::exit(3);
}
}