[Bug]: MSVC ElementsAreArray compilation errors

[robjinman]

Describe the issue

Use of ElementsAreArray causes compilation errors on Windows with MSVC.

As far as I can tell, I'm doing exactly what is written in the online documentation.

A minimal example

#include <gtest/gtest.h>
#include <gmock/gmock.h>

class MyTestClass : public testing::Test
{
};

class Foo
{
public:
  virtual void bar(const int values[]) {}
};

class MockFoo : public Foo
{
public:
  MOCK_METHOD(void, bar, (const int[]), (override));

};

TEST_F(MyTestClass, thisShouldWork)
{
  const int values[] = { 123, 45 };

  MockFoo foo;
  EXPECT_CALL(foo, bar(testing::ElementsAreArray(values, 2))).Times(1);

  foo.bar(values);
}

Here is the compiler output

PS C:\example\build> cmake --build . --config Debug
MSBuild version 17.9.5+33de0b227 for .NET Framework

gmock.vcxproj -> C:\example\build\lib\Debug\gmock.lib
gmock_main.vcxproj -> C:\example\build\lib\Debug\gmock_main.lib
gtest.vcxproj -> C:\example\build\lib\Debug\gtest.lib
gtest_main.vcxproj -> C:\example\build\lib\Debug\gtest_main.lib
foo_test.cpp
C:\example\src\foo_test.cpp(11,30): warning C4100: 'values': unreferenced formal parameter [C:\example\build\unittests.
vcxproj]
C:\example\dependencies\Debug\googletest-src\googlemock\include\gmock\gmock-matchers.h(3373,20): error C2825: 'testing:
:internal::ElementsAreMatcherImpl<const Container &>::StlContainer': must be a class or namespace when followed by '::'
[C:\example\build\unittests.vcxproj]
C:\example\dependencies\Debug\googletest-src\googlemock\include\gmock\gmock-matchers.h(3373,20): error C2825: w
ith [C:\example\build\unittests.vcxproj]
C:\example\dependencies\Debug\googletest-src\googlemock\include\gmock\gmock-matchers.h(3373,20): error C2825: [
[C:\example\build\unittests.vcxproj]
C:\example\dependencies\Debug\googletest-src\googlemock\include\gmock\gmock-matchers.h(3373,20): error C2825:
Container=const int * [C:\example\build\unittests.vcxproj]
C:\example\dependencies\Debug\googletest-src\googlemock\include\gmock\gmock-matchers.h(3373,20): error C2825: ]
[C:\example\build\unittests.vcxproj]
(compiling source file '../src/foo_test.cpp')
C:\example\dependencies\Debug\googletest-src\googlemock\include\gmock\gmock-matchers.h(3373,20):
the template instantiation context (the oldest one first) is
C:\example\src\foo_test.cpp(26,3):
see reference to function template instantiation 'testing::internal::ElementsAreArrayMatcher::operator tes
ting::Matcher<const int >(void) const<const int>' being compiled
C:\example\src\foo_test.cpp(26,68):
see the first reference to 'testing::internal::ElementsAreArrayMatcher::operator testing::Matcher<
const int *>' in 'MyTestClass_thisShouldWork_Test::TestBody'
C:\example\dependencies\Debug\googletest-src\googlemock\include\gmock\gmock-matchers.h(3787,35):
see reference to class template instantiation 'testing::internal::ElementsAreMatcherImpl<const Container &>' be
ing compiled
with
[
Container=const int *
]

C:\example\dependencies\Debug\googletest-src\googlemock\include\gmock\gmock-matchers.h(3373,34): error C2510: 'StlConta
iner': left of '::' must be a class/struct/union [C:\example\build\unittests.vcxproj]
(compiling source file '../src/foo_test.cpp')

C:\example\dependencies\Debug\googletest-src\googlemock\include\gmock\gmock-matchers.h(3373,45): error C3646: 'Element'
: unknown override specifier [C:\example\build\unittests.vcxproj]
(compiling source file '../src/foo_test.cpp')

C:\example\dependencies\Debug\googletest-src\googlemock\include\gmock\gmock-matchers.h(3507,31): error C2146: syntax er
ror: missing '>' before identifier 'Element' [C:\example\build\unittests.vcxproj]
(compiling source file '../src/foo_test.cpp')

Steps to reproduce the problem

src/main.cpp

#include <gtest/gtest.h>

int main(int argc, char** argv) {
  testing::InitGoogleTest(&argc, argv);

  return RUN_ALL_TESTS();
}

src/foo_test.cpp

#include <gtest/gtest.h>
#include <gmock/gmock.h>

class MyTestClass : public testing::Test
{
};

class Foo
{
public:
  virtual void bar(const int values[]) {}
};

class MockFoo : public Foo
{
public:
  MOCK_METHOD(void, bar, (const int[]), (override));

};

TEST_F(MyTestClass, thisShouldWork)
{
  const int values[] = { 123, 45 };

  MockFoo foo;
  EXPECT_CALL(foo, bar(testing::ElementsAreArray(values, 2))).Times(1);

  foo.bar(values);
}

CMakeLists.txt

cmake_minimum_required(VERSION 3.24)

set(PROJECT_NAME gmock_example)
set(TARGET_NAME unittests)

project(${PROJECT_NAME})

if (NOT CMAKE_BUILD_TYPE)
  set(CMAKE_BUILD_TYPE "Debug")
endif()

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

include(FetchContent)
set(FETCHCONTENT_BASE_DIR ${PROJECT_SOURCE_DIR}/dependencies/${CMAKE_BUILD_TYPE})

FetchContent_Declare(googletest
  URL https://github.com/google/googletest/archive/refs/tags/v1.14.0.zip
  DOWNLOAD_EXTRACT_TIMESTAMP ON
)

FetchContent_MakeAvailable(googletest)

file(GLOB_RECURSE SRCS "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp")

add_executable(${TARGET_NAME} ${SRCS})

target_link_libraries(${TARGET_NAME} gtest_main gmock_main)
target_compile_options(${TARGET_NAME} PRIVATE "/W4")

Build commands

Run in powershell

cd (mkdir build)
cmake -G "Visual Studio 17 2022" ..
cmake --build . --config Debug

What version of GoogleTest are you using?

1.14.0

What operating system and version are you using?

Windows 11 Enterprise 10.0.22621 Build 22621

What compiler and version are you using?

MSBuild version 17.9.5+33de0b227 for .NET Framework

What build system are you using?

cmake version 3.28.1

Additional context

No response

[brandl-muc]

Your function argument is const int[] which is equivalent to const int *, that is, the array decays to a pointer to the first argument. This is the reason why you see Container=const int * in your error message. And because const int * is not a container your code does not compile.
The documentation is correct, though, because the ElementsAre* matchers are listed as container matcher. (and those require the size of the container).

Already for security reasons I would highly recommend you to change the signature to something that allows the callee to know the size of the argument, at the same time that would fix your problem.
Either use C-style pointer to first and size, or begin/end iterators, or std::span. (which is of C++20, but I can recommend this pre C++20 implementation).
Then you can use the trick from this thread to make it work. I tested it with the pointer/size variant and it both compiles and tests correctly:

#include <gmock/gmock.h>
#include <gtest/gtest.h>

using namespace ::testing;

class MyTestClass : public testing::Test
{};

class Foo
{
public:
    virtual void bar(const int *, size_t)
    {}
};

class MockFoo : public Foo
{
public:
    MOCK_METHOD(void, bar, (const int *, size_t), (override));
};

TEST_F(MyTestClass, thisShouldWork)
{
    const int values[] = { 123, 45 };

    MockFoo foo;
    EXPECT_CALL(foo, bar(_, _))
        .With(Args<0, 1>(ElementsAreArray(values)))
        .Times(1);

    foo.bar(values, sizeof(values)/sizeof(int));
}

[vincedupuis]

Hello,

I got the same issue as @robjinman but you said that

The documentation is correct, though, because the ElementsAre* matchers are listed as container matcher. (and those require the size of the container).

The documentation is incorrect in this section:

In case the array needs to be dynamically created (and therefore the array size cannot be inferred by the compiler), you can give ElementsAreArray() an additional argument to specify the array size:

using ::testing::ElementsAreArray;
...
int* const expected_vector3 = new int[count];
... fill expected_vector3 with values ...
EXPECT_CALL(mock, Foo(ElementsAreArray(expected_vector3, count)));

So, this is a bug as per the documentation.

Also, I tried your solution, and it also doesn't compile on my end.
Using: gcc 11.4 and gtest 1.15.2

With the following compile error:

/tmp/tests/unitTests/cppTools/Test.cpp:28:18: error: no matching function for call to 'testing::internal::TypedExpectation<void(const int*, long unsigned int)>::With(testing::internal::ArgsMatcher<testing::internal::ElementsAreArrayMatcher, 0, 1>)'
28 | .With(Args<0, 1>(ElementsAreArray(values)))
In file included from /tmp/nuget/Release/include/gmock/gmock-function-mocker.h:43,
from /tmp/nuget/Release/include/gmock/gmock.h:58,
from /tmp/tests/unitTests/cppTools/Test.cpp:1:
/tmp/nuget/Release/include/gmock/gmock-spec-builders.h:895:21: note: candidate: 'testing::internal::TypedExpectation<R(Args ...)>& testing::internal::TypedExpectation<R(Args ...)>::With(const testing::Matcher<const typename testing::internal::Function<R(Args ...)>::ArgumentTuple&>&, long unsigned int) [with R = void; Args = {const int*, long unsigned int}; typename testing::internal::Function<R(Args ...)>::ArgumentTuple = std::tuple<const int*, long unsigned int>]'
895 | TypedExpectation &With(const Matcher<const ArgumentTuple &> &m, unsigned long i)
| ^~~~
/tmp/nuget/Release/include/gmock/gmock-spec-builders.h:895:21: note: candidate expects 2 arguments, 1 provided
gmake[3]: *** [tests/unitTests/CMakeFiles/ppms-lla-UnitTest.dir/build.make:160: tests/unitTests/CMakeFiles/ppms-lla-UnitTest.dir/cppTools/Test.cpp.o] Error 1
gmake[2]: *** [CMakeFiles/Makefile2:196: tests/unitTests/CMakeFiles/ppms-lla-UnitTest.dir/all] Error 2
gmake[1]: *** [CMakeFiles/Makefile2:203: tests/unitTests/CMakeFiles/ppms-lla-UnitTest.dir/rule] Error 2
gmake: *** [Makefile:137: ppms-lla-UnitTest] Error 2

[brandl-muc]

Sadly, you do not really explain what the bug is that you believe you found in the documentation. So I can only guess.

It seems to me that you didn't fully understand matchers yet, and as a consequence come to the (wrong) conclusion that the documentation is incorrect.
Although a matcher may match a specific type only, most of them match a certain concept. For example, Ge() can match any type that implements operator>=(). Similarly, IsEmpty() matches any container type, where container is defined as type with an empty() member function that returns true iff the container is empty. SizeIs(m) is a container matcher as well, this time the container requires a size() function. Both are container matchers but neither is constructed with a container because they don't need one to perform the matching.
ElementsAre(e0, ..., en) also matches a container, this time we (obviously) need size() for a size comparison and probably begin()/end() to be able to iterate the elements and compare them with the eis. Again, this matcher is not constructed with a container but it matches a container.
Lastly, ElementsAreArray() is no different, it matches a container. The only difference is that you don't pass the expected container elements but something which contains those elements. This can be (per the docs) a braced-init-list, a container, a range (iterator pair), an array with static size or an array with dynamic size. The later is what your cited documentation is about. You pass the expected arguments as array expected_vector3 with dynamic size count to ElementsAreArray() but the result still is a container matcher. It will not match a pointer because that does not satisfy the container requirements.

The reason why the approach EXPECT_CALL(foo, bar).With(AllArgs(ElementsAreArray(values))) works is that With() converts both arguments into a std::tuple<int const *, size_t>. That does not satisfy the container requirements either, but the documentation explicitly mentions that container matchers also match "an array passed as a pointer and a count". (see Notes, first bullet, ii)

With this I still stand with my statement that you cited and can affirm that the cited documentation is in fact correct.

As to your compiler error, this still works for me. (albeit not with the same versions as you mentioned because they are not available) It looks to me like you are calling ElementsAreArray(values) where ´values` is a pointer to array. If this is the case then pass the array size as second argument or avoid array to pointer decay. Otherwise you might want to post your code.

[vincedupuis]

I took the example as is from the doc and it doesn't compile. what else you don't understand.

[brandl-muc]

Oh I see now, you are not interested in help. My bad, should have realized that earlier. Good luck, then.