cppcurl/test/helper/libcurl_mock.cpp

#include "libcurl_mock.h"

#pragma GCC diagnostic ignored "-Wvarargs"

libcurl_mock * libcurl_mock::instance = nullptr;

extern "C"
{

    CURLcode curl_global_init ( long flags )
    {
        return libcurl_mock::instance
            ? libcurl_mock::instance->curl_global_init(flags)
            : CURLE_OK;
    }

    void curl_global_cleanup ( void )
    {
        if (libcurl_mock::instance)
            libcurl_mock::instance->curl_global_cleanup();
    }

    struct curl_slist * curl_slist_append ( struct curl_slist * list,
                                            const char *        elem)
    {
        return libcurl_mock::instance
            ? libcurl_mock::instance->curl_slist_append(list, elem)
            : nullptr;
    }

    void curl_slist_free_all ( struct curl_slist * list )
    {
        if (libcurl_mock::instance)
            libcurl_mock::instance->curl_slist_free_all(list);
    }

    CURL * curl_easy_init(void)
    {
        return libcurl_mock::instance
            ? libcurl_mock::instance->curl_easy_init()
            : nullptr;
    }

    void curl_easy_cleanup(CURL * curl)
    {
        if (libcurl_mock::instance)
            libcurl_mock::instance->curl_easy_cleanup(curl);
    }

    CURLcode curl_easy_setopt(CURL *     curl,
                              CURLoption option,
                              ...)
    {
        if (!libcurl_mock::instance)
            return CURLE_OK;

        va_list args;
        va_start(args, option);

        if (option >= CURLOPTTYPE_OFF_T)
            return libcurl_mock::instance->curl_easy_setopt_off(curl, option, va_arg(args, curl_off_t));

        else if (option >= CURLOPTTYPE_FUNCTIONPOINT)
            return libcurl_mock::instance->curl_easy_setopt_ptr(curl, option, va_arg(args, void *));

        else if (option >= CURLOPTTYPE_STRINGPOINT)
            return libcurl_mock::instance->curl_easy_setopt_ptr(curl, option, va_arg(args, void *));

        else if (option >= CURLOPTTYPE_OBJECTPOINT)
            return libcurl_mock::instance->curl_easy_setopt_ptr(curl, option, va_arg(args, void *));

        else if (option >= CURLOPTTYPE_LONG)
            return libcurl_mock::instance->curl_easy_setopt_long(curl, option, va_arg(args, long));

        return CURLE_OK;
    }

    CURLcode curl_easy_perform(CURL * curl)
    {
        return libcurl_mock::instance
            ? libcurl_mock::instance->curl_easy_perform(curl)
            : CURLE_OK;
    }

    CURLcode curl_easy_getinfo(CURL *   curl,
                               CURLINFO info,
                               ...)
    {
        if (!libcurl_mock::instance)
            return CURLE_OK;

        va_list args;
        va_start(args, info);

        if (info >= CURLINFO_OFF_T)
            return libcurl_mock::instance->curl_easy_getinfo_off(curl, info, va_arg(args, curl_off_t *));

        else if (info >= CURLINFO_SOCKET)
            return libcurl_mock::instance->curl_easy_getinfo_socket(curl, info, va_arg(args, curl_socket_t *));

        else if (info >= CURLINFO_PTR)
            return libcurl_mock::instance->curl_easy_getinfo_ptr(curl, info, va_arg(args, void *));

        else if (info >= CURLINFO_SLIST)
            return libcurl_mock::instance->curl_easy_getinfo_ptr(curl, info, va_arg(args, void *));

        else if (info >= CURLINFO_DOUBLE)
            return libcurl_mock::instance->curl_easy_getinfo_double(curl, info, va_arg(args, double *));

        else if (info >= CURLINFO_LONG)
            return libcurl_mock::instance->curl_easy_getinfo_long(curl, info, va_arg(args, long *));

        else if (info >= CURLINFO_STRING)
            return libcurl_mock::instance->curl_easy_getinfo_str(curl, info, va_arg(args, char **));

        return CURLE_OK;
    }

    CURL * curl_easy_duphandle(CURL *curl)
    {
        return libcurl_mock::instance
            ? libcurl_mock::instance->curl_easy_duphandle(curl)
            : nullptr;
    }

    void curl_easy_reset(CURL *curl)
    {
        if (libcurl_mock::instance)
            libcurl_mock::instance->curl_easy_reset(curl);
    }

    CURLcode curl_easy_recv(CURL *      curl,
                            void *      buffer,
                            size_t      buflen,
                            size_t *    n)
    {
        return libcurl_mock::instance
            ? libcurl_mock::instance->curl_easy_recv(curl, buffer, buflen, n)
            : CURLE_OK;
    }

    CURLcode curl_easy_send(CURL *          curl,
                            const void *    buffer,
                            size_t          buflen,
                            size_t *        n)
    {
        return libcurl_mock::instance
            ? libcurl_mock::instance->curl_easy_send(curl, buffer, buflen, n)
            : CURLE_OK;
    }

    const char * curl_easy_strerror ( CURLcode code )
    {
        return libcurl_mock::instance
            ? libcurl_mock::instance->curl_easy_strerror(code)
            : nullptr;
    }

    const char * curl_multi_strerror ( CURLMcode code )
    {
        return libcurl_mock::instance
            ? libcurl_mock::instance->curl_multi_strerror(code)
            : nullptr;
    }

    CURLM * curl_multi_init ( void )
    {
        return libcurl_mock::instance
            ? libcurl_mock::instance->curl_multi_init()
            : nullptr;
    }

    CURLMcode curl_multi_cleanup ( CURLM *multi_handle )
    {
        return libcurl_mock::instance
            ? libcurl_mock::instance->curl_multi_cleanup(multi_handle)
            : CURLM_OK;
    }

    CURLMcode curl_multi_add_handle ( CURLM *   multi_handle,
                                      CURL *    curl_handle )
    {
        return libcurl_mock::instance
            ? libcurl_mock::instance->curl_multi_add_handle(multi_handle, curl_handle)
            : CURLM_OK;
    }

    CURLMcode curl_multi_remove_handle ( CURLM *    multi_handle,
                                         CURL *     curl_handle )
    {
        return libcurl_mock::instance
            ? libcurl_mock::instance->curl_multi_remove_handle(multi_handle, curl_handle)
            : CURLM_OK;
    }

    CURLMcode curl_multi_fdset ( CURLM *    multi_handle,
                                 fd_set *   read_fd_set,
                                 fd_set *   write_fd_set,
                                 fd_set *   exc_fd_set,
                                 int *      max_fd)
    {
        return libcurl_mock::instance
            ? libcurl_mock::instance->curl_multi_fdset(multi_handle, read_fd_set, write_fd_set, exc_fd_set, max_fd)
            : CURLM_OK;
    }

    CURLMcode curl_multi_wait ( CURLM *             multi_handle,
                                struct curl_waitfd  extra_fds[],
                                unsigned int        extra_nfds,
                                int                 timeout_ms,
                                int *               ret)
    {
        return libcurl_mock::instance
            ? libcurl_mock::instance->curl_multi_wait(multi_handle, extra_fds, extra_nfds, timeout_ms, ret)
            : CURLM_OK;
    }

    CURLMcode curl_multi_perform ( CURLM *  multi_handle,
                                   int *    running_handles)
    {
        return libcurl_mock::instance
            ? libcurl_mock::instance->curl_multi_perform(multi_handle, running_handles)
            : CURLM_OK;
    }

    CURLMsg * curl_multi_info_read ( CURLM *    multi_handle,
                                     int *      msgs_in_queue )
    {
        return libcurl_mock::instance
            ? libcurl_mock::instance->curl_multi_info_read(multi_handle, msgs_in_queue)
            : nullptr;
    }

    CURLMcode curl_multi_timeout ( CURLM *  multi_handle,
                                   long *   milliseconds )
    {
        return libcurl_mock::instance
            ? libcurl_mock::instance->curl_multi_timeout(multi_handle, milliseconds)
            : CURLM_OK;
    }

}