| // Copyright 2022 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| // TODO(danakj): Reuse code for comparison macros with an expect_op!() macro? |
| |
| /// Internal helper to log an expectation failure. Other expect_* macros invoke |
| /// it with their standard expectation message, plus optionally a user-provided |
| /// custom string. |
| /// |
| /// Both the the expectation message and the user-provided message are format |
| /// strings with arguments. To disambiguate between them, the expectation |
| /// message is wrapped in extra parentheses. |
| #[macro_export] |
| macro_rules! internal_add_expectation_failure { |
| // Rule that both the below are forwarded to. |
| (@imp $fmt:literal, $($arg:tt)+) => { |
| $crate::__private::add_failure_at( |
| file!(), |
| line!(), |
| &format!($fmt, $($arg)+), |
| ) |
| }; |
| |
| // Add a failure with the standard message. |
| (($expectation:literal, $($e:tt)+)) => { |
| $crate::internal_add_expectation_failure!(@imp $expectation, $($e)+) |
| }; |
| |
| // Add a failure with the standard message plus an additional message. |
| (($expectation:literal, $($e:tt)+), $($arg:tt)+) => { |
| $crate::internal_add_expectation_failure!(@imp |
| "{}\n\n{}", |
| format_args!($expectation, $($e)+), |
| format_args!($($arg)+), |
| ) |
| }; |
| } |
| |
| /// Evaluates the given expression. If false, a failure is reported to Gtest. |
| /// |
| /// # Examples |
| /// ``` |
| /// expect_true(check_the_status_is_true()); |
| /// ``` |
| #[macro_export] |
| macro_rules! expect_true { |
| ($e:expr $(, $($arg:tt)*)?) => { |
| match &$e { |
| val => { |
| if !(*val) { |
| $crate::internal_add_expectation_failure!( |
| ( |
| "Expected: {} is true\nActual: {} is {:?}", |
| stringify!($e), |
| stringify!($e), |
| *val |
| ) |
| $(, $($arg)*)? |
| ) |
| } |
| } |
| } |
| }; |
| } |
| |
| /// Evaluates the given expression. If true, a failure is reported to Gtest. |
| /// |
| /// # Examples |
| /// ``` |
| /// expect_false(check_the_status_is_false()); |
| /// ``` |
| #[macro_export] |
| macro_rules! expect_false { |
| ($e:expr $(, $($arg:tt)*)?) => { |
| match &$e { |
| val => { |
| if *val { |
| $crate::internal_add_expectation_failure!( |
| ( |
| "Expected: {} is false\nActual: {} is {:?}", |
| stringify!($e), |
| stringify!($e), |
| *val |
| ) |
| $(, $($arg)*)? |
| ) |
| } |
| } |
| } |
| }; |
| } |
| |
| /// Evaluates and compares the two given expressions. If not equal, a failure is |
| /// reported to Gtest. The expressions must evaluate to the same type, which |
| /// must be PartialEq. |
| /// |
| /// # Examples |
| /// ``` |
| /// expect_eq(1 + 1, 2); |
| /// ``` |
| #[macro_export] |
| macro_rules! expect_eq { |
| ($e1:expr, $e2:expr $(, $($arg:tt)*)?) => { |
| match (&$e1, &$e2) { |
| (val1, val2) => { |
| if !(*val1 == *val2) { |
| $crate::internal_add_expectation_failure!( |
| ( |
| "Expected: {} == {}\nActual: {:?} vs {:?}", |
| stringify!($e1), |
| stringify!($e2), |
| *val1, |
| *val2 |
| ) |
| $(, $($arg)*)? |
| ) |
| } |
| } |
| } |
| }; |
| } |
| |
| /// Evaluates and compares the two given expressions. If equal, a failure is |
| /// reported to Gtest. The expressions must evaluate to the same type, which |
| /// must be PartialEq. |
| /// |
| /// # Examples |
| /// ``` |
| /// expect_ne(1 + 1, 3); |
| /// ``` |
| #[macro_export] |
| macro_rules! expect_ne { |
| ($e1:expr, $e2:expr $(, $($arg:tt)*)?) => { |
| match (&$e1, &$e2) { |
| (val1, val2) => { |
| if !(*val1 != *val2) { |
| $crate::internal_add_expectation_failure!( |
| ( |
| "Expected: {} != {}\nActual: {:?} vs {:?}", |
| stringify!($e1), |
| stringify!($e2), |
| *val1, |
| *val2 |
| ) |
| $(, $($arg)*)? |
| ) |
| } |
| } |
| } |
| }; |
| } |
| |
| /// Evaluates and compares the two given expressions. If the first is not |
| /// greater than the second, a failure is reported to Gtest. The expressions |
| /// must evaluate to the same type, which must be PartialOrd. If a PartialOrd |
| /// comparison fails, the result is false. |
| /// |
| /// # Examples |
| /// ``` |
| /// expect_gt(1 + 1, 1); |
| /// ``` |
| #[macro_export] |
| macro_rules! expect_gt { |
| ($e1:expr, $e2:expr $(, $($arg:tt)*)?) => { |
| match (&$e1, &$e2) { |
| (val1, val2) => { |
| if !(*val1 > *val2) { |
| $crate::internal_add_expectation_failure!( |
| ( |
| "Expected: {} > {}\nActual: {:?} vs {:?}", |
| stringify!($e1), |
| stringify!($e2), |
| *val1, |
| *val2 |
| ) |
| $(, $($arg)*)? |
| ) |
| } |
| } |
| } |
| }; |
| } |
| |
| /// Evaluates and compares the two given expressions. If the first is not less |
| /// than the second, a failure is reported to Gtest. The expressions must |
| /// evaluate to the same type, which must be PartialOrd. If a PartialOrd |
| /// comparison fails, the result is false. |
| /// |
| /// # Examples |
| /// ``` |
| /// expect_lt(1 + 1, 1 + 2); |
| /// ``` |
| #[macro_export] |
| macro_rules! expect_lt { |
| ($e1:expr, $e2:expr $(, $($arg:tt)*)?) => { |
| match (&$e1, &$e2) { |
| (val1, val2) => { |
| if !(*val1 < *val2) { |
| $crate::internal_add_expectation_failure!( |
| ( |
| "Expected: {} < {}\nActual: {:?} vs {:?}", |
| stringify!($e1), |
| stringify!($e2), |
| *val1, |
| *val2 |
| ) |
| $(, $($arg)*)? |
| ) |
| } |
| } |
| } |
| }; |
| } |
| |
| /// Evaluates and compares the two given expressions. If the first is not |
| /// greater than or equal to the second, a failure is reported to Gtest. The |
| /// expressions must evaluate to the same type, which must be PartialOrd. If a |
| /// PartialOrd comparison fails, the result is false. |
| /// |
| /// # Examples |
| /// ``` |
| /// expect_ge(1 + 1, 2); |
| /// ``` |
| #[macro_export] |
| macro_rules! expect_ge { |
| ($e1:expr, $e2:expr $(, $($arg:tt)*)?) => { |
| match (&$e1, &$e2) { |
| (val1, val2) => { |
| if !(*val1 >= *val2) { |
| $crate::internal_add_expectation_failure!( |
| ( |
| "Expected: {} >= {}\nActual: {:?} vs {:?}", |
| stringify!($e1), |
| stringify!($e2), |
| *val1, |
| *val2 |
| ) $(, $($arg)*)? |
| ) |
| } |
| } |
| } |
| }; |
| } |
| |
| /// Evaluates and compares the two given expressions. If the first is not less |
| /// than or equal to the second, a failure is reported to Gtest. The expressions |
| /// must evaluate to the same type, /which must be PartialOrd. If a PartialOrd |
| /// comparison fails, the result is false. |
| /// |
| /// # Examples |
| /// ``` |
| /// expect_le(2, 1 + 1); |
| /// ``` |
| #[macro_export] |
| macro_rules! expect_le { |
| ($e1:expr, $e2:expr $(, $($arg:tt)*)?) => { |
| match (&$e1, &$e2) { |
| (val1, val2) => { |
| if !(*val1 <= *val2) { |
| $crate::internal_add_expectation_failure!( |
| ( |
| "Expected: {} <= {}\nActual: {:?} vs {:?}", |
| stringify!($e1), |
| stringify!($e2), |
| *val1, |
| *val2 |
| ) $(, $($arg)*)? |
| ) |
| } |
| } |
| } |
| }; |
| } |
| |
| // TODO(danakj): There's a bunch more useful macros to write, even ignoring |
| // gmock: |
| // - EXPECT_NONFATAL_FAILURE |
| // - SCOPED_TRACE |
| // - EXPECT_DEATH |
| // - FAIL (fatal failure, would this work?) |
| // - ADD_FAILURE |
| // - SUCCEED |
| // - EXPECT_PANIC (catch_unwind() with an error if no panic, but this depends on |
| // us using a stdlib with -Cpanic=unwind in tests, currently we use |
| // -Cpanic=abort.) |
| // - EXPECT_NO_PANIC (Like above, depende on -Cpanic=unwind, or else all panics |
| // just abort the process.) |
| // - EXPECT_FLOAT_EQ (Comparison for equality within a small range.) |
| // - EXPECT_NEAR (Comparison for equality within a user-specified range.) |
