Cunit - "verspottete" LIBC -Funktionen

Question

Ich benutze Cunit für meine Projekteinheitstests. Ich muss testen, ob ich LIBC -Funktionen mit den richtigen Parametern aufrufe und ob ich ihre Rückgaberwerte richtig behandle. Zum Beispiel: Wenn ich die Bind (...) -Funktion aufrufe - möchte ich überprüfen, welchen AF -Param ich übergeben und behaupten, wenn dies falsch ist, und ich möchte auch, dass der Rückgabewert und die Behauptung nachdenken, wenn ich sie überprüfe der richtige Weg.

Für diese Zwecke würde ich erwarten, dass die Cunit -Umgebung einen eingebauten Mechanismus hat, der mich beim Testen und eine echte Bind () -Funktion beim Ausführen des Code Dies.

Können Sie mir bitte sagen, ob ich in Cunit etwas fehlt, oder empfehlen Sie vielleicht einen Weg, dies zu implementieren.

Danke, Jo.

Answer 1

Leider können Sie Funktionen in C mit Cunit nicht verspotten.

Sie können jedoch Ihre eigenen Scheinfunktionen implementieren, indem Sie Definierungen verwenden und missbrauchen: Angenommen, Sie definieren unittest beim Kompilieren für Tests.

#ifdef UNITTEST
    #define bind mock_bind
#endif

In einer mothelper.c -Datei, die Sie im Testmodus kompilieren werden:

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

Dann in Ihrer Testdatei:

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 ist eine Lösung der verspotteten LIBC -Funktion mit Google -Test. zum Beispiel:

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