From f497c01ad12f54e2d434ea58e07c65516c094e53 Mon Sep 17 00:00:00 2001 From: "Roger A. Light" Date: Wed, 27 Aug 2025 23:01:20 +0100 Subject: [PATCH] Add mocks for libmosquitto_common --- test/mock/CMakeLists.txt | 1 + test/mock/libcommon/CMakeLists.txt | 24 ++ test/mock/libcommon/Makefile | 44 ++++ test/mock/libcommon/base64_common_mock.cpp | 14 ++ test/mock/libcommon/cjson_common.cpp | 7 + test/mock/libcommon/file_common_mock.cpp | 29 +++ .../libcommon/libmosquitto_common_mock.cpp | 4 + .../libcommon/libmosquitto_common_mock.hpp | 124 ++++++++++ test/mock/libcommon/memory_common_mock.cpp | 46 ++++ test/mock/libcommon/mqtt_common_mock.cpp | 6 + test/mock/libcommon/password_common_mock.cpp | 52 ++++ test/mock/libcommon/property_common_mock.cpp | 229 ++++++++++++++++++ test/mock/libcommon/random_common_mock.cpp | 7 + test/mock/libcommon/strings_common_mock.cpp | 25 ++ test/mock/libcommon/time_common_mock.cpp | 23 ++ test/mock/libcommon/topic_common_mock.cpp | 67 +++++ test/mock/libcommon/utf8_common_mock.cpp | 7 + 17 files changed, 709 insertions(+) create mode 100644 test/mock/libcommon/CMakeLists.txt create mode 100644 test/mock/libcommon/Makefile create mode 100644 test/mock/libcommon/base64_common_mock.cpp create mode 100644 test/mock/libcommon/cjson_common.cpp create mode 100644 test/mock/libcommon/file_common_mock.cpp create mode 100644 test/mock/libcommon/libmosquitto_common_mock.cpp create mode 100644 test/mock/libcommon/libmosquitto_common_mock.hpp create mode 100644 test/mock/libcommon/memory_common_mock.cpp create mode 100644 test/mock/libcommon/mqtt_common_mock.cpp create mode 100644 test/mock/libcommon/password_common_mock.cpp create mode 100644 test/mock/libcommon/property_common_mock.cpp create mode 100644 test/mock/libcommon/random_common_mock.cpp create mode 100644 test/mock/libcommon/strings_common_mock.cpp create mode 100644 test/mock/libcommon/time_common_mock.cpp create mode 100644 test/mock/libcommon/topic_common_mock.cpp create mode 100644 test/mock/libcommon/utf8_common_mock.cpp diff --git a/test/mock/CMakeLists.txt b/test/mock/CMakeLists.txt index 64e08ebc..e34e509e 100644 --- a/test/mock/CMakeLists.txt +++ b/test/mock/CMakeLists.txt @@ -1,3 +1,4 @@ +add_subdirectory(libcommon) add_subdirectory(lib) add_subdirectory(apps) diff --git a/test/mock/libcommon/CMakeLists.txt b/test/mock/libcommon/CMakeLists.txt new file mode 100644 index 00000000..400a73f1 --- /dev/null +++ b/test/mock/libcommon/CMakeLists.txt @@ -0,0 +1,24 @@ +add_library(libmosquitto_common_mock OBJECT + libmosquitto_common_mock.hpp + libmosquitto_common_mock.cpp + base64_common_mock.cpp + file_common_mock.cpp + memory_common_mock.cpp + mqtt_common_mock.cpp + password_common_mock.cpp + property_common_mock.cpp + random_common_mock.cpp + strings_common_mock.cpp + time_common_mock.cpp + topic_common_mock.cpp + utf8_common_mock.cpp +) + +target_include_directories(libmosquitto_common_mock + PUBLIC + ${mosquitto_SOURCE_DIR} + ${mosquitto_SOURCE_DIR}/include + ${mosquitto_SOURCE_DIR}/lib + ${mosquitto_SOURCE_DIR}/test/mock + ${mosquitto_SOURCE_DIR}/test/mock/lib +) diff --git a/test/mock/libcommon/Makefile b/test/mock/libcommon/Makefile new file mode 100644 index 00000000..f2c0b489 --- /dev/null +++ b/test/mock/libcommon/Makefile @@ -0,0 +1,44 @@ +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 = \ + base64_common_mock.o \ + file_common_mock.o \ + libmosquitto_common_mock.o \ + memory_common_mock.o \ + mqtt_common_mock.o \ + password_common_mock.o \ + property_common_mock.o \ + random_common_mock.o \ + strings_common_mock.o \ + time_common_mock.o \ + topic_common_mock.o \ + utf8_common_mock.o + +all : test-compile + +test-compile: ${MOCK_OBJS} +check : test + +# MOCKS + +${MOCK_OBJS} : %.o: %.cpp libmosquitto_common_mock.hpp + $(CROSS_COMPILE)$(CXX) $(LOCAL_CPPFLAGS) $(LOCAL_CXXFLAGS) -c $< -o $@ + +clean : + -rm -rf *.o *.gcda *.gcno + +install: + +uninstall: diff --git a/test/mock/libcommon/base64_common_mock.cpp b/test/mock/libcommon/base64_common_mock.cpp new file mode 100644 index 00000000..114fd7bc --- /dev/null +++ b/test/mock/libcommon/base64_common_mock.cpp @@ -0,0 +1,14 @@ +#include "libmosquitto_common_mock.hpp" + +int mosquitto_base64_encode(const unsigned char *in, size_t in_len, char **encoded) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_base64_encode( + in, in_len, encoded); +} + + +int mosquitto_base64_decode(const char *in, unsigned char **decoded, unsigned int *decoded_len) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_base64_decode( + in, decoded, decoded_len); +} diff --git a/test/mock/libcommon/cjson_common.cpp b/test/mock/libcommon/cjson_common.cpp new file mode 100644 index 00000000..19946bca --- /dev/null +++ b/test/mock/libcommon/cjson_common.cpp @@ -0,0 +1,7 @@ +#include "libmosquitto_common_mock.hpp" + +cJSON *mosquitto_properties_to_json(const mosquitto_property *properties) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_properties_to_json( + properties); +} diff --git a/test/mock/libcommon/file_common_mock.cpp b/test/mock/libcommon/file_common_mock.cpp new file mode 100644 index 00000000..1f46c1ec --- /dev/null +++ b/test/mock/libcommon/file_common_mock.cpp @@ -0,0 +1,29 @@ +#include "libmosquitto_common_mock.hpp" + +FILE *mosquitto_fopen(const char *path, const char *mode, bool restrict_read) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_fopen( + path, mode, restrict_read); +} + +char *mosquitto_trimblanks(char *str) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_trimblanks(str); +} + +char *mosquitto_fgets(char **buf, int *buflen, FILE *stream) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_fgets(buf, buflen, stream); +} + +int mosquitto_write_file(const char* target_path, bool restrict_read, int (*write_fn)(FILE* fptr, void* user_data), void* user_data, void (*log_fn)(const char* msg)) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_write_file( + target_path, restrict_read, write_fn, user_data, log_fn); +} + +int mosquitto_read_file(const char *file, char **buf, size_t *buflen) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_read_file( + file, buf, buflen); +} diff --git a/test/mock/libcommon/libmosquitto_common_mock.cpp b/test/mock/libcommon/libmosquitto_common_mock.cpp new file mode 100644 index 00000000..9ddbfb8e --- /dev/null +++ b/test/mock/libcommon/libmosquitto_common_mock.cpp @@ -0,0 +1,4 @@ +#include "libmosquitto_common_mock.hpp" + +LibMosquittoCommonMock::LibMosquittoCommonMock() {}; +LibMosquittoCommonMock::~LibMosquittoCommonMock() {}; diff --git a/test/mock/libcommon/libmosquitto_common_mock.hpp b/test/mock/libcommon/libmosquitto_common_mock.hpp new file mode 100644 index 00000000..bc88334c --- /dev/null +++ b/test/mock/libcommon/libmosquitto_common_mock.hpp @@ -0,0 +1,124 @@ +#pragma once + +#include +#include + +#include "c_function_mock.hpp" + +class LibMosquittoCommonMock : public CFunctionMock { + public: + LibMosquittoCommonMock(); + virtual ~LibMosquittoCommonMock(); + + /* base64_common.c */ + MOCK_METHOD(int, mosquitto_base64_encode, (const unsigned char *in, size_t in_len, char **encoded)); + MOCK_METHOD(int, mosquitto_base64_decode, (const char *in, unsigned char **decoded, unsigned int *decoded_len)); + + /* cjson_common.c */ + MOCK_METHOD(cJSON *, mosquitto_properties_to_json, (const mosquitto_property *properties)); + + /* file_common.c */ + MOCK_METHOD(FILE *, mosquitto_fopen, (const char *path, const char *mode, bool restrict_read)); + MOCK_METHOD(char *, mosquitto_trimblanks, (char *str)); + MOCK_METHOD(char *, mosquitto_fgets, (char **buf, int *buflen, FILE *stream)); + MOCK_METHOD(int, mosquitto_write_file, (const char* target_path, bool restrict_read, + int (*write_fn)(FILE* fptr, void* user_data), void* user_data, void (*log_fn)(const char* msg))); + MOCK_METHOD(int, mosquitto_read_file, (const char *file, char **buf, size_t *buflen)); + + /* memory_common.c */ + MOCK_METHOD(void, mosquitto_memory_set_limit, (size_t lim)); + MOCK_METHOD(unsigned long, mosquitto_memory_used, ()); + MOCK_METHOD(unsigned long, mosquitto_max_memory_used, ()); + MOCK_METHOD(void *, mosquitto_malloc, (size_t size)); + MOCK_METHOD(void *, mosquitto_realloc, (void *ptr, size_t size)); + MOCK_METHOD(void, mosquitto_free, (void *mem)); + MOCK_METHOD(void *, mosquitto_calloc, (size_t nmemb, size_t size)); + MOCK_METHOD(char *, mosquitto_strdup, (const char *s)); + MOCK_METHOD(char *, mosquitto_strndup, (const char *s, size_t n)); + + /* mqtt_common.c */ + MOCK_METHOD(unsigned int, mosquitto_varint_bytes, (uint32_t word)); + + /* password_common.c */ + MOCK_METHOD(int, mosquitto_pw_new, (struct mosquitto_pw **pw, enum mosquitto_pwhash_type hashtype)); + MOCK_METHOD(int, mosquitto_pw_hash_encoded, (struct mosquitto_pw *pw, const char *password)); + MOCK_METHOD(int, mosquitto_pw_verify, (struct mosquitto_pw *pw, const char *password)); + MOCK_METHOD(void, mosquitto_pw_set_valid, (struct mosquitto_pw *pw, bool valid)); + MOCK_METHOD(bool, mosquitto_pw_is_valid, (struct mosquitto_pw *pw)); + MOCK_METHOD(int, mosquitto_pw_decode, (struct mosquitto_pw *pw, const char *password)); + MOCK_METHOD(const char *, mosquitto_pw_get_encoded, (struct mosquitto_pw *pw)); + MOCK_METHOD(int, mosquitto_pw_set_param, (struct mosquitto_pw *pw, int param, int value)); + MOCK_METHOD(void, mosquitto_pw_cleanup, (struct mosquitto_pw *pw)); + + /* property_common.c */ + MOCK_METHOD(void, mosquitto_property_free, (mosquitto_property **property)); + MOCK_METHOD(void, mosquitto_property_free_all, (mosquitto_property **property)); + MOCK_METHOD(unsigned int, mosquitto_property_get_length, (const mosquitto_property *property)); + MOCK_METHOD(unsigned int, mosquitto_property_get_length_all, (const mosquitto_property *property)); + MOCK_METHOD(int, mosquitto_property_check_command, (int command, int identifier)); + MOCK_METHOD(const char *, mosquitto_property_identifier_to_string, (int identifier)); + MOCK_METHOD(int, mosquitto_string_to_property_info, (const char *propname, int *identifier, int *type)); + MOCK_METHOD(int, mosquitto_property_add_byte, (mosquitto_property **proplist, int identifier, uint8_t value)); + MOCK_METHOD(int, mosquitto_property_add_int16, (mosquitto_property **proplist, int identifier, uint16_t value)); + MOCK_METHOD(int, mosquitto_property_add_int32, (mosquitto_property **proplist, int identifier, uint32_t value)); + MOCK_METHOD(int, mosquitto_property_add_varint, (mosquitto_property **proplist, int identifier, uint32_t value)); + MOCK_METHOD(int, mosquitto_property_add_binary, (mosquitto_property **proplist, int identifier, const void *value, uint16_t len)); + MOCK_METHOD(int, mosquitto_property_add_string, (mosquitto_property **proplist, int identifier, const char *value)); + MOCK_METHOD(int, mosquitto_property_add_string_pair, (mosquitto_property **proplist, int identifier, const char *name, const char *value)); + MOCK_METHOD(int, mosquitto_property_check_all, (int command, const mosquitto_property *properties)); + MOCK_METHOD(int, mosquitto_property_identifier, (const mosquitto_property *property)); + MOCK_METHOD(int, mosquitto_property_type, (const mosquitto_property *property)); + MOCK_METHOD(mosquitto_property *, mosquitto_property_next, (const mosquitto_property *proplist)); + MOCK_METHOD(const mosquitto_property *, mosquitto_property_read_byte, (const mosquitto_property *proplist, int identifier, uint8_t *value, bool skip_first)); + MOCK_METHOD(const mosquitto_property *, mosquitto_property_read_int16, (const mosquitto_property *proplist, int identifier, uint16_t *value, bool skip_first)); + MOCK_METHOD(const mosquitto_property *, mosquitto_property_read_int32, (const mosquitto_property *proplist, int identifier, uint32_t *value, bool skip_first)); + MOCK_METHOD(const mosquitto_property *, mosquitto_property_read_varint, (const mosquitto_property *proplist, int identifier, uint32_t *value, bool skip_first)); + MOCK_METHOD(const mosquitto_property *, mosquitto_property_read_binary, (const mosquitto_property *proplist, int identifier, void **value, uint16_t *len, bool skip_first)); + MOCK_METHOD(const mosquitto_property *, mosquitto_property_read_string, (const mosquitto_property *proplist, int identifier, char **value, bool skip_first)); + MOCK_METHOD(const mosquitto_property *, mosquitto_property_read_string_pair, (const mosquitto_property *proplist, int identifier, char **name, char **value, bool skip_first)); + MOCK_METHOD(int, mosquitto_property_remove, (mosquitto_property **proplist, const mosquitto_property *property)); + MOCK_METHOD(int, mosquitto_property_copy_all, (mosquitto_property **dest, const mosquitto_property *src)); + MOCK_METHOD(uint8_t, mosquitto_property_byte_value, (const mosquitto_property *property)); + MOCK_METHOD(uint16_t, mosquitto_property_int16_value, (const mosquitto_property *property)); + MOCK_METHOD(uint32_t, mosquitto_property_int32_value, (const mosquitto_property *property)); + MOCK_METHOD(uint32_t, mosquitto_property_varint_value, (const mosquitto_property *property)); + MOCK_METHOD(const void *, mosquitto_property_binary_value, (const mosquitto_property *property)); + MOCK_METHOD(uint16_t, mosquitto_property_binary_value_length, (const mosquitto_property *property)); + MOCK_METHOD(const char *, mosquitto_property_string_value, (const mosquitto_property *property)); + MOCK_METHOD(uint16_t, mosquitto_property_string_value_length, (const mosquitto_property *property)); + MOCK_METHOD(const char *, mosquitto_property_string_name, (const mosquitto_property *property)); + MOCK_METHOD(uint16_t, mosquitto_property_string_name_length, (const mosquitto_property *property)); + MOCK_METHOD(unsigned int, mosquitto_property_get_remaining_length, (const mosquitto_property *props)); + + /* random_common.c */ + MOCK_METHOD(int, mosquitto_getrandom, (void *bytes, int count)); + + /* strings_common.c */ + MOCK_METHOD(const char *, mosquitto_strerror, (int mosq_errno)); + MOCK_METHOD(const char *, mosquitto_connack_string, (int connack_code)); + MOCK_METHOD(const char *, mosquitto_reason_string, (int reason_code)); + MOCK_METHOD(int, mosquitto_string_to_command, (const char *str, int *cmd)); + + /* time_common.c */ + MOCK_METHOD(void, mosquitto_time_init, ()); + MOCK_METHOD(time_t, mosquitto_time, ()); + MOCK_METHOD(void, mosquitto_time_ns, (time_t *s, long *ns)); + MOCK_METHOD(long, mosquitto_time_cmp, (time_t t1_s, long t1_ns, time_t t2_s, long t2_ns)); + + /* topic_common.c */ + MOCK_METHOD(int, mosquitto_pub_topic_check, (const char *str)); + MOCK_METHOD(int, mosquitto_pub_topic_check2, (const char *str, size_t len)); + MOCK_METHOD(int, mosquitto_sub_topic_check, (const char *str)); + MOCK_METHOD(int, mosquitto_sub_topic_check2, (const char *str, size_t len)); + MOCK_METHOD(int, mosquitto_sub_matches_acl, (const char *acl, const char *sub, bool *result)); + MOCK_METHOD(int, mosquitto_sub_matches_acl_with_pattern, (const char *acl, const char *sub, const char *clientid, const char *username, bool *result)); + MOCK_METHOD(int, mosquitto_topic_matches_sub, (const char *sub, const char *topic, bool *result)); + MOCK_METHOD(int, mosquitto_topic_matches_sub_with_pattern, (const char *sub, const char *topic, const char *clientid, const char *username, bool *result)); + MOCK_METHOD(int, mosquitto_topic_matches_sub2, (const char *sub, size_t sublen, const char *topic, size_t topiclen, bool *result)); + MOCK_METHOD(int, mosquitto_sub_topic_tokenise, (const char *subtopic, char ***topics, int *count)); + MOCK_METHOD(int, mosquitto_sub_topic_tokens_free, (char ***topics, int count)); + + /* utf8_common.c */ + MOCK_METHOD(int, mosquitto_validate_utf8, (const char *str, int len)); + +}; diff --git a/test/mock/libcommon/memory_common_mock.cpp b/test/mock/libcommon/memory_common_mock.cpp new file mode 100644 index 00000000..0d8989ea --- /dev/null +++ b/test/mock/libcommon/memory_common_mock.cpp @@ -0,0 +1,46 @@ +#include "libmosquitto_common_mock.hpp" + +void mosquitto_memory_set_limit(size_t lim) +{ + LibMosquittoCommonMock::get_mock().mosquitto_memory_set_limit(lim); +} + +unsigned long mosquitto_memory_used(void) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_memory_used(); +} + +unsigned long mosquitto_max_memory_used(void) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_max_memory_used(); +} + +void *mosquitto_malloc(size_t size) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_malloc(size); +} + +void *mosquitto_realloc(void *ptr, size_t size) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_realloc(ptr, size); +} + +void mosquitto_free(void *mem) +{ + LibMosquittoCommonMock::get_mock().mosquitto_free(mem); +} + +void *mosquitto_calloc(size_t nmemb, size_t size) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_calloc(nmemb, size); +} + +char *mosquitto_strdup(const char *s) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_strdup(s); +} + +char *mosquitto_strndup(const char *s, size_t n) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_strndup(s, n); +} diff --git a/test/mock/libcommon/mqtt_common_mock.cpp b/test/mock/libcommon/mqtt_common_mock.cpp new file mode 100644 index 00000000..39211679 --- /dev/null +++ b/test/mock/libcommon/mqtt_common_mock.cpp @@ -0,0 +1,6 @@ +#include "libmosquitto_common_mock.hpp" + +unsigned int mosquitto_varint_bytes(uint32_t word) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_varint_bytes(word); +} diff --git a/test/mock/libcommon/password_common_mock.cpp b/test/mock/libcommon/password_common_mock.cpp new file mode 100644 index 00000000..e2cc56ab --- /dev/null +++ b/test/mock/libcommon/password_common_mock.cpp @@ -0,0 +1,52 @@ +#include "libmosquitto_common_mock.hpp" + +int mosquitto_pw_new(struct mosquitto_pw **pw, enum mosquitto_pwhash_type hashtype) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_pw_new( + pw, hashtype); +} + +int mosquitto_pw_hash_encoded(struct mosquitto_pw *pw, const char *password) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_pw_hash_encoded( + pw, password); +} + +int mosquitto_pw_verify(struct mosquitto_pw *pw, const char *password) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_pw_verify( + pw, password); +} + +void mosquitto_pw_set_valid(struct mosquitto_pw *pw, bool valid) +{ + LibMosquittoCommonMock::get_mock().mosquitto_pw_set_valid( + pw, valid); +} + +bool mosquitto_pw_is_valid(struct mosquitto_pw *pw) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_pw_is_valid(pw); +} + +int mosquitto_pw_decode(struct mosquitto_pw *pw, const char *password) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_pw_decode( + pw, password); +} + +const char *mosquitto_pw_get_encoded(struct mosquitto_pw *pw) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_pw_get_encoded(pw); +} + +int mosquitto_pw_set_param(struct mosquitto_pw *pw, int param, int value) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_pw_set_param( + pw, param, value); +} + +void mosquitto_pw_cleanup(struct mosquitto_pw *pw) +{ + LibMosquittoCommonMock::get_mock().mosquitto_pw_cleanup(pw); +} diff --git a/test/mock/libcommon/property_common_mock.cpp b/test/mock/libcommon/property_common_mock.cpp new file mode 100644 index 00000000..d16f3b2c --- /dev/null +++ b/test/mock/libcommon/property_common_mock.cpp @@ -0,0 +1,229 @@ +#include "libmosquitto_common_mock.hpp" + +void mosquitto_property_free(mosquitto_property **property) +{ + LibMosquittoCommonMock::get_mock().mosquitto_property_free( + property); +} + +void mosquitto_property_free_all(mosquitto_property **property) +{ + LibMosquittoCommonMock::get_mock().mosquitto_property_free_all( + property); +} + +unsigned int mosquitto_property_get_length(const mosquitto_property *property) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_get_length( + property); +} + +unsigned int mosquitto_property_get_length_all(const mosquitto_property *property) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_get_length_all( + property); +} + +int mosquitto_property_check_command(int command, int identifier) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_check_command( + command, identifier); +} + +const char *mosquitto_property_identifier_to_string(int identifier) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_identifier_to_string( + identifier); +} + +int mosquitto_string_to_property_info(const char *propname, int *identifier, int *type) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_string_to_property_info( + propname, identifier, type); +} + +int mosquitto_property_add_byte(mosquitto_property **proplist, int identifier, uint8_t value) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_add_byte( + proplist, identifier, value); +} + +int mosquitto_property_add_int16(mosquitto_property **proplist, int identifier, uint16_t value) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_add_int16( + proplist, identifier, value); +} + +int mosquitto_property_add_int32(mosquitto_property **proplist, int identifier, uint32_t value) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_add_int32( + proplist, identifier, value); +} + +int mosquitto_property_add_varint(mosquitto_property **proplist, int identifier, uint32_t value) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_add_varint( + proplist, identifier, value); +} + +int mosquitto_property_add_binary(mosquitto_property **proplist, int identifier, const void *value, uint16_t len) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_add_binary( + proplist, identifier, value, len); +} + +int mosquitto_property_add_string(mosquitto_property **proplist, int identifier, const char *value) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_add_string( + proplist, identifier, value); +} + +int mosquitto_property_add_string_pair(mosquitto_property **proplist, int identifier, const char *name, const char *value) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_add_string_pair( + proplist, identifier, name, value); +} + +int mosquitto_property_check_all(int command, const mosquitto_property *properties) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_check_all( + command, properties); +} + +int mosquitto_property_identifier(const mosquitto_property *property) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_identifier( + property); +} + +int mosquitto_property_type(const mosquitto_property *property) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_type( + property); +} + +mosquitto_property *mosquitto_property_next(const mosquitto_property *proplist) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_next( + proplist); +} + +const mosquitto_property *mosquitto_property_read_byte(const mosquitto_property *proplist, int identifier, uint8_t *value, bool skip_first) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_read_byte( + proplist, identifier, value, skip_first); +} + +const mosquitto_property *mosquitto_property_read_int16(const mosquitto_property *proplist, int identifier, uint16_t *value, bool skip_first) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_read_int16( + proplist, identifier, value, skip_first); +} + +const mosquitto_property *mosquitto_property_read_int32(const mosquitto_property *proplist, int identifier, uint32_t *value, bool skip_first) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_read_int32( + proplist, identifier, value, skip_first); +} + +const mosquitto_property *mosquitto_property_read_varint(const mosquitto_property *proplist, int identifier, uint32_t *value, bool skip_first) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_read_varint( + proplist, identifier, value, skip_first); +} + +const mosquitto_property *mosquitto_property_read_binary(const mosquitto_property *proplist, int identifier, void **value, uint16_t *len, bool skip_first) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_read_binary( + proplist, identifier, value, len, skip_first); +} + +const mosquitto_property *mosquitto_property_read_string(const mosquitto_property *proplist, int identifier, char **value, bool skip_first) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_read_string( + proplist, identifier, value, skip_first); +} + +const mosquitto_property *mosquitto_property_read_string_pair(const mosquitto_property *proplist, int identifier, char **name, char **value, bool skip_first) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_read_string_pair( + proplist, identifier, name, value, skip_first); +} + +int mosquitto_property_remove(mosquitto_property **proplist, const mosquitto_property *property) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_remove( + proplist, property); +} + +int mosquitto_property_copy_all(mosquitto_property **dest, const mosquitto_property *src) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_copy_all( + dest, src); +} + +uint8_t mosquitto_property_byte_value(const mosquitto_property *property) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_byte_value( + property); +} + +uint16_t mosquitto_property_int16_value(const mosquitto_property *property) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_int16_value( + property); +} + +uint32_t mosquitto_property_int32_value(const mosquitto_property *property) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_int32_value( + property); +} + +uint32_t mosquitto_property_varint_value(const mosquitto_property *property) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_varint_value( + property); +} + +const void *mosquitto_property_binary_value(const mosquitto_property *property) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_binary_value( + property); +} + +uint16_t mosquitto_property_binary_value_length(const mosquitto_property *property) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_binary_value_length( + property); +} + +const char *mosquitto_property_string_value(const mosquitto_property *property) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_string_value( + property); +} + +uint16_t mosquitto_property_string_value_length(const mosquitto_property *property) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_string_value_length( + property); +} + +const char *mosquitto_property_string_name(const mosquitto_property *property) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_string_name( + property); +} + +uint16_t mosquitto_property_string_name_length(const mosquitto_property *property) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_string_name_length( + property); +} + +unsigned int mosquitto_property_get_remaining_length(const mosquitto_property *props) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_property_get_remaining_length( + props); +} diff --git a/test/mock/libcommon/random_common_mock.cpp b/test/mock/libcommon/random_common_mock.cpp new file mode 100644 index 00000000..7397cbe3 --- /dev/null +++ b/test/mock/libcommon/random_common_mock.cpp @@ -0,0 +1,7 @@ +#include "libmosquitto_common_mock.hpp" + +int mosquitto_getrandom(void *bytes, int count) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_getrandom( + bytes, count); +} diff --git a/test/mock/libcommon/strings_common_mock.cpp b/test/mock/libcommon/strings_common_mock.cpp new file mode 100644 index 00000000..16fb9a27 --- /dev/null +++ b/test/mock/libcommon/strings_common_mock.cpp @@ -0,0 +1,25 @@ +#include "libmosquitto_common_mock.hpp" + +const char *mosquitto_strerror(int mosq_errno) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_strerror( + mosq_errno); +} + +const char *mosquitto_connack_string(int connack_code) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_connack_string( + connack_code); +} + +const char *mosquitto_reason_string(int reason_code) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_reason_string( + reason_code); +} + +int mosquitto_string_to_command(const char *str, int *cmd) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_string_to_command( + str, cmd); +} diff --git a/test/mock/libcommon/time_common_mock.cpp b/test/mock/libcommon/time_common_mock.cpp new file mode 100644 index 00000000..05437be2 --- /dev/null +++ b/test/mock/libcommon/time_common_mock.cpp @@ -0,0 +1,23 @@ +#include "libmosquitto_common_mock.hpp" + +void mosquitto_time_init(void) +{ + LibMosquittoCommonMock::get_mock().mosquitto_time_init(); +} + +time_t mosquitto_time(void) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_time(); +} + +void mosquitto_time_ns(time_t *s, long *ns) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_time_ns( + s, ns); +} + +long mosquitto_time_cmp(time_t t1_s, long t1_ns, time_t t2_s, long t2_ns) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_time_cmp( + t1_s, t1_ns, t2_s, t2_ns); +} diff --git a/test/mock/libcommon/topic_common_mock.cpp b/test/mock/libcommon/topic_common_mock.cpp new file mode 100644 index 00000000..78d4a2e9 --- /dev/null +++ b/test/mock/libcommon/topic_common_mock.cpp @@ -0,0 +1,67 @@ +#include "libmosquitto_common_mock.hpp" + +int mosquitto_pub_topic_check(const char *str) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_pub_topic_check( + str); +} + +int mosquitto_pub_topic_check2(const char *str, size_t len) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_pub_topic_check2( + str, len); +} + +int mosquitto_sub_topic_check(const char *str) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_sub_topic_check( + str); +} + +int mosquitto_sub_topic_check2(const char *str, size_t len) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_sub_topic_check2( + str, len); +} + +int mosquitto_sub_matches_acl(const char *acl, const char *sub, bool *result) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_sub_matches_acl( + acl, sub, result); +} + +int mosquitto_sub_matches_acl_with_pattern(const char *acl, const char *sub, const char *clientid, const char *username, bool *result) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_sub_matches_acl_with_pattern( + acl, sub, clientid, username, result); +} + +int mosquitto_topic_matches_sub(const char *sub, const char *topic, bool *result) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_topic_matches_sub( + sub, topic, result); +} + +int mosquitto_topic_matches_sub_with_pattern(const char *sub, const char *topic, const char *clientid, const char *username, bool *result) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_topic_matches_sub_with_pattern( + sub, topic, clientid, username, result); +} + +int mosquitto_topic_matches_sub2(const char *sub, size_t sublen, const char *topic, size_t topiclen, bool *result) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_topic_matches_sub2( + sub, sublen, topic, topiclen, result); +} + +int mosquitto_sub_topic_tokenise(const char *subtopic, char ***topics, int *count) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_sub_topic_tokenise( + subtopic, topics, count); +} + +int mosquitto_sub_topic_tokens_free(char ***topics, int count) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_sub_topic_tokens_free( + topics, count); +} diff --git a/test/mock/libcommon/utf8_common_mock.cpp b/test/mock/libcommon/utf8_common_mock.cpp new file mode 100644 index 00000000..161e9e2f --- /dev/null +++ b/test/mock/libcommon/utf8_common_mock.cpp @@ -0,0 +1,7 @@ +#include "libmosquitto_common_mock.hpp" + +int mosquitto_validate_utf8(const char *str, int len) +{ + return LibMosquittoCommonMock::get_mock().mosquitto_validate_utf8( + str, len); +}