676

I've implemented the following method and unit test:

use std::fs::File;
use std::path::Path;
use std::io::prelude::*;
    
fn read_file(path: &Path) {
    let mut file = File::open(path).unwrap();
    let mut contents = String::new();
    file.read_to_string(&mut contents).unwrap();
    println!("{contents}");
}
    
#[test]
fn test_read_file() {
    let path = &Path::new("/etc/hosts");
    println!("{path:?}");
    read_file(path);
}

I run the unit test this way:

rustc --test app.rs; ./app

I could also run this with

cargo test

I get a message back saying the test passed but the println! is never displayed on screen. Why not?

Improve this question
1

8 Answers 8

Reset to default
775

This happens because Rust test programs hide the stdout of successful tests in order for the test output to be tidy. You can disable this behavior by passing the --nocapture option to the test binary or to cargo test (but, in this case after -- – see below):

#[test]
fn test() {
    println!("Hidden output")
}

Invoking tests:

% rustc --test main.rs; ./main

running 1 test
test test ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured

% ./main --nocapture

running 1 test
Hidden output
test test ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured

% cargo test -- --nocapture

running 1 test
Hidden output
test test ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured

If tests fail, however, their stdout will be printed regardless if this option is present or not.

Improve this answer
Sign up to request clarification or add additional context in comments.

7 Comments

You mentioned passing the --nocapture option to cargo test, but cargo does not recognize this flag for me (using the latest nightly from rustup.sh). Are you sure it should work?
@JimGarrison, indeed, there is an issue on that. Meanwhile you can use cargo test -- --nocapture, it should work.
@Nashenas, the option is called nocapture, not no-capture.
Has anyone figured out how to print when debugging in Visual Studio Code in windows? The following task does not print to the popup shell: "cargo test --no-run -- --nocapture" debugger. Note the use of the no-run argument although it does not seem to make a difference either way. All I see is "running 1 test". Awkward tooling.
@Anonyme2000 --nocapture still works in the 2018 edition. --show-output is another option that organizes the output in a format that is easier to see.
|
194

TL;DR

$ cargo test -- --nocapture

With the following code:

#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum PieceShape {
    King, Queen, Rook, Bishop, Knight, Pawn
}

fn main() {
    println!("Hello, world!");
}

#[test]
fn demo_debug_format() {
    let q = PieceShape::Queen;
    let p = PieceShape::Pawn;
    let k = PieceShape::King;
    println!("q={:?} p={:?} k={:?}", q, p, k);
}

Then run the following:

 $ cargo test -- --nocapture

And you should see

Running target/debug/chess-5d475d8baa0176e4

running 1 test
q=Queen p=Pawn k=King
test demo_debug_format ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured
Improve this answer

3 Comments

cargo test -- --no-capture no longer works. I get the following error: thread '<main>' panicked at '"Unrecognized option: \'no-capture\'."', ../src/libtest/lib.rs:249
I wonder if this issue github.com/rust-lang/cargo/issues/1377 is the problem?
As has been pointed out in previous comments, the option is --nocapture, not --no-capture. However, that's a completely obvious mistake to make given most command line conventions we tend to come across. I just used this option exactly as described in this answer in rust 1.1 (cargo 0.2.0) and it worked exactly as advertised.
95

Preface: This answer reflects a change in Rust 1.41 ("You can now pass --show-output argument to test binaries to print the output of successful tests." per the CHANGELOG)

As mentioned by L. F., --show-output is the way to go.

$ cargo test -- --show-output

Other display flags are mentioned in the documentation of cargo test in display-options.

Improve this answer

6 Comments

This was helpful. The odd extra -- on the CL confused me. I needed to run just one test & show output. That looks like $ cargo test [test_name] -- --show-output
Yeah, the odd extra -- is to control that the next arguments are passed to cargo test, if I remember correctly.
@zingi that is not true. According on documentation it shows output of failed tests too.
I've just tested it. And indeed it looks like this has changed. --show-output prints stdout of successful and failed tests now (🦀 v1.68.2)
Currently, failed tests print their output regardless of this flag
|
32

To include print outs with println!() and keep colors for the test results, use the color and nocapture flags in cargo test.

$ cargo test -- --color always --nocapture

(cargo version: 0.13.0 nightly)

Improve this answer

1 Comment

Works with Rust 1.90.0
14

While testing, standard output is not displayed. Don't use text messages for testing but assert!, assert_eq!, and fail! instead. Rust's unit test system can understand these but not text messages.

The test you have written will pass even if something goes wrong. Let's see why:

read_to_end's signature is fn read_to_end(&mut self) -> IoResult<Vec<u8>>

It returns an IoResult to indicate success or error. This is just a type def for a Result whose error value is an IoError. It's up to you to decide how an error should be handled. In this case, we want the task to fail, which is done by calling unwrap on the Result.

This will work:

let contents = File::open(&Path::new("message.txt"))
    .read_to_end()
    .unwrap();

unwrap should not be overused though.

Improve this answer

2 Comments

True information, but not an answer to OP.
I think this is Rust's way to prevent us from shooting yourself in the foot. Second form of assert is exactly what logging should do, but another way around. Instead of painstakingly write 10K+ logs when all OK, write when something is NOT. std::module_path macro may be useful too.
6

Note that the modern solution (cargo test -- --show-output) doesn't work in doctests defined in a Markdown code-fence in the docstring of your functions. Only println! (etc.) statements done in a concrete #[test] block will be respected.

Improve this answer

Comments

5

In case you want to run the test displaying the printed output everytime the file changes:

cargo watch -x "test -- --nocapture"
Improve this answer

Comments

2

Why? I don't know, but there is a small hack eprintln!("will print in {}", "tests")

Improve this answer

3 Comments

eprintln!() does not work for me for successful tests (cargo/rustc 1.69.0 (2023-04-12))
No; cargo test captures both stdout and stderr by default (when all tests pass).
works in both failing and successful tests, this would solve the original problem

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.