Merge pull request #9 from martelkr/6-add-gtest-and-ctest-usage

6 add gtest and ctest usage

Author: martelkr

.github/workflows/clang.yml

@@ -0,0 +1,41 @@
+name: cmake
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+env:
+  # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
+  BUILD_TYPE: Release
+
+jobs:
+  Linux-clang:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Install gtest manually
+      run: sudo apt-get install libgtest-dev && cd /usr/src/gtest && sudo cmake CMakeLists.txt && sudo make && sudo cp lib/*.a /usr/lib && sudo ln -s /usr/lib/libgtest.a /usr/local/lib/libgtest.a && sudo ln -s /usr/lib/libgtest_main.a /usr/local/lib/libgtest_main.a
+
+    - name: Write files
+      env: 
+        FILE_ONE: ${{ secrets.KRM_MAIN_FILE }}
+        FILE_TWO: ${{ secrets.KRM_SCND_FILE }}
+      run: |
+        echo "${FILE_ONE}" | base64 --decode > ${HOME}/key.pem |
+        echo "${FILE_TWO}" | base64 --decode > ${HOME}/scert.crt
+
+    - name: Build and Test
+      run: |
+        cmake . -B ${{github.workspace}}/build -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++
+        cmake --build ${{github.workspace}}/build
+        ctest -VV --test-dir ${{github.workspace}}/build
+
+    - name: Generate a code coverage report
+      uses: threeal/gcovr-action@latest
+      with:
+        gcov-executable: llvm-cov gcov
+  

.github/workflows/cmake.yml

@@ -1,4 +1,4 @@
-name: CMake
+name: cmake
 
 on:
   push:
@@ -11,27 +11,66 @@ env:
   BUILD_TYPE: Release
 
 jobs:
-  build:
-    # The CMake configure and build commands are platform agnostic and should work equally well on Windows or Mac.
-    # You can convert this to a matrix build if you need cross-platform coverage.
-    # See: https://docs.github.com/en/free-pro-team@latest/actions/learn-github-actions/managing-complex-workflows#using-a-build-matrix
+  Linux:
     runs-on: ubuntu-latest
 
     steps:
     - uses: actions/checkout@v3
 
-    - 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 ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}}
+    - name: Install gtest
+      run: sudo apt-get install libgtest-dev && cd /usr/src/gtest && sudo cmake CMakeLists.txt && sudo make && sudo cp lib/*.a /usr/lib && sudo ln -s /usr/lib/libgtest.a /usr/local/lib/libgtest.a && sudo ln -s /usr/lib/libgtest_main.a /usr/local/lib/libgtest_main.a
 
-    - name: Build
-      # Build your program with the given configuration
-      run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
+    - name: Write files
+      env: 
+        FILE_ONE: ${{ secrets.KRM_MAIN_FILE }}
+        FILE_TWO: ${{ secrets.KRM_SCND_FILE }}
+      run: |
+        echo "${FILE_ONE}" | base64 --decode > ${HOME}/key.pem |
+        echo "${FILE_TWO}" | base64 --decode > ${HOME}/scert.crt
 
-    - name: Test
-      working-directory: ${{github.workspace}}/build
-      # Execute tests defined by the CMake configuration.
-      # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
-      run: ctest -C ${{env.BUILD_TYPE}}
+    - name: Build and test
+      run: |
+          cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}}
+          cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
+          ctest -VV --test-dir ${{github.workspace}}/build -C ${{env.BUILD_TYPE}}
 
+  Windows:
+    runs-on: windows-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - uses: ilammy/setup-nasm@v1
+    - uses: ilammy/msvc-dev-cmd@v1
+
+    - name: Write files
+      env: 
+        FILE_ONE: ${{ secrets.KRM_WIN_MAIN_FILE }}
+        FILE_TWO: ${{ secrets.KRM_WIN_SCND_FILE }}
+      shell: bash
+      run: |
+        echo "${FILE_ONE}" | openssl base64 -d > ${HOME}/privatekey.key |
+        echo "${FILE_TWO}" | openssl base64 -d > ${HOME}/certificate.crt
+
+    - name: Clone openssl
+      uses: actions/checkout@v3
+      with:
+        repository: openssl/openssl
+        path: D:/a/cppsocket/cppsocket/openssl
+        ref: openssl-3.1.0
+
+    - name: Build and install OpenSSL
+      working-directory: D:/a/cppsocket/cppsocket/openssl
+      run: |
+          perl Configure VC-WIN64A
+          nmake
+          nmake install
+
+    - name: Install gtest
+      uses: MarkusJx/googletest-installer@v1.1.1
+
+    - name: Build and Test
+      run: |
+          cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}}
+          cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
+          ctest -VV --test-dir ${{github.workspace}}/build -C ${{env.BUILD_TYPE}}
+  

.github/workflows/profile.yml

@@ -0,0 +1,42 @@
+name: cmake
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+env:
+  # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
+  BUILD_TYPE: Release
+
+jobs:
+  Profile:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+
+    - name: Install gtest
+      run: sudo apt-get install libgtest-dev && cd /usr/src/gtest && sudo cmake CMakeLists.txt && sudo make && sudo cp lib/*.a /usr/lib && sudo ln -s /usr/lib/libgtest.a /usr/local/lib/libgtest.a && sudo ln -s /usr/lib/libgtest_main.a /usr/local/lib/libgtest_main.a
+
+    - name: Write files
+      env: 
+        FILE_ONE: ${{ secrets.KRM_MAIN_FILE }}
+        FILE_TWO: ${{ secrets.KRM_SCND_FILE }}
+      run: |
+        echo "${FILE_ONE}" | base64 --decode > ${HOME}/key.pem |
+        echo "${FILE_TWO}" | base64 --decode > ${HOME}/scert.crt
+
+    - name: Profile build and test
+      run: |
+          cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=PROFILE .
+          cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
+          ctest -VV ${{github.workspace}}/build -C ${{env.BUILD_TYPE}}
+
+    - name: Generate Test Report
+      uses: threeal/gcovr-action@latest
+      with:
+        coveralls-send: true
+        github-token: ${{ secrets.GITHUB_TOKEN }}
+  

.gitignore

@@ -42,7 +42,12 @@ CMakeLists.txt
 *.vcxproj*
 *.sln
 test/Debug
+test/Release
 test/bin
 x64
 /bin
-test/testcppsocket.dir
+test/testcppsocket.dir
+CTestTestfile.cmake
+test/CTestTestfile.cmake
+Testing
+test/Testing

CMakeLists.txt

@@ -13,10 +13,13 @@ project(cppsocket VERSION ${project_version} LANGUAGES CXX)
 
 if (CMAKE_COMPILER_IS_GNUCXX)
     add_definitions(-DLINUX)
+elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+    add_definitions(-DLINUX)
 else()
     add_definitions(-DWINDOWS)
 endif()
 
 include_directories(inc)
 
+enable_testing()
 add_subdirectory(test)

README.md

@@ -1,15 +1,25 @@
-# TCP C++ client/server with SSL/TLS support (header file only)
+# C++ client/server with SSL/TLS support (header file only)
 [![MIT license](https://img.shields.io/badge/license-MIT-blue.svg)](http://opensource.org/licenses/MIT)
-![Cmake Build](https://github.com/martelkr/cppsocket/actions/workflows/cmake.yml/badge.svg)
+![cmake Build](https://github.com/martelkr/cppsocket/actions/workflows/cmake.yml/badge.svg)
+![clang Build](https://github.com/martelkr/cppsocket/actions/workflows/clang.yml/badge.svg)
+[![Coverage Status](https://coveralls.io/repos/github/martelkr/cppsocket/badge.svg)](https://coveralls.io/github/martelkr/cppsocket)
 
 ## About
-This is a header file only implementation of a C++ TCP client/server with or without SSL/TLS for Linux only.
+This is a header file only implementation of a C++ client/server with or without SSL/TLS/DTLS.
 The implementation uses OpenSSL and BSD API to implement the underlying socket interfaces.
 
 Compilation has been tested with:
 - GCC 11.3.0 (GNU/Linux Ubuntu 22.04.1 LTS)
+	- cmake 3.22.1
+	- googletest 1.11.0-3
+- Visual Studio Community 2022 17.4.4 (64-bit) (Windows 11)
+	- cmake 3.26.0-rc1
+	- googletest 1.13.0
 
 ## Usage
+
+### TCP server/client
+
 Create a TCP server object for accepting TCP connections. 
 
 ```cpp
@@ -20,7 +30,7 @@ TCPServer(void);
 TCPServer(const std::string& keyFile, const std::string& certFile); 
 
 // No SSL and IP/port bound
-explicit TCPServer(const uint16_t port, const std::string& ip = "", const int backlog = 3); 
+explicit TCPServer(const uint16_t port, const std::string& ip = "0.0.0.0", const int backlog = 3); 
 
 /// SSL and IP/port bound
 TCPServer(const uint16_t port, const std::string& ip, const std::string& keyFile, const std::string& certFile, const int backlog = 3);
@@ -39,7 +49,7 @@ For a BSD-like approach, the following sequence can be followed:
 // Server
 
 // create server socket
-TCPServer s;
+TCPServer s; // add key file and cert file here for secure connection
 
 // bind to port 54321 on IP 0.0.0.0
 s.bindAndListen(54321); 
@@ -51,20 +61,82 @@ TCPClient c = s.accept();
 // Client
 
 // Connect to TCP server on IP 127.0.0.1 and port 54321
-TCPClient c("127.0.0.1", 54321);
+TCPClient c("127.0.0.1", 54321); // add key file and cert file here for secure connection
+```
+
+### UDP server/client
+
+Create a UDP server object for accepting UDP connections. 
+
+```cpp
+// default constructor creates unbound unsecure UDP server socket
+UDPServer(void);
+
+// default DTLS constructor create unbound UDP server socket ready for DTLS
+// NOTE: UDPServer s("", ""); results in unbound unsecure UDP server socket
+UDPServer(const std::string& keyFile, const std::string& certFile);
+
+// creates unsecure UDP server socket bound to specific port and IP address (default all host IP)
+explicit UDPServer(const uint16_t port, const std::string& ip = "0.0.0.0");
+
+// creates bound UDP server socket ready for DTLS
+// NOTE: UDPServer s("", ""); results in unbound unsecure UDP server socket
+UDPServer(const uint16_t port, const std::string& ip, const std::string& keyFile, const std::string& certFile);
+```
+
+Create a UDP client object to connect to a known UDP server.
+
+```cpp
+
+// default constructor creates unconnected UDP client socket
+UDPClient(void);
+
+// creates UDP client socket connected to UDP server
+UDPClient(const std::string& remoteIp, const uint16_t remotePort);
+
+// creates unconnected UDP client socket for DTLS communication
+UDPClient(const std::string& keyFile, const std::string& certFile);
+
+// created UDP client socket connected to UDP server using DTLS
+UDPClient(const std::string& remoteIp, const uint16_t remotePort, const std::string& keyFile, const std::string& certFile);
+```
+
+For a BSD-like approach, the following sequence can be followed:
+
+```cpp
+// Server
+
+// create server socket
+UDPServer s; // add key file and cert file here for secure connection
+
+// bind to port 54321 on IP 0.0.0.0
+s.bind(54321); 
+
+// following not needed for unsecure connection but is needed for DTLS connection
+s.accept();
+```
+
+```cpp
+// Client
+
+// Connect to UDP server on IP 127.0.0.1 and port 54321
+UDPClient c("127.0.0.1", 54321); // add key file and cert file here for secure connection
 ```
 
 ## Thread Safety
 
-Do not share TCPClient objects across threads unless you provide your own thread safety on the send/read calls.
+Do not share TCPClient, UDPClient or UDPServer objects across threads unless you provide your own thread safety on the send/read calls.
 
 ## Installation
 
 Use the `cppsocket.hpp` file in your source tree and include it in the file that need to use it.
 
 ## Run Unit Tests
 
-There are two basic unit tests included in `test/TestCppSocket.cpp` to test basic data passing for secure and unsecure TCP sockets.
+Unit tests run with ctest:
+```
+ctest -C debug
+```
 
 ## CppCheck Compliancy