ilo 26.5.0

// Regression tests for the `fmt2 x digits` builtin — format a number to `digits`
// decimal places, returning text. Uses Rust's standard half-to-even rounding
// (the default for `format!("{:.N$}")`).
//
// Cross-engine: tree, vm, and (when enabled) cranelift JIT.

use std::process::Command;

fn ilo() -> Command {
    Command::new(env!("CARGO_BIN_EXE_ilo"))
}

fn run(engine: &str, src: &str, entry: &str) -> String {
    let out = ilo()
        .args([src, engine, entry])
        .output()
        .expect("failed to run ilo");
    assert!(
        out.status.success(),
        "ilo {engine} failed for `{src}`: stderr={}",
        String::from_utf8_lossy(&out.stderr)
    );
    String::from_utf8_lossy(&out.stdout).trim().to_string()
}

// Basic: 3.14159 to 2 decimals → "3.14".
const BASIC_SRC: &str = "f>t;fmt2 3.14159 2";

fn check_basic(engine: &str) {
    assert_eq!(run(engine, BASIC_SRC, "f"), "3.14", "engine={engine}");
}

#[test]
fn fmt2_basic_tree() {
    check_basic("--vm");
}

#[test]
fn fmt2_basic_vm() {
    check_basic("--vm");
}

#[test]
#[cfg(feature = "cranelift")]
fn fmt2_basic_cranelift() {
    check_basic("--jit");
}

// Zero decimals: integer-valued float prints without a fractional part.
const ZERO_DIGITS_SRC: &str = "f>t;fmt2 1.0 0";

fn check_zero_digits(engine: &str) {
    assert_eq!(run(engine, ZERO_DIGITS_SRC, "f"), "1", "engine={engine}");
}

#[test]
fn fmt2_zero_digits_tree() {
    check_zero_digits("--vm");
}

#[test]
fn fmt2_zero_digits_vm() {
    check_zero_digits("--vm");
}

#[test]
#[cfg(feature = "cranelift")]
fn fmt2_zero_digits_cranelift() {
    check_zero_digits("--jit");
}

// Long fractional number, asymmetric truncation.
const LONG_FRAC_SRC: &str = "f>t;fmt2 0.85025037 4";

fn check_long_frac(engine: &str) {
    assert_eq!(run(engine, LONG_FRAC_SRC, "f"), "0.8503", "engine={engine}");
}

#[test]
fn fmt2_long_frac_tree() {
    check_long_frac("--vm");
}

#[test]
fn fmt2_long_frac_vm() {
    check_long_frac("--vm");
}

#[test]
#[cfg(feature = "cranelift")]
fn fmt2_long_frac_cranelift() {
    check_long_frac("--jit");
}

// Half-to-even (banker's rounding): 1.5 → "2", 2.5 → "2".
const HALF_EVEN_UP_SRC: &str = "f>t;fmt2 1.5 0";

fn check_half_even_up(engine: &str) {
    assert_eq!(run(engine, HALF_EVEN_UP_SRC, "f"), "2", "engine={engine}");
}

#[test]
fn fmt2_half_even_up_tree() {
    check_half_even_up("--vm");
}

#[test]
fn fmt2_half_even_up_vm() {
    check_half_even_up("--vm");
}

#[test]
#[cfg(feature = "cranelift")]
fn fmt2_half_even_up_cranelift() {
    check_half_even_up("--jit");
}

const HALF_EVEN_DOWN_SRC: &str = "f>t;fmt2 2.5 0";

fn check_half_even_down(engine: &str) {
    assert_eq!(run(engine, HALF_EVEN_DOWN_SRC, "f"), "2", "engine={engine}");
}

#[test]
fn fmt2_half_even_down_tree() {
    check_half_even_down("--vm");
}

#[test]
fn fmt2_half_even_down_vm() {
    check_half_even_down("--vm");
}

#[test]
#[cfg(feature = "cranelift")]
fn fmt2_half_even_down_cranelift() {
    check_half_even_down("--jit");
}

// Doc-pinned composed form: the canonical `fmt "x={}" (fmt2 v 2)` snippet
// from SPEC.md and `skills/ilo/ilo-builtins-text.md`. Pending #5bk surfaced
// that the skill doc described `fmt2` as a list-splat variant; this test
// pins the documented decimal-formatter shape cross-engine so the doc and
// the implementation stay in lock-step.
const COMPOSE_SRC: &str = "f v:n>t;fmt \"x={}\" (fmt2 v 2)";

fn check_compose(engine: &str) {
    // Call entry with arg `3.14159` -> "x=3.14".
    let out = ilo()
        .args([COMPOSE_SRC, engine, "f", "3.14159"])
        .output()
        .expect("failed to run ilo");
    assert!(
        out.status.success(),
        "ilo {engine} failed for compose form: stderr={}",
        String::from_utf8_lossy(&out.stderr)
    );
    let stdout = String::from_utf8_lossy(&out.stdout).trim().to_string();
    assert_eq!(stdout, "x=3.14", "engine={engine}");
}

#[test]
fn fmt2_compose_tree() {
    check_compose("--vm");
}

#[test]
fn fmt2_compose_vm() {
    check_compose("--vm");
}

#[test]
#[cfg(feature = "cranelift")]
fn fmt2_compose_cranelift() {
    check_compose("--jit");
}

// Negative digits clamp to 0 (integer formatting). Use a literal -1.
const NEG_DIGITS_SRC: &str = "f>t;fmt2 3.7 -1";

fn check_neg_digits(engine: &str) {
    assert_eq!(run(engine, NEG_DIGITS_SRC, "f"), "4", "engine={engine}");
}

#[test]
fn fmt2_neg_digits_tree() {
    check_neg_digits("--vm");
}

#[test]
fn fmt2_neg_digits_vm() {
    check_neg_digits("--vm");
}

#[test]
#[cfg(feature = "cranelift")]
fn fmt2_neg_digits_cranelift() {
    check_neg_digits("--jit");
}