¿Cómo compara gtest los valores en dos matrices?

Question

He leído this official document, aprende cómo hacer la comparación binaria y la comparación de cuerdas.

El ASSERT_EQ y ASSERT_STREQ no podían trabajar en el caso la comparación de matrices.

Por ejemplo

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

No necesita agregar una dependencia en googlemock si no lo desea, puede escribir su propia función simple que devuelva testing::AssertionResult, p. Ej.

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

Luego, en su prueba, llame a:

EXPECT_TRUE(ArraysMatch(two_sorted, two)); 

Answer 2

ASSERT_EQ compara sus argumentos usando operator==. Comparando con operator== funciona para std::vector pero no para C-arrays en C++. La razón es que cuando intenta usar un valor de una matriz C en una expresión, en la mayoría de las circunstancias el valor decae en un puntero que apunta al comienzo de la memoria donde se almacena la matriz. Usted termina comparando dos punteros. En el caso de dos matrices C diferentes, esos punteros nunca tendrán el mismo valor.

Su salida más fácil es usar la macro ASSERT_THAT de Google Mock y el marcador ContainerEq. En lugar de ASSERT_EQ, escribir

ASSERT_THAT(two, ContainerEq(two_sorted)); 

Answer 3

creo que es suficiente para escribir al igual que este.

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