Start of mocking support

libmosquitto public mocks
pthread and editline minimal mocks

CMakeLists.txt

@@ -205,6 +205,8 @@ install(
 # Testing
 # ========================================
 if(WITH_TESTS)
+	find_package(GTest REQUIRED)
+	include(GoogleTest)
 	enable_testing()
 	add_subdirectory(test)
 endif()

config.mk

@@ -142,6 +142,9 @@ WITH_OLD_KEEPALIVE=no
 # Build with sqlite3 support - this enables the sqlite persistence plugin.
 WITH_SQLITE=yes
 
+# Use gmock for testing
+WITH_GMOCK:=yes
+
 # Build broker for fuzzing only - does not work as a normal broker. This is
 # currently only suitable for use with oss-fuzz.
 WITH_FUZZING=no
@@ -220,6 +223,7 @@ ifeq ($(UNAME),SunOS)
 endif
 
 ifeq ($(WITH_FUZZING),yes)
+	WITH_GMOCK:=no
 	WITH_SHARED_LIBRARIES:=no
 	WITH_STATIC_LIBRARIES:=yes
 endif

lib/CMakeLists.txt

@@ -23,11 +23,12 @@ set(C_SRC
 	handle_unsuback.c
 	helpers.c
 	http_client.c http_client.h
+	libmosquitto.c
 	logging_mosq.c logging_mosq.h
 	loop.c
 	messages_mosq.c messages_mosq.h
-	mosquitto.c ../include/mosquitto.h
 	mosquitto_internal.h
+	../include/mosquitto.h
 	../include/mosquitto/mqtt_protocol.h
 	net_mosq_ocsp.c net_mosq.c net_mosq.h
 	net_ws.c

lib/Makefile

@@ -39,7 +39,7 @@ endif
 .PHONY : really clean install
 
 OBJS= \
-	mosquitto.o \
+	libmosquitto.o \
 	actions_publish.o \
 	actions_subscribe.o \
 	actions_unsubscribe.o \

test/CMakeLists.txt

@@ -3,6 +3,7 @@ add_subdirectory(broker)
 add_subdirectory(client)
 add_subdirectory(lib)
 add_subdirectory(unit)
+add_subdirectory(mock)
 
 add_custom_target(coverage
     COMMAND lcov --quiet --capture --directory . --output-file ${PROJECT_BINARY_DIR}/coverage.info --no-external

test/Makefile

@@ -6,6 +6,9 @@ include ${R}/config.mk
 all :
 
 test-compile:
+ifeq ($(WITH_GMOCK),yes)
+	$(MAKE) -C mock test-compile
+endif
 	$(MAKE) -C broker test-compile
 	$(MAKE) -C client test-compile
 	$(MAKE) -C lib test-compile

test/mock/CMakeLists.txt

@@ -0,0 +1,13 @@
+add_subdirectory(lib)
+
+add_library(editline_mock OBJECT editline_mock.cpp)
+target_include_directories(editline_mock
+    PUBLIC
+        ${mosquitto_SOURCE_DIR}/test/mock
+)
+
+add_library(pthread_mock OBJECT pthread_mock.cpp)
+target_include_directories(pthread_mock
+    PUBLIC
+        ${mosquitto_SOURCE_DIR}/test/mock
+)

test/mock/Makefile

@@ -0,0 +1,41 @@
+R=../..
+include ${R}/config.mk
+
+.PHONY: all check test-compile test clean
+
+LOCAL_CPPFLAGS+= \
+	-DWITH_THREADING \
+	-DWITH_TLS \
+	-I../ \
+	-I${R}/include \
+	-I${R} \
+	-I${R}/lib \
+	-I${R}/test/mock
+
+LOCAL_CXXFLAGS+=-std=c++20 -Wall -ggdb -D TEST_SOURCE_DIR='"$(realpath .)"'
+
+MOCKS = \
+	editline_mock.o \
+	pthread_mock.o
+
+
+all : test-compile
+test-compile : ${MOCKS}
+	$(MAKE) -C lib test-compile
+
+check : test
+test :
+
+${MOCKS} : %.o: %.cpp
+	$(CROSS_COMPILE)$(CXX) $(LOCAL_CPPFLAGS) $(LOCAL_CXXFLAGS) -c $< -o $@
+
+
+clean :
+	-rm -rf *.o *.gcda *.gcno coverage.info out/
+
+coverage :
+	lcov --capture --directory . --output-file coverage.info
+	genhtml coverage.info --output-directory out
+
+install:
+uninstall:

test/mock/c_function_mock.hpp

@@ -0,0 +1,118 @@
+#pragma once
+
+#include <dlfcn.h>
+
+#include <functional>
+#include <stdexcept>
+
+template <typename MockClass>
+class CFunctionMock {
+  static CFunctionMock<MockClass>*& get_obj() {
+    static CFunctionMock<MockClass>* mock_obj = nullptr;
+    return mock_obj;
+  }
+
+ public:
+  CFunctionMock() {
+    if (get_obj() != nullptr) {
+      throw std::logic_error("only one instance of MockClass allowed");
+    }
+    get_obj() = this;
+  }
+  CFunctionMock(const CFunctionMock&) = delete;
+  CFunctionMock(CFunctionMock&&) = delete;
+  CFunctionMock& operator=(const CFunctionMock&) = delete;
+  CFunctionMock& operator=(CFunctionMock&&) = delete;
+  virtual ~CFunctionMock() { get_obj() = nullptr; }
+
+  static bool mock_exists() { return get_obj() != nullptr; }
+
+  static MockClass& get_mock() {
+    auto* instance = dynamic_cast<MockClass*>(get_obj());
+    if (instance == nullptr) {
+      throw std::logic_error(std::string("mock ") + typeid(MockClass).name() +
+                             " is not initialized");
+    }
+    return *instance;
+  }
+
+  template <class ReturnType, bool Void = std::is_void<ReturnType>::value, typename... Args>
+  static std::function<ReturnType(Args...)> optional_mocked_fn(
+      ReturnType (MockClass::*mock_fn)(Args...), const std::string& function_name) {
+    return std::function<ReturnType(Args...)>{
+        OptionalMockFnWrapper<ReturnType, std::is_void<ReturnType>::value, Args...>(mock_fn,
+                                                                                    function_name)};
+  }
+
+  template <class ReturnType, bool Void = std::is_void<ReturnType>::value, typename... Args>
+  static std::function<ReturnType(Args...)> original_fn(ReturnType (MockClass::*mock_fn)(Args...),
+                                                        const std::string& function_name) {
+    return std::function<ReturnType(Args...)>{
+        OriginalFnWrapper<ReturnType, std::is_void<ReturnType>::value, Args...>(mock_fn,
+                                                                                function_name)};
+  }
+
+ private:
+  template <class ReturnType, bool Void = std::is_void<ReturnType>::value, typename... Args>
+  class OriginalFnWrapper {
+   public:
+    OriginalFnWrapper(ReturnType (MockClass::* /* mock_fn */)(Args...),
+                      const std::string& function_name)
+        : orginial_fn{
+              reinterpret_cast<ReturnType (*)(Args...)>(dlsym(RTLD_NEXT, function_name.c_str()))} {}
+    ReturnType operator()(Args... args) { return (*orginial_fn)(args...); }
+
+   private:
+    ReturnType (*orginial_fn)(Args...);
+  };
+
+  template <class ReturnType, bool Void = std::is_void<ReturnType>::value, typename... Args>
+  class OptionalMockFnWrapper : public OriginalFnWrapper<ReturnType, Void, Args...> {
+   public:
+    using base_class = OriginalFnWrapper<ReturnType, Void, Args...>;
+    OptionalMockFnWrapper(ReturnType (MockClass::*mock_fn)(Args...),
+                          const std::string& function_name)
+        : base_class{mock_fn, function_name}, mock_fn_(mock_fn) {}
+    ReturnType operator()(Args... args) {
+      if (get_obj() != nullptr) {
+        return (get_mock().*mock_fn_)(args...);
+      }
+      return base_class::operator()(args...);
+    }
+
+   private:
+    ReturnType (MockClass::*mock_fn_)(Args...);
+  };
+
+  template <class ReturnType, typename... Args>
+  class OriginalFnWrapper<ReturnType, true, Args...> {
+   public:
+    OriginalFnWrapper(void (MockClass::* /* mock_fn */)(Args...), const std::string& function_name)
+        : orginial_fn{
+              reinterpret_cast<void (*)(Args...)>(dlsym(RTLD_NEXT, function_name.c_str()))} {}
+    void operator()(Args... args) { (*orginial_fn)(args...); }
+
+   private:
+    void (*orginial_fn)(Args...);
+  };
+
+  template <class ReturnType, typename... Args>
+  class OptionalMockFnWrapper<ReturnType, true, Args...>
+      : public OriginalFnWrapper<ReturnType, true, Args...> {
+   public:
+    using base_class = OriginalFnWrapper<ReturnType, true, Args...>;
+    OptionalMockFnWrapper(void (MockClass::*mock_fn)(Args...), const std::string& function_name)
+        : base_class(mock_fn, function_name), mock_fn_(mock_fn) {}
+
+    void operator()(Args... args) {
+      if (get_obj() != nullptr) {
+        (get_mock().*mock_fn_)(args...);
+      } else {
+        base_class::operator()(args...);
+      }
+    }
+
+   private:
+    void (MockClass::*mock_fn_)(Args...);
+  };
+};

test/mock/editline_mock.cpp

@@ -0,0 +1,54 @@
+#include "editline_mock.hpp"
+
+char *rl_line_buffer = nullptr;
+const char *rl_readline_name = nullptr;
+rl_compentry_func_t *rl_completion_entry_function = nullptr;
+int	rl_attempted_completion_over = 0;
+rl_completion_func_t *rl_attempted_completion_function = nullptr;
+
+EditLineMock::EditLineMock() {}
+EditLineMock::~EditLineMock() {}
+
+void EditLineMock::reset() {
+	free(rl_line_buffer);
+	rl_line_buffer = nullptr;
+	rl_readline_name = nullptr;
+	rl_completion_entry_function = nullptr;
+	rl_attempted_completion_over = 9;
+	rl_attempted_completion_function = nullptr;
+}
+
+int add_history(const char *s)
+{
+	return EditLineMock::get_mock().add_history(s);
+}
+
+void clear_history(void)
+{
+	EditLineMock::get_mock().clear_history();
+}
+
+void rl_resize_terminal(void)
+{
+	EditLineMock::get_mock().rl_resize_terminal();
+}
+
+char *readline(const char *s)
+{
+	return EditLineMock::get_mock().readline(s);
+}
+
+char **rl_completion_matches(const char *s, rl_compentry_func_t *f)
+{
+	return EditLineMock::get_mock().rl_completion_matches(s, f);
+}
+
+int rl_complete(int a, int b)
+{
+	return EditLineMock::get_mock().rl_complete(a, b);
+}
+
+int rl_bind_key(int a, rl_command_func_t *f)
+{
+	return EditLineMock::get_mock().rl_bind_key(a, f);
+}

test/mock/editline_mock.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <gmock/gmock.h>
+#include <editline/readline.h>
+
+#include "c_function_mock.hpp"
+
+class EditLineMock : public CFunctionMock<EditLineMock> {
+	public:
+		EditLineMock();
+		virtual ~EditLineMock();
+		void reset();
+
+		MOCK_METHOD(int, add_history, (const char *s));
+		MOCK_METHOD(void, clear_history, ());
+		MOCK_METHOD(void, rl_resize_terminal, ());
+		MOCK_METHOD(char *, readline, (const char *s));
+		MOCK_METHOD(char **, rl_completion_matches, (const char *s, rl_compentry_func_t *f));
+		MOCK_METHOD(int, rl_complete, (int a, int b));
+		MOCK_METHOD(int, rl_bind_key, (int a, rl_command_func_t *f));
+};

test/mock/lib/CMakeLists.txt

@@ -0,0 +1,27 @@
+add_library(libmosquitto_mock OBJECT
+	actions_publish_mock.cpp
+	actions_subscribe_mock.cpp
+	actions_unsubscribe_mock.cpp
+	callbacks_mock.cpp
+	connect_mock.cpp
+	extended_auth_mock.cpp
+	helpers_mock.cpp
+	libmosquitto_mock.cpp
+	libmosquitto_mock.hpp
+	loop_mock.cpp
+	messages_mosq_mock.cpp
+	net_mosq_mock.cpp
+	options_mock.cpp
+	socks_mosq_mock.cpp
+	srv_mosq_mock.cpp
+	thread_mosq_mock.cpp
+)
+
+target_include_directories(libmosquitto_mock
+    PUBLIC
+        ${mosquitto_SOURCE_DIR}
+        ${mosquitto_SOURCE_DIR}/include
+        ${mosquitto_SOURCE_DIR}/lib
+        ${mosquitto_SOURCE_DIR}/test/mock
+        ${mosquitto_SOURCE_DIR}/test/mock/lib
+)

test/mock/lib/Makefile

@@ -0,0 +1,47 @@
+R=../../..
+include ${R}/config.mk
+
+.PHONY: all check test-compile test clean
+
+LOCAL_CPPFLAGS+= \
+	-I../ \
+	-I${R}/include \
+	-I${R} \
+	-I${R}/lib \
+	-I${R}/test/mock
+
+LOCAL_CXXFLAGS+=-std=c++20 -Wall -ggdb -D TEST_SOURCE_DIR='"$(realpath .)"'
+
+MOCK_OBJS = \
+	actions_publish_mock.o \
+	actions_subscribe_mock.o \
+	actions_unsubscribe_mock.o \
+	callbacks_mock.o \
+	connect_mock.o \
+	extended_auth_mock.o \
+	helpers_mock.o \
+	libmosquitto_mock.o \
+	loop_mock.o \
+	messages_mosq_mock.o \
+	net_mosq_mock.o \
+	options_mock.o \
+	socks_mosq_mock.o \
+	srv_mosq_mock.o \
+	thread_mosq_mock.o
+
+all : test-compile
+
+test-compile: ${MOCK_OBJS}
+check : test
+
+# MOCKS
+
+${MOCK_OBJS} : %.o: %.cpp libmosquitto_mock.hpp
+	$(CROSS_COMPILE)$(CXX) $(LOCAL_CPPFLAGS) $(LOCAL_CXXFLAGS) -c $< -o $@
+
+clean :
+	-rm -rf *.o *.gcda *.gcno
+
+install:
+
+uninstall:

test/mock/lib/actions_publish_mock.cpp

@@ -0,0 +1,13 @@
+#include "libmosquitto_mock.hpp"
+
+int mosquitto_publish(struct mosquitto *mosq, int *mid, const char *topic,
+			int payloadlen, const void *payload, int qos, bool retain)
+{
+	return LibMosquittoMock::get_mock().mosquitto_publish(mosq, mid, topic, payloadlen, static_cast<const char*>(payload), qos, retain);
+}
+
+int mosquitto_publish_v5(struct mosquitto *mosq, int *mid, const char *topic,
+			int payloadlen, const void *payload, int qos, bool retain, const mosquitto_property *properties)
+{
+	return LibMosquittoMock::get_mock().mosquitto_publish_v5(mosq, mid, topic, payloadlen, static_cast<const char*>(payload), qos, retain, properties);
+}

test/mock/lib/actions_subscribe_mock.cpp

@@ -0,0 +1,18 @@
+#include "libmosquitto_mock.hpp"
+
+int mosquitto_subscribe(struct mosquitto *mosq, int *mid, const char *sub, int qos)
+{
+	return LibMosquittoMock::get_mock().mosquitto_subscribe(mosq, mid, sub, qos);
+}
+
+int mosquitto_subscribe_v5(struct mosquitto *mosq, int *mid, const char *sub, int qos,
+			int options, const mosquitto_property *properties)
+{
+	return LibMosquittoMock::get_mock().mosquitto_subscribe_v5(mosq, mid, sub, qos, options, properties);
+}
+
+int mosquitto_subscribe_multiple(struct mosquitto *mosq, int *mid, int sub_count,
+			char *const *const sub, int qos, int options, const mosquitto_property *properties)
+{
+	return LibMosquittoMock::get_mock().mosquitto_subscribe_multiple(mosq, mid, sub_count, sub, qos, options, properties);
+}

test/mock/lib/actions_unsubscribe_mock.cpp

@@ -0,0 +1,19 @@
+#include "libmosquitto_mock.hpp"
+
+int mosquitto_unsubscribe(struct mosquitto *mosq, int *mid, const char *sub)
+{
+	return LibMosquittoMock::get_mock().mosquitto_unsubscribe(mosq, mid, sub);
+}
+
+int mosquitto_unsubscribe_v5(struct mosquitto *mosq, int *mid, const char *sub,
+		const mosquitto_property *properties)
+{
+	return LibMosquittoMock::get_mock().mosquitto_unsubscribe_v5(mosq, mid, sub, properties);
+}
+
+int mosquitto_unsubscribe_multiple(struct mosquitto *mosq, int *mid, int sub_count,
+			char *const *const sub, const mosquitto_property *properties)
+{
+	return LibMosquittoMock::get_mock().mosquitto_unsubscribe_multiple(mosq,
+			mid, sub_count, sub, properties);
+}

test/mock/lib/callbacks_mock.cpp

@@ -0,0 +1,107 @@
+#include "libmosquitto_mock.hpp"
+
+void mosquitto_connect_callback_set(struct mosquitto *mosq,
+		void (*on_connect)(struct mosquitto *, void *, int))
+{
+	return LibMosquittoMock::get_mock().mosquitto_connect_callback_set(mosq, on_connect);
+}
+
+void mosquitto_connect_with_flags_callback_set(struct mosquitto *mosq,
+		void (*on_connect)(struct mosquitto *, void *, int, int))
+{
+	return LibMosquittoMock::get_mock().mosquitto_connect_with_flags_callback_set(mosq, on_connect);
+}
+
+void mosquitto_connect_v5_callback_set(struct mosquitto *mosq,
+		void (*on_connect)(struct mosquitto *, void *, int, int, const mosquitto_property *))
+{
+	return LibMosquittoMock::get_mock().mosquitto_connect_v5_callback_set(mosq, on_connect);
+}
+
+void mosquitto_pre_connect_callback_set(struct mosquitto *mosq,
+		void (*on_pre_connect)(struct mosquitto *, void *))
+{
+	return LibMosquittoMock::get_mock().mosquitto_pre_connect_callback_set(mosq, on_pre_connect);
+}
+
+void mosquitto_disconnect_callback_set(struct mosquitto *mosq,
+		void (*on_disconnect)(struct mosquitto *, void *, int))
+{
+	return LibMosquittoMock::get_mock().mosquitto_disconnect_callback_set(mosq, on_disconnect);
+}
+
+void mosquitto_disconnect_v5_callback_set(struct mosquitto *mosq,
+		void (*on_disconnect)(struct mosquitto *, void *, int, const mosquitto_property *))
+{
+	return LibMosquittoMock::get_mock().mosquitto_disconnect_v5_callback_set(mosq, on_disconnect);
+}
+
+void mosquitto_publish_callback_set(struct mosquitto *mosq,
+		void (*on_publish)(struct mosquitto *, void *, int))
+{
+	return LibMosquittoMock::get_mock().mosquitto_publish_callback_set(mosq, on_publish);
+}
+
+void mosquitto_publish_v5_callback_set(struct mosquitto *mosq,
+		void (*on_publish)(struct mosquitto *, void *, int, int, const mosquitto_property *props))
+{
+	return LibMosquittoMock::get_mock().mosquitto_publish_v5_callback_set(mosq, on_publish);
+}
+
+void mosquitto_message_callback_set(struct mosquitto *mosq,
+		void (*on_message)(struct mosquitto *, void *, const struct mosquitto_message *))
+{
+	return LibMosquittoMock::get_mock().mosquitto_message_callback_set(mosq, on_message);
+}
+
+void mosquitto_message_v5_callback_set(struct mosquitto *mosq,
+		void (*on_message)(struct mosquitto *, void *, const struct mosquitto_message *,
+		const mosquitto_property *props))
+{
+	return LibMosquittoMock::get_mock().mosquitto_message_v5_callback_set(mosq, on_message);
+}
+
+void mosquitto_subscribe_callback_set(struct mosquitto *mosq,
+		void (*on_subscribe)(struct mosquitto *, void *, int, int, const int *))
+{
+	return LibMosquittoMock::get_mock().mosquitto_subscribe_callback_set(mosq, on_subscribe);
+}
+
+void mosquitto_subscribe_v5_callback_set(struct mosquitto *mosq,
+		void (*on_subscribe)(struct mosquitto *, void *, int, int, const int *,
+		const mosquitto_property *props))
+{
+	return LibMosquittoMock::get_mock().mosquitto_subscribe_v5_callback_set(mosq, on_subscribe);
+}
+
+void mosquitto_unsubscribe_callback_set(struct mosquitto *mosq,
+		void (*on_unsubscribe)(struct mosquitto *, void *, int))
+{
+	return LibMosquittoMock::get_mock().mosquitto_unsubscribe_callback_set(mosq, on_unsubscribe);
+}
+
+void mosquitto_unsubscribe_v5_callback_set(struct mosquitto *mosq,
+		void (*on_unsubscribe)(struct mosquitto *, void *, int, const mosquitto_property *props))
+{
+	return LibMosquittoMock::get_mock().mosquitto_unsubscribe_v5_callback_set(mosq, on_unsubscribe);
+}
+
+void mosquitto_unsubscribe2_v5_callback_set(struct mosquitto *mosq,
+		void (*on_unsubscribe)(struct mosquitto *, void *, int, int, const int *,
+		const mosquitto_property *props))
+{
+	return LibMosquittoMock::get_mock().mosquitto_unsubscribe2_v5_callback_set(mosq, on_unsubscribe);
+}
+
+void mosquitto_log_callback_set(struct mosquitto *mosq,
+		void (*on_log)(struct mosquitto *, void *, int, const char *))
+{
+	return LibMosquittoMock::get_mock().mosquitto_log_callback_set(mosq, on_log);
+}
+
+void mosquitto_ext_auth_callback_set(struct mosquitto *mosq,
+		int (*on_ext_auth)(struct mosquitto *, void *, const char *, uint16_t, const void *,
+		const mosquitto_property *props))
+{
+	return LibMosquittoMock::get_mock().mosquitto_ext_auth_callback_set(mosq, on_ext_auth);
+}

test/mock/lib/connect_mock.cpp

@@ -0,0 +1,59 @@
+#include "libmosquitto_mock.hpp"
+
+int mosquitto_connect(struct mosquitto *mosq, const char *host,
+		int port, int keepalive)
+{
+	return LibMosquittoMock::get_mock().mosquitto_connect(mosq, host,
+		port, keepalive);
+}
+
+int mosquitto_connect_bind(struct mosquitto *mosq, const char *host,
+		int port, int keepalive, const char *bind_address)
+{
+	return LibMosquittoMock::get_mock().mosquitto_connect_bind(mosq, host,
+		port, keepalive, bind_address);
+}
+
+int mosquitto_connect_bind_v5(struct mosquitto *mosq, const char *host,
+		int port, int keepalive, const char *bind_address,
+		const mosquitto_property *properties)
+{
+	return LibMosquittoMock::get_mock().mosquitto_connect_bind_v5(mosq, host,
+		port, keepalive, bind_address, properties);
+}
+
+int mosquitto_connect_async(struct mosquitto *mosq, const char *host,
+		int port, int keepalive)
+{
+	return LibMosquittoMock::get_mock().mosquitto_connect_async(mosq, host,
+		port, keepalive);
+}
+
+int mosquitto_connect_bind_async(struct mosquitto *mosq, const char *host,
+		int port, int keepalive, const char *bind_address)
+{
+	return LibMosquittoMock::get_mock().mosquitto_connect_bind_async(mosq, host,
+		port, keepalive, bind_address);
+}
+
+int mosquitto_reconnect_async(struct mosquitto *mosq)
+{
+	return LibMosquittoMock::get_mock().mosquitto_reconnect_async(mosq);
+}
+
+int mosquitto_reconnect(struct mosquitto *mosq)
+{
+	return LibMosquittoMock::get_mock().mosquitto_reconnect(mosq);
+}
+
+int mosquitto_disconnect(struct mosquitto *mosq)
+{
+	return LibMosquittoMock::get_mock().mosquitto_disconnect(mosq);
+}
+
+int mosquitto_disconnect_v5(struct mosquitto *mosq, int reason_code,
+		const mosquitto_property *properties)
+{
+	return LibMosquittoMock::get_mock().mosquitto_disconnect_v5(mosq,
+			reason_code, properties);
+}

test/mock/lib/extended_auth_mock.cpp

@@ -0,0 +1,9 @@
+#include "libmosquitto_mock.hpp"
+
+int mosquitto_ext_auth_continue(struct mosquitto *context,
+		const char *auth_method, uint16_t auth_data_len, const void *auth_data,
+		const mosquitto_property *input_props)
+{
+	return LibMosquittoMock::get_mock().mosquitto_ext_auth_continue(context,
+			auth_method, auth_data_len, auth_data, input_props);
+}

test/mock/lib/helpers_mock.cpp

@@ -0,0 +1,25 @@
+#include "libmosquitto_mock.hpp"
+
+int mosquitto_subscribe_simple(struct mosquitto_message **messages,
+		int msg_count, bool want_retained, const char *topic, int qos,
+		const char *host, int port, const char *clientid, int keepalive,
+		bool clean_session, const char *username, const char *password,
+		const struct libmosquitto_will *will, const struct libmosquitto_tls *tls)
+{
+	return LibMosquittoMock::get_mock().mosquitto_subscribe_simple(messages,
+			msg_count, want_retained, topic, qos, host, port, clientid,
+			keepalive, clean_session, username, password, will, tls);
+}
+
+int mosquitto_subscribe_callback(int (*callback)(struct mosquitto *,
+		void *, const struct mosquitto_message *), void *userdata,
+		const char *topic, int qos, const char *host, int port,
+		const char *clientid, int keepalive, bool clean_session,
+		const char *username, const char *password, const struct libmosquitto_will *will,
+		const struct libmosquitto_tls *tls)
+{
+	return LibMosquittoMock::get_mock().mosquitto_subscribe_callback(
+			callback, userdata, topic, qos, host, port, clientid,
+			keepalive, clean_session, username, password, will, tls);
+
+}

test/mock/lib/libmosquitto_mock.cpp

@@ -0,0 +1,46 @@
+#include "libmosquitto_mock.hpp"
+
+LibMosquittoMock::LibMosquittoMock() {};
+LibMosquittoMock::~LibMosquittoMock() {};
+
+int mosquitto_lib_version(int *major, int *minor, int *revision)
+{
+	return LibMosquittoMock::get_mock().mosquitto_lib_version(
+			major, minor, revision);
+}
+
+int mosquitto_lib_init()
+{
+	return LibMosquittoMock::get_mock().mosquitto_lib_init();
+}
+
+int mosquitto_lib_cleanup()
+{
+	return LibMosquittoMock::get_mock().mosquitto_lib_cleanup();
+}
+
+struct mosquitto *mosquitto_new(const char *id, bool clean_start, void *userdata)
+{
+	return LibMosquittoMock::get_mock().mosquitto_new(id, clean_start, userdata);
+}
+
+int mosquitto_reinitialise(struct mosquitto *mosq, const char *id, bool clean_start,
+			void *userdata)
+{
+	return LibMosquittoMock::get_mock().mosquitto_reinitialise(mosq, id, clean_start, userdata);
+}
+
+void mosquitto_destroy(struct mosquitto *mosq)
+{
+	return LibMosquittoMock::get_mock().mosquitto_destroy(mosq);
+}
+
+int mosquitto_socket(struct mosquitto *mosq)
+{
+	return LibMosquittoMock::get_mock().mosquitto_socket(mosq);
+}
+
+bool mosquitto_want_write(struct mosquitto *mosq)
+{
+	return LibMosquittoMock::get_mock().mosquitto_want_write(mosq);
+}

test/mock/lib/libmosquitto_mock.hpp

@@ -0,0 +1,180 @@
+#pragma once
+
+#include <gmock/gmock.h>
+#include <mosquitto_internal.h>
+
+#include "c_function_mock.hpp"
+
+class LibMosquittoMock : public CFunctionMock<LibMosquittoMock> {
+	public:
+		LibMosquittoMock();
+		virtual ~LibMosquittoMock();
+
+		/* libmosquitto.c */
+		MOCK_METHOD(int, mosquitto_lib_version, (int *major, int *minor, int *revision));
+		MOCK_METHOD(int, mosquitto_lib_init, ());
+		MOCK_METHOD(int, mosquitto_lib_cleanup, ());
+		MOCK_METHOD(struct mosquitto *, mosquitto_new, (const char *id, bool clean_start, void *userdata));
+		MOCK_METHOD(int, mosquitto_reinitialise, (struct mosquitto *mosq, const char *id, bool clean_start,
+			void *userdata));
+		MOCK_METHOD(void, mosquitto_destroy, (struct mosquitto *mosq));
+		MOCK_METHOD(int, mosquitto_socket, (struct mosquitto *mosq));
+		MOCK_METHOD(bool, mosquitto_want_write, (struct mosquitto *mosq));
+
+		/* actions_publish.c */
+		MOCK_METHOD(int, mosquitto_publish, (struct mosquitto *mosq, int *mid, const char *topic,
+			int payloadlen, const /*void*/char *payload, int qos, bool retain));
+		MOCK_METHOD(int, mosquitto_publish_v5, (struct mosquitto *mosq, int *mid, const char *topic,
+			int payloadlen, const /*void*/char *payload, int qos, bool retain, const mosquitto_property *properties));
+
+		/* actions_subscribe.c */
+		MOCK_METHOD(int, mosquitto_subscribe, (struct mosquitto *mosq, int *mid, const char *sub, int qos));
+		MOCK_METHOD(int, mosquitto_subscribe_v5, (struct mosquitto *mosq, int *mid, const char *sub, int qos,
+			int options, const mosquitto_property *properties));
+		MOCK_METHOD(int, mosquitto_subscribe_multiple, (struct mosquitto *mosq, int *mid, int sub_count,
+			char *const *const sub, int qos, int options, const mosquitto_property *properties));
+
+		/* actions_unsubscribe.c */
+		MOCK_METHOD(int, mosquitto_unsubscribe, (struct mosquitto *mosq, int *mid, const char *sub));
+		MOCK_METHOD(int, mosquitto_unsubscribe_v5, (struct mosquitto *mosq, int *mid, const char *sub,
+			const mosquitto_property *properties));
+		MOCK_METHOD(int, mosquitto_unsubscribe_multiple, (struct mosquitto *mosq, int *mid, int sub_count,
+			char *const *const sub, const mosquitto_property *properties));
+
+		/* callbacks.c */
+		MOCK_METHOD(void, mosquitto_connect_callback_set, (struct mosquitto *mosq,
+			void (*on_connect)(struct mosquitto *, void *, int)));
+		MOCK_METHOD(void, mosquitto_connect_with_flags_callback_set, (struct mosquitto *mosq,
+			void (*on_connect)(struct mosquitto *, void *, int, int)));
+		MOCK_METHOD(void, mosquitto_connect_v5_callback_set, (struct mosquitto *mosq,
+			void (*on_connect)(struct mosquitto *, void *, int, int, const mosquitto_property *)));
+		MOCK_METHOD(void, mosquitto_pre_connect_callback_set, (struct mosquitto *mosq,
+			void (*on_pre_connect)(struct mosquitto *, void *)));
+		MOCK_METHOD(void, mosquitto_disconnect_callback_set, (struct mosquitto *mosq,
+			void (*on_disconnect)(struct mosquitto *, void *, int)));
+		MOCK_METHOD(void, mosquitto_disconnect_v5_callback_set, (struct mosquitto *mosq,
+			void (*on_disconnect)(struct mosquitto *, void *, int, const mosquitto_property *)));
+		MOCK_METHOD(void, mosquitto_publish_callback_set, (struct mosquitto *mosq,
+			void (*on_publish)(struct mosquitto *, void *, int)));
+		MOCK_METHOD(void, mosquitto_publish_v5_callback_set, (struct mosquitto *mosq,
+			void (*on_publish)(struct mosquitto *, void *, int, int, const mosquitto_property *props)));
+		MOCK_METHOD(void, mosquitto_message_callback_set, (struct mosquitto *mosq,
+			void (*on_message)(struct mosquitto *, void *, const struct mosquitto_message *)));
+		MOCK_METHOD(void, mosquitto_message_v5_callback_set, (struct mosquitto *mosq,
+			void (*on_message)(struct mosquitto *, void *, const struct mosquitto_message *,
+			const mosquitto_property *props)));
+		MOCK_METHOD(void, mosquitto_subscribe_callback_set, (struct mosquitto *mosq,
+			void (*on_subscribe)(struct mosquitto *, void *, int, int, const int *)));
+		MOCK_METHOD(void, mosquitto_subscribe_v5_callback_set, (struct mosquitto *mosq,
+			void (*on_subscribe)(struct mosquitto *, void *, int, int, const int *,
+			const mosquitto_property *props)));
+		MOCK_METHOD(void, mosquitto_unsubscribe_callback_set, (struct mosquitto *mosq,
+			void (*on_unsubscribe)(struct mosquitto *, void *, int)));
+		MOCK_METHOD(void, mosquitto_unsubscribe_v5_callback_set, (struct mosquitto *mosq,
+			void (*on_unsubscribe)(struct mosquitto *, void *, int, const mosquitto_property *props)));
+		MOCK_METHOD(void, mosquitto_unsubscribe2_v5_callback_set, (struct mosquitto *mosq,
+			void (*on_unsubscribe)(struct mosquitto *, void *, int, int, const int *,
+			const mosquitto_property *props)));
+		MOCK_METHOD(void, mosquitto_log_callback_set, (struct mosquitto *mosq,
+			void (*on_log)(struct mosquitto *, void *, int, const char *)));
+		MOCK_METHOD(void, mosquitto_ext_auth_callback_set, (struct mosquitto *mosq,
+			int (*on_ext_auth)(struct mosquitto *, void *, const char *, uint16_t, const void *,
+			const mosquitto_property *props)));
+
+		/* connect.c */
+		MOCK_METHOD(int, mosquitto_connect, (struct mosquitto *mosq, const char *host,
+			int port, int keepalive));
+		MOCK_METHOD(int, mosquitto_connect_bind, (struct mosquitto *mosq, const char *host,
+			int port, int keepalive, const char *bind_address));
+		MOCK_METHOD(int, mosquitto_connect_bind_v5, (struct mosquitto *mosq, const char *host,
+			int port, int keepalive, const char *bind_address, const mosquitto_property *properties));
+		MOCK_METHOD(int, mosquitto_connect_async, (struct mosquitto *mosq, const char *host,
+			int port, int keepalive));
+		MOCK_METHOD(int, mosquitto_connect_bind_async, (struct mosquitto *mosq, const char *host,
+			int port, int keepalive, const char *bind_address));
+		MOCK_METHOD(int, mosquitto_reconnect_async, (struct mosquitto *mosq));
+		MOCK_METHOD(int, mosquitto_reconnect, (struct mosquitto *mosq));
+		MOCK_METHOD(int, mosquitto_disconnect, (struct mosquitto *mosq));
+		MOCK_METHOD(int, mosquitto_disconnect_v5, (struct mosquitto *mosq, int reason_code,
+			const mosquitto_property *properties));
+
+		/* extended_auth.c */
+		MOCK_METHOD(int, mosquitto_ext_auth_continue, (struct mosquitto *context,
+			const char *auth_method, uint16_t auth_data_len, const void *auth_data,
+			const mosquitto_property *input_props));
+
+		/* helpers.c */
+		MOCK_METHOD(int, mosquitto_subscribe_simple, (struct mosquitto_message **messages,
+			int msg_count, bool want_retained, const char *topic, int qos,
+			const char *host, int port, const char *clientid, int keepalive,
+			bool clean_session, const char *username, const char *password,
+			const struct libmosquitto_will *will, const struct libmosquitto_tls *tls));
+		MOCK_METHOD(int, mosquitto_subscribe_callback, (int (*callback)(struct mosquitto *,
+			void *, const struct mosquitto_message *), void *userdata,
+			const char *topic, int qos, const char *host, int port,
+			const char *clientid, int keepalive, bool clean_session,
+			const char *username, const char *password, const struct libmosquitto_will *will,
+			const struct libmosquitto_tls *tls));
+
+		/* loop.c */
+		MOCK_METHOD(int, mosquitto_loop, (struct mosquitto *mosq, int timeout, int max_packets));
+		MOCK_METHOD(int, mosquitto_loop_forever, (struct mosquitto *mosq, int timeout, int max_packets));
+		MOCK_METHOD(int, mosquitto_loop_misc, (struct mosquitto *mosq));
+		MOCK_METHOD(int, mosquitto_loop_read, (struct mosquitto *mosq, int max_packets));
+		MOCK_METHOD(int, mosquitto_loop_write, (struct mosquitto *mosq, int max_packets));
+
+		/* messages_mosq.c */
+		MOCK_METHOD(int, mosquitto_message_copy, (struct mosquitto_message *dst,
+			const struct mosquitto_message *src));
+		MOCK_METHOD(void, mosquitto_message_free, (struct mosquitto_message **message));
+		MOCK_METHOD(void, mosquitto_message_free_contents, (struct mosquitto_message *message));
+		MOCK_METHOD(void, mosquitto_message_retry_set, (struct mosquitto *mosq,
+			unsigned int message_retry));
+
+		/* net_mosq.c */
+		MOCK_METHOD(void *, mosquitto_ssl_get, (struct mosquitto *mosq));
+
+		/* options.c */
+		MOCK_METHOD(int, mosquitto_will_set, (struct mosquitto *mosq, const char *topic,
+			int payloadlen, const void *payload, int qos, bool retain));
+		MOCK_METHOD(int, mosquitto_will_set_v5, (struct mosquitto *mosq, const char *topic,
+			int payloadlen, const void *payload, int qos, bool retain,
+			mosquitto_property *properties));
+		MOCK_METHOD(int, mosquitto_will_clear, (struct mosquitto *mosq));
+		MOCK_METHOD(int, mosquitto_username_pw_set, (struct mosquitto *mosq,
+			const char *username, const char *password));
+		MOCK_METHOD(int, mosquitto_reconnect_delay_set, (struct mosquitto *mosq,
+			unsigned int reconnect_delay, unsigned int reconnect_delay_max,
+			bool reconnect_exponential_backoff));
+		MOCK_METHOD(int, mosquitto_tls_set, (struct mosquitto *mosq, const char *cafile,
+			const char *capath, const char *certfile, const char *keyfile,
+			int (*pw_callback)(char *buf, int size, int rwflag, void *userdata)));
+		MOCK_METHOD(int, mosquitto_tls_opts_set, (struct mosquitto *mosq, int cert_reqs,
+			const char *tls_version, const char *ciphers));
+		MOCK_METHOD(int, mosquitto_tls_insecure_set, (struct mosquitto *mosq, bool value));
+		MOCK_METHOD(int, mosquitto_string_option, (struct mosquitto *mosq,
+			enum mosq_opt_t option, const char *value));
+		MOCK_METHOD(int, mosquitto_tls_psk_set, (struct mosquitto *mosq, const char *psk,
+			const char *identity, const char *ciphers));
+		MOCK_METHOD(int, mosquitto_opts_set, (struct mosquitto *mosq, enum mosq_opt_t option,
+			void *value));
+		MOCK_METHOD(int, mosquitto_int_option, (struct mosquitto *mosq, enum mosq_opt_t option,
+			int value));
+		MOCK_METHOD(int, mosquitto_void_option, (struct mosquitto *mosq, enum mosq_opt_t option,
+			void *value));
+		MOCK_METHOD(void, mosquitto_user_data_set, (struct mosquitto *mosq, void *userdata));
+		MOCK_METHOD(void *, mosquitto_userdata, (struct mosquitto *mosq));
+
+		/* socks_mosq.c */
+		MOCK_METHOD(int,  mosquitto_socks5_set, (struct mosquitto *mosq, const char *host,
+			int port, const char *username, const char *password));
+
+		/* srv_mosq.c */
+		MOCK_METHOD(int, mosquitto_connect_srv, (struct mosquitto *mosq, const char *host,
+			int keepalive, const char *bind_address));
+
+		/* thread_mosq.c */
+		MOCK_METHOD(int, mosquitto_loop_start, (struct mosquitto *mosq));
+		MOCK_METHOD(int, mosquitto_loop_stop, (struct mosquitto *mosq, bool force));
+		MOCK_METHOD(int, mosquitto_threaded_set, (struct mosquitto *mosq, bool threaded));
+};

test/mock/lib/loop_mock.cpp

@@ -0,0 +1,26 @@
+#include "libmosquitto_mock.hpp"
+
+int mosquitto_loop(struct mosquitto *mosq, int timeout, int max_packets)
+{
+	return LibMosquittoMock::get_mock().mosquitto_loop(mosq, timeout, max_packets);
+}
+
+int mosquitto_loop_forever(struct mosquitto *mosq, int timeout, int max_packets)
+{
+	return LibMosquittoMock::get_mock().mosquitto_loop_forever(mosq, timeout, max_packets);
+}
+
+int mosquitto_loop_misc(struct mosquitto *mosq)
+{
+	return LibMosquittoMock::get_mock().mosquitto_loop_misc(mosq);
+}
+
+int mosquitto_loop_read(struct mosquitto *mosq, int max_packets)
+{
+	return LibMosquittoMock::get_mock().mosquitto_loop_read(mosq, max_packets);
+}
+
+int mosquitto_loop_write(struct mosquitto *mosq, int max_packets)
+{
+	return LibMosquittoMock::get_mock().mosquitto_loop_write(mosq, max_packets);
+}

test/mock/lib/messages_mosq_mock.cpp

@@ -0,0 +1,17 @@
+#include "libmosquitto_mock.hpp"
+
+int mosquitto_message_copy(struct mosquitto_message *dst,
+		const struct mosquitto_message *src)
+{
+	return LibMosquittoMock::get_mock().mosquitto_message_copy(dst, src);
+}
+
+void mosquitto_message_free(struct mosquitto_message **message)
+{
+	LibMosquittoMock::get_mock().mosquitto_message_free(message);
+}
+
+void mosquitto_message_free_contents(struct mosquitto_message *message)
+{
+	LibMosquittoMock::get_mock().mosquitto_message_free_contents(message);
+}

test/mock/lib/net_mosq_mock.cpp

@@ -0,0 +1,6 @@
+#include "libmosquitto_mock.hpp"
+
+void *mosquitto_ssl_get(struct mosquitto *mosq)
+{
+	return LibMosquittoMock::get_mock().mosquitto_ssl_get(mosq);
+}

test/mock/lib/options_mock.cpp

@@ -0,0 +1,102 @@
+#include "libmosquitto_mock.hpp"
+
+int mosquitto_will_set(struct mosquitto *mosq, const char *topic,
+		int payloadlen, const void *payload, int qos, bool retain)
+{
+	return LibMosquittoMock::get_mock().mosquitto_will_set(mosq,
+			topic, payloadlen, payload, qos, retain);
+}
+
+int mosquitto_will_set_v5(struct mosquitto *mosq, const char *topic,
+		int payloadlen, const void *payload, int qos, bool retain,
+		mosquitto_property *properties)
+{
+	return LibMosquittoMock::get_mock().mosquitto_will_set_v5(mosq,
+			topic, payloadlen, payload, qos, retain, properties);
+}
+
+int mosquitto_will_clear(struct mosquitto *mosq)
+{
+	return LibMosquittoMock::get_mock().mosquitto_will_clear(mosq);
+}
+
+int mosquitto_username_pw_set(struct mosquitto *mosq,
+		const char *username, const char *password)
+{
+	return LibMosquittoMock::get_mock().mosquitto_username_pw_set(mosq,
+			username, password);
+}
+
+int mosquitto_reconnect_delay_set(struct mosquitto *mosq,
+		unsigned int reconnect_delay, unsigned int reconnect_delay_max,
+		bool reconnect_exponential_backoff)
+{
+	return LibMosquittoMock::get_mock().mosquitto_reconnect_delay_set(mosq,
+			reconnect_delay, reconnect_delay_max, reconnect_exponential_backoff);
+}
+
+int mosquitto_tls_set(struct mosquitto *mosq, const char *cafile,
+		const char *capath, const char *certfile, const char *keyfile,
+		int (*pw_callback)(char *buf, int size, int rwflag, void *userdata))
+{
+	return LibMosquittoMock::get_mock().mosquitto_tls_set(mosq,
+			cafile, capath, certfile, keyfile, pw_callback);
+}
+
+int mosquitto_tls_opts_set(struct mosquitto *mosq, int cert_reqs,
+		const char *tls_version, const char *ciphers)
+{
+	return LibMosquittoMock::get_mock().mosquitto_tls_opts_set(mosq,
+			cert_reqs, tls_version, ciphers);
+}
+
+int mosquitto_tls_insecure_set(struct mosquitto *mosq, bool value)
+{
+	return LibMosquittoMock::get_mock().mosquitto_tls_insecure_set(mosq,
+			value);
+}
+
+int mosquitto_string_option(struct mosquitto *mosq,
+		enum mosq_opt_t option, const char *value)
+{
+	return LibMosquittoMock::get_mock().mosquitto_string_option(mosq,
+			option, value);
+}
+
+int mosquitto_tls_psk_set(struct mosquitto *mosq, const char *psk,
+		const char *identity, const char *ciphers)
+{
+	return LibMosquittoMock::get_mock().mosquitto_tls_psk_set(mosq,
+			psk, identity, ciphers);
+}
+
+int mosquitto_opts_set(struct mosquitto *mosq, enum mosq_opt_t option,
+		void *value)
+{
+	return LibMosquittoMock::get_mock().mosquitto_opts_set(mosq,
+			option, value);
+}
+
+int mosquitto_int_option(struct mosquitto *mosq, enum mosq_opt_t option,
+		int value)
+{
+	return LibMosquittoMock::get_mock().mosquitto_int_option(mosq,
+			option, value);
+}
+
+int mosquitto_void_option(struct mosquitto *mosq, enum mosq_opt_t option,
+		void *value)
+{
+	return LibMosquittoMock::get_mock().mosquitto_void_option(mosq,
+			option, value);
+}
+
+void mosquitto_user_data_set(struct mosquitto *mosq, void *userdata)
+{
+	LibMosquittoMock::get_mock().mosquitto_user_data_set(mosq, userdata);
+}
+
+void *mosquitto_userdata(struct mosquitto *mosq)
+{
+	return LibMosquittoMock::get_mock().mosquitto_userdata(mosq);
+}

test/mock/lib/socks_mosq_mock.cpp

@@ -0,0 +1,8 @@
+#include "libmosquitto_mock.hpp"
+
+int mosquitto_socks5_set(struct mosquitto *mosq, const char *host,
+			int port, const char *username, const char *password)
+{
+	return LibMosquittoMock::get_mock().mosquitto_socks5_set(mosq,
+			host, port, username, password);
+}

test/mock/lib/srv_mosq_mock.cpp

@@ -0,0 +1,8 @@
+#include "libmosquitto_mock.hpp"
+
+int mosquitto_connect_srv(struct mosquitto *mosq, const char *host,
+			int keepalive, const char *bind_address)
+{
+	return LibMosquittoMock::get_mock().mosquitto_connect_srv(mosq,
+			host, keepalive, bind_address);
+}

test/mock/lib/thread_mosq_mock.cpp

@@ -0,0 +1,16 @@
+#include "libmosquitto_mock.hpp"
+
+int mosquitto_loop_start(struct mosquitto *mosq)
+{
+	return LibMosquittoMock::get_mock().mosquitto_loop_start(mosq);
+}
+
+int mosquitto_loop_stop(struct mosquitto *mosq, bool force)
+{
+	return LibMosquittoMock::get_mock().mosquitto_loop_stop(mosq, force);
+}
+
+int mosquitto_threaded_set(struct mosquitto *mosq, bool threaded)
+{
+	return LibMosquittoMock::get_mock().mosquitto_threaded_set(mosq, threaded);
+}

test/mock/pthread_mock.cpp

@@ -0,0 +1,9 @@
+#include "pthread_mock.hpp"
+
+PThreadMock::PThreadMock() {}
+PThreadMock::~PThreadMock() {}
+
+int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime)
+{
+	return PThreadMock::get_mock().pthread_cond_timedwait(cond, mutex, abstime);
+}

test/mock/pthread_mock.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <gmock/gmock.h>
+#include <pthread.h>
+
+#include "c_function_mock.hpp"
+
+class PThreadMock : public CFunctionMock<PThreadMock> {
+	public:
+		PThreadMock();
+		virtual ~PThreadMock();
+
+		MOCK_METHOD(int, pthread_cond_timedwait, (pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime));
+};