108 lines
3.3 KiB
Rust
108 lines
3.3 KiB
Rust
use std::{
|
|
fs,
|
|
path::PathBuf,
|
|
process::{Command, Output},
|
|
sync::atomic::{AtomicUsize, Ordering},
|
|
};
|
|
|
|
static NEXT_ID: AtomicUsize = AtomicUsize::new(0);
|
|
|
|
#[test]
|
|
fn beta_scaffolded_project_runs_current_v1_7_gate_workflow() {
|
|
let project = unique_path("beta-project");
|
|
|
|
let scaffold = run_glagol(["new".as_ref(), project.as_os_str()]);
|
|
assert_success("beta scaffold", &scaffold);
|
|
|
|
fs::write(
|
|
project.join("src/main.slo"),
|
|
"(module main)\n\n(fn main () -> i32\n (let values (array i32 3) (array i32 2 3 4))\n (std.io.print_i32 (index values 1))\n 0)\n\n(test \"fixed array collection subset\"\n (= (index (array i32 1 2 3) 2) 3))\n",
|
|
)
|
|
.expect("write beta project main");
|
|
|
|
let fmt_check = run_glagol(["fmt".as_ref(), "--check".as_ref(), project.as_os_str()]);
|
|
assert_success("beta project fmt --check", &fmt_check);
|
|
|
|
let test = run_glagol(["test".as_ref(), project.as_os_str()]);
|
|
assert_success("beta project test", &test);
|
|
assert_eq!(
|
|
String::from_utf8_lossy(&test.stdout),
|
|
"test \"fixed array collection subset\" ... ok\n1 test(s) passed\n"
|
|
);
|
|
|
|
let docs = unique_path("beta-project-docs");
|
|
let doc = run_glagol([
|
|
"doc".as_ref(),
|
|
project.as_os_str(),
|
|
"-o".as_ref(),
|
|
docs.as_os_str(),
|
|
]);
|
|
assert_success("beta project doc", &doc);
|
|
let doc_index = fs::read_to_string(docs.join("index.md")).expect("read beta docs");
|
|
assert!(doc_index.contains("# Project glagol-beta-"));
|
|
assert!(doc_index.contains("- `main() -> i32`"));
|
|
assert!(doc_index.contains("- `fixed array collection subset`"));
|
|
|
|
let binary = unique_path("beta-project-bin");
|
|
let build = run_glagol([
|
|
"build".as_ref(),
|
|
project.as_os_str(),
|
|
"-o".as_ref(),
|
|
binary.as_os_str(),
|
|
]);
|
|
if build.status.success() {
|
|
let run = Command::new(&binary).output().expect("run beta project");
|
|
assert_success("beta project binary", &run);
|
|
assert_eq!(String::from_utf8_lossy(&run.stdout), "3\n");
|
|
} else {
|
|
assert_stderr_contains("beta project build", &build, "ToolchainUnavailable");
|
|
}
|
|
}
|
|
|
|
fn unique_path(name: &str) -> PathBuf {
|
|
let id = NEXT_ID.fetch_add(1, Ordering::Relaxed);
|
|
let nanos = std::time::SystemTime::now()
|
|
.duration_since(std::time::UNIX_EPOCH)
|
|
.expect("system clock before UNIX_EPOCH")
|
|
.as_nanos();
|
|
std::env::temp_dir().join(format!(
|
|
"glagol-beta-{}-{}-{}-{}",
|
|
std::process::id(),
|
|
nanos,
|
|
id,
|
|
name
|
|
))
|
|
}
|
|
|
|
fn run_glagol<I, S>(args: I) -> Output
|
|
where
|
|
I: IntoIterator<Item = S>,
|
|
S: AsRef<std::ffi::OsStr>,
|
|
{
|
|
Command::new(env!("CARGO_BIN_EXE_glagol"))
|
|
.args(args)
|
|
.output()
|
|
.expect("run glagol")
|
|
}
|
|
|
|
fn assert_success(context: &str, output: &Output) {
|
|
assert!(
|
|
output.status.success(),
|
|
"{} failed\nstdout:\n{}\nstderr:\n{}",
|
|
context,
|
|
String::from_utf8_lossy(&output.stdout),
|
|
String::from_utf8_lossy(&output.stderr)
|
|
);
|
|
}
|
|
|
|
fn assert_stderr_contains(context: &str, output: &Output, needle: &str) {
|
|
let stderr = String::from_utf8_lossy(&output.stderr);
|
|
assert!(
|
|
stderr.contains(needle),
|
|
"{} stderr did not contain `{}`:\n{}",
|
|
context,
|
|
needle,
|
|
stderr
|
|
);
|
|
}
|