pounce-cli 0.8.0

Command-line driver for POUNCE — solves built-in TNLPs and AMPL .nl files.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

//! End-to-end integration test for the `pounce check-x0` subcommand.
//!
//! Drives the real binary against committed fixtures and checks the
//! contract:
//!
//! * a healthy `.nl` (`parametric.nl`) evaluates cleanly → exit 0, JSON
//!   report with `"fatal": false` and the documented schema fields;
//! * a builtin (`rosenbrock`) works through `--builtin` → exit 0;
//! * `--x0-file` with the wrong length → usage error, exit 2;
//! * `--x0-file` overriding the start is honored (a wildly infeasible
//!   point raises the reported constraint violation but stays exit 0 —
//!   infeasibility is not fatal, only non-evaluability is).

use std::path::PathBuf;
use std::process::Command;

fn pounce_exe() -> PathBuf {
    PathBuf::from(env!("CARGO_BIN_EXE_pounce"))
}

fn fixture_nl() -> PathBuf {
    let mut p = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
    p.push("tests");
    p.push("fixtures");
    p.push("parametric.nl");
    p
}

fn tmp(suffix: &str) -> PathBuf {
    let mut p = std::env::temp_dir();
    p.push(format!("pounce_check_x0_{}_{suffix}", std::process::id()));
    p
}

#[test]
fn healthy_nl_is_clean_and_emits_schema_json() {
    let out = Command::new(pounce_exe())
        .arg("check-x0")
        .arg(fixture_nl())
        .arg("--json")
        .output()
        .expect("spawn pounce check-x0");
    assert_eq!(
        out.status.code(),
        Some(0),
        "stderr: {}",
        String::from_utf8_lossy(&out.stderr)
    );
    let v: serde_json::Value =
        serde_json::from_slice(&out.stdout).expect("stdout is a JSON report");
    assert_eq!(v["schema"], "pounce.check-x0/v1");
    assert_eq!(v["fatal"], false);
    assert_eq!(v["problem"]["n_vars"], 5);
    assert_eq!(v["problem"]["n_cons"], 4);
    assert!(v["evaluation"]["objective_finite"].as_bool().unwrap());
    assert!(v["problem"]["sha256"].as_str().is_some());
}

#[test]
fn builtin_is_supported() {
    let out = Command::new(pounce_exe())
        .arg("check-x0")
        .arg("--builtin")
        .arg("rosenbrock")
        .arg("--json")
        .output()
        .expect("spawn pounce check-x0 --builtin");
    assert_eq!(
        out.status.code(),
        Some(0),
        "stderr: {}",
        String::from_utf8_lossy(&out.stderr)
    );
    let v: serde_json::Value = serde_json::from_slice(&out.stdout).expect("JSON");
    assert_eq!(v["fatal"], false);
    assert_eq!(v["problem"]["source"], "builtin:rosenbrock");
}

#[test]
fn x0_file_wrong_length_is_usage_error() {
    let bad = tmp("short_x0.txt");
    std::fs::write(&bad, "1.0 2.0").unwrap(); // parametric.nl has 5 vars
    let code = Command::new(pounce_exe())
        .arg("check-x0")
        .arg(fixture_nl())
        .arg("--x0-file")
        .arg(&bad)
        .status()
        .expect("spawn")
        .code();
    assert_eq!(code, Some(2));
    let _ = std::fs::remove_file(&bad);
}

#[test]
fn x0_file_overrides_start_and_infeasibility_is_not_fatal() {
    let far = tmp("far_x0.txt");
    std::fs::write(&far, "1e6 1e6 1e6 1e6 1e6").unwrap();
    let report = tmp("far_report.json");
    let code = Command::new(pounce_exe())
        .arg("check-x0")
        .arg(fixture_nl())
        .arg("--x0-file")
        .arg(&far)
        .arg("--json-output")
        .arg(&report)
        .status()
        .expect("spawn")
        .code();
    assert_eq!(
        code,
        Some(0),
        "an infeasible-but-evaluable start is not fatal"
    );
    let v: serde_json::Value =
        serde_json::from_slice(&std::fs::read(&report).unwrap()).expect("JSON");
    assert_eq!(v["fatal"], false);
    assert!(v["x0"]["source"].as_str().unwrap().contains("far_x0.txt"));
    // A point at 1e6 in every coordinate must violate something in a
    // 5-var/4-con parametric model with finite constraint bounds.
    assert!(v["constraint_violation"]["max_violation"].as_f64().unwrap() > 1.0);
    let _ = std::fs::remove_file(&far);
    let _ = std::fs::remove_file(&report);
}