# Tests

* To change a function into a test function, add `#[test]` on the line before `fn`.
* You can run the test using command `cargo test`.
* By convention, test functions reside in a module named `tests`, which is usually placed at the bottom of the file containing the code to be tested.
* We can check panics adding `#[should_panic]` attributes.
* References:
  * [How to Write Tests](https://doc.rust-lang.org/book/ch11-01-writing-tests.html)

## tests1.rs

```rust
// Tests are important to ensure that your code does what you think it should
// do.

fn is_even(n: i64) -> bool {
    n % 2 == 0
}

fn main() {
    // You can optionally experiment here.
}

#[cfg(test)]
mod tests {
    // Import `is_even`. You can use a wildcard to import everything in
    // the outer module.
    use super::is_even;

    #[test]
    fn you_can_assert() {
        // Test the function `is_even` with some values.
        assert!(is_even(10));
        assert!(!is_even(5));
    }
}
```

* In this exercise we need to test the functions `is_even` using `assert!`.
* Assert macro accept `bool` type, will success if value `true` and fails/panics when value is `false`.
* So we need to add two cases for even and odd input like this.

  ```rust
  assert!(is_even(10)); // expect true
  assert!(!is_even(5)); // expect false
  ```

## test2.rs

```rust
// Calculates the power of 2 using a bit shift.
// `1 << n` is equivalent to "2 to the power of n".
fn power_of_2(n: u8) -> u64 {
    1 << n
}

fn main() {
    // You can optionally experiment here.
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn you_can_assert_eq() {
        // Test the function `power_of_2` with some values.
        assert_eq!(power_of_2(0), 1);
        assert_eq!(power_of_2(1), 2);
        assert_eq!(power_of_2(2), 4);
        assert_eq!(power_of_2(3), 8);
    }
}
```

* Similar like previous exercise we need to add test cases for function `power_of_2`.
* But this time using `assert_eq`.
  * It will assert if given two values are equal.
  * If not it will fail/panic.
* So let's add the test cases like this:

  ```rust
  assert_eq!(power_of_2(0), 1);
  assert_eq!(power_of_2(1), 2);
  assert_eq!(power_of_2(2), 4);
  assert_eq!(power_of_2(3), 8);
  ```

## tests3.rs

```rust
struct Rectangle {
    width: i32,
    height: i32,
}

impl Rectangle {
    // Don't change this function.
    fn new(width: i32, height: i32) -> Self {
        if width <= 0 || height <= 0 {
            // Returning a `Result` would be better here. But we want to learn
            // how to test functions that can panic.
            panic!("Rectangle width and height must be positive");
        }

        Rectangle { width, height }
    }
}

fn main() {
    // You can optionally experiment here.
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn correct_width_and_height() {
        // This test should check if the rectangle has the size that we
        // pass to its constructor.
        let rect = Rectangle::new(10, 20);
        assert_eq!(rect.width, 10); // Check width
        assert_eq!(rect.height, 20); // Check height
    }

    // This test should check if the program panics when we try to create
    // a rectangle with negative width.
    #[test]
    #[should_panic]
    fn negative_width() {
        let _rect = Rectangle::new(-10, 10);
    }

    // This test should check if the program panics when we try to create
    // a rectangle with negative height.
    #[test]
    #[should_panic]
    fn negative_height() {
        let _rect = Rectangle::new(10, -10);
    }
}
```

* First task in this exercise is to fix `assert_eq!` in test function `correct_width_and_height()`.
* We just need to put correct fields like this:

  ```rust
  assert_eq!(rect.width, 10); // Check width
  assert_eq!(rect.height, 20); // Check height
  ```
* Second have test functions `negative_width` and `negative_height` that check if we give negative value when calling `Rectangle::new` it should panic.
* We can check panics adding `#[should_panic]` attributes.