Question

我是谷歌测试的新手，我发现的任何方法都没有用。

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

示例：

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?中的方法，但没有一种方法有效。

还有“ElementsAreArray”是正确的比较器吗？

感谢您的帮助。

Answer 1

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

您的foo是int expected_result。您的 result和int是N的指针。这些都不是STL风格的容器，并且指针在任何意义上都不是容器。

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

使用单个result调用来测试该问题的唯一方法当你调用一个确切地确定它的函数时，期望得到一个真实的结果带有参数expected_result和#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(); }的问题，并返回一个布尔判决（或可转换为布尔判决的东西）。

C ++标准库（C ++ 11或更高版本）为此目的提供了一个通用函数：C-style array，您将如图所示申请：

[==========] 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.

输出：

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

请注意，使用C风格的数组会迫使您管理堆内存手：

#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();
}

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

std::array

而且，由于std::vector和#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(); } 是 STL风格的容器，如果您使用过其中任何一个，那么原始尝试会起作用：

SELECT
    CASE 
       WHEN Substring(dbo.LIMIT_HIST.ID,8,5) = '.0010' 
            OR Substring(dbo.LIMIT_HIST.ID,8,5) = '.0020' 
       THEN Left(dbo_LIMIT_HIST.ID,18)
       ELSE '' 
    END AS IDs
FROM
    dbo.LIMIT_HIST INNER JOIN
    dbo.CUSTOMER ON 
    dbo.LIMIT_HIST.LIABILITY_NUMBER = dbo.CUSTOMER.CUSTOMER_CODE

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

1 个答案: