Rust Testing Framework: Ensuring Tool Reliability

Click the above to follow us!

Today, let’s talk about Rust’s testing framework. To be honest, testing always feels like a hassle when writing code, but it is really important. Rust has a built-in set of simple and easy-to-use testing tools that can help us easily write high-quality code. Let’s see how to use this framework to ensure our programs are reliable and stable.

Where Is the Testing Module Hidden?

The testing module in Rust is usually hidden in the source code files, marked with #[cfg(test)]. What are the benefits of doing this? Keeping the test code together with the normal code makes it easier to maintain, and it won’t be compiled into the final program.

#[cfg(test)]
mod tests {
    #[test]
    fn it_works() {
        assert_eq!(2 + 2, 4);
    }
}

In this code, mod tests is our testing module. #[test] tells the Rust compiler that this is a test function.

Friendly reminder: Don’t forget to add #[test] before each test function, otherwise Rust won’t recognize it as a test function!

Assertions: The Soul of Testing

Assertions are the core of testing, which check if the results are as expected. Rust provides several assertion macros:

assert!: Checks if the expression is true
assert_eq!: Checks if two values are equal
assert_ne!: Checks if two values are not equal

#[test]
fn test_math() {
    assert!(1 + 1 == 2);
    assert_eq!(2 + 2, 4);
    assert_ne!(5 - 2, 4);
}

When these assertions fail, Rust will tell you where the problem is, which is quite considerate.

Running Tests: Command Line Wizard

After writing the tests, we need to run them to see the results. In the root directory of the project, use the cargo test command to run all tests.

$ cargo test
running 3 tests
test tests::it_works ... ok
test tests::test_math ... ok
test tests::another_test ... ok
test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

If you see all ok, it means all tests passed!

Ignoring Tests: Sometimes You Need to Pretend to Sleep

Some tests may not want to run temporarily, for example, if they are not completed or too time-consuming. In this case, you can use the #[ignore] marker:

#[test]
#[ignore]
fn expensive_test() {
    // Super time-consuming operation
}

This way, cargo test will skip this test. Want to run ignored tests? Just use cargo test -- --ignored.

Testing Private Functions: Don’t Be Shy

Rust allows testing private functions, which is great. We don’t have to make functions public just for testing.

fn private_function() -> bool {
    true
}
#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_private_function() {
        assert!(private_function());
    }
}

use super::*; allows the testing module to access everything outside, including private functions.

Integration Tests: The Big Picture

Once unit tests are done, we need to look at the overall performance. Rust uses the tests directory to hold integration tests:

myproject/
├── src/
│   └── lib.rs
└── tests/
    └── integration_test.rs

Each function in integration_test.rs is an independent test case.

use myproject;
#[test]
fn test_add_two() {
    assert_eq!(4, myproject::add_two(2));
}

cargo test will automatically run all tests in the tests directory.

Alright, that’s all for today’s Rust testing framework. Although testing is a hassle, it can help us catch a lot of bugs, so it’s worth the time. Writing more tests will significantly improve program quality, making the boss happy, so why not? See you next time, let’s continue learning new knowledge!

Previous Reviews

◆ Python Automation Exams: Smart Questioning and Grading to Improve Efficiency

◆ Batch Compress Files: Python Makes File Transfer Faster and Saves Space

◆ Efficiency Improvement: 45 Tips for Handling Excel with Python

Like and Share