merging refactor (replacing)

slsDetectorSoftware/tests/CMakeLists.txt

@@ -0,0 +1,5 @@
+target_sources(tests PRIVATE 
+    ${CMAKE_CURRENT_SOURCE_DIR}/test-SharedMemory.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/test-slsDetector.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/test-multiSlsDetector.cpp
+)

slsDetectorSoftware/tests/test-SharedMemory.cpp

@@ -0,0 +1,135 @@
+
+#include "SharedMemory.h"
+#include "catch.hpp"
+#include "string_utils.h"
+
+#include <iostream>
+
+struct Data {
+    int x;
+    double y;
+    char mess[50];
+};
+
+using namespace sls;
+
+constexpr int shm_id = 10;
+
+TEST_CASE("Create SharedMemory read and write", "[detector]") {
+
+    SharedMemory<Data> shm(shm_id, -1);
+    shm.CreateSharedMemory();
+    CHECK(shm.GetName() ==
+          std::string("/slsDetectorPackage_multi_") + std::to_string(shm_id));
+
+    shm()->x = 3;
+    shm()->y = 5.7;
+    sls::strcpy_safe(shm()->mess, "Some string");
+
+    CHECK(shm()->x == 3);
+    CHECK(shm()->y == 5.7);
+    CHECK(std::string(shm()->mess) == "Some string");
+
+    shm.UnmapSharedMemory();
+    shm.RemoveSharedMemory();
+
+    CHECK(shm.IsExisting() == false);
+}
+
+TEST_CASE("Open existing SharedMemory and read", "[detector]") {
+
+    {
+        SharedMemory<double> shm(shm_id, -1);
+        shm.CreateSharedMemory();
+        *shm() = 5.3;
+    }
+
+    SharedMemory<double> shm2(shm_id, -1);
+    shm2.OpenSharedMemory();
+    CHECK(*shm2() == 5.3);
+
+    shm2.RemoveSharedMemory();
+}
+
+TEST_CASE("Creating a second shared memory with the same name throws",
+          "[detector]") {
+
+    SharedMemory<double> shm0(shm_id, -1);
+    SharedMemory<double> shm1(shm_id, -1);
+
+    shm0.CreateSharedMemory();
+    CHECK_THROWS(shm1.CreateSharedMemory());
+    shm0.RemoveSharedMemory();
+}
+
+TEST_CASE("Open two shared memories to the same place", "[detector]") {
+
+    //Create the first shared memory
+    SharedMemory<Data> shm(shm_id, -1);
+    shm.CreateSharedMemory();
+    shm()->x = 5;
+    CHECK(shm()->x == 5);
+
+    //Open the second shared memory with the same name
+    SharedMemory<Data> shm2(shm_id, -1);
+    shm2.OpenSharedMemory();
+    CHECK(shm2()->x == 5);
+    CHECK(shm.GetName() == shm2.GetName());
+
+    //Check that they still point to the same place
+    shm2()->x = 7;
+    CHECK(shm()->x == 7);
+
+    //Remove only needs to be done once since they refer
+    //to the same memory
+    shm2.RemoveSharedMemory();
+    CHECK(shm.IsExisting() == false);
+    CHECK(shm2.IsExisting() == false);
+}
+
+TEST_CASE("Move SharedMemory", "[detector]") {
+
+    SharedMemory<Data> shm(shm_id, -1);
+    CHECK(shm.GetName() ==
+          std::string("/slsDetectorPackage_multi_") + std::to_string(shm_id));
+    shm.CreateSharedMemory();
+    shm()->x = 9;
+
+    CHECK(shm.size()== sizeof(Data));
+
+    SharedMemory<Data> shm2(shm_id+1, -1);
+    shm2 = std::move(shm); //shm is now a moved from object!
+
+    CHECK(shm2()->x == 9);
+    CHECK(shm() == nullptr);
+    CHECK(shm.size() == 0);
+
+    CHECK(shm2.GetName() == std::string("/slsDetectorPackage_multi_") +
+                                std::to_string(shm_id));
+    shm2.RemoveSharedMemory();
+
+}
+
+TEST_CASE("Create several shared memories", "[detector]") {
+    constexpr int N = 5;
+    std::vector<SharedMemory<int>> v;
+    v.reserve(N);
+    for (int i = 0; i != N; ++i) {
+        v.emplace_back(shm_id+i, -1);
+        CHECK(v[i].IsExisting() == false);
+        v[i].CreateSharedMemory();
+        *v[i]() = i;
+        CHECK(*v[i]() == i);
+    }
+
+    for (int i = 0; i != N; ++i) {
+        CHECK(*v[i]() == i);
+        CHECK(v[i].GetName() == std::string("/slsDetectorPackage_multi_") +
+                                    std::to_string(i + shm_id));
+    }
+
+    for (int i = 0; i != N; ++i) {
+        v[i].RemoveSharedMemory();
+        CHECK(v[i].IsExisting() == false);
+    }
+}

slsDetectorSoftware/tests/test-multiSlsDetector.cpp

@@ -0,0 +1,84 @@
+
+#include "catch.hpp"
+#include "container_utils.h"
+#include "multiSlsDetector.h"
+#include "slsDetector.h"
+#include "string_utils.h"
+
+#include <iostream>
+
+using namespace sls;
+
+SCENARIO("Multi detector operation", "[detector]") {
+
+    multiSlsDetector::freeSharedMemory(20, -1);
+
+    GIVEN("An empty multi detector") {
+        multiSlsDetector m(20);
+        THEN("the size is zero") {
+            CHECK(m.getNumberOfDetectors() == 0);
+            CHECK(m.getDataBytes() == 0);
+            CHECK(m.getTotalNumberOfChannels() == 0);
+        }
+
+        WHEN("we add a detector") {
+            m.addSlsDetector(sls::make_unique<slsDetector>(
+                slsDetectorDefs::detectorType::EIGER, 20, 0));
+            THEN("the size and number of detector changes") {
+                CHECK(m.getNumberOfDetectors() == 1);
+                CHECK(m.getTotalNumberOfChannels() == 256 * 1024);
+            }
+
+            WHEN("we add another detector") {
+                m.addSlsDetector(sls::make_unique<slsDetector>(
+                    slsDetectorDefs::detectorType::EIGER, 20, 1));
+                THEN("the size and number of detector changes") {
+                    CHECK(m.getNumberOfDetectors() == 2);
+                    CHECK(m.getTotalNumberOfChannels() == 2 * 256 * 1024);
+                }
+
+                WHEN("We set the trimen") {
+                    std::vector<int> energies{5000, 6000, 7000, 8000, 9000};
+                    m.setTrimEn(energies);
+                    THEN("we read back the same values") {
+                        CHECK(m.getTrimEn() == energies);
+                    }
+                }
+                WHEN("We set the trimen to different values") {
+                    std::vector<int> en0{5000, 6000, 7000, 8000, 9000};
+                    std::vector<int> en1{6000, 7000, 8000, 9000};
+                    m.setTrimEn(en0, 0);
+                    m.setTrimEn(en1, 1);
+                    THEN("we read back the same values") {
+                        CHECK(m.getTrimEn(0) == en0);
+                        CHECK(m.getTrimEn(1) == en1);
+                        CHECK(m.getTrimEn() == std::vector<int>{-1});
+                    }
+                }
+            }
+        }
+
+        m.freeSharedMemory();
+    }
+}
+
+TEST_CASE("Set and get partialFramesPadding", "[detector]"){
+
+    multiSlsDetector::freeSharedMemory(20, -1);
+    multiSlsDetector m(20);
+    m.addSlsDetector(sls::make_unique<slsDetector>(
+        slsDetectorDefs::detectorType::EIGER, 20, 0));
+    m.addSlsDetector(sls::make_unique<slsDetector>(
+        slsDetectorDefs::detectorType::EIGER, 20, 1));
+
+    m.setPartialFramesPadding(0);
+    CHECK(m.getPartialFramesPadding() == 0);
+
+    m.setPartialFramesPadding(1);
+    CHECK(m.getPartialFramesPadding() == 1);
+
+    m.setPartialFramesPadding(0, 0);
+    CHECK(m.getPartialFramesPadding() == -1);
+
+    m.freeSharedMemory();
+}

slsDetectorSoftware/tests/test-slsDetector.cpp

@@ -0,0 +1,194 @@
+
+#include "catch.hpp"
+#include "container_utils.h"
+#include "slsDetector.h"
+#include "sls_detector_defs.h"
+#include "string_utils.h"
+#include <algorithm>
+#include <iostream>
+
+using namespace sls;
+
+TEST_CASE("Set and get trimen", "[detector]") {
+    // Free shared memory to be sure that we start in a clean state
+    slsDetector::freeSharedMemory(20, 20);
+
+    // Create a detector and check that the type is set correctly
+    slsDetector d(slsDetectorDefs::detectorType::EIGER, 20, 20);
+    CHECK(d.getDetectorTypeAsEnum() == slsDetectorDefs::detectorType::EIGER);
+
+    // At the beginning there should be no trimen set
+    auto res = d.getTrimEn();
+    CHECK(res.empty());
+
+    std::vector<int> energies{5200, 6400, 8500, 9900, 12000};
+    d.setTrimEn(energies);
+    auto res2 = d.getTrimEn();
+
+    // Check that the size and every element matches what we set
+    CHECK(res2.size() == energies.size());
+    for (size_t i = 0; i != res2.size(); ++i)
+        CHECK(res2[i] == energies[i]);
+
+    // Setting trimen with too many vales throws an exception and keeps the
+    // old values
+    std::vector<int> too_many(150, 1000);
+    CHECK_THROWS(d.setTrimEn(too_many));
+    auto res3 = d.getTrimEn();
+    CHECK(res3.size() == energies.size());
+    for (size_t i = 0; i != res3.size(); ++i)
+        CHECK(res3[i] == energies[i]);
+
+    // Setting trimen without arguments resets to zero
+    d.setTrimEn();
+    CHECK(d.getTrimEn().empty());
+
+    // Clean up before next test
+    d.freeSharedMemory();
+}
+
+TEST_CASE("Set additional JSON header", "[detector]") {
+    slsDetector::freeSharedMemory(20, 20);
+    slsDetector d(slsDetectorDefs::detectorType::EIGER, 20, 20);
+    auto header = d.getAdditionalJsonHeader();
+    CHECK(header.empty());
+
+    // The header set is not validated
+    d.setAdditionalJsonHeader("any header");
+    header = d.getAdditionalJsonHeader();
+    CHECK(header == "any header");
+
+    // make sure reset works
+    d.setAdditionalJsonHeader("");
+    CHECK(d.getAdditionalJsonHeader().empty());
+
+    // Setting and getting one parameter
+    d.setAdditionalJsonParameter("exptime", "5");
+    CHECK(d.getAdditionalJsonParameter("exptime") == "5");
+    CHECK(d.getAdditionalJsonHeader() == "\"exptime\":5");
+
+    // Making sure setting another paramer does not mess up
+    // the first
+    d.setAdditionalJsonParameter("gain", "low");
+    CHECK(d.getAdditionalJsonParameter("exptime") == "5");
+    CHECK(d.getAdditionalJsonParameter("gain") == "low");
+    CHECK(d.getAdditionalJsonHeader() == "\"exptime\":5,\"gain\":\"low\"");
+
+    // Change a value
+    d.setAdditionalJsonParameter("exptime", "90");
+    CHECK(d.getAdditionalJsonParameter("exptime") == "90");
+    CHECK(d.getAdditionalJsonHeader() == "\"exptime\":90,\"gain\":\"low\"");
+
+    // Ask for a key that does not exists
+    // TODO!(Erik) Is an empty string the right return or should we throw
+    CHECK(d.getAdditionalJsonParameter("somerandomkey").empty());
+
+    // Throws if value or key is empty
+    CHECK_THROWS(d.setAdditionalJsonParameter("somekey", ""));
+    CHECK_THROWS(d.setAdditionalJsonParameter("", "parameter"));
+    CHECK_THROWS(d.setAdditionalJsonParameter("", ""));
+
+    // Throws if key or value has illegal char
+    CHECK_THROWS(d.setAdditionalJsonParameter("mykey,", "5"));
+    CHECK_THROWS(d.setAdditionalJsonParameter("some:key", "9"));
+    CHECK_THROWS(d.setAdditionalJsonParameter("some\"key", "1"));
+    CHECK_THROWS(d.setAdditionalJsonParameter("key", "value:"));
+    CHECK_THROWS(d.setAdditionalJsonParameter("key", "va,lue"));
+    CHECK_THROWS(d.setAdditionalJsonParameter("key", "va\"l\"ue"));
+
+    d.freeSharedMemory();
+}
+
+TEST_CASE("Set ROI", "[detector]") {
+    using ROI = slsDetectorDefs::ROI;
+
+    slsDetector::freeSharedMemory(20,20);
+    slsDetector d(slsDetectorDefs::detectorType::EIGER, 20, 20);
+
+    int n{0};
+    d.getROI(n);
+    CHECK(n == 0);
+    CHECK(d.getNRoi() == 0);
+
+    // set one ROI
+    ROI r;
+    r.xmin = 5;
+    r.xmax = 100;
+    r.ymin = 10;
+    r.ymax = 300;
+    d.setROI(1, &r);
+
+    auto res2 = d.getROI(n);
+    CHECK(n == 1);
+    CHECK(d.getNRoi() == 1);
+
+    CHECK(res2->xmin == 5);
+    CHECK(res2->xmax == 100);
+    CHECK(res2->ymin == 10);
+    CHECK(res2->ymax == 300);
+
+    d.freeSharedMemory();
+}
+
+TEST_CASE("Set multiple ROIs", "[detector]") {
+    using ROI = slsDetectorDefs::ROI;
+
+    slsDetector::freeSharedMemory(20, 20);
+    slsDetector d(slsDetectorDefs::detectorType::EIGER, 20, 20);
+
+    // set one ROI
+    constexpr int n = 3;
+    ROI r[n];
+    r[0].xmin = 500;
+    r[0].xmax = 60000;
+    r[0].ymin = 100;
+    r[0].ymax = 800;
+
+    r[1].xmin = 2;
+    r[1].xmax = 100;
+    r[1].ymin = 1;
+    r[1].ymax = 300;
+
+    r[2].xmin = 200;
+    r[2].xmax = 300;
+    r[2].ymin = 15;
+    r[2].ymax = 307;
+    d.setROI(n, r);
+
+    int n_roi{0};
+    auto res = d.getROI(n_roi);
+    CHECK(n_roi == n);
+    CHECK(d.getNRoi() == n);
+
+    CHECK(res[0].xmin == 2);
+    CHECK(res[0].xmax == 100);
+    CHECK(res[0].ymin == 1);
+    CHECK(res[0].ymax == 300);
+
+    CHECK(res[1].xmin == 200);
+    CHECK(res[1].xmax == 300);
+    CHECK(res[1].ymin == 15);
+    CHECK(res[1].ymax == 307);
+
+    CHECK(res[2].xmin == 500);
+    CHECK(res[2].xmax == 60000);
+    CHECK(res[2].ymin == 100);
+    CHECK(res[2].ymax == 800);
+
+    d.freeSharedMemory();
+}
+
+TEST_CASE("Padding and discard policy", "[detector][new]"){
+    slsDetector::freeSharedMemory(20, 20);
+    slsDetector d(slsDetectorDefs::detectorType::EIGER, 20, 20);
+
+    //
+    d.setPartialFramesPadding(false);
+    CHECK(d.getPartialFramesPadding() == false);
+    d.setPartialFramesPadding(true);
+    CHECK(d.getPartialFramesPadding() == true);
+
+    
+    d.freeSharedMemory();
+    
+}