eson/googletest
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

avoids clash with the max() macro on Windows

Browse Source
This commit is contained in:
zhanyong.wan 2013-09-18 17:51:08 +00:00
parent 6e0fba4de0
commit 35877b7967
1 changed files with 59 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

153
test/gmock-matchers_test.cc
View File

@ -2645,43 +2645,30 @@ TEST(MatcherAssertionTest, WorksForMonomorphicMatcher) {
template <typename RawType> template <typename RawType>
class FloatingPointTest : public testing::Test { class FloatingPointTest : public testing::Test {
protected: protected:
typedef typename testing::internal::FloatingPoint<RawType> Floating; typedef testing::internal::FloatingPoint<RawType> Floating;
typedef typename Floating::Bits Bits; typedef typename Floating::Bits Bits;
virtual void SetUp() { FloatingPointTest()
const size_t max_ulps = Floating::kMaxUlps; : max_ulps_(Floating::kMaxUlps),
zero_bits_(Floating(0).bits()),
// The bits that represent 0.0. one_bits_(Floating(1).bits()),
const Bits zero_bits = Floating(0).bits(); infinity_bits_(Floating(Floating::Infinity()).bits()),
close_to_positive_zero_(
// Makes some numbers close to 0.0. Floating::ReinterpretBits(zero_bits_ + max_ulps_/2)),
close_to_positive_zero_ = Floating::ReinterpretBits(zero_bits + max_ulps/2); close_to_negative_zero_(
close_to_negative_zero_ = -Floating::ReinterpretBits( -Floating::ReinterpretBits(zero_bits_ + max_ulps_ - max_ulps_/2)),
zero_bits + max_ulps - max_ulps/2); further_from_negative_zero_(-Floating::ReinterpretBits(
further_from_negative_zero_ = -Floating::ReinterpretBits( zero_bits_ + max_ulps_ + 1 - max_ulps_/2)),
zero_bits + max_ulps + 1 - max_ulps/2); close_to_one_(Floating::ReinterpretBits(one_bits_ + max_ulps_)),
further_from_one_(Floating::ReinterpretBits(one_bits_ + max_ulps_ + 1)),
// The bits that represent 1.0. infinity_(Floating::Infinity()),
const Bits one_bits = Floating(1).bits(); close_to_infinity_(
Floating::ReinterpretBits(infinity_bits_ - max_ulps_)),
// Makes some numbers close to 1.0. further_from_infinity_(
close_to_one_ = Floating::ReinterpretBits(one_bits + max_ulps); Floating::ReinterpretBits(infinity_bits_ - max_ulps_ - 1)),
further_from_one_ = Floating::ReinterpretBits(one_bits + max_ulps + 1); max_(Floating::Max()),
nan1_(Floating::ReinterpretBits(Floating::kExponentBitMask | 1)),
// +infinity. nan2_(Floating::ReinterpretBits(Floating::kExponentBitMask | 200)) {
infinity_ = Floating::Infinity();
// The bits that represent +infinity.
const Bits infinity_bits = Floating(infinity_).bits();
// Makes some numbers close to infinity.
close_to_infinity_ = Floating::ReinterpretBits(infinity_bits - max_ulps);
further_from_infinity_ = Floating::ReinterpretBits(
infinity_bits - max_ulps - 1);
// Makes some NAN's.
nan1_ = Floating::ReinterpretBits(Floating::kExponentBitMask | 1);
nan2_ = Floating::ReinterpretBits(Floating::kExponentBitMask | 200);
} }
void TestSize() { void TestSize() {
@ -2736,51 +2723,34 @@ class FloatingPointTest : public testing::Test {
// Pre-calculated numbers to be used by the tests. // Pre-calculated numbers to be used by the tests.
static RawType close_to_positive_zero_; const size_t max_ulps_;
static RawType close_to_negative_zero_;
static RawType further_from_negative_zero_;
static RawType close_to_one_; const Bits zero_bits_; // The bits that represent 0.0.
static RawType further_from_one_; const Bits one_bits_; // The bits that represent 1.0.
const Bits infinity_bits_; // The bits that represent +infinity.
static RawType infinity_; // Some numbers close to 0.0.
static RawType close_to_infinity_; const RawType close_to_positive_zero_;
static RawType further_from_infinity_; const RawType close_to_negative_zero_;
const RawType further_from_negative_zero_;
static RawType nan1_; // Some numbers close to 1.0.
static RawType nan2_; const RawType close_to_one_;
const RawType further_from_one_;
// Some numbers close to +infinity.
const RawType infinity_;
const RawType close_to_infinity_;
const RawType further_from_infinity_;
// Maximum representable value that's not infinity.
const RawType max_;
// Some NaNs.
const RawType nan1_;
const RawType nan2_;
}; };
template <typename RawType>
RawType FloatingPointTest<RawType>::close_to_positive_zero_;
template <typename RawType>
RawType FloatingPointTest<RawType>::close_to_negative_zero_;
template <typename RawType>
RawType FloatingPointTest<RawType>::further_from_negative_zero_;
template <typename RawType>
RawType FloatingPointTest<RawType>::close_to_one_;
template <typename RawType>
RawType FloatingPointTest<RawType>::further_from_one_;
template <typename RawType>
RawType FloatingPointTest<RawType>::infinity_;
template <typename RawType>
RawType FloatingPointTest<RawType>::close_to_infinity_;
template <typename RawType>
RawType FloatingPointTest<RawType>::further_from_infinity_;
template <typename RawType>
RawType FloatingPointTest<RawType>::nan1_;
template <typename RawType>
RawType FloatingPointTest<RawType>::nan2_;
// Tests floating-point matchers with fixed epsilons. // Tests floating-point matchers with fixed epsilons.
template <typename RawType> template <typename RawType>
class FloatingPointNearTest : public FloatingPointTest<RawType> { class FloatingPointNearTest : public FloatingPointTest<RawType> {
@ -2820,32 +2790,27 @@ class FloatingPointNearTest : public FloatingPointTest<RawType> {
EXPECT_FALSE(m4.Matches(ParentType::infinity_)); EXPECT_FALSE(m4.Matches(ParentType::infinity_));
// Test various overflow scenarios. // Test various overflow scenarios.
Matcher<RawType> m5 = matcher_maker( Matcher<RawType> m5 = matcher_maker(ParentType::max_, ParentType::max_);
std::numeric_limits<RawType>::max(), EXPECT_TRUE(m5.Matches(ParentType::max_));
std::numeric_limits<RawType>::max()); EXPECT_FALSE(m5.Matches(-ParentType::max_));
EXPECT_TRUE(m5.Matches(std::numeric_limits<RawType>::max()));
EXPECT_FALSE(m5.Matches(-std::numeric_limits<RawType>::max()));
Matcher<RawType> m6 = matcher_maker( Matcher<RawType> m6 = matcher_maker(-ParentType::max_, ParentType::max_);
-std::numeric_limits<RawType>::max(), EXPECT_FALSE(m6.Matches(ParentType::max_));
std::numeric_limits<RawType>::max()); EXPECT_TRUE(m6.Matches(-ParentType::max_));
EXPECT_FALSE(m6.Matches(std::numeric_limits<RawType>::max()));
EXPECT_TRUE(m6.Matches(-std::numeric_limits<RawType>::max()));
Matcher<RawType> m7 = matcher_maker(std::numeric_limits<RawType>::max(), 0); Matcher<RawType> m7 = matcher_maker(ParentType::max_, 0);
EXPECT_TRUE(m7.Matches(std::numeric_limits<RawType>::max())); EXPECT_TRUE(m7.Matches(ParentType::max_));
EXPECT_FALSE(m7.Matches(-std::numeric_limits<RawType>::max())); EXPECT_FALSE(m7.Matches(-ParentType::max_));
Matcher<RawType> m8 = matcher_maker( Matcher<RawType> m8 = matcher_maker(-ParentType::max_, 0);
-std::numeric_limits<RawType>::max(), 0); EXPECT_FALSE(m8.Matches(ParentType::max_));
EXPECT_FALSE(m8.Matches(std::numeric_limits<RawType>::max())); EXPECT_TRUE(m8.Matches(-ParentType::max_));
EXPECT_TRUE(m8.Matches(-std::numeric_limits<RawType>::max()));
// The difference between max() and -max() normally overflows to infinity, // The difference between max() and -max() normally overflows to infinity,
// but it should still match if the max_abs_error is also infinity. // but it should still match if the max_abs_error is also infinity.
Matcher<RawType> m9 = matcher_maker( Matcher<RawType> m9 = matcher_maker(
std::numeric_limits<RawType>::max(), ParentType::infinity_); ParentType::max_, ParentType::infinity_);
EXPECT_TRUE(m8.Matches(-std::numeric_limits<RawType>::max())); EXPECT_TRUE(m8.Matches(-ParentType::max_));
// matcher_maker can produce a Matcher<const RawType&>, which is needed in // matcher_maker can produce a Matcher<const RawType&>, which is needed in
// some cases. // some cases.