Google 测试比较指针数组的内容

Question

我是 google 测试的新手，我发现的任何方法都行不通。

假设我有一个数组，然后是一个函数 returns 我是一个指向新数组的指针，我想比较这两个数组是否包含相同的元素。

示例：

int foo[] {1,2,3};
int* expected result = foo;
int* result = bar(foo);

//comparison
EXPECT_THAT(foo, testing::UnorderedElementsAreArray(result, 3));
//other way
EXPECT_THAT(foo, testing::ContainerEq(result));

这两种方式都没有（类似的尝试也奏效）。

我想检查两个数组是否包含相同的元素，而不考虑顺序。

我已经尝试了 Comparison of arrays in google test? 中的方法，但其中 none 行得通。

另外 "ElementsAreArray" 是正确的比较器吗？

感谢您的帮助。

Answer 1

您尝试使用的 gtest 匹配器，testing::UnorderedElementsAreArray 和 testing::ContainerEq，仅适用于作为 STL 样式容器的对象。参见 the documentation。

您的 foo 是 int 的 C-style array。您的 expected_result 和 result 是指向 int 的指针。 None 其中是 STL 样式的容器，指针在任何意义上都不是容器。

你要测试的问题是 N 个整数是否从 expected_result 开始是从 result 开始的 N 整数的任何排列，其中 N 是数字数组中的元素数 foo.

通过单个 EXPECT... 调用来测试该问题的唯一方法当您调用某个准确确定的函数时，期望得到一个真实的结果带有参数 result 和 expected_result 以及 returns 布尔判定（或可转换为布尔判定的东西）的问题。

C++ 标准库（C++11 或更高版本）为此提供了一个通用函数：std::is_permutation，如图所示应用：

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

int * reverse(int in[], std::size_t len)
{
    int * permute = new int[len];
    std::reverse_copy(in,in + len,permute);
    return permute;
}

TEST(reverse,is_correct)
{
    int foo[] {1,2,3};
    int* expected_result = foo;
    std::size_t len = sizeof(foo)/sizeof(foo[0]);
    int* result = reverse(foo,len);
    EXPECT_TRUE(std::is_permutation(result,result + len,expected_result));
    delete [] result;
}

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

输出：

[==========] Running 1 test from 1 test case.
[----------] Global test environment set-up.
[----------] 1 test from reverse
[ RUN      ] reverse.is_correct
[       OK ] reverse.is_correct (0 sec)
[----------] 1 test from reverse (0 sec total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test case ran. (0 ms total)
[  PASSED  ] 1 test.

请注意，C 风格数组的使用要求您通过以下方式管理堆内存手：

    int * permute = new int[len];
    ...
    ...
    delete [] result

这在 C++ 中是对堆泄漏或堆损坏的无端邀请错误。对于固定大小的数组，请使用 std::array。对于动态大小的数组，使用 std::vector。这个比较好：

#include <gtest/gtest.h>
#include <algorithm>
#include <array>

template<std::size_t N>
std::array<int,N> reverse(std::array<int,N> const & in)
{
    std::array<int,N> permute;
    std::reverse_copy(in.begin(),in.end(),permute.begin());
    return permute;
}

TEST(reverse,is_correct)
{
    std::array<int,3> foo {1,2,3};
    auto result = reverse(foo);
    EXPECT_TRUE(std::is_permutation(result.begin(),result.end(),foo.begin()));
}

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

而且，由于 std::array 和 std::vector 是 STL 风格的容器，您的如果您使用其中之一，最初的尝试会奏效：

#include <gmock/gmock.h>
#include <algorithm>
#include <array>

template<std::size_t N>
std::array<int,N> reverse(std::array<int,N> const & in)
{
    std::array<int,N> permute;
    std::reverse_copy(in.begin(),in.end(),permute.begin());
    return permute;
}

TEST(reverse,is_correct)
{
    std::array<int,3> foo {1,2,3};
    auto result = reverse(foo);
    EXPECT_THAT(foo,testing::UnorderedElementsAreArray(result));
}

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

Google 测试比较指针数组的内容

Google test compare pointer-arrays' content

c++

arrays

pointers

googletest

gmock