mirror of
https://github.com/ellmau/adf-obdd.git
synced 2025-12-19 09:29:36 +01:00
d7e71e5da7
* Add NoGood and NoGoodStore (#65) * Update Flake to nix 22.05 * Add nogood-algorithm to the ADF * Add public api for the nogood-learner * Add direnv to gitignore * Avoid a Box, support custom heuristics functions * Add ng option with heu to binary * Introduce a new flag to handle big instances (modelcount vs adhoccount) Note that adhoccount without modelcount will not produce correct modelcounts if memoization is used * Add new heuristic * Add crossbeam-channel to represent an output-stream of stable models Uses a crossbeam-channel to fill a Queue, which can be used safely from outside the function. This rework is done to also allow ad-hoc output of results in a potentially multi-threaded setup. * Added documentation on this new feature on the module-page * Fix broken links in rust-doc * Update Readme for lib to reflect the new NoGood API * Add metadata to bin/Cargo.toml, add features * added a benchmark feature, to easily compile benchmark-releases * Fix facet count tests * Add multithread-safe functionality for the dictionary/ordering * Streamline a couple of API calls * Expose more structs and methods to the public API * Breaking some API (though nothing which is currently used in the binary) * Simple version of gh pages * Added more links and information to the landing page * Fix badges in the app-doc * Add two valued interpretation Parameterised the stable-nogood algorithm to allow a variable stability check function. * Refactor nogood-algorithm name * Update README.md and documentation (`docu` folder) `README.md` on the `/` level is now presenting the same information which is provided in `docs/index.md` * Update main - Update main functionality - Update naming * Fix cli-test * Update Version to 0.3.0 Due to braking API changes and reaching a milestone, the version is incremented to 0.3.0 (beta) * Update Documentation navigation (#81) * flake.lock: Update Flake lock file updates: • Updated input 'flake-utils': 'github:numtide/flake-utils/1ed9fb1935d260de5fe1c2f7ee0ebaae17ed2fa1' (2022-05-30) → 'github:numtide/flake-utils/7e2a3b3dfd9af950a856d66b0a7d01e3c18aa249' (2022-07-04) • Updated input 'gitignoresrc': 'github:hercules-ci/gitignore.nix/bff2832ec341cf30acb3a4d3e2e7f1f7b590116a' (2022-03-05) → 'github:hercules-ci/gitignore.nix/f2ea0f8ff1bce948ccb6b893d15d5ea3efaf1364' (2022-07-21) • Updated input 'nixpkgs': 'github:NixOS/nixpkgs/8b538fcb329a7bc3d153962f17c509ee49166973' (2022-06-15) → 'github:NixOS/nixpkgs/e43cf1748462c81202a32b26294e9f8eefcc3462' (2022-08-01) • Updated input 'nixpkgs-unstable': 'github:NixOS/nixpkgs/b1957596ff1c7aa8c55c4512b7ad1c9672502e8e' (2022-06-15) → 'github:NixOS/nixpkgs/7b9be38c7250b22d829ab6effdee90d5e40c6e5c' (2022-07-30) • Updated input 'rust-overlay': 'github:oxalica/rust-overlay/9eea93067eff400846c36f57b7499df9ef428ba0' (2022-06-17) → 'github:oxalica/rust-overlay/9055cb4f33f062c0dd33aa7e3c89140da8f70057' (2022-08-02) * Add type alias for NoGood Add a type alias `Interpretation` for NoGood to reflect the duality where an Interpretation might become a NoGood. * Add documentation information about later revisions on VarContainer Co-authored-by: Maximilian Marx <mmarx@wh2.tu-dresden.de>
355 lines
12 KiB
Rust
355 lines
12 KiB
Rust
use assert_cmd::prelude::*; // Add methods on commands
|
|
use assert_fs::prelude::*;
|
|
use predicates::prelude::*; // Used for writing assertions
|
|
use std::process::Command; // Run programs
|
|
|
|
#[test]
|
|
fn arguments() -> Result<(), Box<dyn std::error::Error>> {
|
|
let mut cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.arg("-vvv").arg("--lx").arg("file.txt");
|
|
cmd.assert()
|
|
.failure()
|
|
.stderr(predicate::str::contains("No such file or directory"));
|
|
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.arg("-v").arg("--lx").arg("--an").arg("file.txt");
|
|
cmd.assert().failure().stderr(predicate::str::contains(
|
|
"The argument '--lx' cannot be used with '--an'",
|
|
));
|
|
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.arg("-h");
|
|
cmd.assert().success().stdout(predicate::str::contains(
|
|
"stefan.ellmauthaler@tu-dresden.de",
|
|
));
|
|
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.arg("--version");
|
|
cmd.assert()
|
|
.success()
|
|
.stdout(predicate::str::contains("adf-bdd-solver "));
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn runs_naive() -> Result<(), Box<dyn std::error::Error>> {
|
|
let file = assert_fs::NamedTempFile::new("input_instance.adf")?;
|
|
file.write_str("s(7).s(4).s(8).s(3).s(5).s(9).s(10).s(1).s(6).s(2).ac(7,or(or(and(7,neg(1)),neg(9)),3)).ac(4,5).ac(8,or(or(8,1),neg(7))).ac(3,or(and(or(6,7),neg(and(6,7))),neg(2))).ac(5,c(f)).ac(9,and(neg(7),2)).ac(10,or(neg(2),6)).ac(1,and(or(or(neg(2),neg(1)),8),7)).ac(6,and(and(neg(2),10),and(or(7,4),neg(and(7,4))))).ac(2,and(and(and(neg(10),3),neg(6)),or(9,1))).")?;
|
|
let wrong_file = assert_fs::NamedTempFile::new("wrong_format.adf")?;
|
|
wrong_file.write_str("s(7).s(4).s(8).s(3).s(5).s(9).s(10).s(1).s(6).s(2).ac(7,or(or(and(7,neg(1)),neg(9)),3)).ac(4,5).ac(8,or(or(8,1),neg(7))).ac(3,or(and(or(6,7),neg(and(6,7))),neg(2))).ac(5,c(f)).ac(9,and(neg(7),2)).ac(10,or(neg(2),6)).ac(1,and(or(or(neg(2),neg(1)),8),7)).ac(6,and(and(neg(2),10),and(or(7,4),neg(and(7,4))))).ac(2,and(and(and(neg(10),3),neg(6)),or(9,1)))).")?;
|
|
|
|
let mut cmd = Command::cargo_bin("adf-bdd")?;
|
|
|
|
cmd.arg(wrong_file.path());
|
|
cmd.assert()
|
|
.failure()
|
|
.stderr(predicate::str::contains("code: Eof"));
|
|
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.arg(file.path())
|
|
.arg("-vv")
|
|
.arg("--grd")
|
|
.arg("--lib")
|
|
.arg("naive");
|
|
cmd.assert().success().stdout(predicate::str::contains(
|
|
"u(7) F(4) u(8) u(3) F(5) u(9) u(10) u(1) u(6) u(2)",
|
|
));
|
|
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.arg(file.path())
|
|
.arg("-q")
|
|
.arg("--grd")
|
|
.arg("--lib")
|
|
.arg("naive");
|
|
cmd.assert().success().stdout(predicate::str::contains(
|
|
"u(7) F(4) u(8) u(3) F(5) u(9) u(10) u(1) u(6) u(2)",
|
|
));
|
|
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.arg(file.path())
|
|
.arg("--lx")
|
|
.arg("-v")
|
|
.arg("--grd")
|
|
.arg("--lib")
|
|
.arg("naive");
|
|
cmd.assert().success().stdout(predicate::str::contains(
|
|
"u(1) u(10) u(2) u(3) F(4) F(5) u(6) u(7) u(8) u(9)",
|
|
));
|
|
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.arg(file.path())
|
|
.arg("--an")
|
|
.arg("--grd")
|
|
.arg("--stm")
|
|
.arg("--lib")
|
|
.arg("naive");
|
|
cmd.assert().success().stdout(predicate::str::contains(
|
|
"u(1) u(2) u(3) F(4) F(5) u(6) u(7) u(8) u(9) u(10) \n",
|
|
));
|
|
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.env_clear();
|
|
cmd.arg(file.path())
|
|
.arg("--an")
|
|
.arg("--grd")
|
|
.arg("--lib")
|
|
.arg("naive");
|
|
cmd.assert().success().stdout(predicate::str::contains(
|
|
"u(1) u(2) u(3) F(4) F(5) u(6) u(7) u(8) u(9) u(10) \n",
|
|
));
|
|
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.arg(file.path())
|
|
.arg("--an")
|
|
.arg("--grd")
|
|
.arg("--rust_log")
|
|
.arg("trace")
|
|
.arg("--lib")
|
|
.arg("naive");
|
|
cmd.assert().success().stdout(predicate::str::contains(
|
|
"u(1) u(2) u(3) F(4) F(5) u(6) u(7) u(8) u(9) u(10) \n",
|
|
));
|
|
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.arg(file.path())
|
|
.arg("--an")
|
|
.arg("--grd")
|
|
.arg("--rust_log")
|
|
.arg("warn")
|
|
.arg("--lib")
|
|
.arg("naive");
|
|
cmd.assert().success().stdout(predicate::str::contains(
|
|
"u(1) u(2) u(3) F(4) F(5) u(6) u(7) u(8) u(9) u(10) \n",
|
|
));
|
|
|
|
let tempdir = assert_fs::TempDir::new()?;
|
|
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.arg(file.path())
|
|
.arg("--an")
|
|
.arg("--grd")
|
|
.arg("--lib")
|
|
.arg("naive")
|
|
.arg("--export")
|
|
.arg(tempdir.path().with_file_name("test.json"));
|
|
cmd.assert().success().stdout(predicate::str::contains(
|
|
"u(1) u(2) u(3) F(4) F(5) u(6) u(7) u(8) u(9) u(10) \n",
|
|
));
|
|
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.arg(file.path())
|
|
.arg("--an")
|
|
.arg("--grd")
|
|
.arg("--lib")
|
|
.arg("naive")
|
|
.arg("--export")
|
|
.arg(tempdir.path().with_file_name("test.json"));
|
|
cmd.assert().success().stdout(predicate::str::contains(
|
|
"u(1) u(2) u(3) F(4) F(5) u(6) u(7) u(8) u(9) u(10) \n",
|
|
));
|
|
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.arg(tempdir.path().with_file_name("test.json"))
|
|
.arg("--an")
|
|
.arg("--grd")
|
|
.arg("--import")
|
|
.arg("--lib")
|
|
.arg("naive");
|
|
cmd.assert().success().stdout(predicate::str::contains(
|
|
"u(1) u(2) u(3) F(4) F(5) u(6) u(7) u(8) u(9) u(10) \n",
|
|
));
|
|
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.arg(file.path())
|
|
.arg("--an")
|
|
.arg("--com")
|
|
.arg("--rust_log")
|
|
.arg("warn")
|
|
.arg("--lib")
|
|
.arg("naive");
|
|
cmd.assert().success().stdout(predicate::str::contains(
|
|
"u(1) u(2) u(3) F(4) F(5) u(6) u(7) u(8) u(9) u(10) \n",
|
|
));
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn runs_biodivine() -> Result<(), Box<dyn std::error::Error>> {
|
|
let file = assert_fs::NamedTempFile::new("input_instance.adf")?;
|
|
file.write_str("s(7).s(4).s(8).s(3).s(5).s(9).s(10).s(1).s(6).s(2).ac(7,or(or(and(7,neg(1)),neg(9)),3)).ac(4,5).ac(8,or(or(8,1),neg(7))).ac(3,or(and(or(6,7),neg(and(6,7))),neg(2))).ac(5,c(f)).ac(9,and(neg(7),2)).ac(10,or(neg(2),6)).ac(1,and(or(or(neg(2),neg(1)),8),7)).ac(6,and(and(neg(2),10),and(or(7,4),neg(and(7,4))))).ac(2,and(and(and(neg(10),3),neg(6)),or(9,1))).")?;
|
|
let wrong_file = assert_fs::NamedTempFile::new("wrong_format.adf")?;
|
|
wrong_file.write_str("s(7).s(4).s(8).s(3).s(5).s(9).s(10).s(1).s(6).s(2).ac(7,or(or(and(7,neg(1)),neg(9)),3)).ac(4,5).ac(8,or(or(8,1),neg(7))).ac(3,or(and(or(6,7),neg(and(6,7))),neg(2))).ac(5,c(f)).ac(9,and(neg(7),2)).ac(10,or(neg(2),6)).ac(1,and(or(or(neg(2),neg(1)),8),7)).ac(6,and(and(neg(2),10),and(or(7,4),neg(and(7,4))))).ac(2,and(and(and(neg(10),3),neg(6)),or(9,1)))).")?;
|
|
|
|
let mut cmd = Command::cargo_bin("adf-bdd")?;
|
|
|
|
cmd.arg(wrong_file.path());
|
|
cmd.assert()
|
|
.failure()
|
|
.stderr(predicate::str::contains("code: Eof"));
|
|
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.arg(file.path()).arg("-vv").arg("--grd");
|
|
cmd.assert().success().stdout(predicate::str::contains(
|
|
"u(7) F(4) u(8) u(3) F(5) u(9) u(10) u(1) u(6) u(2)",
|
|
));
|
|
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.arg(file.path()).arg("-q").arg("--grd");
|
|
cmd.assert().success().stdout(predicate::str::contains(
|
|
"u(7) F(4) u(8) u(3) F(5) u(9) u(10) u(1) u(6) u(2)",
|
|
));
|
|
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.arg(file.path()).arg("--lx").arg("-v").arg("--grd");
|
|
cmd.assert().success().stdout(predicate::str::contains(
|
|
"u(1) u(10) u(2) u(3) F(4) F(5) u(6) u(7) u(8) u(9)",
|
|
));
|
|
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.arg(file.path()).arg("--an").arg("--grd").arg("--stm");
|
|
cmd.assert().success().stdout(predicate::str::contains(
|
|
"u(1) u(2) u(3) F(4) F(5) u(6) u(7) u(8) u(9) u(10) \n",
|
|
));
|
|
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.env_clear();
|
|
cmd.arg(file.path()).arg("--an").arg("--grd");
|
|
cmd.assert().success().stdout(predicate::str::contains(
|
|
"u(1) u(2) u(3) F(4) F(5) u(6) u(7) u(8) u(9) u(10) \n",
|
|
));
|
|
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.arg(file.path())
|
|
.arg("--an")
|
|
.arg("--grd")
|
|
.arg("--rust_log")
|
|
.arg("trace");
|
|
cmd.assert().success().stdout(predicate::str::contains(
|
|
"u(1) u(2) u(3) F(4) F(5) u(6) u(7) u(8) u(9) u(10) \n",
|
|
));
|
|
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.arg(file.path())
|
|
.arg("--an")
|
|
.arg("--grd")
|
|
.arg("--rust_log")
|
|
.arg("warn");
|
|
cmd.assert().success().stdout(predicate::str::contains(
|
|
"u(1) u(2) u(3) F(4) F(5) u(6) u(7) u(8) u(9) u(10) \n",
|
|
));
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.arg(file.path())
|
|
.arg("--an")
|
|
.arg("--com")
|
|
.arg("--rust_log")
|
|
.arg("warn");
|
|
cmd.assert().success().stdout(predicate::str::contains(
|
|
"u(1) u(2) u(3) F(4) F(5) u(6) u(7) u(8) u(9) u(10) \n",
|
|
));
|
|
Ok(())
|
|
}
|
|
|
|
#[test]
|
|
fn runs_biodivine_hybrid() -> Result<(), Box<dyn std::error::Error>> {
|
|
let file = assert_fs::NamedTempFile::new("input_instance.adf")?;
|
|
file.write_str("s(7).s(4).s(8).s(3).s(5).s(9).s(10).s(1).s(6).s(2).ac(7,or(or(and(7,neg(1)),neg(9)),3)).ac(4,5).ac(8,or(or(8,1),neg(7))).ac(3,or(and(or(6,7),neg(and(6,7))),neg(2))).ac(5,c(f)).ac(9,and(neg(7),2)).ac(10,or(neg(2),6)).ac(1,and(or(or(neg(2),neg(1)),8),7)).ac(6,and(and(neg(2),10),and(or(7,4),neg(and(7,4))))).ac(2,and(and(and(neg(10),3),neg(6)),or(9,1))).")?;
|
|
let wrong_file = assert_fs::NamedTempFile::new("wrong_format.adf")?;
|
|
wrong_file.write_str("s(7).s(4).s(8).s(3).s(5).s(9).s(10).s(1).s(6).s(2).ac(7,or(or(and(7,neg(1)),neg(9)),3)).ac(4,5).ac(8,or(or(8,1),neg(7))).ac(3,or(and(or(6,7),neg(and(6,7))),neg(2))).ac(5,c(f)).ac(9,and(neg(7),2)).ac(10,or(neg(2),6)).ac(1,and(or(or(neg(2),neg(1)),8),7)).ac(6,and(and(neg(2),10),and(or(7,4),neg(and(7,4))))).ac(2,and(and(and(neg(10),3),neg(6)),or(9,1)))).")?;
|
|
|
|
let mut cmd = Command::cargo_bin("adf-bdd")?;
|
|
|
|
cmd.arg(wrong_file.path());
|
|
cmd.assert()
|
|
.failure()
|
|
.stderr(predicate::str::contains("code: Eof"));
|
|
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.arg(file.path())
|
|
.arg("-vv")
|
|
.arg("--grd")
|
|
.arg("--lib")
|
|
.arg("hybrid");
|
|
cmd.assert().success().stdout(predicate::str::contains(
|
|
"u(7) F(4) u(8) u(3) F(5) u(9) u(10) u(1) u(6) u(2)",
|
|
));
|
|
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.arg(file.path())
|
|
.arg("-q")
|
|
.arg("--grd")
|
|
.arg("--lib")
|
|
.arg("hybrid");
|
|
cmd.assert().success().stdout(predicate::str::contains(
|
|
"u(7) F(4) u(8) u(3) F(5) u(9) u(10) u(1) u(6) u(2)",
|
|
));
|
|
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.arg(file.path())
|
|
.arg("--lx")
|
|
.arg("-v")
|
|
.arg("--grd")
|
|
.arg("--lib")
|
|
.arg("hybrid");
|
|
cmd.assert().success().stdout(predicate::str::contains(
|
|
"u(1) u(10) u(2) u(3) F(4) F(5) u(6) u(7) u(8) u(9)",
|
|
));
|
|
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.arg(file.path())
|
|
.arg("--an")
|
|
.arg("--grd")
|
|
.arg("--stm")
|
|
.arg("--lib")
|
|
.arg("hybrid");
|
|
cmd.assert().success().stdout(predicate::str::contains(
|
|
"u(1) u(2) u(3) F(4) F(5) u(6) u(7) u(8) u(9) u(10) \n",
|
|
));
|
|
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.env_clear();
|
|
cmd.arg(file.path())
|
|
.arg("--an")
|
|
.arg("--grd")
|
|
.arg("--lib")
|
|
.arg("hybrid");
|
|
cmd.assert().success().stdout(predicate::str::contains(
|
|
"u(1) u(2) u(3) F(4) F(5) u(6) u(7) u(8) u(9) u(10) \n",
|
|
));
|
|
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.arg(file.path())
|
|
.arg("--an")
|
|
.arg("--grd")
|
|
.arg("--rust_log")
|
|
.arg("trace")
|
|
.arg("--lib")
|
|
.arg("hybrid");
|
|
cmd.assert().success().stdout(predicate::str::contains(
|
|
"u(1) u(2) u(3) F(4) F(5) u(6) u(7) u(8) u(9) u(10) \n",
|
|
));
|
|
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.arg(file.path())
|
|
.arg("--an")
|
|
.arg("--grd")
|
|
.arg("--rust_log")
|
|
.arg("warn")
|
|
.arg("--lib")
|
|
.arg("hybrid");
|
|
cmd.assert().success().stdout(predicate::str::contains(
|
|
"u(1) u(2) u(3) F(4) F(5) u(6) u(7) u(8) u(9) u(10) \n",
|
|
));
|
|
cmd = Command::cargo_bin("adf-bdd")?;
|
|
cmd.arg(file.path())
|
|
.arg("--an")
|
|
.arg("--com")
|
|
.arg("--rust_log")
|
|
.arg("warn")
|
|
.arg("--lib")
|
|
.arg("hybrid");
|
|
cmd.assert().success().stdout(predicate::str::contains(
|
|
"u(1) u(2) u(3) F(4) F(5) u(6) u(7) u(8) u(9) u(10) \n",
|
|
));
|
|
Ok(())
|
|
}
|