mod common;
use common::SourceRoot;
use std::process::{Command, Output};
fn cli(args: &[&std::ffi::OsStr]) -> Output {
Command::new(env!("CARGO_BIN_EXE_qleisli"))
.args(args)
.output()
.unwrap()
}
#[test]
fn native_transport_failures_use_the_closed_v1_project_code() {
let root = SourceRoot::new("observe fn main()->CBit{true}");
let artifact = root.0.join("valid.qirf");
let emitted = cli(&[
"emit-ir".as_ref(),
root.0.as_os_str(),
format!("--output={}", artifact.display()).as_ref(),
]);
assert!(emitted.status.success(), "{emitted:?}");
for command in ["check", "run", "sample", "emit-ir", "verify-ir"] {
let mut process = Command::new(env!("CARGO_BIN_EXE_qleisli"));
process
.arg(command)
.arg(if command == "verify-ir" {
&artifact
} else {
&root.0
})
.arg("--format=json")
.arg(format!("--lean-kernel={}", root.0.join("absent").display()));
if command == "sample" {
process.args(["--shots=1", "--seed=1"]);
}
if command == "emit-ir" {
process.arg(format!(
"--output={}",
root.0.join("blocked.qirf").display()
));
}
let output = process.output().unwrap();
assert_eq!(output.status.code(), Some(1), "{output:?}");
let text = String::from_utf8(output.stdout).unwrap();
assert!(text.contains("\"code\":\"project\""), "{command}: {text}");
assert!(!text.contains("\"code\":\"io\"") && !text.contains("\"code\":\"kernel\""));
}
}
#[test]
fn function_equation_mismatch_has_the_same_contract_code_in_text_and_json() {
let root = SourceRoot::new(include_str!(
"fixtures/review_v029/contract_mismatch/main.qli"
));
for json in [false, true] {
let mut command = Command::new(env!("CARGO_BIN_EXE_qleisli"));
command.arg("check").arg(&root.0);
if json {
command.arg("--format=json");
}
let output = command.output().unwrap();
assert_eq!(output.status.code(), Some(1));
let text = String::from_utf8(if json { output.stdout } else { output.stderr }).unwrap();
assert!(
text.contains(if json {
"\"code\":\"contract\""
} else {
": contract:"
}),
"{text}"
);
assert!(text.contains("function semantic contract"), "{text}");
}
}
#[test]
fn truncated_static_arguments_emit_one_located_json_parse_error() {
for source in [
"unitary fn f(q: Q<Bit>) -> Q<Bit> { g[",
"unitary fn f(q: Q<Bit>) -> Q<Bit> { g[repeat_op(0,",
] {
let root = SourceRoot::new(source);
let end = source.len();
let column = end + 1;
for command in ["check", "run"] {
let output = cli(&[
command.as_ref(),
root.0.as_os_str(),
"--format=json".as_ref(),
]);
assert_eq!(output.status.code(), Some(1), "{output:?}");
assert!(output.stderr.is_empty(), "{output:?}");
assert_eq!(
String::from_utf8(output.stdout).unwrap(),
format!(
"{{\"format\":\"qleisli.result\",\"version\":1,\"command\":\"{command}\",\"outcome\":\"error\",\"diagnostics\":[{{\"code\":\"parse\",\"severity\":\"error\",\"message\":\"parse error: expected a static operation description\",\"primary\":{{\"path\":\"main.qli\",\"start\":{end},\"end\":{end},\"line\":1,\"column\":{column}}},\"related\":[]}}],\"result\":null}}\n"
)
);
}
}
}
#[test]
fn json_check_and_run_have_golden_envelopes_in_every_flag_position() {
let root = SourceRoot::new("observe fn main() -> CBit { true }");
for (command, result) in [
("check", "{\"verified\":true}"),
(
"run",
"{\"distribution\":[{\"bits\":[true],\"probability\":1}]}",
),
] {
for flag_index in 0..3 {
let mut args = vec![command.as_ref(), root.0.as_os_str()];
args.insert(flag_index, "--format=json".as_ref());
let output = cli(&args);
assert_eq!(output.status.code(), Some(0), "{output:?}");
assert!(output.stderr.is_empty(), "{output:?}");
assert_eq!(
String::from_utf8(output.stdout).unwrap(),
format!(
"{{\"format\":\"qleisli.result\",\"version\":1,\"command\":\"{command}\",\"outcome\":\"ok\",\"diagnostics\":[],\"result\":{result}}}\n"
)
);
}
}
}
#[test]
fn json_usage_is_atomic_and_keeps_the_usage_exit_code() {
let usage = include_str!("fixtures/verification_v029/usage.txt")
.trim_end()
.replace('\n', "\\u000a");
for args in [
vec!["check", "--format=json"],
vec!["check", ".", "--format=json", "--format=json"],
vec!["check", ".", "--unknown", "--format=json"],
vec!["check", ".", "--format", "--format=json"],
vec!["check", ".", "--format=xml", "--format=json"],
vec!["check", "--unknown", "--format=json"],
] {
let args: Vec<_> = args.iter().map(std::ffi::OsStr::new).collect();
let output = cli(&args);
assert_eq!(output.status.code(), Some(2));
assert!(output.stderr.is_empty());
assert_eq!(
String::from_utf8(output.stdout).unwrap(),
concat!(
"{\"format\":\"qleisli.result\",\"version\":1,\"command\":\"check\",\"outcome\":\"error\",",
"\"diagnostics\":[{\"code\":\"usage\",\"severity\":\"error\",",
"\"message\":\"USAGE\",",
"\"primary\":null,\"related\":[]}],\"result\":null}\n"
).replace("USAGE", &usage)
);
}
}
#[test]
fn json_runtime_limit_does_not_emit_a_partial_distribution() {
let mut source = String::from(
"use std::quantum::init0; use std::observe::discard; observe fn main() -> Unit {",
);
for i in 0..17 {
source.push_str(&format!("let q{i} = init0();"));
}
for i in 0..17 {
source.push_str(&format!("discard(q{i});"));
}
source.push_str("() }");
let root = SourceRoot::new(&source);
let output = cli(&["run".as_ref(), root.0.as_os_str(), "--format=json".as_ref()]);
assert_eq!(output.status.code(), Some(1));
assert!(output.stderr.is_empty());
assert_eq!(
String::from_utf8(output.stdout).unwrap(),
concat!(
"{\"format\":\"qleisli.result\",\"version\":1,\"command\":\"run\",\"outcome\":\"error\",",
"\"diagnostics\":[{\"code\":\"limit\",\"severity\":\"error\",",
"\"message\":\"simulation requires 17 qubits; limit is 16\",",
"\"primary\":null,\"related\":[]}],\"result\":null}\n"
)
);
}
#[test]
fn json_type_failure_is_located_in_the_original_source() {
let root = SourceRoot::new("observe fn main() -> CBit { () }");
let output = cli(&[
"check".as_ref(),
"--format=json".as_ref(),
root.0.as_os_str(),
]);
assert_eq!(output.status.code(), Some(1));
assert!(output.stderr.is_empty());
let output = String::from_utf8(output.stdout).unwrap();
assert!(output.contains("\"code\":\"type_mismatch\""), "{output}");
assert!(output.contains("\"path\":\"main.qli\""), "{output}");
assert!(!output.contains(&root.0.display().to_string()), "{output}");
}