From 5a1949c5ef1692e3cc766b9ab5311aeafa70cc0c Mon Sep 17 00:00:00 2001 From: kanjoe24 <165808281+kanjoe24@users.noreply.github.com> Date: Fri, 20 Dec 2024 22:56:55 +0000 Subject: [PATCH] Update gh #162 : Updating the weak stub lib to shared libraray Updating the weak stub static libraray to shared library as the vendor specific libs are mostly shared rather than static. Also added some tests to check the functionality --- Makefile | 12 +- tests/Makefile | 2 + tests/src_weak/ut_test_weak_kvp.c | 305 ++++++++++++++++++++++++++++++ tests/src_weak/ut_test_weak_log.c | 88 +++++++++ 4 files changed, 402 insertions(+), 5 deletions(-) create mode 100644 tests/src_weak/ut_test_weak_kvp.c create mode 100644 tests/src_weak/ut_test_weak_log.c diff --git a/Makefile b/Makefile index ed603ed..0a8d8af 100755 --- a/Makefile +++ b/Makefile @@ -79,12 +79,12 @@ endif ifdef BUILD_WEAK_STUBS_SRC # Define variables for the static library and its source files -WEAK_STUBS_LIB := $(LIB_DIR)/libweak_stubs_libs.a +WEAK_STUBS_LIB := $(LIB_DIR)/libweak_stubs_libs.so WEAK_STUBS_OUTPUT_DIR ?= $(BUILD_DIR)/weak_stubs/src WEAK_STUBS_SRC := $(shell find $(BUILD_WEAK_STUBS_SRC) -name *.c) WEAK_STUBS_OBJ := $(patsubst $(BUILD_WEAK_STUBS_SRC)/%, $(WEAK_STUBS_OUTPUT_DIR)/%, $(WEAK_STUBS_SRC:.c=.o)) # Apply the pattern substitution to create object file paths -XLDFLAGS := -L$(LIB_DIR) -lweak_stubs_libs $(XLDFLAGS) +XLDFLAGS := $(XLDFLAGS) -L$(LIB_DIR) -lweak_stubs_libs endif VARIANT_FILE := .variant @@ -185,13 +185,15 @@ checkvariantchange: # Create the library weak_stubs_libs $(WEAK_STUBS_LIB): $(WEAK_STUBS_OBJ) - ${ECHOE} ${GREEN}Building weak_stubs_libs...${NC} - @$(AR) rcs $@ $^ + @${ECHOE} ${GREEN}Building shared library weak_stubs_libs...${NC} + @$(COMPILER) -shared -o $@ $^ + @${ECHOE} ${GREEN}Copy shared library weak_stubs_libs to [${BIN_DIR}]${NC} + cp $(WEAK_STUBS_LIB) $(BIN_DIR) # Rule to compile .c files into .o files in the correct directory $(WEAK_STUBS_OUTPUT_DIR)/%.o: $(BUILD_WEAK_STUBS_SRC)/%.c @$(MKDIR_P) $(dir $@) - @$(COMPILER) $(XCFLAGS) -c $< -o $@ + @$(COMPILER) $(XCFLAGS) -fPIC -c $< -o $@ arm: make TARGET=arm diff --git a/tests/Makefile b/tests/Makefile index ef968a7..e120271 100644 --- a/tests/Makefile +++ b/tests/Makefile @@ -24,6 +24,7 @@ TARGET_EXEC = ut-test # Switch on Linux & disable asserts for the testing suites CFLAGS += -DNDEBUG +BUILD_WEAK_STUBS_SRC = $(ROOT_DIR)/src_weak ifneq ($(VARIANT),CPP) VARIANT = C XCFLAGS += -DUT_CUNIT @@ -55,6 +56,7 @@ export TARGET export TARGET_EXEC export CFLAGS export LDFLAGS +export BUILD_WEAK_STUBS_SRC GREEN='\033[0;32m' NC='\033[0m' diff --git a/tests/src_weak/ut_test_weak_kvp.c b/tests/src_weak/ut_test_weak_kvp.c new file mode 100644 index 0000000..591709a --- /dev/null +++ b/tests/src_weak/ut_test_weak_kvp.c @@ -0,0 +1,305 @@ +/* + * If not stated otherwise in this file or this component's LICENSE file the + * following copyright and licenses apply: + * + * Copyright 2023 RDK Management + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +#include +#include +#include // For NULL +#include // For malloc/free +#include "ut_kvp.h" + +/** + * @brief Weak implementation of ut_kvp_createInstance. + * + * Creates a new KVP instance. + * Always returns NULL to indicate failure. + * + * @returns NULL. + */ +ut_kvp_instance_t *__attribute__((weak)) ut_kvp_createInstance(void) +{ + printf("Weak implementation of [%s]", __func__); + return NULL; // Default failure +} + +/** + * @brief Weak implementation of ut_kvp_destroyInstance. + * + * Destroys a KVP instance. + * Does nothing by default. + * + * @param[in] pInstance - Handle to the instance to destroy. + */ +void __attribute__((weak)) ut_kvp_destroyInstance(ut_kvp_instance_t *pInstance) +{ + printf("Weak implementation of [%s]", __func__); + (void)pInstance; // Default no-op +} + +/** + * @brief Weak implementation of ut_kvp_open. + * + * Opens and parses a KVP file into a KVP instance. + * Always returns UT_KVP_STATUS_INVALID_INSTANCE. + * + * @param[in] pInstance - Handle to the KVP instance. + * @param[in] fileName - Path to the KVP file. + * @returns UT_KVP_STATUS_INVALID_INSTANCE. + */ +ut_kvp_status_t __attribute__((weak)) ut_kvp_open(ut_kvp_instance_t *pInstance, char *fileName) +{ + printf("Weak implementation of [%s]", __func__); + return UT_KVP_STATUS_INVALID_INSTANCE; +} + +/** + * @brief Weak implementation of ut_kvp_openMemory. + * + * Opens and parses a memory block into a KVP instance. + * Always returns UT_KVP_STATUS_INVALID_INSTANCE. + * + * @param[in] pInstance - Handle to the KVP instance. + * @param[in] pData - Pointer to memory containing KVP data. + * @param[in] length - Size of the KVP data. + * @returns UT_KVP_STATUS_INVALID_INSTANCE. + */ +ut_kvp_status_t __attribute__((weak)) ut_kvp_openMemory(ut_kvp_instance_t *pInstance, char *pData, uint32_t length) +{ + printf("Weak implementation of [%s]", __func__); + return UT_KVP_STATUS_INVALID_INSTANCE; +} + +/** + * @brief Weak implementation of ut_kvp_close. + * + * Closes a previously opened KVP instance. + * Does nothing by default. + * + * @param[in] pInstance - Handle to the KVP instance. + */ +void __attribute__((weak)) ut_kvp_close(ut_kvp_instance_t *pInstance) +{ + (void)pInstance; // Default no-op + printf("Weak implementation of [%s]", __func__); +} + +/** + * @brief Weak implementation of ut_kvp_getBoolField. + * + * Always returns false. + * + * @param[in] pInstance - Handle to the KVP instance. + * @param[in] pszKey - Key to search for. + * @returns false. + */ +bool __attribute__((weak)) ut_kvp_getBoolField(ut_kvp_instance_t *pInstance, const char *pszKey) +{ + printf("Weak implementation of [%s]", __func__); + return false; // Default behavior +} + +/** + * @brief Weak implementation of ut_kvp_getUInt8Field. + * + * Always returns 0. + * + * @param[in] pInstance - Handle to the KVP instance. + * @param[in] pszKey - Key to search for. + * @returns 0. + */ +uint8_t __attribute__((weak)) ut_kvp_getUInt8Field(ut_kvp_instance_t *pInstance, const char *pszKey) +{ + printf("Weak implementation of [%s]", __func__); + return 0; +} + +/** + * @brief Weak implementation of ut_kvp_getUInt16Field. + * + * Always returns 0. + * + * @param[in] pInstance - Handle to the KVP instance. + * @param[in] pszKey - Key to search for. + * @returns 0. + */ +uint16_t __attribute__((weak)) ut_kvp_getUInt16Field(ut_kvp_instance_t *pInstance, const char *pszKey) +{ + printf("Weak implementation of [%s]", __func__); + return 0; +} + +/** + * @brief Weak implementation of ut_kvp_getUInt32Field. + * + * Always returns 0. + * + * @param[in] pInstance - Handle to the KVP instance. + * @param[in] pszKey - Key to search for. + * @returns 0. + */ +uint32_t __attribute__((weak)) ut_kvp_getUInt32Field(ut_kvp_instance_t *pInstance, const char *pszKey) +{ + printf("Weak implementation of [%s]", __func__); + return 0; +} + +/** + * @brief Weak implementation of ut_kvp_getUInt64Field. + * + * Always returns 0. + * + * @param[in] pInstance - Handle to the KVP instance. + * @param[in] pszKey - Key to search for. + * @returns 0. + */ +uint64_t __attribute__((weak)) ut_kvp_getUInt64Field(ut_kvp_instance_t *pInstance, const char *pszKey) +{ + printf("Weak implementation of [%s]", __func__); + return 0; +} + +/** + * @brief Weak implementation of ut_kvp_getStringField. + * + * Always returns UT_KVP_STATUS_KEY_NOT_FOUND. + * + * @param[in] pInstance - Handle to the KVP instance. + * @param[in] pszKey - Key to search for. + * @param[out] pszReturnedString - Buffer to store the string. + * @param[in] uStringSize - Size of the buffer. + * @returns UT_KVP_STATUS_KEY_NOT_FOUND. + */ +ut_kvp_status_t __attribute__((weak)) ut_kvp_getStringField( + ut_kvp_instance_t *pInstance, + const char *pszKey, + char *pszReturnedString, + uint32_t uStringSize) +{ + (void)pInstance; + (void)pszKey; + (void)pszReturnedString; + (void)uStringSize; + printf("Weak implementation of [%s]", __func__); + return UT_KVP_STATUS_KEY_NOT_FOUND; +} + +/** + * @brief Weak implementation of ut_kvp_getFloatField. + * + * Always returns 0.0f. + * + * @param[in] pInstance - Handle to the KVP instance. + * @param[in] pszKey - Key to search for. + * @returns 0.0f. + */ +float __attribute__((weak)) ut_kvp_getFloatField(ut_kvp_instance_t *pInstance, const char *pszKey) +{ + (void)pInstance; + (void)pszKey; + printf("Weak implementation of [%s]", __func__); + return 0.0f; +} + +/** + * @brief Weak implementation of ut_kvp_getDoubleField. + * + * Always returns 0.0. + * + * @param[in] pInstance - Handle to the KVP instance. + * @param[in] pszKey - Key to search for. + * @returns 0.0. + */ +double __attribute__((weak)) ut_kvp_getDoubleField(ut_kvp_instance_t *pInstance, const char *pszKey) +{ + (void)pInstance; + (void)pszKey; + printf("Weak implementation of [%s]", __func__); + return 0.0; +} + +/** + * @brief Weak implementation of ut_kvp_fieldPresent. + * + * Always returns false. + * + * @param[in] pInstance - Handle to the KVP instance. + * @param[in] pszKey - Key to search for. + * @returns false. + */ +bool __attribute__((weak)) ut_kvp_fieldPresent(ut_kvp_instance_t *pInstance, const char *pszKey) +{ + (void)pInstance; + (void)pszKey; + printf("Weak implementation of [%s]", __func__); + return false; +} + +/** + * @brief Weak implementation of ut_kvp_getData. + * + * Always returns NULL. + * + * @param[in] pInstance - Handle to the KVP instance. + * @returns NULL. + */ +char *__attribute__((weak)) ut_kvp_getData(ut_kvp_instance_t *pInstance) +{ + (void)pInstance; + printf("Weak implementation of [%s]", __func__); + return NULL; +} + +/** + * @brief Weak implementation of ut_kvp_getListCount. + * + * Always returns 0. + * + * @param[in] pInstance - Handle to the KVP instance. + * @param[in] pszKey - Key to search for. + * @returns 0. + */ +uint32_t __attribute__((weak)) ut_kvp_getListCount(ut_kvp_instance_t *pInstance, const char *pszKey) +{ + (void)pInstance; + (void)pszKey; + printf("Weak implementation of [%s]", __func__); + return 0; +} + +/** + * @brief Weak implementation of ut_kvp_getDataBytes. + * + * Always returns NULL and sets size to 0. + * + * @param[in] pInstance - Handle to the KVP instance. + * @param[in] pszKey - Key to search for. + * @param[out] size - Pointer to store the size of the data. + * @returns NULL. + */ +unsigned char *__attribute__((weak)) ut_kvp_getDataBytes(ut_kvp_instance_t *pInstance, const char *pszKey, int *size) +{ + (void)pInstance; + (void)pszKey; + if (size) + { + *size = 0; + } + printf("Weak implementation of [%s]", __func__); + return NULL; +} \ No newline at end of file diff --git a/tests/src_weak/ut_test_weak_log.c b/tests/src_weak/ut_test_weak_log.c new file mode 100644 index 0000000..3c792bc --- /dev/null +++ b/tests/src_weak/ut_test_weak_log.c @@ -0,0 +1,88 @@ +/* + * If not stated otherwise in this file or this component's LICENSE file the + * following copyright and licenses apply: + * + * Copyright 2023 RDK Management + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/* Standard Libraries */ +#include +#include + +/* Module Includes */ +#include + +/** + * @brief Weak implementation of UT_log_setLogFilePath. + * + * This function provides a default, weak implementation that does nothing. + * Override this function by defining your own implementation elsewhere. + * + * @param inputFilePath Path to the log file. + */ +void __attribute__((weak)) UT_log_setLogFilePath(char *inputFilePath) +{ + // Default no-op implementation + printf("Weak implementation of [%s]", __func__); +} + +/** + * @brief Weak implementation of UT_log_getLogFilename. + * + * This function provides a default, weak implementation that returns a static filename. + * Override this function by defining your own implementation elsewhere. + * + * @returns A static string representing a default log filename. + */ +const char *__attribute__((weak)) UT_log_getLogFilename(void) +{ + printf("Weak implementation of [%s]", __func__); + return "default_log_file.log"; // Default filename +} + +/** + * @brief Weak implementation of UT_log. + * + * This function provides a default, weak implementation that does nothing. + * Override this function by defining your own implementation elsewhere. + * + * @param function Name of the calling function. + * @param line Line number in the source file. + * @param format Format string for the log message. + * @param ... Variable arguments for the format string. + */ +void __attribute__((weak)) UT_log(const char *function, int line, const char *format, ...) +{ + // Default no-op implementation + printf("Weak implementation of [%s]", __func__); +} + +/** + * @brief Weak implementation of UT_logPrefix. + * + * This function provides a default, weak implementation that does nothing. + * Override this function by defining your own implementation elsewhere. + * + * @param function Name of the calling function. + * @param line Line number in the source file. + * @param prefix Prefix string to be added before the message. + * @param format Format string for the log message. + * @param ... Variable arguments for the format string. + */ +void __attribute__((weak)) UT_logPrefix(const char *function, int line, const char *prefix, const char *format, ...) +{ + // Default no-op implementation + printf("Weak implementation of [%s]", __func__); +} \ No newline at end of file