Cunit - 'Mocking' fonctions libc

Question

J'utilise Cunit pour mon test de l'unité de projet. Je dois tester si j'appelle les fonctions libc avec les bons paramètres et si je traite leur retour des valeurs de la bonne façon. par exemple: si je l'appelle la liaison (...) la fonction - je voudrais vérifier quelle af param je passe et assert si tel est le mauvais, et aussi je voudrais imiter sa valeur de retour et assert si je vérifierai le droit chemin.

Pour ces fins, j'attendre l'environnement de Cunit avoir une fonction intégrée dans le mécanisme de me laisser appeler une liaison « moqué » () tout en testant et une fonction réelle bind () lors de l'exécution du code - mais je ne peux pas trouver quelque chose comme ça.

Pouvez-vous s'il vous plaît me dire si je me manque quelque chose à Cunit, ou suggérer peut-être un moyen de mettre en œuvre.

Merci, Jo.

Answer 1

Malheureusement, vous ne pouvez pas les fonctions simulées en C avec Cunit.

Mais vous pouvez mettre en œuvre vos propres fonctions simulées en usant et abusant des defines: En supposant que vous définir UnitTest lors de la compilation pour les tests, vous pouvez dans le fichier testé (ou dans un include) définir quelque chose comme ceci:

#ifdef UNITTEST
    #define bind mock_bind
#endif

Dans un fichier mock_helper.c que vous compilez en mode test:

static int mock_bind_return;    // maybe a more complete struct would be usefull here
static int mock_bind_sockfd;

int mock_bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
{
    CU_ASSERT_EQUAL(sockfd, mock_bind_sockfd);
    return mock_bind_return;
}

Ensuite, dans votre fichier de test:

extern int mock_bind_return;
extern int mock_bind_sockfd;

void test_function_with_bind(void)
{

   mock_bind_return = 0;
   mock_bind_sockfd = 5;
   function_using_bind(mock_bind_sockfd);
}

Answer 2

glibcmock est une solution de moqueuse fonction libc avec Google test . par exemple:

#include "got_hook.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"

#include <sys/socket.h>

#include <mutex>
#include <memory>

struct MockBind {
    MOCK_METHOD3(Bind, int(int, const struct sockaddr*, socklen_t));
};

static MockBind *g_mock{nullptr};

static int Bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {
    return g_mock->Bind(sockfd, addr, addrlen);
}

static std::mutex g_test_mutex;

TEST(BindTest, MockSample) {
    std::lock_guard<std::mutex> lock(g_test_mutex);
    std::unique_ptr<MockBind> mock(g_mock = new MockBind());
    testing::GotHook got_hook;
    ASSERT_NO_FATAL_FAILURE(got_hook.MockFunction("bind", (void*)&Bind));
    // ... do your test here, for example:
    struct sockaddr* addr = nullptr;
    EXPECT_CALL(*g_mock, Bind(1, addr, 20)).WillOnce(testing::Return(0));
    EXPECT_EQ(0, bind(1, addr, 20));
}