Testing code

Sure, here is a simple example of testing in Rust:

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

This code defines a test function called it_works(). The it_works() function uses the assert_eq!() macro to check that the expression 2 + 2 is equal to 4. If the expression is not equal to 4, the test will fail.

To run the tests, you can use the cargo test command. For example, if you have saved the code above as main.rs, you would run the tests by typing the following command into your terminal:

#![allow(unused)]
fn main() {
 cargo test
}

The cargo test command will compile your code and run all of the tests. If any of the tests fail, the cargo test command will print an error message.

Here is a breakdown of the code:

The #[cfg(test)] attribute tells Rust that this code should only be compiled when the test feature is enabled. This is useful for preventing tests from being compiled into your production code.
The mod tests keyword defines a new module called tests. This module will contain all of the tests for your project.
The #[test] attribute tells Rust that this function is a test function. Test functions are special functions that are run by the cargo test command.
The assert_eq!() macro checks that the two expressions on either side of the equal sign are equal. If the expressions are not equal, the test will fail.

In Rust, testing is an important part of the development process, and the Rust language provides built-in testing support through the #[test] attribute and the cargo test command. Here's a simple example to demonstrate testing in Rust:

#![allow(unused)]
fn main() {
// Code to be tested: a function that returns the sum of two numbers
fn add(a: i32, b: i32) -> i32 {
    a + b
}

// Unit test for the add() function
#[test]
fn test_add() {
    // Test case 1: Testing positive numbers
    assert_eq!(add(2, 3), 5);

    // Test case 2: Testing negative numbers
    assert_eq!(add(-5, -10), -15);

    // Test case 3: Testing zero
    assert_eq!(add(0, 100), 100);
}

// Integration test for the add() function
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_add_integration() {
        // Test case: Testing integration with other functions
        assert_eq!(add(5, multiply(2, 3)), 11);
    }

    // Auxiliary function for integration testing
    fn multiply(a: i32, b: i32) -> i32 {
        a * b
    }
}
}

In this example, we have a function add() that calculates the sum of two numbers. To test this function, we use the #[test] attribute to mark the test function test_add().

Inside test_add(), we define several test cases using the assert_eq! macro. Each test case compares the result of calling add() with the expected result using the assert_eq! macro.

We can run the tests using the cargo test command. It will automatically discover and execute all test functions marked with the #[test] attribute.

Additionally, we also demonstrate an integration test in the tests module. The test_add_integration() test case shows how the add() function can be used in conjunction with another function (multiply() in this case).

Integration tests are defined in separate files under the tests directory in your Rust project. They are treated as separate crates and can use the #[cfg(test)] attribute to conditionally compile the integration test code.

Testing is an essential aspect of building reliable and robust applications in Rust. By writing tests, you can verify the correctness of your code, detect bugs early, and ensure that your code behaves as expected.

learn-rust

Testing code