Struct Execs

pub struct Execs {

    pub(crate) ran: bool,
    pub(crate) process_builder: Option<ProcessBuilder>,
    pub(crate) expect_stdin: Option<String>,
    pub(crate) expect_exit_code: Option<i32>,
    pub(crate) expect_stdout_data: Option<Data>,
    pub(crate) expect_stderr_data: Option<Data>,
    pub(crate) expect_stdout_contains: Vec<String>,
    pub(crate) expect_stderr_contains: Vec<String>,
    pub(crate) expect_stdout_contains_n: Vec<(String, usize)>,
    pub(crate) expect_stdout_not_contains: Vec<String>,
    pub(crate) expect_stderr_not_contains: Vec<String>,
    pub(crate) expect_stdout_unordered: Vec<String>,
    pub(crate) expect_stderr_unordered: Vec<String>,
    pub(crate) expect_stderr_with_without: Vec<(Vec<String>, Vec<String>)>,
    pub(crate) stream_output: bool,
    pub(crate) assert: Assert,
}

Run and verify a ProcessBuilder

Construct with

• execs
• cargo_process
• Project methods

Fields

ran: bool

process_builder: Option<ProcessBuilder>

expect_stdin: Option<String>

expect_exit_code: Option<i32>

expect_stdout_data: Option<Data>

expect_stderr_data: Option<Data>

expect_stdout_contains: Vec<String>

expect_stderr_contains: Vec<String>

expect_stdout_contains_n: Vec<(String, usize)>

expect_stdout_not_contains: Vec<String>

expect_stderr_not_contains: Vec<String>

expect_stdout_unordered: Vec<String>

expect_stderr_unordered: Vec<String>

expect_stderr_with_without: Vec<(Vec<String>, Vec<String>)>

stream_output: bool

assert: Assert

Implementations

impl Execs

pub fn with_process_builder(self, p: ProcessBuilder) -> Execs

impl Execs

Configure assertions

pub fn with_stdout_data(&mut self, expected: impl IntoData) -> &mut Self

Verifies that stdout is equal to the given lines.

See compare::assert_e2e for assertion details.

pub fn with_stderr_data(&mut self, expected: impl IntoData) -> &mut Self

Verifies that stderr is equal to the given lines.

See compare::assert_e2e for assertion details.

pub fn with_stdin<S: ToString>(&mut self, expected: S) -> &mut Self

Writes the given lines to stdin.

pub fn with_status(&mut self, expected: i32) -> &mut Self

Verifies the exit code from the process.

This is not necessary if the expected exit code is 0.

pub fn without_status(&mut self) -> &mut Self

Removes exit code check for the process.

By default, the expected exit code is 0.

pub fn with_stdout_contains<S: ToString>(&mut self, expected: S) -> &mut Self

👎Deprecated: replaced with Execs::with_stdout_data(expected)

Verifies that stdout contains the given contiguous lines somewhere in its output.

See compare for supported patterns.

pub fn with_stderr_contains<S: ToString>(&mut self, expected: S) -> &mut Self

👎Deprecated: replaced with Execs::with_stderr_data(expected)

Verifies that stderr contains the given contiguous lines somewhere in its output.

See compare for supported patterns.

pub fn with_stdout_does_not_contain<S: ToString>( &mut self, expected: S, ) -> &mut Self

👎Deprecated

Verifies that stdout does not contain the given contiguous lines.

See compare for supported patterns.

See note on Self::with_stderr_does_not_contain.

pub fn with_stderr_does_not_contain<S: ToString>( &mut self, expected: S, ) -> &mut Self

👎Deprecated

Verifies that stderr does not contain the given contiguous lines.

See compare for supported patterns.

Care should be taken when using this method because there is a limitless number of possible things that won’t appear. A typo means your test will pass without verifying the correct behavior. If possible, write the test first so that it fails, and then implement your fix/feature to make it pass.

pub fn with_stdout_unordered<S: ToString>(&mut self, expected: S) -> &mut Self

👎Deprecated: replaced with Execs::with_stdout_data(expected.unordered())

Verifies that all of the stdout output is equal to the given lines, ignoring the order of the lines.

See Execs::with_stderr_unordered for more details.

pub fn with_stderr_unordered<S: ToString>(&mut self, expected: S) -> &mut Self

👎Deprecated: replaced with Execs::with_stderr_data(expected.unordered())

Verifies that all of the stderr output is equal to the given lines, ignoring the order of the lines.

See compare for supported patterns.

This is useful when checking the output of cargo build -v since the order of the output is not always deterministic. Recommend use with_stderr_contains instead unless you really want to check every line of output.

Be careful when using patterns such as [..], because you may end up with multiple lines that might match, and this is not smart enough to do anything like longest-match. For example, avoid something like:

 [RUNNING] `rustc [..]
 [RUNNING] `rustc --crate-name foo [..]

This will randomly fail if the other crate name is bar, and the order changes.

pub fn with_stderr_line_without<S: ToString>( &mut self, with: &[S], without: &[S], ) -> &mut Self

👎Deprecated

Verify that a particular line appears in stderr with and without the given substrings. Exactly one line must match.

The substrings are matched as contains. Example:

use cargo_test_support::execs;

execs().with_stderr_line_without(
    &[
        "[RUNNING] `rustc --crate-name build_script_build",
        "-C opt-level=3",
    ],
    &["-C debuginfo", "-C incremental"],
);

This will check that a build line includes -C opt-level=3 but does not contain -C debuginfo or -C incremental.

Be careful writing the without fragments, see note in with_stderr_does_not_contain.

impl Execs

Configure the process

pub fn stream(&mut self) -> &mut Self

Forward subordinate process stdout/stderr to the terminal. Useful for printf debugging of the tests. CAUTION: CI will fail if you leave this in your test!

pub fn arg<T: AsRef<OsStr>>(&mut self, arg: T) -> &mut Self

pub fn args<T: AsRef<OsStr>>(&mut self, args: &[T]) -> &mut Self

pub fn cwd<T: AsRef<OsStr>>(&mut self, path: T) -> &mut Self

pub(crate) fn get_cwd(&self) -> Option<&Path>

pub fn env<T: AsRef<OsStr>>(&mut self, key: &str, val: T) -> &mut Self

pub fn env_remove(&mut self, key: &str) -> &mut Self

pub fn masquerade_as_nightly_cargo(&mut self, reasons: &[&str]) -> &mut Self

Enables nightly features for testing

The list of reasons should be why nightly cargo is needed. If it is because of an unstable feature put the name of the feature as the reason, e.g. &["print-im-a-teapot"]

pub fn replace_crates_io(&mut self, url: &Url) -> &mut Self

Overrides the crates.io URL for testing.

Can be used for testing crates-io functionality where alt registries cannot be used.

pub fn overlay_registry(&mut self, url: &Url, path: &str) -> &mut Self

pub fn enable_split_debuginfo_packed(&mut self) -> &mut Self

pub fn enable_mac_dsym(&mut self) -> &mut Self

impl Execs

Run and verify the process

pub fn exec_with_output(&mut self) -> Result<Output>

pub fn build_command(&mut self) -> Command

pub fn run(&mut self)

pub fn run_json(&mut self) -> Value

Runs the process, checks the expected output, and returns the first JSON object on stdout.

pub fn run_output(&mut self, output: &Output)

pub(crate) fn verify_checks_output(&self, stdout: &[u8], stderr: &[u8])

pub(crate) fn match_process( &self, process: &ProcessBuilder, ) -> Result<RawOutput>

pub(crate) fn match_output( &self, code: Option<i32>, stdout: &[u8], stderr: &[u8], ) -> Result<()>

Trait Implementations

impl Clone for Execs

fn clone(&self) -> Execs

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Drop for Execs

fn drop(&mut self)

Executes the destructor for this type.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 776 bytes