How does gtest compare the values in two arrays?

Question

I have read this official document, learn how to do Binary Comparison and String Comparison.

The ASSERT_EQ and ASSERT_STREQ could not work in the array comparison case.

For example

li@li:~/poc$ g++ -I${GTEST_DIR}/include insertion_sort.cpp insertion_sort_unittest.cpp /home/li/libgtest.a -lpthread -o inser_unit
li@li:~/poc$ ./inser_unit 
[==========] Running 1 test from 1 test case.
[----------] Global test environment set-up.
[----------] 1 test from InsertionSortTest
[ RUN      ] InsertionSortTest.Two
insertion_sort_unittest.cpp:18: Failure
Value of: two_sorted
  Actual: { 2, 5 }
Expected: two
Which is: { 2, 5 }
[  FAILED  ] InsertionSortTest.Two (1 ms)
[----------] 1 test from InsertionSortTest (1 ms total)

[----------] Global test environment tear-down
[==========] 1 test from 1 test case ran. (1 ms total)
[  PASSED  ] 0 tests.
[  FAILED  ] 1 test, listed below:
[  FAILED  ] InsertionSortTest.Two

 1 FAILED TEST

insertion_sort_unittest.cpp

#include <limits.h>
#include "insertionsort.h"
#include "gtest/gtest.h"

namespace{
    class InsertionSortTest : public ::testing::Test{
        protected:
            InsertionSortTest() {}
            virtual ~InsertionSortTest() {}
            virtual void SetUp() {}
            virtual void TearDown() {}
    };

    TEST(InsertionSortTest, Two){
        int two[] = {5, 2};
        int two_sorted[] = {2, 5};
        insertionSort(two, 2);
        EXPECT_EQ(two, two_sorted);
    }
}

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

insertion_sort.cpp

#include "insertionsort.h"
void insertionSort(int *data, int size){
    for (int i=1,j; i<size; i++){
        int key = data[i];
        for (j=i-1; j>=0; j--){
            if (data[j] > key){
                data[j+1]=data[j];
                data[j]=key;
            }
        }
    }
}

insertionsort.h

#ifndef INSERTIONSORT_H_
#define INSERTIONSORT_H_
void insertionSort(int *data, int size);
#endif

Answer 1

You don't need to add a dependency on googlemock if you don't want, you could write your own simple function that returns a testing::AssertionResult, e.g.

    template<typename T, size_t size>
    ::testing::AssertionResult ArraysMatch(const T (&expected)[size],
                                           const T (&actual)[size]){
        for (size_t i(0); i < size; ++i){
            if (expected[i] != actual[i]){
                return ::testing::AssertionFailure() << "array[" << i
                    << "] (" << actual[i] << ") != expected[" << i
                    << "] (" << expected[i] << ")";
            }
        }

        return ::testing::AssertionSuccess();
    }

Then in your test, call:

    EXPECT_TRUE(ArraysMatch(two_sorted, two));

Answer 2

ASSERT_EQ compares its arguments using operator==. Comparing with operator== works for std::vector's but not for C-arrays in C++. The reason is, when you try to use a value of a C-array in an expression, in most circumstances the value decays into a pointer pointing to the beginning of the memory where the array is stored. You end up comparing two pointers. In case of two different C-arrays those pointers will never have the same value.

Your easiest way out is to use Google Mock's ASSERT_THAT macro and the ContainerEq matcher. Instead of ASSERT_EQ, write

ASSERT_THAT(two, ContainerEq(two_sorted));

Answer 3

I think it is enough to write just like this.

EXPECT_EQ(memcmp(two, two_sorted, 2 * sizeof(int)), 0);