step one project reorganization

slsSupportLib/tests/CMakeLists.txt

@@ -0,0 +1,26 @@
+
+
+include_directories(
+    ${PROJECT_SOURCE_DIR}/catch
+    ../include
+)
+
+set(SOURCES
+    test.cpp
+    test-CmdLineParser.cpp
+    test-container_utils.cpp
+    test-string_utils.cpp
+    test-Timer.cpp
+)
+
+add_executable(testSlsSupportLib ${SOURCES})
+target_link_libraries(testSlsSupportLib 
+    slsSupportLib
+    pthread
+    rt
+)  
+set_target_properties(testSlsSupportLib PROPERTIES
+        RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+    )
+#TODO! Move to automatic test discovery
+add_test(test-slsSupportLib ${CMAKE_BINARY_DIR}/bin/testSlsSupportLib)

slsSupportLib/tests/test-CmdLineParser.cpp

@@ -0,0 +1,278 @@
+#include "CmdLineParser.h"
+#include "catch.hpp"
+#include <exception>
+#include <string>
+//tests to add
+//help for all docs
+//command for all depreciated commands
+
+TEST_CASE("Parse with no arguments results in no command and default id")
+{
+    //build up argc and argv
+    //first argument is the command used to call the binary
+    int argc = 1;
+    char* argv[argc];
+    char a0[] = "call";
+    argv[0]   = a0;
+
+    CmdLineParser p;
+    p.Parse(argc, argv);
+
+    REQUIRE(p.detector_id() == -1);
+    REQUIRE(p.multi_id() == 0);
+    REQUIRE(p.command() == std::string(""));
+    REQUIRE(p.arguments().size() == 0);
+}
+
+TEST_CASE("Parse empty string")
+{
+    std::string s = "";
+    CmdLineParser p;
+    p.Parse(s);
+
+    REQUIRE(p.detector_id() == -1);
+    REQUIRE(p.multi_id() == 0);
+    REQUIRE(p.command() == std::string(""));
+    REQUIRE(p.arguments().size() == 0);
+}
+
+TEST_CASE("Parse a command without client id and detector id results in default")
+{
+    int argc = 2;
+    char* argv[argc];
+    char a0[] = "call";
+    char a1[] = "vrf";
+    argv[0]   = a0;
+    argv[1]   = a1;
+
+    CmdLineParser p;
+    p.Parse(argc, argv);
+
+    REQUIRE(p.detector_id() == -1);
+    REQUIRE(p.multi_id() == 0);
+    REQUIRE(p.command() == std::string("vrf"));
+    REQUIRE(p.arguments().size() == 0);
+}
+
+TEST_CASE("Parse a string without client id and detector id results in default")
+{
+    std::string s = "vrf";
+    CmdLineParser p;
+    p.Parse(s);
+
+    REQUIRE(p.detector_id() == -1);
+    REQUIRE(p.multi_id() == 0);
+    REQUIRE(p.command() == std::string("vrf"));
+    REQUIRE(p.arguments().size() == 0);
+}
+
+TEST_CASE("Parse a command with value but without client or detector id")
+{
+    int argc = 3;
+    char* argv[argc];
+    char a0[] = "call";
+    char a1[] = "vrf";
+    char a2[] = "3000";
+    argv[0]   = a0;
+    argv[1]   = a1;
+    argv[2]   = a2;
+
+    CmdLineParser p;
+    p.Parse(argc, argv);
+
+    REQUIRE(p.detector_id() == -1);
+    REQUIRE(p.multi_id() == 0);
+    REQUIRE(p.command() == std::string("vrf"));
+    REQUIRE(p.arguments().size() == 1);
+    REQUIRE(p.arguments()[0] == std::string("3000"));
+}
+TEST_CASE("Parse a string with value but without client or detector id")
+{
+    std::string s = "vrf 3000\n";
+
+    CmdLineParser p;
+    p.Parse(s);
+
+    REQUIRE(p.detector_id() == -1);
+    REQUIRE(p.multi_id() == 0);
+    REQUIRE(p.command() == std::string("vrf"));
+    REQUIRE(p.arguments().size() == 1);
+    REQUIRE(p.arguments()[0] == std::string("3000"));
+}
+
+TEST_CASE("Decodes position")
+{
+    int argc = 2;
+    char* argv[argc];
+    char a0[] = "call";
+    char a1[] = "7:vrf";
+    argv[0]   = a0;
+    argv[1]   = a1;
+
+    CmdLineParser p;
+    p.Parse(argc, argv);
+
+    REQUIRE(p.detector_id() == 7);
+    REQUIRE(p.multi_id() == 0);
+    REQUIRE(p.command() == std::string("vrf"));
+    REQUIRE(p.arguments().size() == 0);
+}
+TEST_CASE("Decodes position from string")
+{
+    std::string s =  "7:vrf\n";
+
+    CmdLineParser p;
+    p.Parse(s);
+
+    REQUIRE(p.detector_id() == 7);
+    REQUIRE(p.multi_id() == 0);
+    REQUIRE(p.command() == std::string("vrf"));
+    REQUIRE(p.arguments().size() == 0);
+}
+
+TEST_CASE("Decodes double digit position")
+{
+    int argc = 2;
+    char* argv[argc];
+    char a0[] = "call";
+    char a1[] = "73:vcmp";
+    argv[0]   = a0;
+    argv[1]   = a1;
+
+    CmdLineParser p;
+    p.Parse(argc, argv);
+
+    REQUIRE(p.detector_id() == 73);
+    REQUIRE(p.multi_id() == 0);
+    REQUIRE(p.command() == std::string("vcmp"));
+    REQUIRE(p.arguments().size() == 0);
+}
+
+TEST_CASE("Decodes double digit position from string")
+{
+
+    std::string s = "73:vcmp";
+    CmdLineParser p;
+    p.Parse(s);
+
+    REQUIRE(p.detector_id() == 73);
+    REQUIRE(p.multi_id() == 0);
+    REQUIRE(p.command() == std::string("vcmp"));
+    REQUIRE(p.arguments().size() == 0);
+}
+
+TEST_CASE("Decodes position and id")
+{
+    int argc = 2;
+    char* argv[argc];
+    char a0[] = "call";
+    char a1[] = "5-8:vrf";
+    argv[0]   = a0;
+    argv[1]   = a1;
+
+    CmdLineParser p;
+    p.Parse(argc, argv);
+
+    REQUIRE(p.detector_id() == 8);
+    REQUIRE(p.multi_id() == 5);
+    REQUIRE(p.command() == std::string("vrf"));
+    REQUIRE(p.arguments().size() == 0);
+}
+TEST_CASE("Decodes position and id from string")
+{
+
+    std::string s = "5-8:vrf";
+
+
+    CmdLineParser p;
+    p.Parse(s);
+
+    REQUIRE(p.detector_id() == 8);
+    REQUIRE(p.multi_id() == 5);
+    REQUIRE(p.command() == std::string("vrf"));
+    REQUIRE(p.arguments().size() == 0);
+}
+
+TEST_CASE("Double digit id")
+{
+    int argc = 2;
+    char* argv[argc];
+    char a0[] = "call";
+    char a1[] = "56-8:vrf";
+    argv[0]   = a0;
+    argv[1]   = a1;
+
+    CmdLineParser p;
+    p.Parse(argc, argv);
+
+    REQUIRE(p.detector_id() == 8);
+    REQUIRE(p.multi_id() == 56);
+    REQUIRE(p.command() == std::string("vrf"));
+    REQUIRE(p.arguments().size() == 0);
+}
+
+TEST_CASE("Double digit id from string")
+{
+    std::string s = "56-8:vrf";
+
+
+    CmdLineParser p;
+    p.Parse(s);
+
+    REQUIRE(p.detector_id() == 8);
+    REQUIRE(p.multi_id() == 56);
+    REQUIRE(p.command() == std::string("vrf"));
+    REQUIRE(p.arguments().size() == 0);
+}
+
+TEST_CASE("Calling with wrong id throws invalid_argument")
+{
+
+    int argc = 2;
+    char* argv[argc];
+    char a0[] = "call";
+    char a1[] = "asvldkn:vrf";
+    argv[0]   = a0;
+    argv[1]   = a1;
+
+    CmdLineParser p;
+    CHECK_THROWS(p.Parse(argc, argv));
+}
+TEST_CASE("Calling with string with wrong id throws invalid_argument")
+{
+    std::string s = "asvldkn:vrf";
+    CmdLineParser p;
+    CHECK_THROWS(p.Parse(s));
+}
+
+
+TEST_CASE("Calling with wrong client throws invalid_argument")
+{
+
+    int argc = 2;
+    char* argv[argc];
+    char a0[] = "call";
+    char a1[] = "lki-3:vrf";
+    argv[0]   = a0;
+    argv[1]   = a1;
+
+    CmdLineParser p;
+    CHECK_THROWS(p.Parse(argc, argv));
+}
+TEST_CASE("Calling with string with wrong client throws invalid_argument")
+{
+    std::string s = "lki-3:vrf";
+    CmdLineParser p;
+    CHECK_THROWS(p.Parse(s));
+}
+
+TEST_CASE("Parses string with two arguments"){
+  std::string s = "trimen 3000 4000\n";
+  CmdLineParser p;
+  p.Parse(s);
+
+  REQUIRE("trimen" == p.command());
+  REQUIRE("3000" == p.arguments()[0]);
+  REQUIRE("4000" == p.arguments()[1]);
+  REQUIRE(2 == p.arguments().size());
+}

slsSupportLib/tests/test-Timer.cpp

@@ -0,0 +1,23 @@
+#include "Timer.h"
+#include "catch.hpp"
+
+#include <chrono>
+#include <thread>
+
+TEST_CASE("Time 1s restart then time 2s") {
+    auto sleep_duration = std::chrono::seconds(1);
+    auto t = sls::Timer();
+    std::this_thread::sleep_for(sleep_duration);
+    REQUIRE(t.elapsed_s() == Approx(1).epsilon(0.01));
+
+    t.restart();
+    std::this_thread::sleep_for(sleep_duration * 2);
+    REQUIRE(t.elapsed_s() == Approx(2).epsilon(0.01));
+}
+
+TEST_CASE("Return ms") {
+    auto sleep_duration = std::chrono::milliseconds(1300);
+    auto t = sls::Timer();
+    std::this_thread::sleep_for(sleep_duration);
+    REQUIRE(t.elapsed_ms() == Approx(1300).epsilon(0.5));
+}

slsSupportLib/tests/test-container_utils.cpp

@@ -0,0 +1,106 @@
+#include "catch.hpp"
+#include "container_utils.h"
+#include <exception>
+#include <string>
+#include <vector>
+
+using sls::allEqual;
+using sls::allEqualTo;
+using sls::anyEqualTo;
+using sls::allEqualToWithTol;
+using sls::allEqualWithTol;
+using sls::anyEqualToWithTol;
+
+using sls::sum;
+
+TEST_CASE("Equality of an empty vector") {
+  std::vector<int> v;
+  REQUIRE(v.empty());
+  REQUIRE_FALSE(allEqual(v));
+  REQUIRE_FALSE(allEqualWithTol(v, 2));
+  REQUIRE_FALSE(allEqualTo(v, 5));
+  REQUIRE_FALSE(anyEqualTo(v, 5));
+  REQUIRE_FALSE(anyEqualToWithTol(v, 5, 1));
+}
+
+TEST_CASE("Equality of a vector with one element") {
+  std::vector<int> v{5};
+  REQUIRE(v.size() == 1);
+  REQUIRE(allEqual(v));
+  REQUIRE(allEqualWithTol(v, 1));
+  REQUIRE(allEqualTo(v, 5));
+  REQUIRE(allEqualToWithTol(v, 5, 2));
+  REQUIRE(anyEqualTo(v, 5));
+  REQUIRE(anyEqualToWithTol(v, 5, 1));
+}
+
+TEST_CASE("A larger vector of the same elements") {
+  std::vector<int> v(101, 5);
+  REQUIRE(v.size() == 101);
+  REQUIRE(allEqual(v));
+  REQUIRE(allEqualWithTol(v, 1));
+  REQUIRE(allEqualTo(v, 5));
+  REQUIRE(anyEqualTo(v, 5));
+
+  SECTION(
+      "Push back another element to create a vector where not all are equal") {
+    v.push_back(7);
+    REQUIRE(v.size() == 102);
+    REQUIRE_FALSE(allEqual(v));
+
+    REQUIRE_FALSE(allEqualWithTol(v, 1));
+    REQUIRE(allEqualWithTol(v, 3));
+
+    REQUIRE_FALSE(allEqualTo(v, 5));
+
+    REQUIRE_FALSE(allEqualToWithTol(v, 5, 1));
+    REQUIRE(allEqualToWithTol(v, 5, 3));
+    REQUIRE(anyEqualTo(v, 5));
+  }
+}
+
+TEST_CASE("A vector of double with different values") {
+  std::vector<double> v{1.2, 2., 4.2, 4, 1.1};
+
+  REQUIRE(allEqual(v) == false);
+  REQUIRE(allEqualWithTol(v, 0.3) == false);
+  REQUIRE(allEqualWithTol(v, 3.2));
+}
+
+TEST_CASE("Sum of empty vector") {
+  std::vector<float> v;
+  REQUIRE(sls::sum(v) == Approx(0));
+}
+
+TEST_CASE("Sum of vector") {
+  std::vector<double> v{1.2, 2., 4.2, 4, 1.13};
+  REQUIRE(sls::sum(v) == Approx(12.53));
+}
+
+TEST_CASE("Minus one if different") {
+  std::vector<double> v;
+  REQUIRE(v.empty());
+  double d = -1;
+  REQUIRE(sls::minusOneIfDifferent(v) == d);
+
+  SECTION("single element") {
+    v.push_back(7.3);
+    REQUIRE(v.size() == 1);
+    REQUIRE(sls::minusOneIfDifferent(v) == Approx(7.3));
+  }
+  SECTION("different elements") {
+    v.push_back(7.3);
+    v.push_back(1.0);
+    v.push_back(62.1);
+    REQUIRE(sls::minusOneIfDifferent(v) == Approx(-1.0));
+  }
+}
+
+TEST_CASE("minus one does not have side effects"){
+    std::vector<int> v{1,1,1};
+    int i = sls::minusOneIfDifferent(v);
+    REQUIRE(i==1);
+    i=5;
+    REQUIRE(v[0]==1);
+}
+

slsSupportLib/tests/test-string_utils.cpp

@@ -0,0 +1,113 @@
+#include "MySocketTCP.h"
+#include "catch.hpp"
+// #include "multiSlsDetector.h"
+#include "logger.h"
+#include <iostream>
+#include <vector>
+
+#include "string_utils.h"
+
+
+TEST_CASE("copy a string") {
+
+    char src[10] = "hej";
+    REQUIRE(src[3]=='\0');
+
+    char dst[20];
+
+    sls::strcpy_safe(dst, src);
+    REQUIRE(dst[0]=='h');
+    REQUIRE(dst[1]=='e');
+    REQUIRE(dst[2]=='j');
+    REQUIRE(dst[3]=='\0');
+
+}
+
+TEST_CASE("copy a long string"){
+    auto src = "some very very long sting that does not fit";
+    char dst[3];
+    sls::strcpy_safe(dst, src);
+    REQUIRE(dst[0]=='s');
+    REQUIRE(dst[1]=='o');
+    REQUIRE(dst[2]=='\0');
+    
+}
+
+TEST_CASE("Concat") {
+  std::vector<std::string> v{"one", "one", "one"};
+  std::vector<std::string> v2{"one", "one", "one"};
+  auto r = sls::concatenateIfDifferent(v);
+  REQUIRE(r == std::string("one"));
+  r.clear();
+
+  // make sure we didn't modify the string
+  REQUIRE(v == v2);
+
+  SECTION("add a different value"){
+      v.emplace_back("two");
+      REQUIRE(v!=v2);
+      REQUIRE( sls::concatenateIfDifferent(v) == "one+one+one+two+");
+  }
+}
+
+TEST_CASE("split a string with end delimiter"){
+  std::string s("abra+kadabra+");
+  auto r =sls::split(s, '+');
+  REQUIRE(r.size()==2);
+  REQUIRE(r[0]=="abra");
+  REQUIRE(r[1]=="kadabra");
+}
+
+TEST_CASE("split a string without end delimiter"){
+  std::string s("abra+kadabra+filibom");
+  auto r =sls::split(s, '+');
+  REQUIRE(r.size()==3);
+  REQUIRE(r[0]=="abra");
+  REQUIRE(r[1]=="kadabra");
+  REQUIRE(r[2]=="filibom");
+}
+
+TEST_CASE("concatenate non empty strings"){
+  std::vector<std::string> vec{"hej", "kalas", "", "foto"};
+  REQUIRE(vec.size()==4);
+  auto ret = sls::concatenateNonEmptyStrings(vec);
+  REQUIRE(ret == "hej+kalas+foto+");
+}
+
+TEST_CASE("concatenate non empty strings with only emty"){
+  std::vector<std::string> vec{"", "", ""};
+  REQUIRE(vec.size()==3);
+  auto ret = sls::concatenateNonEmptyStrings(vec);
+  REQUIRE(ret.empty());
+}
+
+TEST_CASE("concatenate non empty strings with one element"){
+  std::vector<std::string> vec{"", "hej", "", "", ""};
+  REQUIRE(vec.size()==5);
+  auto ret = sls::concatenateNonEmptyStrings(vec);
+  REQUIRE(ret=="hej+");
+}
+
+TEST_CASE("Convert ip address"){
+  std::string address = "101.255.103.1";
+  REQUIRE(sls::stringIpToHex(address) == "65ff6701");
+
+}
+
+TEST_CASE("Remove char from string"){
+  char str[] = "sometest"; 
+  sls::removeChar(str, 'e');
+  REQUIRE(std::string(str) == "somtst");
+}
+
+TEST_CASE("Remove char from empty string"){
+  char str[50] = {}; 
+  sls::removeChar(str, 'e');
+  REQUIRE(std::string(str) == "");
+}
+
+TEST_CASE("Many characters in a row"){
+  char str[] = "someeequitellll::ongstring"; 
+  sls::removeChar(str, 'l');
+  REQUIRE(std::string(str) == "someeequite::ongstring");
+}

slsSupportLib/tests/test.cpp

@@ -0,0 +1,3 @@
+// tests-main.cpp
+#define CATCH_CONFIG_MAIN
+#include "catch.hpp"