Verify (EXPECT_NE/EXPECT_EQ) struct members for a Template class in a function

Question

I have a unit test that validates whether certain member values (valueA, valueB) equate to 0 or not. And the object being tested i.e Object is a template and what I am looking to accomplish is to:

wrap the validation part in a function so instead of invoking EXPECT_NE/EXPECT_EQ for each member value, I just invoke a function that takes care of the validation

This is the original snippet:

template<typename T>
struct Object
{
    struct Values
    {
        int valueA;
        int valueB;
    };
    Values values = {};
    T otherStuff;
    
    void setValues(int valueA, int valueB)
    {
        values.valueA = valueA;
        values.valueB = valueB;
    }
};

TEST(UnitTest, testA)
{
    Object<int> object;
    // do stuff that modified object's values via setValues()
    EXPECT_NE(object.values.valueA, 0);
    EXPECT_EQ(object.values.valueB, 0); 
}

Following is what I came up with but I get the following error

gmock-matchers.h:2074:31: error: no matching function for call to 'testing::internal::FieldMatcher<Object<int>::Values, int>::MatchAndExplainImpl(std::integral_constant<bool, false>::type, const Object<int>&, testing::MatchResultListener*&) const'
 2074 |     return MatchAndExplainImpl(
      |            ~~~~~~~~~~~~~~~~~~~^
 2075 |         typename std::is_pointer<typename std::remove_const<T>::type>::type(),
      |         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 2076 |         value, listener);

If I were to use a member variable outside of a struct i.e testVar in MatchesStruct, it would compile fine. Why the complain with struct member?

using ::testing::Eq;
using ::testing::Ne;
using ::testing::Field;
using ::testing::AllOf;

template<typename T>
struct Object
{
    int testVar;
    struct Values
    {
        int valueA;
        int valueB;
    };
    Values values = {};
    T otherStuff;
    
    void setValues(int valueA, int valueB)
    {
        values.valueA = valueA;
        values.valueB = valueB;
    }
};

template <typename T, class M1, class M2>
auto MatchesStruct(M1 m1, M2 m2)
{
    return AllOf(Field(&Object<T>::Values::valueA, m1), 
                 Field(&Object<T>::Values::valueB, m2));
}

TEST(UnitTest, testA)
{
    Object<int> object;
    // do stuff that modified object's values via setValues()
    EXPECT_THAT(object, MatchesStruct<int>(Ne(0), Eq(0)));
}

Here's a live sample

Answer 1

This is almost the same question as the one you asked a few hours ago and is actually based on my initial answer there, but with the twist that here Object is a template and its members valueA and valueB are in another struct. You cannot form a member pointer to a member within a member variable like you attempt to do (i.e. &Object<T>::Values::valueA is not allowed by the C++ standard), so Field cannot be used that way.

In any case, the answer to this is almost the same as my answer in the other post (which I amended just now after you said in a comment there that your Object is a template): Write a proper matcher using MATCHER_P2, like so (live example):

template<typename T>
struct Object
{
    int ran;
    struct Values
    {
        int valueA = 42;
        int valueB = 0;
    };

    Values values = {};
    T otherStuff;
};

MATCHER_P2(MatchesStruct, m1, m2, "")
{
    return ExplainMatchResult(m1, arg.values.valueA, result_listener) 
        && ExplainMatchResult(m2, arg.values.valueB, result_listener);
}

TEST(UnitTest, testA)
{
    Object<int> object;
    EXPECT_THAT(object, MatchesStruct(Ne(0), Eq(0)));
}