GTest中的嵌套匹配器

Question

GTest中的嵌套匹配器

5

我想在其他匹配器中使用一些现有的匹配器。我知道MatcherInterface解决方案，但我想知道能否使用由MATCHER_P定义的匹配器。我找到了以下解决方案:

struct Foo
{
    double x;
    double y;
};

struct Bar
{
    Foo foo;
    int i;
};

MATCHER_P(EqFoo, foo, "")
{
    ::testing::Matcher<double> x_matcher = ::testing::DoubleNear(foo.x, 0.0001);
    if (!x_matcher.MatchAndExplain(arg.x, result_listener))
    {
        return false;
    }

    ::testing::Matcher<double> y_matcher = ::testing::DoubleNear(foo.y, 0.0001);
    if (!y_matcher.MatchAndExplain(arg.y, result_listener))
    {
        return false;
    }

    return true;
}

MATCHER_P(EqBar, bar, "")
{
    ::testing::Matcher<Foo> foo_matcher = EqFooMatcherP<Foo>(bar.foo);

    if (!foo_matcher.MatchAndExplain(arg.foo, result_listener))
    {
        return false;
    }

    if (bar.i != arg.i)
    {
        return false;
    }

    return true;
}

TEST_F(TestClass, BarTest)
{
    Bar bar_val{{10.12, 76.43}, 78};
    Bar bar_exp{{10.12, 99.99}, 78};

    EXPECT_THAT(bar_val, EqBar(bar_exp));
}

我在想，是否有更好、更好的解决方案来

在另一个匹配器中使用我的 MATCHER_P 匹配器
在另一个匹配器中使用原始 GTest 匹配器。

- Tibor Takács

你的测试是一个例子吗？否则你将不需要匹配器。 - Tobias Wollgam

当然，这只是我原始代码的简化版。 - Tibor Takács

1个回答

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- PiotrNycz · Accepted Answer

正确的方式是尽可能使用来自gtest/gmock的匹配器。只有在没有已提供的匹配器时才使用自己的。

在您的示例中，就像这样简单：

auto EqFoo(const Foo& expected)
{
   return ::testing::AllOf(
         ::testing::Field(&Foo::x, ::testing::DoubleNear(expected.x, 0.0001)),
         ::testing::Field(&Foo::y, ::testing::DoubleNear(expected.y, 0.0001))
     );
}

auto EqBar(const Bar& expected)
{
   return ::testing::AllOf(
         ::testing::Field(&Bar::foo, EqFoo(expected.foo)),
         ::testing::Field(&Bar::i, expected.i)
     );
}

更一般的方法是使用重载：

auto MatchDouble(double expected)   
{
    return ::testing::DoubleNear(expected.x, 0.0001);
}
auto MatchFoo(::testing::Matcher<double> x, ::testing::Matcher<double> y)
{
   return ::testing::AllOf(
         ::testing::Field(&Foo::x, x),
         ::testing::Field(&Foo::y, y)
     );
}
auto MatchFoo(double x, double y)
{
   return MatchFoo(MatchDouble(x), MatchDouble(y));
}

auto MatchBar(::testing::Matcher<Foo> foo, ::testing::Matcher<int> i)
{
   return ::testing::AllOf(
         ::testing::Field(&Bar::foo, foo),
         ::testing::Field(&Bar::i, expected.i),
     );
}
auto MatchBar(const Bar& expected)
{
   return MatchBar(expected.foo, expected.i);
}

那么，您的测试：

TEST_F(TestClass, BarTest)
{
    Bar bar_val{{10.12, 76.43}, 78};
    Bar bar_exp{{10.12, 99.99}, 78};

    EXPECT_THAT(bar_val, MatchBar(bar_exp));

    // or - e.g. you can match only Bar::y if other things are irrelevant in your test
    EXPECT_THAT(bar_val, MatchBar(MatchFoo(_, MatchDouble(2.001)), _);
}

无论如何 - 使用 MATCHER_P 应该是相当罕见的情况，我的观察是这个宏确实被过度使用了。

如果您的项目是 C++14 之前的版本，请在这些函数的返回类型中使用 ::testing::Matcher<T> 而不是 auto。