In che modo gtest confronta i valori in due matrici?

Question

Ho letto this official document, ho imparato come fare il confronto binario e il confronto delle stringhe.

L'ASSERT_EQ e ASSERT_STREQ potrebbero non funzionare nel caso di confronto degli array.

Ad esempio

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

Non è necessario aggiungere una dipendenza su googlemock se non si desidera, è possibile scrivere la propria funzione semplice che restituisce un testing::AssertionResult, ad es.

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

Poi nel test, lo chiamano:

EXPECT_TRUE(ArraysMatch(two_sorted, two)); 

Answer 2

ASSERT_EQ confronta i suoi argomenti con operator==. Il confronto con operator== funziona per std::vector ma non per C-array in C++. Il motivo è che, quando si tenta di utilizzare un valore di un array C in un'espressione, nella maggior parte dei casi il valore decade in un puntatore che punta all'inizio della memoria in cui è archiviato l'array. Finisci per confrontare due indicatori. In caso di due diversi array C, i puntatori non avranno mai lo stesso valore.

Il tuo modo più semplice è quello di utilizzare le ASSERT_THAT macro e la ContainerEq matcher di Google Mock. Invece di ASSERT_EQ, scrivere

ASSERT_THAT(two, ContainerEq(two_sorted)); 

Answer 3

penso che sia sufficiente scrivere proprio come questo.

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