How to suppress “function is never used” warning for a function used by tests?

39
votes

I'm writing a program in Rust and I have some tests for it. I wrote a helper function for these tests, but whenever I build using cargo build it warns me that the function is never used:

warning: function is never used: ... #[warn(dead_code)] on by default

How I can mark this function as used so as not to get the warnings?

6
rust

6 Answers

52
votes

Specific question

How I can mark this function as used so as not to get the warnings?

The Rust compiler runs many lints to warn you about possible issues in your code and the dead_code lint is one of them. It can be very useful in pointing out mistakes when code is complete, but may also be a nuisance at earlier stages. Often, this can be solved by either deleting unused code, or by marking a public method. However, all lints can be turned off by allowing them, and your error message (#[warn(dead_code)] on by default) contains the name of the lint you could disable.

#[allow(dead_code)]
fn my_unused_function() {}

Alternative for testing

I wrote a helper function for these tests, but whenever I build using cargo build it warns me that the function is never used.

This happens to be a special case, which is that code that is only used for testing isn't needed in the real executable and should probably not be included.

In order to optionally disable compilation of test code, you can mark it accordingly using the cfg attribute with the test profile.

#[cfg(test)]
fn my_test_specific_function() {}

When marked in this way, the compiler knows to ignore the method during compilation. This is similar to commonly used ifdef usage in other languages like C or C++, where you are telling a preprocessor to ignore the enclosed code unless TESTING is defined.

#ifdef TESTING
...
#endif
13
votes

If something is only used in tests, it should be omitted altogether. This can be done with the #[cfg(test)] attribute.

6
votes

dead_code is a lint, which means you can allow it on the thing that's causing it to trigger.

#[allow(dead_code)]
fn dummy() {}

fn main() {}
1
votes

For people getting this warning while making a rust library, you may get this if you don't have your modules set to pub in your lib.rs.

pub mod foo;
0
votes

There is another situation where this can occur. If you have several helper functions in a module, e.g. in tests/utils/mod.rs and then several integration tests (tests/a.rs, tests/b.rs) each of which does

mod utils;
use utils::...;

then you will get dead code warnings if you do not use all of the code from all of the tests. For example if test a.rs only uses utils::foo and b.rs only uses utils::bar then you will get dead code warnings for both.

That is because each test is compiled as an independent crate. Here is the bug report for it. It looks difficult to solve so I wouldn't hold my breath.

0
votes

You max prefix the unused function name with an underscore:

fn _dummy() {}

fn main() {}

See: https://doc.rust-lang.org/rustc/lints/listing/warn-by-default.html#dead-code