Added google test to demo

.github/workflows/cmake-multi-platform.yml

@@ -0,0 +1,75 @@
+# This starter workflow is for a CMake project running on multiple platforms. There is a different starter workflow if you just want a single platform.
+# See: https://github.com/actions/starter-workflows/blob/main/ci/cmake-single-platform.yml
+name: CMake on multiple platforms
+
+on:
+  push:
+    branches: [ "*" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      # Set fail-fast to false to ensure that feedback is delivered for all matrix combinations. Consider changing this to true when your workflow is stable.
+      fail-fast: false
+
+      # Set up a matrix to run the following 3 configurations:
+      # 1. <Windows, Release, latest MSVC compiler toolchain on the default runner image, default generator>
+      # 2. <Linux, Release, latest GCC compiler toolchain on the default runner image, default generator>
+      # 3. <Linux, Release, latest Clang compiler toolchain on the default runner image, default generator>
+      #
+      # To add more build types (Release, Debug, RelWithDebInfo, etc.) customize the build_type list.
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+        build_type: [Release]
+        c_compiler: [gcc, clang, cl]
+        include:
+          - os: windows-latest
+            c_compiler: cl
+            cpp_compiler: cl
+          - os: ubuntu-latest
+            c_compiler: gcc
+            cpp_compiler: g++
+          - os: ubuntu-latest
+            c_compiler: clang
+            cpp_compiler: clang++
+        exclude:
+          - os: windows-latest
+            c_compiler: gcc
+          - os: windows-latest
+            c_compiler: clang
+          - os: ubuntu-latest
+            c_compiler: cl
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Set reusable strings
+      # Turn repeated input strings (such as the build output directory) into step outputs. These step outputs can be used throughout the workflow file.
+      id: strings
+      shell: bash
+      run: |
+        echo "build-output-dir=${{ github.workspace }}/build" >> "$GITHUB_OUTPUT"
+
+    - name: Configure CMake
+      # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
+      # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
+      run: >
+        cmake -B ${{ steps.strings.outputs.build-output-dir }}
+        -DCMAKE_CXX_COMPILER=${{ matrix.cpp_compiler }}
+        -DCMAKE_C_COMPILER=${{ matrix.c_compiler }}
+        -DCMAKE_BUILD_TYPE=${{ matrix.build_type }}
+        -S ${{ github.workspace }}
+
+    - name: Build
+      # Build your program with the given configuration. Note that --config is needed because the default Windows generator is a multi-config generator (Visual Studio generator).
+      run: cmake --build ${{ steps.strings.outputs.build-output-dir }} --config ${{ matrix.build_type }}
+
+    - name: Test
+      working-directory: ${{ steps.strings.outputs.build-output-dir }}
+      # Execute tests defined by the CMake configuration. Note that --build-config is needed because the default Windows generator is a multi-config generator (Visual Studio generator).
+      # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
+      run: ctest --build-config ${{ matrix.build_type }}

.gitignore

@@ -9,3 +9,5 @@ install_manifest.txt
 compile_commands.json
 CTestTestfile.cmake
 _deps
+build
+/.vs

CMakeLists.txt

@@ -1,10 +1,8 @@
-# FILEPATH: /C:/Users/green/source/repos/callbackDemo/c_library/CMakeLists.txt
-
-# Set the minimum version of CMake required to build the project
 cmake_minimum_required(VERSION 3.20)
 
 # Set the name of the project and the language it is written in
-project(C_Callback C)
+# CXX is included because we are using googletest.
+project(C_Callback C CXX)
 
 # create a shared library
 add_library(C_Callback SHARED)
@@ -13,4 +11,9 @@ add_library(C_Callback SHARED)
 target_include_directories(C_Callback PUBLIC include)
 
 # add the sources to the library
-target_sources(C_Callback PRIVATE src/C_Callback.c)
+target_sources(C_Callback PUBLIC src/C_Callback.c)
+
+# Add the tests
+include(CTest)
+add_subdirectory(tests)
+

include/C_Callback.h

@@ -1,16 +1,35 @@
 #ifndef CALLBACK_DEMO_H
 #define CALLBACK_DEMO_H
 
-typedef const char* (*CallbackFunction)(int, char*, size_t);
+#ifdef _WIN32
+#define DLL_EXPORT __declspec(dllexport)
+#else
+#define DLL_EXPORT
+#endif
+
+DLL_EXPORT void YourFunction();  // Example function declaration
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef const void (*CallbackFunction)(int, char*, size_t);
 
 // Simple function that prints a number to the console
-void printNumberInDec(int number, char* buffer, size_t bufferSize);
+DLL_EXPORT CallbackFunction printNumberInDec(int number, char* buffer, size_t bufferSize);
 
 // Simple function that prints a number to the console in hex
-void printNumberInHex(int number, char* buffer, size_t bufferSize);
+DLL_EXPORT CallbackFunction printNumberInHex(int number, char* buffer, size_t bufferSize);
 
 // Function that takes a function pointer as an argument and
 // set the callback function to the one passed in
-void setCallback(CallbackFunction callback);
+DLL_EXPORT void setCallback(CallbackFunction callback);
+
+// Run the callback function with the given number
+DLL_EXPORT void runCallback(int number, char* buffer, size_t bufferSize);
+
+#ifdef __cplusplus
+} 
+#endif
 
-#endif // CALLBACK_DEMO_H
+#endif // CALLBACK_DEMO_H

src/C_Callback.c

@@ -7,15 +7,15 @@
 static CallbackFunction callbackFunction = NULL;
 
 // Print a number to a string
-void printNumberInDec(int number, char* buffer, size_t bufferSize)
+CallbackFunction printNumberInDec(int number, char* buffer, size_t bufferSize)
 {
     snprintf(buffer, bufferSize, "Number: %d\n", number);
 }
 
 // Prints a number to a string in hex
-void printNumberInHex(int number, char* buffer, size_t bufferSize)
+CallbackFunction printNumberInHex(int number, char* buffer, size_t bufferSize)
 {
-    snprintf(buffer, bufferSize, "Number: 0x%x\n", number);
+    snprintf(buffer, bufferSize, "Number: 0x%X\n", number);
 }
 
 // Function that takes a function pointer as an argument and 
@@ -35,4 +35,4 @@ void runCallback(int number, char* buffer, size_t bufferSize)
     {
         snprintf(buffer, bufferSize, "No callback function set\n");
     }
-}
+}

tests/CMakeLists.txt

@@ -0,0 +1,23 @@
+cmake_minimum_required(VERSION 3.20)
+
+# fetch google test to use for testing
+include(FetchContent)
+
+FetchContent_Declare(
+  googletest
+  GIT_REPOSITORY https://github.com/google/googletest.git
+  GIT_TAG        v1.14.0
+)
+
+FetchContent_MakeAvailable(googletest)
+
+# Add test executables
+add_executable(self_test self_test.cpp)
+add_executable(C_Callback_test test_C_Callback.cpp)
+
+# Link against google test and the C_Callback library
+target_link_libraries(self_test gtest_main C_Callback)
+target_link_libraries(C_Callback_test gtest_main C_Callback)
+
+add_test(NAME self_test COMMAND self_test)
+add_test(NAME C_Callback_test COMMAND C_Callback_test)

tests/self_test.cpp

@@ -0,0 +1,7 @@
+#include <gtest/gtest.h>
+
+TEST(SelfTest, Test1) {
+    EXPECT_EQ(1, 1);
+    EXPECT_TRUE(true);
+    EXPECT_FALSE(false);
+}

tests/test_C_Callback.cpp

@@ -0,0 +1,55 @@
+#include <stdio.h>
+#include <string.h>
+#include <gtest/gtest.h>
+#include <C_Callback.h>
+
+// Test printNumberInDec function
+TEST(C_Callback, testPrintNumberInDec)
+{
+    char buffer[100];
+    int number = 42;
+    printNumberInDec(number, buffer, sizeof(buffer));
+    printf("PrintNumberInDec: %s\n", buffer);
+    // Add assertions to check the output
+    ASSERT_STREQ(buffer, "Number: 42\n");
+}
+
+// Test printNumberInHex function
+TEST(C_Callback, testPrintNumberInHex)
+{
+    char buffer[100];
+    int number = 42;
+    printNumberInHex(number, buffer, sizeof(buffer));
+    printf("PrintNumberInHex: %s\n", buffer);
+    // Add assertions to check the output
+    ASSERT_STREQ(buffer, "Number: 0x2A\n");
+
+}
+
+ // Test setCallback and runCallback functions
+ TEST(C_Callback, testCallbackFunctions)
+ {
+     char buffer[100];
+     int number = 42;
+
+     // Test when callback function is not set
+     setCallback(NULL);
+     runCallback(number, buffer, sizeof(buffer));
+     printf("Callback Function (NULL): %s\n", buffer);
+     // Add assertions to check the output
+     ASSERT_STREQ(buffer, "No callback function set\n");
+
+     // Test when callback function is set
+     setCallback((CallbackFunction) printNumberInDec);
+     runCallback(number, buffer, sizeof(buffer));
+     printf("Callback Function (printNumberInDec): %s\n", buffer);
+     // Add assertions to check the output
+     ASSERT_STREQ(buffer, "Number: 42\n");
+
+     // Test when callback function is set
+     setCallback((CallbackFunction)printNumberInHex);
+     runCallback(number, buffer, sizeof(buffer));
+     printf("Callback Function (printNumberInDec): %s\n", buffer);
+     // Add assertions to check the output
+     ASSERT_STREQ(buffer, "Number: 0x2A\n");
+ }