Skip to content

Commit bbe4b73

Browse files
Abseil Teamgennadiycivil
Abseil Team
authored and
gennadiycivil
committed
Googletest export
Added IsNan matcher PiperOrigin-RevId: 275278634
1 parent 2995ca5 commit bbe4b73

File tree

3 files changed

+133
-2
lines changed

3 files changed

+133
-2
lines changed

‎googlemock/docs/cheat_sheet.md

+1
Original file line numberDiff line numberDiff line change
@@ -287,6 +287,7 @@ is not changed afterwards, or the meaning of your matcher will be changed.
287287
| `FloatEq(a_float)` | `argument` is a `float` value approximately equal to `a_float`, treating two NaNs as unequal. |
288288
| `NanSensitiveDoubleEq(a_double)` | `argument` is a `double` value approximately equal to `a_double`, treating two NaNs as equal. |
289289
| `NanSensitiveFloatEq(a_float)` | `argument` is a `float` value approximately equal to `a_float`, treating two NaNs as equal. |
290+
| `IsNan()` | `argument` is any floating-point type with a NaN value. |
290291
<!-- mdformat on -->
291292
292293
The above matchers use ULP-based comparison (the same as used in googletest).

‎googlemock/include/gmock/gmock-matchers.h

+24-2
Original file line numberDiff line numberDiff line change
@@ -42,8 +42,8 @@
4242
#ifndef GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
4343
#define GMOCK_INCLUDE_GMOCK_GMOCK_MATCHERS_H_
4444

45-
#include <math.h>
4645
#include <algorithm>
46+
#include <cmath>
4747
#include <initializer_list>
4848
#include <iterator>
4949
#include <limits>
@@ -54,6 +54,7 @@
5454
#include <type_traits>
5555
#include <utility>
5656
#include <vector>
57+
5758
#include "gmock/internal/gmock-internal-utils.h"
5859
#include "gmock/internal/gmock-port.h"
5960
#include "gtest/gtest.h"
@@ -1349,6 +1350,22 @@ MakePredicateFormatterFromMatcher(M matcher) {
13491350
return PredicateFormatterFromMatcher<M>(std::move(matcher));
13501351
}
13511352

1353+
// Implements the polymorphic IsNan() matcher, which matches any floating type
1354+
// value that is Nan.
1355+
class IsNanMatcher {
1356+
public:
1357+
template <typename FloatType>
1358+
bool MatchAndExplain(const FloatType& f,
1359+
MatchResultListener* /* listener */) const {
1360+
return (::std::isnan)(f);
1361+
}
1362+
1363+
void DescribeTo(::std::ostream* os) const { *os << "is NaN"; }
1364+
void DescribeNegationTo(::std::ostream* os) const {
1365+
*os << "isn't NaN";
1366+
}
1367+
};
1368+
13521369
// Implements the polymorphic floating point equality matcher, which matches
13531370
// two float values using ULP-based approximation or, optionally, a
13541371
// user-specified epsilon. The template is meant to be instantiated with
@@ -1409,7 +1426,7 @@ class FloatingEqMatcher {
14091426
}
14101427

14111428
const FloatType diff = value - expected_;
1412-
if (fabs(diff) <= max_abs_error_) {
1429+
if (::std::fabs(diff) <= max_abs_error_) {
14131430
return true;
14141431
}
14151432

@@ -3626,6 +3643,11 @@ inline internal::RefMatcher<T&> Ref(T& x) { // NOLINT
36263643
return internal::RefMatcher<T&>(x);
36273644
}
36283645

3646+
// Creates a polymorphic matcher that matches any NaN floating point.
3647+
inline PolymorphicMatcher<internal::IsNanMatcher> IsNan() {
3648+
return MakePolymorphicMatcher(internal::IsNanMatcher());
3649+
}
3650+
36293651
// Creates a matcher that matches any double argument approximately
36303652
// equal to rhs, where two NANs are considered unequal.
36313653
inline internal::FloatingEqMatcher<double> DoubleEq(double rhs) {

‎googlemock/test/gmock-matchers_test.cc

+108
Original file line numberDiff line numberDiff line change
@@ -2054,6 +2054,114 @@ TEST(PairMatchBaseTest, WorksWithMoveOnly) {
20542054
EXPECT_TRUE(matcher.Matches(pointers));
20552055
}
20562056

2057+
// Tests that IsNan() matches a NaN, with float.
2058+
TEST(IsNan, FloatMatchesNan) {
2059+
float quiet_nan = std::numeric_limits<float>::quiet_NaN();
2060+
float other_nan = std::nan("1");
2061+
float real_value = 1.0f;
2062+
2063+
Matcher<float> m = IsNan();
2064+
EXPECT_TRUE(m.Matches(quiet_nan));
2065+
EXPECT_TRUE(m.Matches(other_nan));
2066+
EXPECT_FALSE(m.Matches(real_value));
2067+
2068+
Matcher<float&> m_ref = IsNan();
2069+
EXPECT_TRUE(m_ref.Matches(quiet_nan));
2070+
EXPECT_TRUE(m_ref.Matches(other_nan));
2071+
EXPECT_FALSE(m_ref.Matches(real_value));
2072+
2073+
Matcher<const float&> m_cref = IsNan();
2074+
EXPECT_TRUE(m_cref.Matches(quiet_nan));
2075+
EXPECT_TRUE(m_cref.Matches(other_nan));
2076+
EXPECT_FALSE(m_cref.Matches(real_value));
2077+
}
2078+
2079+
// Tests that IsNan() matches a NaN, with double.
2080+
TEST(IsNan, DoubleMatchesNan) {
2081+
double quiet_nan = std::numeric_limits<double>::quiet_NaN();
2082+
double other_nan = std::nan("1");
2083+
double real_value = 1.0;
2084+
2085+
Matcher<double> m = IsNan();
2086+
EXPECT_TRUE(m.Matches(quiet_nan));
2087+
EXPECT_TRUE(m.Matches(other_nan));
2088+
EXPECT_FALSE(m.Matches(real_value));
2089+
2090+
Matcher<double&> m_ref = IsNan();
2091+
EXPECT_TRUE(m_ref.Matches(quiet_nan));
2092+
EXPECT_TRUE(m_ref.Matches(other_nan));
2093+
EXPECT_FALSE(m_ref.Matches(real_value));
2094+
2095+
Matcher<const double&> m_cref = IsNan();
2096+
EXPECT_TRUE(m_cref.Matches(quiet_nan));
2097+
EXPECT_TRUE(m_cref.Matches(other_nan));
2098+
EXPECT_FALSE(m_cref.Matches(real_value));
2099+
}
2100+
2101+
// Tests that IsNan() matches a NaN, with long double.
2102+
TEST(IsNan, LongDoubleMatchesNan) {
2103+
long double quiet_nan = std::numeric_limits<long double>::quiet_NaN();
2104+
long double other_nan = std::nan("1");
2105+
long double real_value = 1.0;
2106+
2107+
Matcher<long double> m = IsNan();
2108+
EXPECT_TRUE(m.Matches(quiet_nan));
2109+
EXPECT_TRUE(m.Matches(other_nan));
2110+
EXPECT_FALSE(m.Matches(real_value));
2111+
2112+
Matcher<long double&> m_ref = IsNan();
2113+
EXPECT_TRUE(m_ref.Matches(quiet_nan));
2114+
EXPECT_TRUE(m_ref.Matches(other_nan));
2115+
EXPECT_FALSE(m_ref.Matches(real_value));
2116+
2117+
Matcher<const long double&> m_cref = IsNan();
2118+
EXPECT_TRUE(m_cref.Matches(quiet_nan));
2119+
EXPECT_TRUE(m_cref.Matches(other_nan));
2120+
EXPECT_FALSE(m_cref.Matches(real_value));
2121+
}
2122+
2123+
// Tests that IsNan() works with Not.
2124+
TEST(IsNan, NotMatchesNan) {
2125+
Matcher<float> mf = Not(IsNan());
2126+
EXPECT_FALSE(mf.Matches(std::numeric_limits<float>::quiet_NaN()));
2127+
EXPECT_FALSE(mf.Matches(std::nan("1")));
2128+
EXPECT_TRUE(mf.Matches(1.0));
2129+
2130+
Matcher<double> md = Not(IsNan());
2131+
EXPECT_FALSE(md.Matches(std::numeric_limits<double>::quiet_NaN()));
2132+
EXPECT_FALSE(md.Matches(std::nan("1")));
2133+
EXPECT_TRUE(md.Matches(1.0));
2134+
2135+
Matcher<long double> mld = Not(IsNan());
2136+
EXPECT_FALSE(mld.Matches(std::numeric_limits<long double>::quiet_NaN()));
2137+
EXPECT_FALSE(mld.Matches(std::nan("1")));
2138+
EXPECT_TRUE(mld.Matches(1.0));
2139+
}
2140+
2141+
// Tests that IsNan() can describe itself.
2142+
TEST(IsNan, CanDescribeSelf) {
2143+
Matcher<float> mf = IsNan();
2144+
EXPECT_EQ("is NaN", Describe(mf));
2145+
2146+
Matcher<double> md = IsNan();
2147+
EXPECT_EQ("is NaN", Describe(md));
2148+
2149+
Matcher<long double> mld = IsNan();
2150+
EXPECT_EQ("is NaN", Describe(mld));
2151+
}
2152+
2153+
// Tests that IsNan() can describe itself with Not.
2154+
TEST(IsNan, CanDescribeSelfWithNot) {
2155+
Matcher<float> mf = Not(IsNan());
2156+
EXPECT_EQ("isn't NaN", Describe(mf));
2157+
2158+
Matcher<double> md = Not(IsNan());
2159+
EXPECT_EQ("isn't NaN", Describe(md));
2160+
2161+
Matcher<long double> mld = Not(IsNan());
2162+
EXPECT_EQ("isn't NaN", Describe(mld));
2163+
}
2164+
20572165
// Tests that FloatEq() matches a 2-tuple where
20582166
// FloatEq(first field) matches the second field.
20592167
TEST(FloatEq2Test, MatchesEqualArguments) {

0 commit comments

Comments
 (0)