Fixed #1 added locally check for reserved IPv4 Ranges

Author: sea5kg

src.wsjcpp/CMakeLists.txt

@@ -14,7 +14,10 @@ set (WSJCPP_LIBRARIES "")
 set (WSJCPP_INCLUDE_DIRS "")
 set (WSJCPP_SOURCES "")
 
-# wsjcpp-core:v0.0.4
+find_package(Threads REQUIRED)
+list (APPEND WSJCPP_LIBRARIES ${CMAKE_THREAD_LIBS_INIT})
+
+# wsjcpp-core:v0.0.5
 list (APPEND WSJCPP_INCLUDE_DIRS "./src.wsjcpp/wsjcpp_core/")
 list (APPEND WSJCPP_SOURCES "./src.wsjcpp/wsjcpp_core/wsjcpp_core.cpp")
 list (APPEND WSJCPP_SOURCES "./src.wsjcpp/wsjcpp_core/wsjcpp_core.h")
@@ -23,6 +26,11 @@ list (APPEND WSJCPP_SOURCES "./src.wsjcpp/wsjcpp_core/wsjcpp_core.h")
 list (APPEND WSJCPP_INCLUDE_DIRS "./src.wsjcpp/nlohmann_json/")
 list (APPEND WSJCPP_SOURCES "./src.wsjcpp/nlohmann_json/json.hpp")
 
+# wsjcpp-validators:v0.0.3
+list (APPEND WSJCPP_INCLUDE_DIRS "./src.wsjcpp/wsjcpp_validators/")
+list (APPEND WSJCPP_SOURCES "./src.wsjcpp/wsjcpp_validators/wsjcpp_validators.h")
+list (APPEND WSJCPP_SOURCES "./src.wsjcpp/wsjcpp_validators/wsjcpp_validators.cpp")
+
 # required-libraries
 list (APPEND WSJCPP_LIBRARIES "-lpthread")
 

src.wsjcpp/wsjcpp_core/wsjcpp.hold.yml

@@ -3,7 +3,7 @@ cmake_cxx_standard: 11
 cmake_minimum_required: 3.0
 
 name: wsjcpp-core
-version: v0.0.4
+version: v0.0.5
 description: Basic Utils for wsjcpp
 issues: https://github.com/wsjcpp/wsjcpp-core/issues
 repositories:
@@ -23,24 +23,24 @@ required-libraries:
 distribution:
   - source-file: src/wsjcpp_core.cpp
     target-file: wsjcpp_core.cpp
-    sha1: "04a9e3c6db3c7190c6589514a4b5957dbb4c366d"
+    sha1: "d892bfee196af88dcada57b39bc6bd65ce2ce075"
     type: "source-code"
   - source-file: src/wsjcpp_core.h
     target-file: wsjcpp_core.h
-    sha1: "1d76447c6880f43f9afeca89111ec64d3574ccb7"
-    type: "source-code"
-  - source-file: "src/unit_tests.cpp"
-    target-file: "unit_tests.cpp"
+    sha1: "8f5e7b7ada06814ed123a08e49acffe2e12d398a"
+    type: "source-code" # todo must be header-file
+  - source-file: "src/wsjcpp_unit_tests.cpp"
+    target-file: "wsjcpp_unit_tests.cpp"
     type: "unit-tests"
-    sha1: "a36d71646ddd6041346909c0481a59299f01f898"
-  - source-file: "src/unit_tests.h"
-    target-file: "unit_tests.h"
+    sha1: "4208e039ec2923636655b3ada79ec223cca7bae2"
+  - source-file: "src/wsjcpp_unit_tests.h"
+    target-file: "wsjcpp_unit_tests.h"
     type: "unit-tests"
-    sha1: "a20248c9801c53519ad847aa19d80460289a5dd1"
-  - source-file: "src/unit_tests_main.cpp"
-    target-file: "unit_tests_main.cpp"
+    sha1: "8d2ec886f23161a639bb2419bb5e4af48278f18b"
+  - source-file: "src/wsjcpp_unit_tests_main.cpp"
+    target-file: "wsjcpp_unit_tests_main.cpp"
     type: "unit-tests"
-    sha1: "81a2b3d7328575c0087fa43000b05a96e278da07"
+    sha1: "2c02fb58f51687eeac2076096b7df698cc246c9d"
 
 unit-tests:
   cases:
@@ -50,7 +50,7 @@ unit-tests:
       description: Check test generate uuid function
     - name: CoreExtractFilename
       description: Check function extract filenane from path
-    - name: IPv4
-      description: Check function isIPv4
-    - name: IPv6
-      description: Check function isIPv6
+    - name: "ToUpper"
+      description: "String to upper"
+    - name: "CreateUuid"
+      description: "Test generation uuids"

src.wsjcpp/wsjcpp_core/wsjcpp_core.cpp

@@ -389,6 +389,14 @@ std::string& WSJCppCore::to_lower(std::string& str) {
     return str;
 }
 
+// ---------------------------------------------------------------------
+// will worked only with latin
+
+std::string WSJCppCore::toUpper(const std::string& str) {
+    std::string sRet = str;
+    std::transform(sRet.begin(), sRet.end(), sRet.begin(), ::toupper);
+    return sRet;
+}
 
 // ---------------------------------------------------------------------
 
@@ -413,40 +421,30 @@ std::string WSJCppCore::createUuid() {
 
 // ---------------------------------------------------------------------
 
-bool WSJCppCore::isIPv4(const std::string& str) {
-    int n = 0;
-    std::string s[4] = {"", "", "", ""};
-    for (int i = 0; i < str.length(); i++) {
-        char c = str[i];
-        if (n > 3) {
-            return false;
-        }
-        if (c >= '0' && c <= '9') {
-            s[n] += c;
-        } else if (c == '.') {
-            n++;
-        } else {
-            return false;
-        }
-    }
-    for (int i = 0; i < 4; i++) {
-        if (s[i].length() > 3) {
-            return false;
-        }
-        int p = std::stoi(s[i]);
-        if (p > 255 || p < 0) {
-            return false;
-        }
-    }
-    return true;
+unsigned long WSJCppCore::convertVoidToULong(void *p) {
+    unsigned long ret = *(unsigned long *)p;
+    return ret;
+}
+
+// ---------------------------------------------------------------------
+
+std::string WSJCppCore::getPointerAsHex(void *p) {
+    std::uintptr_t i = reinterpret_cast<std::uintptr_t>(p);
+    std::stringstream stream;
+    stream << std::hex << i;
+    return "0x" + std::string(stream.str());
 }
 
 // ---------------------------------------------------------------------
 
-bool WSJCppCore::isIPv6(const std::string& str) {
-    unsigned char buf[sizeof(struct in6_addr)];
-    bool isValid = inet_pton(AF_INET6, str.c_str(), buf);
-    return isValid;
+std::string WSJCppCore::extractURLProtocol(const std::string& sValue) {
+    std::string sRet = "";
+    int nPosProtocol = sValue.find("://");
+    if (nPosProtocol == std::string::npos) {
+        return sRet;
+    }
+    sRet = sValue.substr(0, nPosProtocol);
+    return sRet;
 }
 
 // ---------------------------------------------------------------------
@@ -511,6 +509,18 @@ void WSJCppLog::ok(const std::string &sTag, const std::string &sMessage) {
 
 // ---------------------------------------------------------------------
 
+std::vector<std::string> WSJCppLog::getLastLogMessages() {
+    WSJCppLog::initGlobalVariables();
+    std::lock_guard<std::mutex> lock(*WSJCppLog::g_WSJCPP_LOG_MUTEX);
+    std::vector<std::string> vRet;
+    for (int i = 0; i < g_WSJCPP_LOG_LAST_MESSAGES->size(); i++) {
+        vRet.push_back(g_WSJCPP_LOG_LAST_MESSAGES->at(i));
+    }
+    return vRet;
+}
+
+// ---------------------------------------------------------------------
+
 void WSJCppLog::setLogDirectory(const std::string &sDirectoryPath) {
     WSJCppLog::g_WSJCPP_LOG_DIR = sDirectoryPath;
     WSJCppLog::doLogRotateUpdateFilename(true);

src.wsjcpp/wsjcpp_core/wsjcpp_core.h

@@ -45,11 +45,14 @@ class WSJCppCore {
         static std::string& rtrim(std::string& str, const std::string& chars = "\t\n\v\f\r ");
         static std::string& trim(std::string& str, const std::string& chars = "\t\n\v\f\r ");
         static std::string& to_lower(std::string& str);
+        static std::string toUpper(const std::string& str);
 
         static void initRandom();
         static std::string createUuid();
-        static bool isIPv4(const std::string& str);
-        static bool isIPv6(const std::string& str);
+
+        static unsigned long convertVoidToULong(void *p);
+        static std::string getPointerAsHex(void *p);
+        static std::string extractURLProtocol(const std::string& sValue);
 };
 
 
@@ -96,6 +99,7 @@ class WSJCppLog {
         static void throw_err(const std::string &sTag, const std::string &sMessage);
         static void warn(const std::string &sTag, const std::string &sMessage);
         static void ok(const std::string &sTag, const std::string &sMessage);
+        static std::vector<std::string> getLastLogMessages();
         static void setLogDirectory(const std::string &sDirectoryPath);
         static void setPrefixLogFile(const std::string &sPrefixLogFile);
         static void initGlobalVariables();

src.wsjcpp/wsjcpp_core/unit_tests.cpp renamed to src.wsjcpp/wsjcpp_core/wsjcpp_unit_tests.cpp

@@ -1,20 +1,20 @@
-#include "unit_tests.h"
+#include "wsjcpp_unit_tests.h"
 
-UnitTestBase::UnitTestBase(const std::string &sTestName) {
+WSJCppUnitTestBase::WSJCppUnitTestBase(const std::string &sTestName) {
     m_sTestName = sTestName;
     TAG = m_sTestName;
-    UnitTests::addUnitTest(sTestName, this);
+    WSJCppUnitTests::addUnitTest(sTestName, this);
 }
 
 // ---------------------------------------------------------------------
 
-std::string UnitTestBase::name() {
+std::string WSJCppUnitTestBase::name() {
     return m_sTestName;
 }
 
 // ---------------------------------------------------------------------
 
-void UnitTestBase::compareS(bool &bTestSuccess, const std::string &sPoint,
+void WSJCppUnitTestBase::compareS(bool &bTestSuccess, const std::string &sPoint,
     const std::string &sValue, const std::string &sExpected) {
     if (sValue != sExpected) {
         WSJCppLog::err(TAG, " {" + sPoint + "} Expected '" + sExpected + "', but got '" + sValue + "'");
@@ -24,7 +24,7 @@ void UnitTestBase::compareS(bool &bTestSuccess, const std::string &sPoint,
 
 // ---------------------------------------------------------------------
 
-bool UnitTestBase::compareN(bool &bTestSuccess, const std::string &sPoint, int nValue, int nExpected) {
+bool WSJCppUnitTestBase::compareN(bool &bTestSuccess, const std::string &sPoint, int nValue, int nExpected) {
     if (nValue != nExpected) {
         WSJCppLog::err(TAG, " {" + sPoint + "} Expected '" + std::to_string(nExpected) + "', but got '" + std::to_string(nValue) + "'");
         bTestSuccess = false;
@@ -35,7 +35,7 @@ bool UnitTestBase::compareN(bool &bTestSuccess, const std::string &sPoint, int n
 
 // ---------------------------------------------------------------------
 
-bool UnitTestBase::compareD(bool &bTestSuccess, const std::string &sPoint, double nValue, double nExpected) {
+bool WSJCppUnitTestBase::compareD(bool &bTestSuccess, const std::string &sPoint, double nValue, double nExpected) {
     if (nValue != nExpected) {
         WSJCppLog::err(TAG, " {" + sPoint + "} Expected '" + std::to_string(nExpected) + "', but got '" + std::to_string(nValue) + "'");
         bTestSuccess = false;
@@ -46,7 +46,7 @@ bool UnitTestBase::compareD(bool &bTestSuccess, const std::string &sPoint, doubl
 
 // ---------------------------------------------------------------------
 
-void UnitTestBase::compareB(bool &bTestSuccess, const std::string &sPoint, bool bValue, bool bExpected) {
+void WSJCppUnitTestBase::compareB(bool &bTestSuccess, const std::string &sPoint, bool bValue, bool bExpected) {
     if (bValue != bExpected) {
         WSJCppLog::err(TAG, " {" + sPoint + "} Expected '" + (bExpected ? "true" : "false") + "', but got '" + (bValue ? "true" : "false") + "'");
         bTestSuccess = false;
@@ -55,22 +55,22 @@ void UnitTestBase::compareB(bool &bTestSuccess, const std::string &sPoint, bool
 
 // ---------------------------------------------------------------------
 
-std::vector<UnitTestBase*> *g_pUnitTests = NULL;
+std::vector<WSJCppUnitTestBase*> *g_pUnitTests = NULL;
 
-void UnitTests::initGlobalVariables() {
+void WSJCppUnitTests::initGlobalVariables() {
     if (g_pUnitTests == NULL) {
         // Log::info(std::string(), "Create handlers map");
-        g_pUnitTests = new std::vector<UnitTestBase*>();
+        g_pUnitTests = new std::vector<WSJCppUnitTestBase*>();
     }
 }
 
 // ---------------------------------------------------------------------
 
-void UnitTests::addUnitTest(const std::string &sTestName, UnitTestBase* pUnitTest) {
-    UnitTests::initGlobalVariables();
+void WSJCppUnitTests::addUnitTest(const std::string &sTestName, WSJCppUnitTestBase* pUnitTest) {
+    WSJCppUnitTests::initGlobalVariables();
     bool bFound = false;
     for (int i = 0; i < g_pUnitTests->size(); i++) {
-        UnitTestBase* p = g_pUnitTests->at(i);
+        WSJCppUnitTestBase* p = g_pUnitTests->at(i);
         if (p->name() == sTestName) {
             bFound = true;
         }
@@ -86,13 +86,13 @@ void UnitTests::addUnitTest(const std::string &sTestName, UnitTestBase* pUnitTes
 
 // ---------------------------------------------------------------------
 
-bool UnitTests::runUnitTests() {
-    UnitTests::initGlobalVariables();
+bool WSJCppUnitTests::runUnitTests() {
+    WSJCppUnitTests::initGlobalVariables();
     int nAll = g_pUnitTests->size();
     WSJCppLog::info("runUnitTests",  "All tests count " + std::to_string(nAll));
     int nSuccess = 0;
     for (int i = 0; i < g_pUnitTests->size(); i++) {
-        UnitTestBase* pUnitTest = g_pUnitTests->at(i);
+        WSJCppUnitTestBase* pUnitTest = g_pUnitTests->at(i);
         std::string sTestName = pUnitTest->name();
         WSJCppLog::info("runUnitTests",  "Run test " + sTestName);
         if (pUnitTest->run()) {
@@ -102,7 +102,7 @@ bool UnitTests::runUnitTests() {
             WSJCppLog::err(sTestName,  "Test failed");
         }
     }
-    WSJCppLog::info("runUnitTests",  "Passed tests " + std::to_string(nSuccess) + " / " + std::to_string(nAll));
+    WSJCppLog::info("WSJCpp::runUnitTests",  "Passed tests " + std::to_string(nSuccess) + " / " + std::to_string(nAll));
     return nSuccess == nAll;
 }
 

src.wsjcpp/wsjcpp_core/unit_tests.h renamed to src.wsjcpp/wsjcpp_core/wsjcpp_unit_tests.h

@@ -1,13 +1,13 @@
-#ifndef UNIT_TESTS_H
-#define UNIT_TESTS_H
+#ifndef WSJCPP_UNIT_TESTS_H
+#define WSJCPP_UNIT_TESTS_H
 
 #include <map>
 #include <vector>
 #include <wsjcpp_core.h>
 
-class UnitTestBase {
+class WSJCppUnitTestBase {
     public:
-        UnitTestBase(const std::string &sTestName);
+        WSJCppUnitTestBase(const std::string &sTestName);
         std::string name();
         virtual void init() = 0;
         virtual bool run() = 0;
@@ -23,18 +23,18 @@ class UnitTestBase {
         std::string m_sTestName;
 };
 
-extern std::vector<UnitTestBase*> *g_pUnitTests;
+extern std::vector<WSJCppUnitTestBase*> *g_pUnitTests;
 
-class UnitTests {
+class WSJCppUnitTests {
     public:
         static void initGlobalVariables();
-        static void addUnitTest(const std::string &sTestName, UnitTestBase* pCmdHandler);
+        static void addUnitTest(const std::string &sTestName, WSJCppUnitTestBase* pCmdHandler);
         static bool runUnitTests();
 };
 
 // RegistryCmdHandler
 #define REGISTRY_UNIT_TEST( classname ) \
-    static classname * pRegistryUnitTest ## classname = new classname(); \
+    static classname * pRegistryWSJCppUnitTest ## classname = new classname(); \
 
 
-#endif // UNIT_TESTS_H
+#endif // WSJCPP_UNIT_TESTS_H

src.wsjcpp/wsjcpp_core/unit_tests_main.cpp renamed to src.wsjcpp/wsjcpp_core/wsjcpp_unit_tests_main.cpp

@@ -1,6 +1,6 @@
 #include <string>
 #include <wsjcpp_core.h>
-#include <unit_tests.h>
+#include <wsjcpp_unit_tests.h>
 
 int main(int argc, char** argv) {
     WSJCppCore::initRandom();
@@ -16,7 +16,7 @@ int main(int argc, char** argv) {
         return -1;
     }
 
-    if (!UnitTests::runUnitTests()) {
+    if (!WSJCppUnitTests::runUnitTests()) {
         WSJCppLog::err(TAG, "Some unit tests failed");
         return -1;
     }