batch_run 1.2.0

Batch runner for arbitrary Rust files within current project
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

//! Batch Run
//! =========
//!
//! [![Latest Version](https://img.shields.io/crates/v/batch_run.svg)](https://crates.io/crates/batch_run)
//! [![Rust Documentation](https://img.shields.io/badge/api-rustdoc-blue.svg)](https://docs.rs/batch_run)
//!
//! `batch_run` is a runner for a set of Rust source files, based on [dtolnay's `trybuild`](https://github.com/dtolnay/trybuild).
//! It can be useful when you have a bunch of Rust sources which are not complex enough to be
//! packed into dedicated crates, but which are (by their meaning) not just integration test cases.
//! It also checks for output correctness, either on compile-time (for `compile_fail` cases)
//! or at runtime (for `run_pass` cases).
//!
//! ```toml
//! [dependencies]
//! batch_run = "1.0"
//! ```
//!
//! *Compiler support: requires rustc 1.31+*
//!
//! <br>
//!
//! ## Compile-fail cases
//!
//! A minimal batch_run setup looks like this:
//!
//! ```rust
//! fn main() {
//!     let b = batch_run::Batch::new();
//!     b.compile_fail("batches/ui/*.rs");
//!     match b.run() {
//!         Ok(_) => {},
//!         Err(err) => println!("{:?}", err)
//!     };
//! }
//! ```
//!
//! This program will individually compile each of the
//! source files matching the glob pattern, expect them to fail to compile, and
//! assert that the compiler's error message matches an adjacently named _*.stderr_
//! file containing the expected output (same file name as the test except with a
//! different extension). If it doesn't match, the program will print the error message
//! with expected vs actual compiler output.
//!
//! Dependencies listed under `[dependencies]` in the project's Cargo.toml are
//! accessible from within the batch.
//!
//! A compile\_fail case that fails to fail to compile is also a failure.
//!
//! <br>
//!
//! ## Run-match cases
//!
//! In the run_match cases, we not only check that the code compiles, but also actually run it
//! and match the stdout/stderr output with the corresponding _*.stdout_/_*.stderr_ files.
//!
//! You can mix compile_fail and run_match cases in one batch:
//!
//! ```rust
//! fn main() {
//!     let t = batch_run::Batch::new();
//!     t.run_match("batches/01-parse-header.rs");
//!     t.run_match("batches/02-parse-body.rs");
//!     t.compile_fail("batches/03-expand-four-errors.rs");
//!     t.run_match("batches/04-paste-ident.rs");
//!     t.run_match("batches/05-repeat-section.rs");
//! }
//! ```
//!
//! <br>
//!
//! ## Details
//!
//! That's the entire API for now.
//!
//! <br>
//!
//! ## Workflow
//!
//! (TODO)
//!

mod batch;
mod binary;
mod cargo_rustc;
mod entry;
mod logging;
mod mismatch;
mod normalize;
mod runner;
mod rustflags;
mod snapshot;
mod term;

pub mod config;
pub mod result;
pub use crate::batch::Batch;
pub use termcolor;