Rustでassert_eq!とassert_ne!を使ったテストの書き方と応用例

#[test]
fn test_addition() {
    let result = 2 + 2;
    assert_eq!(result, 4); // テスト成功
    assert_eq!(result, 5); // テスト失敗
}

#[test]
fn test_subtraction() {
    let result = 10 - 5;
    assert_ne!(result, 6); // テスト成功
    assert_ne!(result, 5); // テスト失敗
}

cargo test

macro_rules! assert_eq {
    ($left:expr, $right:expr $(, $arg:tt)*) => {
        if !($left == $right) {
            panic!(
                "assertion failed: `(left == right)`\n  left: `{:?}`,\n right: `{:?}`{}",
                $left, $right, format_args!($($arg)*)
            );
        }
    };
}

macro_rules! assert_ne {
    ($left:expr, $right:expr $(, $arg:tt)*) => {
        if $left == $right {
            panic!(
                "assertion failed: `(left != right)`\n  left: `{:?}`,\n right: `{:?}`{}",
                $left, $right, format_args!($($arg)*)
            );
        }
    };
}

assert_eq!(3, 5, "3 should equal 5");

thread 'main' panicked at 'assertion failed: `(left == right)`
  left: `3`,
 right: `5`: 3 should equal 5', src/main.rs:2:5

running 1 test
test tests::test_addition ... ok

#[test]
fn test_failure() {
    let a = 10;
    let b = 20;
    assert_eq!(a, b);
}

thread 'tests::test_failure' panicked at 'assertion failed: `(left == right)`
  left: `10`,
 right: `20`', src/lib.rs:5:5

#[test]
fn test_failure_with_message() {
    let x = 3;
    let y = 5;
    assert_eq!(x, y, "x and y should be equal, but got {} and {}", x, y);
}

thread 'tests::test_failure_with_message' panicked at 'x and y should be equal, but got 3 and 5', src/lib.rs:6:5

#[test]
fn test_custom_message() {
    let expected = 42;
    let actual = 40 + 1;
    assert_eq!(expected, actual, "Expected {} but got {}", expected, actual);
}

thread 'tests::test_custom_message' panicked at 'Expected 42 but got 41', src/lib.rs:5:5

   assert_eq!(user_input, expected_value, "User input '{}' did not match the expected value '{}'", user_input, expected_value);

   assert_ne!(result, None, "Function output was None for input: {}", input);

#[test]
fn test_with_detailed_message() {
    let input = "Rust";
    let expected = "Rustacean";
    let actual = format!("{}acean", input);
    assert_eq!(
        actual, expected,
        "String transformation failed. Input: '{}', Expected: '{}', Actual: '{}'",
        input, expected, actual
    );
}

thread 'tests::test_with_detailed_message' panicked at 'String transformation failed. Input: 'Rust', Expected: 'Rustacean', Actual: 'Rustacean'', src/lib.rs:7:5

#[test]
fn test_primitive_types() {
    assert_eq!(42, 42); // 整数型
    assert_ne!(3.14, 2.71); // 浮動小数点型
    assert_eq!("hello", "hello"); // 文字列型
}

#[derive(PartialEq)]
struct Point {
    x: i32,
    y: i32,
}

#[test]
fn test_custom_type() {
    let p1 = Point { x: 1, y: 2 };
    let p2 = Point { x: 1, y: 2 };
    assert_eq!(p1, p2); // カスタム型
}

   #[test]
   fn test_floating_point() {
       let a = 0.1 + 0.2;
       let b = 0.3;
       assert!(a == b); // 失敗する可能性がある
   }

   #[test]
   fn test_different_types() {
       let a = 42;
       let b = 42u64;
       assert_eq!(a, b); // コンパイルエラー
   }

#[test]
fn test_collections() {
    let v1 = vec![1, 2, 3];
    let v2 = vec![1, 2, 3];
    let v3 = vec![3, 2, 1];
    assert_eq!(v1, v2); // 成功
    assert_ne!(v1, v3); // 成功
}

fn add(a: i32, b: i32) -> i32 {
    a + b
}

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

    #[test]
    fn test_add() {
        let result = add(2, 3);
        assert_eq!(result, 5, "Addition result was not as expected.");
    }
}

fn is_even(num: i32) -> bool {
    num % 2 == 0
}

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

    #[test]
    fn test_is_even() {
        assert_eq!(is_even(4), true, "4 should be even.");
        assert_eq!(is_even(5), false, "5 should not be even.");
    }
}

running 2 tests
test tests::test_is_even ... ok

fn square(num: i32) -> i32 {
    num * num
}

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

    #[test]
    fn test_square() {
        let test_cases = [(2, 4), (-3, 9), (0, 0)];
        for (input, expected) in test_cases {
            assert_eq!(square(input), expected, "Failed for input: {}", input);
        }
    }
}

fn divide(a: i32, b: i32) -> i32 {
    if b == 0 {
        panic!("Division by zero is not allowed!");
    }
    a / b
}

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

    #[test]
    #[should_panic(expected = "Division by zero is not allowed!")]
    fn test_divide_by_zero() {
        divide(10, 0);
    }
}

async fn async_add(a: i32, b: i32) -> i32 {
    a + b
}

#[cfg(test)]
mod tests {
    use super::*;
    #[tokio::test]
    async fn test_async_add() {
        let result = async_add(3, 4).await;
        assert_eq!(result, 7, "Async addition failed.");
    }
}

fn parse_response(response: &str) -> Result<&str, &str> {
    if response.starts_with("200") {
        Ok("Success")
    } else {
        Err("Error")
    }
}

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

    #[test]
    fn test_parse_response() {
        assert_eq!(parse_response("200 OK"), Ok("Success"), "Valid response failed.");
        assert_eq!(parse_response("500 Internal Server Error"), Err("Error"), "Error response failed.");
    }
}

#[test]
fn test_assert() {
    let is_valid = 2 + 2 == 4;
    assert!(is_valid, "The condition must be true.");
}

#[test]
fn test_debug_assert() {
    let value = 10;
    debug_assert!(value < 20, "Value should be less than 20.");
}

fn example_function(value: i32) -> &'static str {
    match value {
        1 => "One",
        2 => "Two",
        _ => unreachable!("Unexpected value: {}", value),
    }
}

#[test]
fn test_unreachable() {
    let result = example_function(1);
    assert_eq!(result, "One");
}

#[test]
fn test_todo() {
    // テストを書く途中でのプレースホルダーとして利用
    todo!("This test is not implemented yet.");
}

fn calculate_discount(price: f64, discount: f64) -> f64 {
    if discount < 0.0 || discount > 1.0 {
        panic!("Discount must be between 0 and 1.");
    }
    price * (1.0 - discount)
}

#[test]
fn test_calculate_discount() {
    let original_price = 100.0;
    let discount = 0.2;

    // 条件確認
    assert!(discount >= 0.0 && discount <= 1.0, "Invalid discount range.");

    // 計算結果の検証
    let discounted_price = calculate_discount(original_price, discount);
    assert_eq!(discounted_price, 80.0, "Discount calculation failed.");

    // エラー条件を検証
    let invalid_discount = -0.5;
    let result = std::panic::catch_unwind(|| calculate_discount(original_price, invalid_discount));
    assert!(result.is_err(), "Panic was expected for invalid discount.");
}

#[test]
fn test_complex_conditions() {
    let values = vec![2, 4, 6];
    for &value in &values {
        assert!(value % 2 == 0, "Value {} is not even.", value);
        debug_assert!(value > 0, "Value {} must be positive.", value);
    }
}

fn setup_test_data() -> Vec<i32> {
    vec![1, 2, 3, 4, 5]
}

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

    #[test]
    fn test_sum() {
        let data = setup_test_data();
        assert_eq!(data.iter().sum::<i32>(), 15);
    }

    #[test]
    fn test_product() {
        let data = setup_test_data();
        assert_eq!(data.iter().product::<i32>(), 120);
    }
}

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

    fn square(x: i32) -> i32 {
        x * x
    }

    #[test]
    fn test_square() {
        let cases = vec![(2, 4), (3, 9), (-1, 1), (0, 0)];
        for (input, expected) in cases {
            assert_eq!(square(input), expected, "Failed for input: {}", input);
        }
    }
}

cargo test test_sum

cargo test --test-threads=4

cargo test -- --nocapture

name: Rust Tests

on:
  push:
    branches:
      - main
  pull_request:

jobs:
  test:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v2
    - name: Install Rust
      uses: actions-rs/toolchain@v1
      with:
        toolchain: stable
    - name: Run tests
      run: cargo test

cargo install cargo-tarpaulin
cargo tarpaulin