merging refactor (replacing)

integrationTests/CMakeLists.txt

@@ -0,0 +1,48 @@
+# MESSAGE( STATUS "CMAKE_CURRENT_SOURCE_DIR: " ${CMAKE_CURRENT_SOURCE_DIR} )
+# MESSAGE( STATUS "PROJECT_SOURCE_DIR: " ${PROJECT_SOURCE_DIR} )
+
+
+
+# include_directories(
+#     ${PROJECT_SOURCE_DIR}/catch
+# )
+
+target_sources(tests PRIVATE 
+    ${CMAKE_CURRENT_SOURCE_DIR}/test-integrationMulti.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/test-integrationDectector.cpp
+)
+
+# if(SLS_USE_TESTS)
+#     set(TEST_SOURCES
+#         src/test-slsDetector.cpp
+#         src/test.cpp
+#     )
+#     add_executable(detector_test ${TEST_SOURCES})
+    
+#     target_link_libraries(detector_test 
+#         slsDetectorShared
+#         slsProjectOptions
+#         slsProjectWarnings
+#         slsSupportLib
+#         pthread
+#         rt
+#     )  
+#     set_target_properties(detector_test PROPERTIES
+#             RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+#     )
+
+#     add_executable(a src/a.cpp)
+#     target_link_libraries(a 
+#         slsProjectOptions
+#         slsProjectWarnings
+#         slsDetectorShared
+#         slsSupportLib
+#         pthread
+#         rt
+#     )  
+#     set_target_properties(a PROPERTIES
+#         RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin
+#     )
+
+# endif()
+

integrationTests/a.cpp

@@ -0,0 +1,87 @@
+
+#include "catch.hpp"
+
+#include "ClientSocket.h"
+#include "Timer.h"
+#include "logger.h"
+#include "network_utils.h"
+#include "slsDetector.h"
+#include "sls_detector_defs.h"
+#include "sls_detector_exceptions.h"
+#include "sls_detector_funcs.h"
+#include <iomanip>
+#include <iostream>
+#include <vector>
+
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <string>
+#include <sys/socket.h>
+#include <sys/types.h>
+
+#include <algorithm>
+
+#include "network_utils.h"
+
+using namespace sls;
+using ROI = slsDetectorDefs::ROI;
+
+// Easy printing of an ROI
+std::ostream &operator<<(std::ostream &out, const ROI &r) {
+    return out << "xmin: " << std::setw(5) << r.xmin
+               << " xmax: " << std::setw(5) << r.xmax
+               << " ymin: " << std::setw(5) << r.ymin
+               << " ymax: " << std::setw(5) << r.ymax;
+}
+
+int main() {
+
+    int ret[]{0,0,0};
+    for (auto i: ret)
+        std::cout << i << "\n";
+    // uint32_t imageSize = 101;
+    // uint32_t packetSize = 100;
+    // std::cout << "a: " << std::ceil((double)imageSize / (double)packetSize) <<'\n';
+    // std::cout << "b: " << imageSize / packetSize <<'\n';
+    // std::cout << "c: " << static_cast<double>(imageSize / packetSize) << '\n';
+    // std::cout << "c: " << (imageSize + packetSize-1) / packetSize << '\n';
+
+    // slsDetectorDefs::ROI roilimits[5];
+    // roilimits[0].xmin = 5;
+    // roilimits[0].xmax = 12;
+    // roilimits[0].ymin = 5;
+    // roilimits[0].ymax = 15;
+
+    // roilimits[1].xmin = 0;
+    // roilimits[1].xmax = 3;
+    // roilimits[1].ymin = 20;
+    // roilimits[1].ymax = 25;
+
+    // roilimits[2].xmin = 500;
+    // roilimits[2].xmax = 600;
+    // roilimits[2].ymin = 100;
+    // roilimits[2].ymax = 200;
+
+    // roilimits[3].xmin = 300;
+    // roilimits[3].xmax = 500;
+    // roilimits[3].ymin = 800;
+    // roilimits[3].ymax = 900;
+
+    // roilimits[4].xmin = 1000;
+    // roilimits[4].xmax = 2000;
+    // roilimits[4].ymin = 300;
+    // roilimits[4].ymax = 500;
+
+    // std::cout << "Before sorting:\n";
+    // for (auto r : roilimits) {
+    //     std::cout << r << '\n';
+    // }
+
+    // std::sort(std::begin(roilimits), std::end(roilimits),
+    //           [](ROI a, ROI b) { return a.xmin < b.xmin; });
+
+    // std::cout << "After sorting: \n";
+    // for (auto r : roilimits) {
+    //     std::cout << r << '\n';
+    // }
+}

integrationTests/config.h

@@ -0,0 +1,9 @@
+#pragma once
+#include <string>
+struct SingleDetectorConfig {
+    slsDetectorDefs::detectorType type_enum =
+        slsDetectorDefs::detectorType::EIGER;
+    const std::string hostname = "beb083";
+    const std::string type_string = "Eiger";
+    const std::string my_ip = "129.129.205.242";
+};

integrationTests/test-integrationDectector.cpp

@@ -0,0 +1,224 @@
+
+#include "catch.hpp"
+
+#include "ClientSocket.h"
+#include "logger.h"
+#include "slsDetector.h"
+#include "sls_detector_defs.h"
+
+#include "Timer.h"
+#include "sls_detector_funcs.h"
+#include <iostream>
+#include <vector>
+#define VERBOSE
+
+//Header holding all configurations for different detectors
+#include "config.h"
+
+TEST_CASE("single EIGER detector no receiver basic set and get", "[.integration]") {
+    //TODO! this test should take command line arguments for config
+    SingleDetectorConfig c;
+
+    //Read type by connecting to the detector
+    auto type = slsDetector::getTypeFromDetector(c.hostname);
+    CHECK(type == c.type_enum);
+
+    //Create slsDetector of said type and set hostname and detector online
+    slsDetector d(type);
+    CHECK(d.getDetectorTypeAsEnum() == type);
+    CHECK(d.getDetectorTypeAsString() == c.type_string);
+
+    d.setHostname(c.hostname);
+    CHECK(d.getHostname() == c.hostname);
+
+    d.setOnline(true);
+    CHECK(d.getOnlineFlag() == true);
+
+    CHECK(d.getReceiverOnline() == false);
+    CHECK(d.checkDetectorVersionCompatibility() == slsDetectorDefs::OK);
+
+    //Setting and reading exposure time
+    auto t = 1000000000;
+    d.setTimer(slsDetectorDefs::timerIndex::ACQUISITION_TIME, t);
+    CHECK(d.setTimer(slsDetectorDefs::timerIndex::ACQUISITION_TIME) == t);
+
+    //size of an eiger half module with and without gap pixels
+    CHECK(d.getTotalNumberOfChannels() == 256 * 256 * 4);
+    CHECK(d.getTotalNumberOfChannels(slsDetectorDefs::dimension::X) == 1024);
+    CHECK(d.getTotalNumberOfChannels(slsDetectorDefs::dimension::Y) == 256);
+    // CHECK(d.getTotalNumberOfChannels(slsDetectorDefs::dimension::Z) == 1);
+    CHECK(d.getTotalNumberOfChannelsInclGapPixels(slsDetectorDefs::dimension::X) == 1024);
+    CHECK(d.getTotalNumberOfChannelsInclGapPixels(slsDetectorDefs::dimension::Y) == 256);
+    // CHECK(d.getTotalNumberOfChannelsInclGapPixels(slsDetectorDefs::dimension::Z) == 1);
+
+    CHECK(d.getNChans() == 256 * 256);
+    CHECK(d.getNChans(slsDetectorDefs::dimension::X) == 256);
+    CHECK(d.getNChans(slsDetectorDefs::dimension::Y) == 256);
+    // CHECK(d.getNChans(slsDetectorDefs::dimension::Z) == 1);
+
+    CHECK(d.getNChips() == 4);
+    CHECK(d.getNChips(slsDetectorDefs::dimension::X) == 4);
+    CHECK(d.getNChips(slsDetectorDefs::dimension::Y) == 1);
+    // CHECK(d.getNChips(slsDetectorDefs::dimension::Z) == 1);
+
+    d.freeSharedMemory();
+}
+
+TEST_CASE("Set control port then create a new object with this control port",
+          "[.integration]") {
+    /*
+    TODO!
+    Standard port but should not be hardcoded 
+    Is this the best way to initialize the detectors
+    Using braces to make the object go out of scope
+    */
+    int old_cport = DEFAULT_PORTNO;
+    int old_sport = DEFAULT_PORTNO + 1;
+    int new_cport = 1993;
+    int new_sport = 2000;
+    SingleDetectorConfig c;
+    {
+        auto type = slsDetector::getTypeFromDetector(c.hostname);
+        CHECK(type == c.type_enum);
+        slsDetector d(type);
+        d.setHostname(c.hostname);
+        d.setOnline(true);
+        CHECK(d.getControlPort() == old_cport);
+        d.setControlPort(new_cport);
+        CHECK(d.getStopPort() == old_sport);
+        d.setStopPort(new_sport);
+        d.freeSharedMemory();
+    }
+    {
+        auto type = slsDetector::getTypeFromDetector(c.hostname, new_cport);
+        CHECK(type == c.type_enum);
+        slsDetector d(type);
+        d.setHostname(c.hostname);
+        d.setControlPort(new_cport);
+        d.setStopPort(new_sport);
+        CHECK(d.getControlPort() == new_cport);
+        CHECK(d.getStopPort() == new_sport);
+
+        d.setOnline(true);
+
+        //Reset standard ports
+        d.setControlPort(old_cport);
+        d.setStopPort(old_sport);
+        d.freeSharedMemory();
+    }
+
+    auto type = slsDetector::getTypeFromDetector(c.hostname);
+    CHECK(type == c.type_enum);
+    slsDetector d(type);
+    d.setHostname(c.hostname);
+    d.setOnline(true);
+    CHECK(d.getStopPort() == DEFAULT_PORTNO + 1);
+    d.freeSharedMemory();
+}
+
+TEST_CASE("Locking mechanism and last ip", "[.integration]") {
+    SingleDetectorConfig c;
+    auto type = slsDetector::getTypeFromDetector(c.hostname);
+    slsDetector d(type);
+    d.setHostname(c.hostname);
+    d.setOnline(true);
+
+    //Check that detector server is unlocked then lock
+    CHECK(d.lockServer() == 0);
+    d.lockServer(1);
+    CHECK(d.lockServer() == 1);
+
+    //Can we still access the detector while it's locked
+    auto t = 1300000000;
+    d.setTimer(slsDetectorDefs::timerIndex::ACQUISITION_TIME, t);
+    CHECK(d.setTimer(slsDetectorDefs::timerIndex::ACQUISITION_TIME) == t);
+
+    //unlock again and free
+    d.lockServer(0);
+    CHECK(d.lockServer() == 0);
+
+    CHECK(d.getLastClientIP() == c.my_ip);
+    d.freeSharedMemory();
+}
+
+TEST_CASE("Excersise all possible set timer functions", "[.integration]") {
+    // FRAME_NUMBER, /**< number of real time frames: total number of acquisitions is number or frames*number of cycles */
+    // ACQUISITION_TIME, /**< exposure time */
+    // FRAME_PERIOD, /**< period between exposures */
+    // DELAY_AFTER_TRIGGER, /**< delay between trigger and start of exposure or readout (in triggered mode) */
+    // GATES_NUMBER, /**< number of gates per frame (in gated mode) */
+    // CYCLES_NUMBER, /**< number of cycles: total number of acquisitions is number or frames*number of cycles */
+    // ACTUAL_TIME, /**< Actual time of the detector's internal timer */
+    // MEASUREMENT_TIME,  /**< Time of the measurement from the detector (fifo) */
+
+    // PROGRESS, /**< fraction of measurement elapsed - only get! */
+    // MEASUREMENTS_NUMBER,
+    // FRAMES_FROM_START,
+    // FRAMES_FROM_START_PG,
+    // SAMPLES,
+    // SUBFRAME_ACQUISITION_TIME, /**< subframe exposure time */
+    // STORAGE_CELL_NUMBER, /**<number of storage cells */
+    // SUBFRAME_DEADTIME, /**< subframe deadtime */
+    // MEASURED_PERIOD,	/**< measured period */
+    // MEASURED_SUBPERIOD,	/**< measured subperiod */
+    // MAX_TIMERS
+    SingleDetectorConfig c;
+    auto type = slsDetector::getTypeFromDetector(c.hostname);
+    slsDetector d(type);
+    d.setHostname(c.hostname);
+    d.setOnline(true);
+
+    //Number of frames
+    auto frames = 10;
+    d.setTimer(slsDetectorDefs::timerIndex::FRAME_NUMBER, frames);
+    CHECK(d.setTimer(slsDetectorDefs::timerIndex::FRAME_NUMBER) == frames);
+
+    auto t = 10000000;
+    d.setTimer(slsDetectorDefs::timerIndex::ACQUISITION_TIME, t);
+    CHECK(d.setTimer(slsDetectorDefs::timerIndex::ACQUISITION_TIME) == t);
+
+    auto period = 1000000000;
+    d.setTimer(slsDetectorDefs::timerIndex::FRAME_PERIOD, period);
+    CHECK(d.setTimer(slsDetectorDefs::timerIndex::FRAME_PERIOD) == period);
+
+    // not implemented for EIGER
+    // auto delay = 10000;
+    // d.setTimer(slsDetectorDefs::timerIndex::DELAY_AFTER_TRIGGER, delay);
+    // CHECK(d.setTimer(slsDetectorDefs::timerIndex::DELAY_AFTER_TRIGGER) == delay);
+
+    // auto gates = 1;
+    // d.setTimer(slsDetectorDefs::timerIndex::GATES_NUMBER, gates);
+    // CHECK(d.setTimer(slsDetectorDefs::timerIndex::GATES_NUMBER) == gates);
+
+    auto cycles = 2;
+    d.setTimer(slsDetectorDefs::timerIndex::CYCLES_NUMBER, cycles);
+    CHECK(d.setTimer(slsDetectorDefs::timerIndex::CYCLES_NUMBER) == cycles);
+
+    auto subtime = 200;
+    d.setTimer(slsDetectorDefs::timerIndex::SUBFRAME_ACQUISITION_TIME, subtime);
+    CHECK(d.setTimer(slsDetectorDefs::timerIndex::SUBFRAME_ACQUISITION_TIME) == subtime);
+
+    d.freeSharedMemory();
+}
+
+// TEST_CASE("Aquire", "[.integration][eiger]"){
+//     SingleDetectorConfig c;
+//     auto type = slsDetector::getTypeFromDetector(c.hostname);
+//     slsDetector d(type);
+//     d.setHostname(c.hostname);
+//     d.setOnline(true);
+
+//     auto period = 1000000000;
+//     auto exptime = 100000000;
+//     d.setTimer(slsDetectorDefs::timerIndex::FRAME_NUMBER, 5);
+//     d.setTimer(slsDetectorDefs::timerIndex::ACQUISITION_TIME, exptime);
+//     d.setTimer(slsDetectorDefs::timerIndex::FRAME_PERIOD, period);
+//     d.startAndReadAll();
+
+    
+
+//     auto rperiod = d.getTimeLeft(slsDetectorDefs::timerIndex::MEASURED_PERIOD);
+//     CHECK(rperiod == 0.1);
+
+//     d.freeSharedMemory();
+// }

integrationTests/test-integrationMulti.cpp

@@ -0,0 +1,11 @@
+// #include "catch.hpp"
+// #include "multiSlsDetector.h"
+
+// #include <iostream>
+// TEST_CASE("Initialize a detector") {
+// multiSlsDetector det(0, true, true);
+//   std::cout << "Size: " << det.getNumberOfDetectors() << std::endl;
+//   std::cout << "Hostname: " << det.getHostname() << std::endl;
+//   REQUIRE(false);
+  
+// }

integrationTests/test.cpp

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