Xilinx client tests (#887)

* implemented testbus, testfpga, set/get #frames, triggers, allowed that and for connection to client, also allowed, getnumchannels, configuremac, getrunstatus, setdetectorposition with dummy values

* allowing tests for xilinx

* binaries in

slsDetectorServers/slsDetectorServer/include/arm64.h

@@ -5,6 +5,8 @@
 #include <inttypes.h>
 #include <sys/types.h>
 
-int mapCSP0(void);
 void bus_w(u_int32_t offset, u_int32_t data);
 u_int32_t bus_r(u_int32_t offset);
+uint64_t getU64BitReg(int aLSB, int aMSB);
+void setU64BitReg(uint64_t value, int aLSB, int aMSB);
+int mapCSP0(void);

slsDetectorServers/slsDetectorServer/include/slsDetectorFunctionList.h

@@ -65,10 +65,8 @@ typedef struct udpStruct_s {
 int isInitCheckDone();
 int getInitResult(char **mess);
 void basictests();
+#if !defined(EIGERD)
 int checkType();
-
-#if defined(GOTTHARDD) || defined(JUNGFRAUD) || defined(MOENCHD) ||            \
-    defined(CHIPTESTBOARDD) || defined(MYTHEN3D) || defined(GOTTHARD2D)
 int testFpga();
 int testBus();
 #endif
@@ -251,11 +249,11 @@ int getMaxStoragecellStart();
 int setNextFrameNumber(uint64_t value);
 int getNextFrameNumber(uint64_t *value);
 #endif
-#ifndef XILINX_CHIPTESTBOARDD
 void setNumFrames(int64_t val);
 int64_t getNumFrames();
 void setNumTriggers(int64_t val);
 int64_t getNumTriggers();
+#ifndef XILINX_CHIPTESTBOARDD
 #ifndef MYTHEN3D
 int setExpTime(int64_t val);
 int64_t getExpTime();
@@ -501,9 +499,7 @@ void calcChecksum(udp_header *udp);
 int getAdcConfigured();
 #endif
 
-#ifndef XILINX_CHIPTESTBOARDD
 int configureMAC();
-#endif
 int setDetectorPosition(int pos[]);
 int *getDetectorPosition();
 
@@ -715,9 +711,7 @@ int softwareTrigger(int block);
 #if defined(EIGERD) || defined(MYTHEN3D) || defined(CHIPTESTBOARDD)
 int startReadOut();
 #endif
-#ifndef XILINX_CHIPTESTBOARDD
 enum runStatus getRunStatus();
-#endif
 #ifdef EIGERD
 void waitForAcquisitionEnd(int *ret, char *mess);
 #else
@@ -748,9 +742,11 @@ u_int32_t runState(enum TLogLevel lev);
 #ifndef XILINX_CHIPTESTBOARDD
 int calculateDataBytes();
 int getTotalNumberOfChannels();
-#if defined(CHIPTESTBOARDD)
+#endif
+#if defined(CHIPTESTBOARDD) || defined (XILINX_CHIPTESTBOARDD)
 void getNumberOfChannels(int *nchanx, int *nchany);
 #endif
+#ifndef XILINX_CHIPTESTBOARDD
 int getNumberOfChips();
 int getNumberOfDACs();
 int getNumberOfChannelsPerChip();

slsDetectorServers/slsDetectorServer/src/slsDetectorServer_funcs.c

@@ -2219,9 +2219,6 @@ int get_num_frames(int file_des) {
     memset(mess, 0, sizeof(mess));
     int64_t retval = -1;
 
-#ifdef XILINX_CHIPTESTBOARDD
-    functionNotImplemented();
-#else
     // get only
     if (!scan) {
         retval = getNumFrames();
@@ -2231,7 +2228,6 @@ int get_num_frames(int file_des) {
         LOG(logDEBUG1, ("retval num frames (num scan steps) %lld\n",
                         (long long int)retval));
     }
-#endif
     return Server_SendResult(file_des, INT64, &retval, sizeof(retval));
 }
 
@@ -2244,9 +2240,6 @@ int set_num_frames(int file_des) {
         return printSocketReadError();
     LOG(logDEBUG1, ("Setting number of frames %lld\n", (long long int)arg));
 
-#ifdef XILINX_CHIPTESTBOARDD
-    functionNotImplemented();
-#else
     // only set
     if (Server_VerifyLock() == OK) {
         // only set number of frames if normal mode (not scan)
@@ -2292,7 +2285,6 @@ int set_num_frames(int file_des) {
             }
         }
     }
-#endif
     return Server_SendResult(file_des, INT64, NULL, 0);
 }
 
@@ -2301,13 +2293,9 @@ int get_num_triggers(int file_des) {
     memset(mess, 0, sizeof(mess));
     int64_t retval = -1;
 
-#ifdef XILINX_CHIPTESTBOARDD
-    functionNotImplemented();
-#else
     // get only
     retval = getNumTriggers();
     LOG(logDEBUG1, ("retval num triggers %lld\n", (long long int)retval));
-#endif
     return Server_SendResult(file_des, INT64, &retval, sizeof(retval));
 }
 
@@ -2320,9 +2308,6 @@ int set_num_triggers(int file_des) {
         return printSocketReadError();
     LOG(logDEBUG1, ("Setting number of triggers %lld\n", (long long int)arg));
 
-#ifdef XILINX_CHIPTESTBOARDD
-    functionNotImplemented();
-#else
     // only set
     if (Server_VerifyLock() == OK) {
 #if JUNGFRAUD
@@ -2342,7 +2327,6 @@ int set_num_triggers(int file_des) {
             validate64(&ret, mess, arg, retval, "set number of triggers", DEC);
         }
     }
-#endif
     return Server_SendResult(file_des, INT64, NULL, 0);
 }
 
@@ -3622,7 +3606,7 @@ int write_adc_register(int file_des) {
     uint32_t val = args[1];
     LOG(logDEBUG1, ("Writing 0x%x to ADC Register 0x%x\n", val, addr));
 
-#if defined(EIGERD) || defined(GOTTHARD2D) || defined(MYTHEN3D)
+#if defined(EIGERD) || defined(GOTTHARD2D) || defined(MYTHEN3D) || defined(XILINX_CHIPTESTBOARDD)
     functionNotImplemented();
 #else
 #ifndef VIRTUAL
@@ -4017,7 +4001,7 @@ int reset_fpga(int file_des) {
 
     LOG(logDEBUG1, ("Reset FPGA\n"));
 #if defined(EIGERD) || defined(GOTTHARDD) || defined(GOTTHARD2D) ||            \
-    defined(MYTHEN3D)
+    defined(MYTHEN3D) || defined (XILINX_CHIPTESTBOARDD)
     functionNotImplemented();
 #else
     // only set
@@ -5026,9 +5010,6 @@ int set_detector_position(int file_des) {
     LOG(logDEBUG, ("Setting detector positions: [maxy:%u, modIndex:%u]\n",
                    args[0], args[1]));
 
-#ifdef XILINX_CHIPTESTBOARDD
-    functionNotImplemented();
-#else
     // only set
     if (Server_VerifyLock() == OK) {
         // if in update mode, there is no need to do this (also detector not set
@@ -5039,14 +5020,10 @@ int set_detector_position(int file_des) {
             calculate_and_set_position();
         }
     }
-#endif
     return Server_SendResult(file_des, INT32, NULL, 0);
 }
 
 int check_detector_idle(const char *s) {
-#ifdef XILINX_CHIPTESTBOARDD
-    return FAIL;
-#else
     enum runStatus status = getRunStatus();
     if (status != IDLE && status != RUN_FINISHED && status != STOPPED &&
         status != ERROR) {
@@ -5058,7 +5035,6 @@ int check_detector_idle(const char *s) {
         LOG(logERROR, (mess));
     }
     return ret;
-#endif
 }
 
 int is_udp_configured() {
@@ -5125,7 +5101,6 @@ int is_udp_configured() {
 }
 
 void configure_mac() {
-#ifndef XILINX_CHIPTESTBOARDD
     if (isControlServer) {
         if (is_udp_configured() == OK) {
             ret = configureMAC();
@@ -5152,7 +5127,6 @@ void configure_mac() {
     }
     configured = FAIL;
     LOG(logWARNING, ("Configure FAIL, not all parameters configured yet\n"));
-#endif
 }
 
 int set_source_udp_ip(int file_des) {
@@ -7105,7 +7079,7 @@ int get_num_channels(int file_des) {
 
     LOG(logDEBUG1, ("Getting number of channels\n"));
 
-#if !defined(CHIPTESTBOARDD)
+#if !defined(CHIPTESTBOARDD) && !defined(XILINX_CHIPTESTBOARDD)
     functionNotImplemented();
 #else
     // get only

slsDetectorServers/xilinx_ctbDetectorServer/slsDetectorFunctionList.c

@@ -51,14 +51,10 @@ void basictests() {
     }
 
 #ifndef VIRTUAL
-    /*if ((!debugflag) && (!updateFlag) &&
-        ((validateKernelVersion(KERNEL_DATE_VRSN) == FAIL) ||
-         (checkType() == FAIL) || (testFpga() == FAIL) ||
-         (testBus() == FAIL))) {*/
     if ((!debugflag) && (!updateFlag) &&
         ((validateKernelVersion(KERNEL_DATE_VRSN) == FAIL) ||
-         (checkType() == FAIL) /*|| (testFpga() == FAIL) ||
+         (checkType() == FAIL) || (testFpga() == FAIL) ||
-         (testBus() == FAIL)*/)) {
+         (testBus() == FAIL))) {
         sprintf(initErrorMessage,
                 "Could not pass basic tests of FPGA and bus. Cannot proceed. "
                 "Check Firmware. (Firmware version:0x%lx) \n",
@@ -103,6 +99,123 @@ int checkType() {
     return OK;
 }
 
+
+int testFpga() {
+#ifdef VIRTUAL
+    return OK;
+#endif
+    LOG(logINFO, ("Testing FPGA:\n"));
+
+    // fixed pattern
+    int ret = OK;
+    
+    /* TODO: FIX PATTERN not defined in firmware
+    uint32_t val = bus_r(FIX_PATT_REG);
+    if (val == FIX_PATT_VAL) {
+        LOG(logINFO, ("\tFixed pattern: successful match (0x%08x)\n", val));
+    } else {
+        LOG(logERROR,
+            ("Fixed pattern does not match! Read 0x%08x, expected 0x%08x\n",
+             val, FIX_PATT_VAL));
+        ret = FAIL;
+    }
+    */
+
+    if (ret == OK) {
+        // Delay LSB reg
+        LOG(logINFO, ("\tTesting Delay LSB Register:\n"));
+        uint32_t addr = DELAYINREG1;
+
+        // store previous delay value
+        uint32_t previousValue = bus_r(addr);
+
+        volatile uint32_t val = 0, readval = 0;
+        int times = 1000 * 1000;
+        for (int i = 0; i < times; ++i) {
+            val = 0x5A5A5A5A - i;
+            bus_w(addr, val);
+            readval = bus_r(addr);
+            if (readval != val) {
+                LOG(logERROR, ("1:Mismatch! Loop(%d): Wrote 0x%x, read 0x%x\n",
+                               i, val, readval));
+                ret = FAIL;
+                break;
+            }
+            val = (i + (i << 10) + (i << 20));
+            bus_w(addr, val);
+            readval = bus_r(addr);
+            if (readval != val) {
+                LOG(logERROR, ("2:Mismatch! Loop(%d): Wrote 0x%x, read 0x%x\n",
+                               i, val, readval));
+                ret = FAIL;
+                break;
+            }
+            val = 0x0F0F0F0F;
+            bus_w(addr, val);
+            readval = bus_r(addr);
+            if (readval != val) {
+                LOG(logERROR, ("3:Mismatch! Loop(%d): Wrote 0x%x, read 0x%x\n",
+                               i, val, readval));
+                ret = FAIL;
+                break;
+            }
+            val = 0xF0F0F0F0;
+            bus_w(addr, val);
+            readval = bus_r(addr);
+            if (readval != val) {
+                LOG(logERROR, ("4:Mismatch! Loop(%d): Wrote 0x%x, read 0x%x\n",
+                               i, val, readval));
+                ret = FAIL;
+                break;
+            }
+        }
+        // write back previous value
+        bus_w(addr, previousValue);
+        if (ret == OK) {
+            LOG(logINFO,
+                ("\tSuccessfully tested FPGA Delay LSB Register %d times\n",
+                 times));
+        }
+    }
+
+    return ret;
+}
+
+int testBus() {
+#ifdef VIRTUAL
+    return OK;
+#endif
+    LOG(logINFO, ("Testing Bus:\n"));
+
+    int ret = OK;
+    uint32_t addr = DELAYINREG1;
+
+    // store previous delay value
+    uint32_t previousValue = bus_r(addr);
+
+    volatile uint32_t val = 0, readval = 0;
+    int times = 1000 * 1000;
+
+    for (int i = 0; i < times; ++i) {
+        val += 0xbbbbb;
+        bus_w(addr, val);
+        readval = bus_r(addr);
+        if (readval != val) {
+            LOG(logERROR, ("Mismatch! Loop(%d): Wrote 0x%x, read 0x%x\n", i,
+                           val, readval));
+            ret = FAIL;
+        }
+    }
+
+    // write back previous value
+    bus_w(addr, previousValue);
+
+    if (ret == OK) {
+        LOG(logINFO, ("\tSuccessfully tested bus %d times\n", times));
+    }
+    return ret;
+}
+
 /* Ids */
 
 void getServerVersion(char *version) { strcpy(version, APIXILINXCTB); }
@@ -194,18 +307,81 @@ void initStopServer() {
 /* set up detector */
 
 void setupDetector() {
-    LOG(logINFO, ("This Server is for 1 Xilinx Chip Test Board\n"));
+    LOG(logINFO, ("Setting up Server for 1 Xilinx Chip Test Board\n"));
 #ifdef VIRTUAL
     sharedMemory_setStatus(IDLE);
 #endif
-    LOG(logINFO, ("Goodbye...\n"));
+
+    LOG(logINFOBLUE, ("Setting Default parameters\n"));
+
+    setNumFrames(DEFAULT_NUM_FRAMES);
+    setNumTriggers(DEFAULT_NUM_CYCLES);
 }
 
+/* parameters - timer */
+
+void setNumFrames(int64_t val) {
+    if (val > 0) {
+        LOG(logINFO, ("Setting number of frames %ld\n", val));
+        setU64BitReg(val, FRAMESINREG1, FRAMESINREG2);
+    }
+}
+
+int64_t getNumFrames() { return getU64BitReg(FRAMESINREG1, FRAMESINREG2); }
+
+void setNumTriggers(int64_t val) {
+    if (val > 0) {
+        LOG(logINFO, ("Setting number of triggers %ld\n", val));
+        setU64BitReg(val, CYCLESINREG1, CYCLESINREG2);
+    }
+}
+
+int64_t getNumTriggers() { return getU64BitReg(CYCLESINREG1, CYCLESINREG2); }
+
 int setDetectorPosition(int pos[]) {
     memcpy(detPos, pos, sizeof(detPos));
+    // TODO
+    return OK;
+}
+
+int configureMAC() {
+    // TODO
+    LOG(logINFO, ("Configuring MAC\n"));
     return OK;
 }
 
 int *getDetectorPosition() { return detPos; }
 
 int getNumberofUDPInterfaces() { return 1; }
+
+/* aquisition */
+
+enum runStatus getRunStatus() {
+    LOG(logDEBUG1, ("Getting status\n"));
+    // scan error or running
+    if (sharedMemory_getScanStatus() == ERROR) {
+        LOG(logINFOBLUE, ("Status: scan ERROR\n"));
+        return ERROR;
+    }
+    if (sharedMemory_getScanStatus() == RUNNING) {
+        LOG(logINFOBLUE, ("Status: scan RUNNING\n"));
+        return RUNNING;
+    }
+#ifdef VIRTUAL
+    if (sharedMemory_getStatus() == RUNNING) {
+        LOG(logINFOBLUE, ("Status: RUNNING\n"));
+        return RUNNING;
+    }
+    LOG(logINFOBLUE, ("Status: IDLE\n"));
+    return IDLE;
+#endif
+    //TODO: get status
+    LOG(logINFOBLUE, ("Status: IDLE\n"));   
+    return IDLE;
+}
+
+void getNumberOfChannels(int *nchanx, int *nchany) {
+    // TODO
+    *nchanx = NCHAN;
+    *nchany = 1;
+}

slsDetectorServers/xilinx_ctbDetectorServer/slsDetectorServer_defs.h

@@ -16,3 +16,8 @@
 
 enum ADCINDEX { V_PWR_IO };
 enum DACINDEX { D0 };
+
+
+/** Default Parameters */
+#define DEFAULT_NUM_FRAMES            (1)
+#define DEFAULT_NUM_CYCLES            (1)

slsDetectorSoftware/src/Detector.cpp

@@ -653,7 +653,6 @@ std::vector<defs::dacIndex> Detector::getTemperatureList() const {
     std::vector<defs::dacIndex> retval;
     switch (getDetectorType().squash()) {
     case defs::CHIPTESTBOARD:
-    case defs::XILINX_CHIPTESTBOARD:
         return std::vector<defs::dacIndex>{defs::SLOW_ADC_TEMP};
     case defs::JUNGFRAU:
     case defs::MOENCH:

slsDetectorSoftware/tests/Caller/test-Caller-chiptestboard.cpp

@@ -24,7 +24,7 @@ TEST_CASE("CALLER::dacname", "[.cmdcall]") {
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
 
-    if (det_type == defs::CHIPTESTBOARD) {
+    if (det_type == defs::CHIPTESTBOARD || det_type == defs::XILINX_CHIPTESTBOARD) {
         defs::dacIndex ind = static_cast<defs::dacIndex>(2);
         std::string str_dac_index = "2";
         auto prev = det.getDacName(ind);
@@ -58,7 +58,7 @@ TEST_CASE("CALLER::dacindex", "[.cmdcall]") {
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
 
-    if (det_type == defs::CHIPTESTBOARD) {
+    if (det_type == defs::CHIPTESTBOARD || det_type == defs::XILINX_CHIPTESTBOARD) {
         defs::dacIndex ind = static_cast<defs::dacIndex>(2);
         std::string str_dac_index = "2";
 
@@ -83,7 +83,7 @@ TEST_CASE("CALLER::adclist", "[.cmdcall]") {
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
 
-    if (det_type == defs::CHIPTESTBOARD) {
+    if (det_type == defs::CHIPTESTBOARD || det_type == defs::XILINX_CHIPTESTBOARD) {
         auto prev = det.getAdcNames();
 
         REQUIRE_THROWS(caller.call("adclist", {"a", "s", "d"}, -1, PUT));
@@ -115,7 +115,7 @@ TEST_CASE("CALLER::adcname", "[.cmdcall]") {
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
 
-    if (det_type == defs::CHIPTESTBOARD) {
+    if (det_type == defs::CHIPTESTBOARD || det_type == defs::XILINX_CHIPTESTBOARD) {
         int ind = 2;
         std::string str_adc_index = "2";
         auto prev = det.getAdcName(ind);
@@ -149,7 +149,7 @@ TEST_CASE("CALLER::adcindex", "[.cmdcall]") {
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
 
-    if (det_type == defs::CHIPTESTBOARD) {
+    if (det_type == defs::CHIPTESTBOARD || det_type == defs::XILINX_CHIPTESTBOARD) {
         int ind = 2;
         std::string str_adc_index = "2";
 
@@ -174,7 +174,7 @@ TEST_CASE("CALLER::signallist", "[.cmdcall]") {
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
 
-    if (det_type == defs::CHIPTESTBOARD) {
+    if (det_type == defs::CHIPTESTBOARD || det_type == defs::XILINX_CHIPTESTBOARD) {
         auto prev = det.getSignalNames();
 
         REQUIRE_THROWS(caller.call("signallist", {"a", "s", "d"}, -1, PUT));
@@ -206,7 +206,7 @@ TEST_CASE("CALLER::signalname", "[.cmdcall]") {
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
 
-    if (det_type == defs::CHIPTESTBOARD) {
+    if (det_type == defs::CHIPTESTBOARD || det_type == defs::XILINX_CHIPTESTBOARD) {
         int ind = 2;
         std::string str_signal_index = "2";
         auto prev = det.getSignalName(ind);
@@ -240,7 +240,7 @@ TEST_CASE("CALLER::signalindex", "[.cmdcall]") {
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
 
-    if (det_type == defs::CHIPTESTBOARD) {
+    if (det_type == defs::CHIPTESTBOARD || det_type == defs::XILINX_CHIPTESTBOARD) {
         int ind = 2;
         std::string str_signal_index = "2";
 
@@ -266,7 +266,7 @@ TEST_CASE("CALLER::powerlist", "[.cmdcall]") {
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
 
-    if (det_type == defs::CHIPTESTBOARD) {
+    if (det_type == defs::CHIPTESTBOARD || det_type == defs::XILINX_CHIPTESTBOARD) {
         auto prev = det.getPowerNames();
 
         REQUIRE_THROWS(caller.call("powerlist", {"a", "s", "d"}, -1, PUT));
@@ -298,7 +298,7 @@ TEST_CASE("CALLER::powername", "[.cmdcall]") {
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
 
-    if (det_type == defs::CHIPTESTBOARD) {
+    if (det_type == defs::CHIPTESTBOARD || det_type == defs::XILINX_CHIPTESTBOARD) {
         defs::dacIndex ind = static_cast<defs::dacIndex>(2 + defs::V_POWER_A);
         std::string str_power_index = "2";
         auto prev = det.getPowerName(ind);
@@ -332,7 +332,7 @@ TEST_CASE("CALLER::powerindex", "[.cmdcall]") {
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
 
-    if (det_type == defs::CHIPTESTBOARD) {
+    if (det_type == defs::CHIPTESTBOARD || det_type == defs::XILINX_CHIPTESTBOARD) {
         defs::dacIndex ind = static_cast<defs::dacIndex>(2 + defs::V_POWER_A);
         std::string str_power_index = "2";
 
@@ -382,7 +382,7 @@ TEST_CASE("CALLER::slowadclist", "[.cmdcall]") {
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
 
-    if (det_type == defs::CHIPTESTBOARD) {
+    if (det_type == defs::CHIPTESTBOARD || det_type == defs::XILINX_CHIPTESTBOARD) {
         auto prev = det.getSlowADCNames();
 
         REQUIRE_THROWS(caller.call("slowadclist", {"a", "s", "d"}, -1, PUT));
@@ -414,7 +414,7 @@ TEST_CASE("CALLER::slowadcname", "[.cmdcall]") {
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
 
-    if (det_type == defs::CHIPTESTBOARD) {
+    if (det_type == defs::CHIPTESTBOARD || det_type == defs::XILINX_CHIPTESTBOARD) {
         defs::dacIndex ind = static_cast<defs::dacIndex>(2 + defs::SLOW_ADC0);
         std::string str_slowadc_index = "2";
         auto prev = det.getSlowADCName(ind);
@@ -449,7 +449,7 @@ TEST_CASE("CALLER::slowadcindex", "[.cmdcall]") {
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
 
-    if (det_type == defs::CHIPTESTBOARD) {
+    if (det_type == defs::CHIPTESTBOARD || det_type == defs::XILINX_CHIPTESTBOARD) {
         defs::dacIndex ind = static_cast<defs::dacIndex>(2 + defs::SLOW_ADC0);
         std::string str_slowadc_index = "2";
 
@@ -478,12 +478,17 @@ TEST_CASE("CALLER::dac", "[.cmdcall][.dacs]") {
     Detector det;
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
-    if (det_type == defs::CHIPTESTBOARD) {
+    if (det_type == defs::CHIPTESTBOARD || det_type == defs::XILINX_CHIPTESTBOARD) {
         for (int i = 0; i < 18; ++i) {
             SECTION("dac " + std::to_string(i)) {
+                if (det_type == defs::CHIPTESTBOARD) {
                     test_dac_caller(static_cast<defs::dacIndex>(i), "dac", 0);
+                } else {
+                    REQUIRE_THROWS(caller.call("dac", {std::to_string(i)}, -1, GET));
                 }
             }
+        }
+
         // eiger
         // REQUIRE_THROWS(caller.call("dac", {"vthreshold"}, -1, GET));
         // REQUIRE_THROWS(caller.call("dac", {"vsvp"}, -1, GET));

slsDetectorSoftware/tests/Caller/test-Caller-rx.cpp

@@ -27,6 +27,8 @@ python/scripts/list_tested_cmd.py to check if all commands are covered
 TEST_CASE("Caller::rx_version", "[.cmdcall][.rx]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         std::ostringstream oss;
         caller.call("rx_version", {}, -1, GET, oss);
         sls::Version v(APIRECEIVER);
@@ -35,12 +37,17 @@ TEST_CASE("Caller::rx_version", "[.cmdcall][.rx]") {
         REQUIRE(oss.str() == vs.str());
 
         REQUIRE_THROWS(caller.call("rx_version", {"0"}, -1, PUT));
+    } else {
+        REQUIRE_THROWS(caller.call("rx_version", {}, -1, GET));
+    }
 }
 
 /* acquisition */
 TEST_CASE("Caller::rx_start", "[.cmdcall][.rx]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         det.setFileWrite(false); // avoid writing or error on file creation
         // PUT only command
         REQUIRE_THROWS(caller.call("rx_start", {}, -1, GET));
@@ -54,11 +61,16 @@ TEST_CASE("Caller::rx_start", "[.cmdcall][.rx]") {
             caller.call("rx_status", {}, -1, GET, oss);
             REQUIRE(oss.str() == "rx_status running\n");
         }
+    } else {
+        REQUIRE_THROWS(caller.call("rx_start", {}, -1, GET));
+    }
 }
 
 TEST_CASE("Caller::rx_stop", "[.cmdcall][.rx]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         // PUT only command
         REQUIRE_THROWS(caller.call("rx_stop", {}, -1, GET));
         {
@@ -71,10 +83,16 @@ TEST_CASE("Caller::rx_stop", "[.cmdcall][.rx]") {
             caller.call("rx_status", {}, -1, GET, oss);
             REQUIRE(oss.str() == "rx_status idle\n");
         }
+    } else {
+        REQUIRE_THROWS(caller.call("rx_stop", {}, -1, GET));
+    }
 }
 
 TEST_CASE("Caller::rx_status", "[.cmdcall][.rx]") {
     Detector det;
+    Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         det.setFileWrite(false); // avoid writing or error on file creation
         Caller caller(&det);
         det.startReceiver();
@@ -89,12 +107,16 @@ TEST_CASE("Caller::rx_status", "[.cmdcall][.rx]") {
             caller.call("rx_status", {}, -1, GET, oss);
             REQUIRE(oss.str() == "rx_status idle\n");
         }
+    } else {
+        REQUIRE_THROWS(caller.call("rx_status", {}, -1, GET));
+    }
 }
 
 TEST_CASE("Caller::rx_framescaught", "[.cmdcall][.rx]") {
     Detector det;
     Caller caller(&det);
-
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         // This ensures 0 caught frames
         auto prev_val = det.getFileWrite();
         det.setFileWrite(false); // avoid writing or error on file creation
@@ -124,10 +146,16 @@ TEST_CASE("Caller::rx_framescaught", "[.cmdcall][.rx]") {
         for (int i = 0; i != det.size(); ++i) {
             det.setFileWrite(prev_val[i], {i});
         }
+    } else {
+        REQUIRE_THROWS(caller.call("rx_framescaught", {}, -1, GET));
+    }
 }
 
 TEST_CASE("Caller::rx_missingpackets", "[.cmdcall][.rx]") {
     Detector det;
+    Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getFileWrite();
         det.setFileWrite(false); // avoid writing or error on file creation
         Caller caller(&det);
@@ -167,15 +195,23 @@ TEST_CASE("Caller::rx_missingpackets", "[.cmdcall][.rx]") {
             det.setFileWrite(prev_val[i], {i});
         }
         det.setNumberOfFrames(prev_frames);
+    } else {
+        REQUIRE_THROWS(caller.call("rx_missingpackets", {}, -1, GET));
+    }
 }
 
 TEST_CASE("Caller::rx_frameindex", "[.cmdcall][.rx]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         caller.call("rx_frameindex", {}, -1, GET);
 
         // This is a get only command
         REQUIRE_THROWS(caller.call("rx_frameindex", {"2"}, -1, PUT));
+    } else {
+        REQUIRE_THROWS(caller.call("rx_frameindex", {}, -1, GET));
+    }
 }
 
 /* Network Configuration (Detector<->Receiver) */
@@ -183,7 +219,12 @@ TEST_CASE("Caller::rx_frameindex", "[.cmdcall][.rx]") {
 TEST_CASE("Caller::rx_printconfig", "[.cmdcall][.rx]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         REQUIRE_NOTHROW(caller.call("rx_printconfig", {}, -1, GET));
+    } else {
+        REQUIRE_THROWS(caller.call("rx_printconfig", {}, -1, GET));
+    }
 }
 
 /* Receiver Config */
@@ -191,6 +232,8 @@ TEST_CASE("Caller::rx_printconfig", "[.cmdcall][.rx]") {
 TEST_CASE("Caller::rx_hostname", "[.cmdcall][.rx]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getRxHostname();
 
         // Cannot set rx_hostname (will reset parameters in rxr and no shm variables
@@ -218,6 +261,9 @@ TEST_CASE("Caller::rx_hostname", "[.cmdcall][.rx]") {
             caller.call("rx_hostname", {}, 0, GET, oss);
             REQUIRE(oss.str() == "rx_hostname " + prev_val[0] + "\n");
         }
+    } else {
+        REQUIRE_THROWS(caller.call("rx_hostname", {"localhost"}, -1, PUT));
+    }
 }
 
 TEST_CASE("Caller::rx_tcpport", "[.cmdcall][.rx]") {
@@ -262,6 +308,8 @@ TEST_CASE("Caller::rx_tcpport", "[.cmdcall][.rx]") {
 TEST_CASE("Caller::rx_fifodepth", "[.cmdcall][.rx]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getRxFifoDepth();
         {
             std::ostringstream oss;
@@ -281,11 +329,16 @@ TEST_CASE("Caller::rx_fifodepth", "[.cmdcall][.rx]") {
         for (int i = 0; i != det.size(); ++i) {
             det.setRxFifoDepth(prev_val[i], {i});
         }
+    } else {
+        REQUIRE_THROWS(caller.call("rx_fifodepth", {}, -1, GET));
+    }
 }
 
 TEST_CASE("Caller::rx_silent", "[.cmdcall][.rx]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getRxSilentMode();
         {
             std::ostringstream oss;
@@ -305,11 +358,16 @@ TEST_CASE("Caller::rx_silent", "[.cmdcall][.rx]") {
         for (int i = 0; i != det.size(); ++i) {
             det.setRxSilentMode(prev_val[i], {i});
         }
+    } else {
+        REQUIRE_THROWS(caller.call("rx_silent", {}, -1, GET));
+    }
 }
 
 TEST_CASE("Caller::rx_discardpolicy", "[.cmdcall][.rx]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getRxFrameDiscardPolicy();
         {
             std::ostringstream oss;
@@ -334,11 +392,16 @@ TEST_CASE("Caller::rx_discardpolicy", "[.cmdcall][.rx]") {
         for (int i = 0; i != det.size(); ++i) {
             det.setRxFrameDiscardPolicy(prev_val[i], {i});
         }
+    } else {
+        REQUIRE_THROWS(caller.call("rx_discardpolicy", {}, -1, GET));
+    }
 }
 
 TEST_CASE("Caller::rx_padding", "[.cmdcall][.rx]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getPartialFramesPadding();
         {
             std::ostringstream oss;
@@ -358,11 +421,16 @@ TEST_CASE("Caller::rx_padding", "[.cmdcall][.rx]") {
         for (int i = 0; i != det.size(); ++i) {
             det.setPartialFramesPadding(prev_val[i], {i});
         }
+    } else {
+        REQUIRE_THROWS(caller.call("rx_padding", {}, -1, GET));
+    }
 }
 
 TEST_CASE("Caller::rx_udpsocksize", "[.cmdcall][.rx]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         int64_t prev_val = det.getRxUDPSocketBufferSize().tsquash(
             "Need same udp socket buffer size to test");
         std::string s_new_val = std::to_string(prev_val);
@@ -378,11 +446,16 @@ TEST_CASE("Caller::rx_udpsocksize", "[.cmdcall][.rx]") {
             REQUIRE(oss.str() >= "rx_udpsocksize " + s_new_val + "\n");
         }
         det.setRxUDPSocketBufferSize(prev_val);
+    } else {
+        REQUIRE_THROWS(caller.call("rx_udpsocksize", {}, -1, GET));
+    }
 }
 
 TEST_CASE("Caller::rx_realudpsocksize", "[.cmdcall][.rx]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         uint64_t val = 0;
         {
             std::ostringstream oss;
@@ -397,11 +470,16 @@ TEST_CASE("Caller::rx_realudpsocksize", "[.cmdcall][.rx]") {
             uint64_t rval = std::stol(s);
             REQUIRE(rval >= val * 2);
         }
+    } else {
+        REQUIRE_THROWS(caller.call("rx_realudpsocksize", {}, -1, GET));
+    }
 }
 
 TEST_CASE("Caller::rx_lock", "[.cmdcall][.rx]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getRxLock();
         {
             std::ostringstream oss;
@@ -421,28 +499,43 @@ TEST_CASE("Caller::rx_lock", "[.cmdcall][.rx]") {
         for (int i = 0; i != det.size(); ++i) {
             det.setRxLock(prev_val[i], {i});
         }
+    } else {
+        REQUIRE_THROWS(caller.call("rx_lock", {}, -1, GET));
+    }
 }
 
 TEST_CASE("Caller::rx_lastclient", "[.cmdcall][.rx]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         std::ostringstream oss;
         REQUIRE_NOTHROW(caller.call("rx_lastclient", {}, -1, GET, oss));
         if (test::my_ip != "undefined") {
             REQUIRE(oss.str() == "rx_lastclient " + test::my_ip + "\n");
         }
+    } else {
+        REQUIRE_THROWS(caller.call("rx_lastclient", {}, -1, GET));
+    }
 }
 
 TEST_CASE("Caller::rx_threads", "[.cmdcall][.rx]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         std::ostringstream oss;
         REQUIRE_NOTHROW(caller.call("rx_threads", {}, -1, GET, oss));
+    } else {
+        REQUIRE_THROWS(caller.call("rx_threads", {}, -1, GET));
+    }
 }
 
 TEST_CASE("Caller::rx_arping", "[.cmdcall][.rx]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getRxArping();
         {
             std::ostringstream oss;
@@ -462,13 +555,16 @@ TEST_CASE("Caller::rx_arping", "[.cmdcall][.rx]") {
         for (int i = 0; i != det.size(); ++i) {
             det.setRxArping(prev_val[i], {i});
         }
+    } else {
+        REQUIRE_THROWS(caller.call("rx_arping", {}, -1, GET));
+    }
 }
 
 TEST_CASE("Caller::rx_roi", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
-
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         if (det_type == defs::CHIPTESTBOARD) {
             REQUIRE_THROWS(caller.call("rx_roi", {"5", "10"}, -1, PUT));
         } else {
@@ -524,13 +620,16 @@ TEST_CASE("Caller::rx_roi", "[.cmdcall]") {
                 det.setRxROI(prev_val);
             }
         }
+    } else {
+        REQUIRE_THROWS(caller.call("rx_roi", {}, -1, GET));
+    }
 }
 
 TEST_CASE("Caller::rx_clearroi", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
-
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         if (det_type == defs::CHIPTESTBOARD) {
             REQUIRE_THROWS(caller.call("rx_clearroi", {}, -1, PUT));
         } else {
@@ -544,6 +643,9 @@ TEST_CASE("Caller::rx_clearroi", "[.cmdcall]") {
                 det.setRxROI(prev_val);
             }
         }
+    } else {
+        REQUIRE_THROWS(caller.call("rx_clearroi", {}, -1, PUT));
+    }
 }
 
 /* File */
@@ -551,6 +653,8 @@ TEST_CASE("Caller::rx_clearroi", "[.cmdcall]") {
 TEST_CASE("Caller::fformat", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getFileFormat();
         {
             std::ostringstream oss;
@@ -565,11 +669,16 @@ TEST_CASE("Caller::fformat", "[.cmdcall]") {
         for (int i = 0; i != det.size(); ++i) {
             det.setFileFormat(prev_val[i], {i});
         }
+    } else {
+        REQUIRE_THROWS(caller.call("fformat", {}, -1, GET));
+    }
 }
 
 TEST_CASE("Caller::fpath", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getFilePath();
         {
             std::ostringstream oss;
@@ -584,11 +693,16 @@ TEST_CASE("Caller::fpath", "[.cmdcall]") {
         for (int i = 0; i != det.size(); ++i) {
             det.setFilePath(prev_val[i], {i});
         }
+    } else {
+        REQUIRE_THROWS(caller.call("fpath", {}, -1, GET));
+    }
 }
 
 TEST_CASE("Caller::fname", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getFileNamePrefix();
         {
             std::ostringstream oss;
@@ -611,11 +725,16 @@ TEST_CASE("Caller::fname", "[.cmdcall]") {
         for (int i = 0; i != det.size(); ++i) {
             det.setFileNamePrefix(prev_val[i], {i});
         }
+    } else {
+        REQUIRE_THROWS(caller.call("fname", {}, -1, GET));
+    }
 }
 
 TEST_CASE("Caller::findex", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getAcquisitionIndex();
         {
             std::ostringstream oss;
@@ -635,11 +754,16 @@ TEST_CASE("Caller::findex", "[.cmdcall]") {
         for (int i = 0; i != det.size(); ++i) {
             det.setAcquisitionIndex(prev_val[i], {i});
         }
+    } else {
+        REQUIRE_THROWS(caller.call("findex", {}, -1, GET));
+    }
 }
 
 TEST_CASE("Caller::fwrite", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getFileWrite();
         {
             std::ostringstream oss;
@@ -659,11 +783,16 @@ TEST_CASE("Caller::fwrite", "[.cmdcall]") {
         for (int i = 0; i != det.size(); ++i) {
             det.setFileWrite(prev_val[i], {i});
         }
+    } else {
+        REQUIRE_THROWS(caller.call("fwrite", {}, -1, GET));
+    }
 }
 
 TEST_CASE("Caller::fmaster", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getMasterFileWrite();
         {
             std::ostringstream oss;
@@ -681,11 +810,16 @@ TEST_CASE("Caller::fmaster", "[.cmdcall]") {
             REQUIRE(oss.str() == "fmaster 1\n");
         }
         det.setMasterFileWrite(prev_val);
+    } else {
+        REQUIRE_THROWS(caller.call("fmaster", {}, -1, GET));
+    }
 }
 
 TEST_CASE("Caller::foverwrite", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getFileOverWrite();
         {
             std::ostringstream oss;
@@ -705,11 +839,16 @@ TEST_CASE("Caller::foverwrite", "[.cmdcall]") {
         for (int i = 0; i != det.size(); ++i) {
             det.setFileOverWrite(prev_val[i], {i});
         }
+    } else {
+        REQUIRE_THROWS(caller.call("foverwrite", {}, -1, GET));
+    }
 }
 
 TEST_CASE("Caller::rx_framesperfile", "[.cmdcall][.rx]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getFramesPerFile();
         {
             std::ostringstream oss;
@@ -734,6 +873,9 @@ TEST_CASE("Caller::rx_framesperfile", "[.cmdcall][.rx]") {
         for (int i = 0; i != det.size(); ++i) {
             det.setFramesPerFile(prev_val[i], {i});
         }
+    } else {
+        REQUIRE_THROWS(caller.call("rx_framesperfile", {}, -1, GET));
+    }
 }
 
 /* ZMQ Streaming Parameters (Receiver<->Client) */
@@ -741,6 +883,8 @@ TEST_CASE("Caller::rx_framesperfile", "[.cmdcall][.rx]") {
 TEST_CASE("Caller::rx_zmqstream", "[.cmdcall][.rx]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getRxZmqDataStream();
         {
             std::ostringstream oss;
@@ -762,11 +906,16 @@ TEST_CASE("Caller::rx_zmqstream", "[.cmdcall][.rx]") {
         for (int i = 0; i != det.size(); ++i) {
             det.setRxZmqDataStream(prev_val[i], {i});
         }
+    } else {
+        REQUIRE_THROWS(caller.call("rx_zmqstream", {}, -1, GET));
+    }
 }
 
 TEST_CASE("Caller::rx_zmqfreq", "[.cmdcall][.rx]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getRxZmqFrequency();
         {
             std::ostringstream oss;
@@ -786,11 +935,16 @@ TEST_CASE("Caller::rx_zmqfreq", "[.cmdcall][.rx]") {
         for (int i = 0; i != det.size(); ++i) {
             det.setRxZmqFrequency(prev_val[i], {i});
         }
+    } else {
+        REQUIRE_THROWS(caller.call("rx_zmqfreq", {}, -1, GET));
+    }
 }
 
 TEST_CASE("Caller::rx_zmqstartfnum", "[.cmdcall][.rx]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getRxZmqStartingFrame();
         {
             std::ostringstream oss;
@@ -810,11 +964,17 @@ TEST_CASE("Caller::rx_zmqstartfnum", "[.cmdcall][.rx]") {
         for (int i = 0; i != det.size(); ++i) {
             det.setRxZmqStartingFrame(prev_val[i], {i});
         }
+    } else {
+        REQUIRE_THROWS(caller.call("rx_zmqstartfnum", {}, -1, GET));
+    
+    }
 }
 
 TEST_CASE("Caller::rx_zmqport", "[.cmdcall][.rx]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val_zmqport = det.getRxZmqPort();
         auto prev_val_numinterfaces = det.getNumberofUDPInterfaces().tsquash(
             "inconsistent number of udp interfaces to test");
@@ -858,11 +1018,16 @@ TEST_CASE("Caller::rx_zmqport", "[.cmdcall][.rx]") {
         if (det_type == defs::JUNGFRAU || det_type == defs::MOENCH) {
             det.setNumberofUDPInterfaces(prev_val_numinterfaces);
         }
+    } else {
+        REQUIRE_THROWS(caller.call("rx_zmqport", {}, -1, GET));
+    }
 }
 
 TEST_CASE("Caller::rx_zmqip", "[.cmdcall][.rx]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getRxZmqIP();
         {
             std::ostringstream oss;
@@ -878,11 +1043,16 @@ TEST_CASE("Caller::rx_zmqip", "[.cmdcall][.rx]") {
         for (int i = 0; i != det.size(); ++i) {
             det.setRxZmqIP(prev_val[i], {i});
         }
+    } else {
+        REQUIRE_THROWS(caller.call("rx_zmqip", {}, -1, GET));
+    }
 }
 
 TEST_CASE("Caller::rx_zmqhwm", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val =
             det.getRxZmqHwm().tsquash("Inconsistent values for rx_zmqhwm to test");
         {
@@ -906,6 +1076,9 @@ TEST_CASE("Caller::rx_zmqhwm", "[.cmdcall]") {
             REQUIRE(oss.str() == "rx_zmqhwm -1\n");
         }
         det.setRxZmqHwm(prev_val);
+    } else {
+        REQUIRE_THROWS(caller.call("rx_zmqhwm", {}, -1, GET));
+    }
 }
 
 /* CTB Specific */
@@ -976,6 +1149,8 @@ TEST_CASE("Caller::rx_dbitoffset", "[.cmdcall][.rx]") {
 TEST_CASE("Caller::rx_jsonaddheader", "[.cmdcall][.rx]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getAdditionalJsonHeader();
 
         {
@@ -997,11 +1172,16 @@ TEST_CASE("Caller::rx_jsonaddheader", "[.cmdcall][.rx]") {
         for (int i = 0; i != det.size(); ++i) {
             det.setAdditionalJsonHeader(prev_val[i], {i});
         }
+    } else {
+        REQUIRE_THROWS(caller.call("rx_jsonaddheader", {}, -1, GET));
+    }
 }
 
 TEST_CASE("Caller::rx_jsonpara", "[.cmdcall][.rx]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getAdditionalJsonHeader();
         {
             std::ostringstream oss;
@@ -1027,6 +1207,9 @@ TEST_CASE("Caller::rx_jsonpara", "[.cmdcall][.rx]") {
         for (int i = 0; i != det.size(); ++i) {
             det.setAdditionalJsonHeader(prev_val[i], {i});
         }
+    } else {
+        REQUIRE_THROWS(caller.call("rx_jsonpara", {}, -1, GET));
+    }
 }
 
 /* Insignificant */

slsDetectorSoftware/tests/Caller/test-Caller.cpp

@@ -27,30 +27,6 @@ TEST_CASE("CALLER::Caller::Calling help doesn't throw or cause segfault") {
             caller.call(cmd, {}, -1, slsDetectorDefs::HELP_ACTION, os));
 }
 
-TEST_CASE("CALLER::Caller::period", "[.cmdcall]") {
-    Detector det;
-    Caller caller(&det);
-    auto prev_val = det.getPeriod();
-    {
-        std::ostringstream oss;
-        caller.call("period", {"1.25s"}, -1, PUT, oss);
-        REQUIRE(oss.str() == "period 1.25s\n");
-    }
-    {
-        std::ostringstream oss;
-        caller.call("period", {}, -1, GET, oss);
-        REQUIRE(oss.str() == "period 1.25s\n");
-    }
-    {
-        std::ostringstream oss;
-        caller.call("period", {"0"}, -1, PUT, oss);
-        REQUIRE(oss.str() == "period 0\n");
-    }
-    for (int i = 0; i != det.size(); ++i) {
-        det.setPeriod(prev_val[i], {i});
-    }
-}
-
 TEST_CASE("CALLER::Unknown command", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
@@ -111,8 +87,13 @@ TEST_CASE("CALLER::virtual", "[.cmdcall]") {
 TEST_CASE("CALLER::versions", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         REQUIRE_NOTHROW(caller.call("versions", {}, -1, GET));
         REQUIRE_THROWS(caller.call("versions", {"0"}, -1, PUT));
+    } else {
+        REQUIRE_THROWS(caller.call("versions", {}, -1, GET));
+    }
 }
 
 TEST_CASE("CALLER::packageversion", "[.cmdcall]") {
@@ -146,22 +127,32 @@ TEST_CASE("CALLER::detectorserverversion", "[.cmdcall]") {
 TEST_CASE("CALLER::hardwareversion", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         REQUIRE_NOTHROW(caller.call("hardwareversion", {}, -1, GET));
         REQUIRE_THROWS(caller.call("hardwareversion", {"0"}, -1, PUT));
+    } else {
+        REQUIRE_THROWS(caller.call("hardwareversion", {}, -1, GET));
+    }
 }
 
 TEST_CASE("CALLER::kernelversion", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         REQUIRE_NOTHROW(caller.call("kernelversion", {}, -1, GET));
         REQUIRE_THROWS(caller.call("kernelversion", {"0"}, -1, PUT));
+    } else {
+        REQUIRE_THROWS(caller.call("kernelversion", {}, -1, GET));
+    }
 }
 
 TEST_CASE("CALLER::serialnumber", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
-    if (det_type == defs::EIGER) {
+    if (det_type == defs::EIGER || det_type == defs::XILINX_CHIPTESTBOARD) {
         REQUIRE_THROWS(caller.call("serialnumber", {}, -1, GET));
     } else {
         REQUIRE_NOTHROW(caller.call("serialnumber", {}, -1, GET));
@@ -203,7 +194,7 @@ TEST_CASE("CALLER::settingslist", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
-    if (det_type == defs::CHIPTESTBOARD) {
+    if (det_type == defs::CHIPTESTBOARD || det_type == defs::XILINX_CHIPTESTBOARD) {
         REQUIRE_THROWS(caller.call("settingslist", {}, -1, GET));
     } else {
         REQUIRE_NOTHROW(caller.call("settingslist", {}, -1, GET));
@@ -848,6 +839,7 @@ TEST_CASE("CALLER::exptime", "[.cmdcall][.time]") {
     Detector det;
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         std::chrono::nanoseconds prev_val;
         if (det_type != defs::MYTHEN3) {
             prev_val = det.getExptime().tsquash("inconsistent exptime to test");
@@ -892,11 +884,16 @@ TEST_CASE("CALLER::exptime", "[.cmdcall][.time]") {
             }
         }
         det.setExptime(-1, prev_val);
+    } else {
+        REQUIRE_THROWS(caller.call("exptime", {}, -1, GET));
+    }
 }
 
 TEST_CASE("CALLER::period", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getPeriod();
         {
             std::ostringstream oss;
@@ -916,12 +913,16 @@ TEST_CASE("CALLER::period", "[.cmdcall]") {
         for (int i = 0; i != det.size(); ++i) {
             det.setPeriod(prev_val[i], {i});
         }
+    } else {
+        REQUIRE_THROWS(caller.call("period", {}, -1, GET));
+    }
 }
 
 TEST_CASE("CALLER::delay", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         if (det_type == defs::EIGER) {
             REQUIRE_THROWS(caller.call("delay", {"1"}, -1, PUT));
             REQUIRE_THROWS(caller.call("delay", {}, -1, GET));
@@ -949,13 +950,16 @@ TEST_CASE("CALLER::delay", "[.cmdcall]") {
                 det.setDelayAfterTrigger(prev_val[i], {i});
             }
         }
+    } else {
+        REQUIRE_THROWS(caller.call("delay", {}, -1, GET));
+    }
 }
 
 TEST_CASE("CALLER::framesl", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
-    if (det_type == defs::EIGER) {
+    if (det_type == defs::EIGER || det_type == defs::XILINX_CHIPTESTBOARD) {
         REQUIRE_THROWS(caller.call("framesl", {}, -1, GET));
     } else {
         REQUIRE_NOTHROW(caller.call("framesl", {}, -1, GET));
@@ -966,7 +970,7 @@ TEST_CASE("CALLER::triggersl", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
-    if (det_type == defs::EIGER) {
+    if (det_type == defs::EIGER || det_type == defs::XILINX_CHIPTESTBOARD) {
         REQUIRE_THROWS(caller.call("triggersl", {}, -1, GET));
     } else {
         REQUIRE_NOTHROW(caller.call("triggersl", {}, -1, GET));
@@ -980,6 +984,7 @@ TEST_CASE("CALLER::delayl", "[.cmdcall]") {
     switch (det_type) {
     case defs::EIGER:
     case defs::CHIPTESTBOARD:
+    case defs::XILINX_CHIPTESTBOARD:
     case defs::GOTTHARD2:
     case defs::MYTHEN3:
         REQUIRE_THROWS(caller.call("delayl", {}, -1, GET));
@@ -997,6 +1002,7 @@ TEST_CASE("CALLER::periodl", "[.cmdcall]") {
     switch (det_type) {
     case defs::EIGER:
     case defs::CHIPTESTBOARD:
+    case defs::XILINX_CHIPTESTBOARD:
     case defs::GOTTHARD2:
     case defs::MYTHEN3:
         REQUIRE_THROWS(caller.call("periodl", {}, -1, GET));
@@ -1011,6 +1017,7 @@ TEST_CASE("CALLER::dr", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         if (det_type == defs::EIGER) {
             auto dr = det.getDynamicRange().squash();
             std::array<int, 4> vals{4, 8, 16, 32};
@@ -1047,6 +1054,9 @@ TEST_CASE("CALLER::dr", "[.cmdcall]") {
             caller.call("dr", {"16"}, -1, PUT, oss2);
             REQUIRE(oss2.str() == "dr 16\n");
         }
+    } else {
+        REQUIRE_THROWS(caller.call("dr", {}, -1, GET));
+    }
 }
 
 TEST_CASE("CALLER::drlist", "[.cmdcall]") {
@@ -1059,6 +1069,8 @@ TEST_CASE("CALLER::drlist", "[.cmdcall]") {
 TEST_CASE("CALLER::timing", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getTimingMode();
         det.setTimingMode(defs::AUTO_TIMING);
         {
@@ -1075,7 +1087,6 @@ TEST_CASE("CALLER::timing", "[.cmdcall]") {
             caller.call("timing", {}, -1, GET, oss2);
             REQUIRE(oss2.str() == "timing trigger\n");
         }
-    auto det_type = det.getDetectorType().squash();
         if (det_type == defs::EIGER) {
             {
                 std::ostringstream oss1, oss2;
@@ -1116,6 +1127,10 @@ TEST_CASE("CALLER::timing", "[.cmdcall]") {
         for (int i = 0; i != det.size(); ++i) {
             det.setTimingMode(prev_val[i], {i});
         }
+    } else {
+        REQUIRE_THROWS(caller.call("timing", {}, -1, GET));
+    
+    }
 }
 
 TEST_CASE("CALLER::timinglist", "[.cmdcall]") {
@@ -1417,6 +1432,7 @@ TEST_CASE("CALLER::highvoltage", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getHighVoltage();
         // selected values
         if (det_type == defs::GOTTHARD) {
@@ -1509,6 +1525,10 @@ TEST_CASE("CALLER::highvoltage", "[.cmdcall]") {
         for (int i = 0; i != det.size(); ++i) {
             det.setHighVoltage(prev_val[i], {i});
         }
+    } else {
+        REQUIRE_THROWS(caller.call("highvoltage", {"0"}, -1, PUT));
+        REQUIRE_THROWS(caller.call("highvoltage", {}, -1, GET));
+    }
 }
 
 TEST_CASE("CALLER::powerchip", "[.cmdcall]") {
@@ -2005,7 +2025,7 @@ TEST_CASE("CALLER::temp_fpga", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
-    if (det_type != defs::CHIPTESTBOARD) {
+    if (det_type != defs::CHIPTESTBOARD && det_type != defs::XILINX_CHIPTESTBOARD) {
         REQUIRE_NOTHROW(caller.call("temp_fpga", {}, -1, GET));
         std::ostringstream oss;
         REQUIRE_NOTHROW(caller.call("temp_fpga", {}, 0, GET, oss));
@@ -2056,15 +2076,21 @@ TEST_CASE("CALLER::daclist", "[.cmdcall]") {
 TEST_CASE("CALLER::dacvalues", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         REQUIRE_NOTHROW(caller.call("dacvalues", {}, -1, GET));
         REQUIRE_THROWS(caller.call("dacvalues", {}, -1, PUT));
+    } else {
+        REQUIRE_THROWS(caller.call("dacvalues", {}, -1, GET));
+    
+    }
 }
 
 TEST_CASE("CALLER::defaultdac", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
-    if (det_type != defs::CHIPTESTBOARD) {
+    if (det_type != defs::CHIPTESTBOARD && det_type != defs::XILINX_CHIPTESTBOARD) {
         REQUIRE_THROWS(caller.call("defaultdac", {}, -1, GET));
         REQUIRE_THROWS(caller.call("defaultdac", {"blabla"}, -1, PUT));
         auto daclist = det.getDacList();
@@ -2123,7 +2149,7 @@ TEST_CASE("CALLER::resetdacs", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
-    if (det_type != defs::CHIPTESTBOARD) {
+    if (det_type != defs::CHIPTESTBOARD && det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getSettings();
 
         REQUIRE_THROWS(caller.call("resetdacs", {}, -1, GET));
@@ -2241,6 +2267,8 @@ TEST_CASE("CALLER::clearbusy", "[.cmdcall]") {
 TEST_CASE("CALLER::start", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         // PUT only command
         REQUIRE_THROWS(caller.call("start", {}, -1, GET));
         auto det_type = det.getDetectorType().squash();
@@ -2275,11 +2303,16 @@ TEST_CASE("CALLER::start", "[.cmdcall]") {
         det.setExptime(-1, prev_val);
         det.setPeriod(prev_period);
         det.setNumberOfFrames(prev_frames);
+    } else {
+        REQUIRE_THROWS(caller.call("start", {}, -1, GET));
+    }
 }
 
 TEST_CASE("CALLER::stop", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         // PUT only command
         REQUIRE_THROWS(caller.call("stop", {}, -1, GET));
         auto det_type = det.getDetectorType().squash();
@@ -2320,12 +2353,16 @@ TEST_CASE("CALLER::stop", "[.cmdcall]") {
         det.setExptime(-1, prev_val);
         det.setPeriod(prev_period);
         det.setNumberOfFrames(prev_frames);
+    } else {
+        REQUIRE_THROWS(caller.call("stop", {}, -1, GET));
+    }
 }
 
 TEST_CASE("CALLER::status", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         std::chrono::nanoseconds prev_val;
         if (det_type != defs::MYTHEN3) {
             prev_val = det.getExptime().tsquash("inconsistent exptime to test");
@@ -2359,6 +2396,9 @@ TEST_CASE("CALLER::status", "[.cmdcall]") {
         det.setExptime(-1, prev_val);
         det.setPeriod(prev_period);
         det.setNumberOfFrames(prev_frames);
+    } else {
+        REQUIRE_THROWS(caller.call("status", {}, -1, GET));
+    }
 }
 
 TEST_CASE("CALLER::nextframenumber", "[.cmdcall]") {
@@ -2433,6 +2473,7 @@ TEST_CASE("CALLER::scan", "[.cmdcall]") {
     defs::dacIndex ind = defs::DAC_0;
     defs::dacIndex notImplementedInd = defs::DAC_0;
     auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         switch (det_type) {
         case defs::CHIPTESTBOARD:
             ind = defs::DAC_0;
@@ -2554,6 +2595,9 @@ TEST_CASE("CALLER::scan", "[.cmdcall]") {
             //     {i});
             // }
         }
+    } else {
+        REQUIRE_THROWS(caller.call("scan", {ToString(defs::DAC_0), "500", "1500", "500"}, -1, PUT));
+    }
 }
 
 TEST_CASE("CALLER::scanerrmsg", "[.cmdcall]") {
@@ -2608,6 +2652,8 @@ TEST_CASE("CALLER::numinterfaces", "[.cmdcall]") {
 TEST_CASE("CALLER::udp_srcip", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getSourceUDPIP();
         REQUIRE_THROWS(caller.call("udp_srcip", {"0.0.0.0"}, -1, PUT));
         {
@@ -2618,6 +2664,9 @@ TEST_CASE("CALLER::udp_srcip", "[.cmdcall]") {
         for (int i = 0; i != det.size(); ++i) {
             det.setSourceUDPIP(prev_val[i], {i});
         }
+    } else {
+        REQUIRE_THROWS(caller.call("udp_srcip", {}, -1, GET));
+    }
 }
 
 TEST_CASE("CALLER::udp_dstlist", "[.cmdcall]") {
@@ -2652,9 +2701,15 @@ TEST_CASE("CALLER::udp_numdst", "[.cmdcall]") {
 TEST_CASE("CALLER::udp_cleardst", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         REQUIRE_THROWS(caller.call("udp_cleardst", {}, -1, GET));
         /* dont clear all udp destinations */
         /*REQUIRE_NOTHROW(caller.call("udp_cleardst", {}, -1, PUT));*/
+    } else {
+        REQUIRE_THROWS(caller.call("udp_cleardst", {}, -1, PUT));
+    
+    }
 }
 
 TEST_CASE("CALLER::udp_firstdst", "[.cmdcall]") {
@@ -2700,6 +2755,8 @@ TEST_CASE("CALLER::udp_dstip", "[.cmdcall]") {
 TEST_CASE("CALLER::udp_srcmac", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getSourceUDPMAC();
         REQUIRE_THROWS(caller.call("udp_srcmac", {"00:00:00:00:00:00"}, -1, PUT));
         {
@@ -2712,6 +2769,9 @@ TEST_CASE("CALLER::udp_srcmac", "[.cmdcall]") {
                 det.setSourceUDPMAC(prev_val[i], {i});
             }
         }
+    } else {
+        REQUIRE_THROWS(caller.call("udp_srcmac", {}, -1, GET));
+    }
 }
 
 TEST_CASE("CALLER::udp_dstmac", "[.cmdcall]") {
@@ -2723,6 +2783,8 @@ TEST_CASE("CALLER::udp_dstmac", "[.cmdcall]") {
 TEST_CASE("CALLER::udp_dstport", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         auto prev_val = det.getDestinationUDPPort();
         {
             std::ostringstream oss;
@@ -2739,6 +2801,9 @@ TEST_CASE("CALLER::udp_dstport", "[.cmdcall]") {
         for (int i = 0; i != det.size(); ++i) {
             det.setDestinationUDPPort(prev_val[i], {i});
         }
+    } else {
+        REQUIRE_THROWS(caller.call("udp_dstport", {}, -1, GET));
+    }
 }
 
 TEST_CASE("CALLER::udp_srcip2", "[.cmdcall]") {
@@ -2844,15 +2909,26 @@ TEST_CASE("CALLER::udp_dstport2", "[.cmdcall]") {
 TEST_CASE("CALLER::udp_reconfigure", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         REQUIRE_THROWS(caller.call("udp_reconfigure", {}, -1, GET));
         REQUIRE_NOTHROW(caller.call("udp_reconfigure", {}, -1, PUT));
+    } else {
+        REQUIRE_THROWS(caller.call("udp_reconfigure", {}, -1, PUT));
+    }
 }
 
 TEST_CASE("CALLER::udp_validate", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         REQUIRE_THROWS(caller.call("udp_validate", {}, -1, GET));
         REQUIRE_NOTHROW(caller.call("udp_validate", {}, -1, PUT));
+    } else {
+        REQUIRE_THROWS(caller.call("udp_validate", {}, -1, PUT));
+    
+    }
 }
 
 TEST_CASE("CALLER::tengiga", "[.cmdcall]") {
@@ -3072,6 +3148,8 @@ TEST_CASE("CALLER::zmqport", "[.cmdcall]") {
 TEST_CASE("CALLER::zmqip", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         std::ostringstream oss1, oss2;
         auto zmqip = det.getClientZmqIp();
         caller.call("zmqip", {}, 0, GET, oss1);
@@ -3083,6 +3161,7 @@ TEST_CASE("CALLER::zmqip", "[.cmdcall]") {
         for (int i = 0; i != det.size(); ++i) {
             det.setRxZmqIP(zmqip[i], {i});
         }
+    }
 }
 
 TEST_CASE("CALLER::zmqhwm", "[.cmdcall]") {
@@ -3238,6 +3317,7 @@ TEST_CASE("CALLER::reg", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
+    if (det_type != defs::XILINX_CHIPTESTBOARD) {
         if (det_type != defs::EIGER) {
             uint32_t addr = 0x64;
             std::string saddr = ToStringHex(addr);
@@ -3257,6 +3337,9 @@ TEST_CASE("CALLER::reg", "[.cmdcall]") {
         else {
             REQUIRE_NOTHROW(caller.call("reg", {"0x64"}, -1, GET));
         }
+    } else {
+        REQUIRE_THROWS(caller.call("reg", {}, -1, GET));
+    }
 }
 
 TEST_CASE("CALLER::adcreg", "[.cmdcall]") {
@@ -3281,7 +3364,7 @@ TEST_CASE("CALLER::setbit", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
-    if (det_type != defs::EIGER) {
+    if (det_type != defs::EIGER && det_type != defs::XILINX_CHIPTESTBOARD) {
         uint32_t addr = 0x64;
         std::string saddr = ToStringHex(addr);
         auto prev_val = det.readRegister(addr);
@@ -3303,7 +3386,7 @@ TEST_CASE("CALLER::clearbit", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
-    if (det_type != defs::EIGER) {
+    if (det_type != defs::EIGER && det_type != defs::XILINX_CHIPTESTBOARD) {
         uint32_t addr = 0x64;
         std::string saddr = ToStringHex(addr);
         auto prev_val = det.readRegister(addr);
@@ -3325,7 +3408,9 @@ TEST_CASE("CALLER::getbit", "[.cmdcall]") {
     Detector det;
     Caller caller(&det);
     auto det_type = det.getDetectorType().squash();
-    if (det_type != defs::EIGER) {
+    if (det_type == defs::XILINX_CHIPTESTBOARD) {
+        REQUIRE_THROWS(caller.call("getbit", {"0x64", "1"}, -1, GET));
+    } else if (det_type != defs::EIGER) {
         uint32_t addr = 0x64;
         std::string saddr = ToStringHex(addr);
         auto prev_val = det.readRegister(addr);

slsSupportLib/include/sls/versionAPI.h

@@ -4,11 +4,11 @@
 #define RELEASE      "developer"
 #define APILIB       "developer 0x230224"
 #define APIRECEIVER  "developer 0x230224"
-#define APIXILINXCTB "developer 0x240104"
+#define APIXILINXCTB "developer 0x240109"
-#define APICTB "developer 0x240104"
+#define APICTB "developer 0x240109"
-#define APIGOTTHARD "developer 0x240104"
+#define APIGOTTHARD "developer 0x240109"
-#define APIGOTTHARD2 "developer 0x240104"
+#define APIGOTTHARD2 "developer 0x240109"
-#define APIJUNGFRAU "developer 0x240104"
+#define APIJUNGFRAU "developer 0x240109"
-#define APIMYTHEN3 "developer 0x240104"
+#define APIMYTHEN3 "developer 0x240109"
-#define APIMOENCH "developer 0x240104"
+#define APIMOENCH "developer 0x240109"
-#define APIEIGER "developer 0x240104"
+#define APIEIGER "developer 0x240109"

tests/scripts/test_simulators.py

@@ -99,7 +99,9 @@ def loadConfig(name, rx_hostname, settingsdir):
     Log(Fore.GREEN, 'Loading config')
     try:
         d = Detector()
-        if name == 'eiger':
+        if name == 'xilinx_ctb':
+            d.hostname = 'localhost'
+        elif name == 'eiger':
             d.hostname = 'localhost:' + str(DEFAULT_TCP_CNTRL_PORTNO) + '+localhost:' + str(HALFMOD2_TCP_CNTRL_PORTNO)
             #d.udp_dstport = {2: 50003} 
             # will set up for every module
@@ -174,6 +176,7 @@ if args.servers is None:
         'gotthard',
         'ctb',
         'moench',
+        'xilinx_ctb'
     ]
 else:
     servers = args.servers