Comparaison des tableaux dans google test?

Question

Je cherche à comparer deux tableaux dans google test. Dans UnitTest ++, cela est effectué via CHECK_ARRAY_EQUAL. Comment faites-vous dans google test?

Answer 1

Je suggère à la recherche à la Google C++ se moquant de Cadre. Même si vous ne voulez pas de se moquer de quelque chose, il vous permet de vous écrire plutôt compliqué assertions avec facilité.

Par exemple

//checks that vector v is {5, 10, 15}
ASSERT_THAT(v, ElementsAre(5, 10, 15));

//checks that map m only have elements 1 => 10, 2 => 20
ASSERT_THAT(m, ElementsAre(Pair(1, 10), Pair(2, 20)));

//checks that in vector v all the elements are greater than 10 and less than 20
ASSERT_THAT(v, Each(AllOf(Gt(10), Lt(20))));

//checks that vector v consist of 
//   5, number greater than 10, anything.
ASSERT_THAT(v, ElementsAre(5, Gt(10), _));

Il y a beaucoup de rapprochement pour toutes les situations possibles, et vous pouvez les combiner pour obtenir presque n'importe quoi.

Ai-je dit qu' ElementsAre des besoins seulement iterators et size() méthode d'une classe au travail? Donc, non seulement il fonctionne avec n'importe quel conteneur de la STL, mais avec des conteneurs personnalisés également.

Google se Moquer prétend être presque aussi portable que Google Test et franchement je ne vois pas pourquoi vous ne l'utilisez pas. C'est juste purement génial.

Answer 2

Si vous avez juste besoin de vérifier si les tableaux sont égaux, alors la force brute fonctionne également:

 int arr1[10];
int arr2[10];

// initialize arr1 and arr2

EXPECT_TRUE( 0 == std::memcmp( arr1, arr2, sizeof( arr1 ) ) );
 

Cependant, cela ne vous dit pas quel élément diffère.

Answer 3

Si vous souhaitez comparer un style c tableau de pointeur sur un tableau à l'aide de Google s'en Moquer, vous pouvez passer par des std::vector. Par exemple:

uint8_t expect[] = {1, 2, 3, 42};
uint8_t * buffer = expect;
uint32_t buffer_size = sizeof(expect) / sizeof(expect[0]);
ASSERT_THAT(std::vector<uint8_t>(buffer, buffer + buffer_size), 
            ::testing::ElementsAreArray(expect));

Google se Moquer du ElementsAreArray accepte aussi le pointeur et d'une longueur de permettre la comparaison des deux c de style de tableau de pointeurs. Par exemple:

ASSERT_THAT(std::vector<uint8_t>(buffer, buffer + buffer_size), 
            ::testing::ElementsAreArray(buffer, buffer_size));

J'ai passé beaucoup trop de temps à essayer de pièce de cet ensemble. Grâce à cette StackOverlow post pour le rappel sur les std::vector itérateur d'initialisation. A noter que cette méthode de copie de la mémoire tampon d'éléments de tableau dans le std::vector avant la comparaison.

Answer 4

J'ai eu exactement la même question, j'ai donc écrit un couple de macros permettant de faire des comparaisons entre les deux génériques de conteneurs. C'est extensible à un conteneur qui a const_iterator, begin, et end. Si il échoue, il va afficher un message détaillé de l'endroit où le tableau s'est mal passé et fera de même pour chaque élément qui ne fonctionne pas; il va s'assurer qu'ils sont de la même longueur; et l'emplacement dans votre code, il signale que l'échec est la même ligne où vous appelez EXPECT_ITERABLE_EQ( std::vector< double >, a, b).

//! Using the google test framework, check all elements of two containers
#define EXPECT_ITERABLE_BASE( PREDICATE, REFTYPE, TARTYPE, ref, target) \
    { \
    const REFTYPE& ref_(ref); \
    const TARTYPE& target_(target); \
    REFTYPE::const_iterator refIter = ref_.begin(); \
    TARTYPE::const_iterator tarIter = target_.begin(); \
    unsigned int i = 0; \
    while(refIter != ref_.end()) { \
        if ( tarIter == target_.end() ) { \
            ADD_FAILURE() << #target " has a smaller length than " #ref ; \
            break; \
        } \
        PREDICATE(* refIter, * tarIter) \
            << "Containers " #ref  " (refIter) and " #target " (tarIter)" \
               " differ at index " << i; \
        ++refIter; ++tarIter; ++i; \
    } \
    EXPECT_TRUE( tarIter == target_.end() ) \
        << #ref " has a smaller length than " #target ; \
    }

//! Check that all elements of two same-type containers are equal
#define EXPECT_ITERABLE_EQ( TYPE, ref, target) \
    EXPECT_ITERABLE_BASE( EXPECT_EQ, TYPE, TYPE, ref, target )

//! Check that all elements of two different-type containers are equal
#define EXPECT_ITERABLE_EQ2( REFTYPE, TARTYPE, ref, target) \
    EXPECT_ITERABLE_BASE( EXPECT_EQ, REFTYPE, TARTYPE, ref, target )

//! Check that all elements of two same-type containers of doubles are equal
#define EXPECT_ITERABLE_DOUBLE_EQ( TYPE, ref, target) \
    EXPECT_ITERABLE_BASE( EXPECT_DOUBLE_EQ, TYPE, TYPE, ref, target )

Espérons que cela fonctionne pour vous (et que vous avez réellement vérifier cette réponse deux mois après votre question a été soumise).

Answer 5

Ci-dessous est une affirmation que j'ai écrit pour comparer [fragments] deux virgule flottante tableaux:

/* See
http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/
for thorough information about comparing floating point values.
For this particular application we know that the value range is -1 to 1 (audio signal),
so we can compare to absolute delta of 1/2^22 which is the smallest representable value in
a 22-bit recording.
*/
const float FLOAT_INEQUALITY_TOLERANCE = float(1.0 / (1 << 22));


template <class T>
::testing::AssertionResult AreFloatingPointArraysEqual(
                                const T* const expected,
                                const T* const actual,
                                unsigned long length)
{
    ::testing::AssertionResult result = ::testing::AssertionFailure();
    int errorsFound = 0;
    const char* separator = " ";
    for (unsigned long index = 0; index < length; index++)
    {
        if (fabs(expected[index] - actual[index]) > FLOAT_INEQUALITY_TOLERANCE)
        {
            if (errorsFound == 0)
            {
                result << "Differences found:";
            }
            if (errorsFound < 3)
            {
                result << separator
                        << expected[index] << " != " << actual[index]
                        << " @ " << index;
                separator = ", ";
            }
            errorsFound++;
        }
    }
    if (errorsFound > 0)
    {
        result << separator << errorsFound << " differences in total";
        return result;
    }
    return ::testing::AssertionSuccess();
}

L'utilisation de Google, un Framework de Test est ceci:

EXPECT_TRUE(AreFloatingPointArraysEqual(expectedArray, actualArray, lengthToCompare));

Dans le cas d'une erreur, quelque chose comme le résultat suivant est obtenu:

..\MyLibraryTestMain.cpp:145: Failure
Value of: AreFloatingPointArraysEqual(expectedArray, actualArray, lengthToCompare)
  Actual: false (Differences found: 0.86119759082794189 != 0.86119747161865234 @ 14, -0.5552707314491272 != -0.55527061223983765 @ 24, 0.047732405364513397 != 0.04773232713341713 @ 36, 339 differences in total)
Expected: true

Pour une discussion approfondie sur la comparaison des valeurs à virgule flottante en général, veuillez consulter c'.