diff --git a/slsDetectorSoftware/src/CmdProxy.h b/slsDetectorSoftware/src/CmdProxy.h
index eb6ad61e8..ef35f0db2 100644
--- a/slsDetectorSoftware/src/CmdProxy.h
+++ b/slsDetectorSoftware/src/CmdProxy.h
@@ -572,11 +572,9 @@ class CmdProxy {
                           {"acquire", &CmdProxy::acquire},
                           {"frames", &CmdProxy::frames},                          
                           {"triggers", &CmdProxy::triggers},
-                          {"bursts", &CmdProxy::bursts},
                           {"exptime", &CmdProxy::exptime},
                           {"period", &CmdProxy::period},
                           {"delay", &CmdProxy::delay},
-                          {"burstperiod", &CmdProxy::burstperiod},
                           {"framesl", &CmdProxy::framesl},
                           {"triggersl", &CmdProxy::triggersl},
                           {"delayl", &CmdProxy::delayl},
@@ -794,6 +792,8 @@ class CmdProxy {
                           {"imagetest", &CmdProxy::imagetest},
 
                           /* Gotthard2 Specific */  
+                          {"bursts", &CmdProxy::bursts},
+                          {"burstperiod", &CmdProxy::burstperiod},
                           {"inj_ch", &CmdProxy::InjectChannel},
                           {"vetophoton", &CmdProxy::VetoPhoton},
                           {"vetoref", &CmdProxy::VetoReference},
@@ -1036,10 +1036,6 @@ class CmdProxy {
                          StringTo<int64_t>,
                          "[n_triggers]\n\tNumber of triggers per aquire. Use timing command to set timing mode.");
 
-    INTEGER_COMMAND_NOID(bursts, getNumberOfBursts, setNumberOfBursts,
-                         StringTo<int64_t>,
-                         "[n_bursts]\n\t[Gotthard2] Number of bursts per aquire. Only in auto timing mode and burst mode. Use timing command to set timing mode and burstmode command to set burst mode.");
-
     TIME_COMMAND(exptime, getExptime, setExptime,
         "[duration] [(optional unit) ns|us|ms|s]\n\tExposure time"
         "\n\t[Gotthard2] Uploaded to detector just before acquisition starts");
@@ -1590,6 +1586,10 @@ class CmdProxy {
                     "[0, 1]\n\t[Gotthard] 1 adds channel intensity with precalculated values when taking an acquisition. Default is 0.");  
 
     /* Gotthard2 Specific */
+    INTEGER_COMMAND_NOID(bursts, getNumberOfBursts, setNumberOfBursts,
+                         StringTo<int64_t>,
+                         "[n_bursts]\n\t[Gotthard2] Number of bursts per aquire. Only in auto timing mode and burst mode. Use timing command to set timing mode and burstmode command to set burst mode.");
+
     INTEGER_COMMAND(currentsource, getCurrentSource, setCurrentSource, StringTo<int>,
                     "[0, 1]\n\t[Gotthard2] Enable or disable current source. Default is disabled.");
 
diff --git a/slsDetectorSoftware/tests/test-CmdProxy-gotthard2.cpp b/slsDetectorSoftware/tests/test-CmdProxy-gotthard2.cpp
index 6b70975b7..4d3dc66fa 100644
--- a/slsDetectorSoftware/tests/test-CmdProxy-gotthard2.cpp
+++ b/slsDetectorSoftware/tests/test-CmdProxy-gotthard2.cpp
@@ -15,6 +15,89 @@ using sls::Detector;
 using test::GET;
 using test::PUT;
 
+/* acquisition parameters */
+
+TEST_CASE("bursts", "[.cmd][.new]") {
+    Detector det;
+    CmdProxy proxy(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type == defs::GOTTHARD2) {
+        auto prev_burst = det.getNumberOfBursts().tsquash("#bursts should be same to test");
+        auto prev_trigger = det.getNumberOfFrames().tsquash("#frames should be same to test");
+        auto prev_frames = det.getNumberOfTriggers().tsquash("#triggers should be same to test");
+        auto prev_timingMode = det.getTimingMode();
+        auto prev_burstMode = det.getBurstMode();
+        // changing continuous mode frames and bursts
+        det.setBurstMode(defs::BURST_INTERNAL);
+        det.setTimingMode(defs::AUTO_TIMING);
+        {
+            std::ostringstream oss;
+            proxy.Call("bursts", {"3"}, -1, PUT, oss);
+            REQUIRE(oss.str() == "bursts 3\n");
+        }
+        {
+            std::ostringstream oss;
+            proxy.Call("bursts", {}, -1, GET, oss);
+            REQUIRE(oss.str() == "bursts 3\n");
+        }
+        REQUIRE_THROWS(proxy.Call("bursts", {"0"}, -1, PUT));
+        // trigger mode: reg set to 1, but bursts must be same
+        det.setTimingMode(defs::TRIGGER_EXPOSURE);
+        {
+            std::ostringstream oss;
+            proxy.Call("bursts", {}, -1, GET, oss);
+            REQUIRE(oss.str() == "bursts 3\n");
+        }        
+        det.setTimingMode(defs::AUTO_TIMING);
+        {
+            std::ostringstream oss;
+            proxy.Call("bursts", {}, -1, GET, oss);
+            REQUIRE(oss.str() == "bursts 3\n");
+        }
+        // continuous mode: reg set to #frames,
+        // but bursts should return same value
+        det.setBurstMode(defs::BURST_OFF);
+        det.setNumberOfFrames(2);
+        {
+            std::ostringstream oss;
+            proxy.Call("bursts", {}, -1, GET, oss);
+            REQUIRE(oss.str() == "bursts 3\n");
+        }
+        det.setTimingMode(defs::TRIGGER_EXPOSURE);
+        {
+            std::ostringstream oss;
+            proxy.Call("bursts", {}, -1, GET, oss);
+            REQUIRE(oss.str() == "bursts 3\n");
+        }
+        det.setBurstMode(defs::BURST_INTERNAL);
+        {
+            std::ostringstream oss;
+            proxy.Call("bursts", {}, -1, GET, oss);
+            REQUIRE(oss.str() == "bursts 3\n");
+        }
+        // set to previous values
+        det.setNumberOfBursts(prev_burst);
+        det.setNumberOfFrames(prev_frames);
+        det.setNumberOfTriggers(prev_trigger);
+        for (int i = 0; i != det.size(); ++i) {
+            det.setTimingMode(prev_timingMode[i], {i});
+            det.setBurstMode(prev_burstMode[i], {i});
+        }
+    } else {
+        REQUIRE_THROWS(proxy.Call("bursts", {}, -1, GET));
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
 TEST_CASE("Setting and reading back GOTTHARD2 dacs", "[.cmd][.dacs]") {
     // vref_h_adc,   vb_comp_fe, vb_comp_adc,  vcom_cds,
     // vref_restore, vb_opa_1st, vref_comp_fe, vcom_adc1,
@@ -229,35 +312,7 @@ TEST_CASE("inj_ch", "[.cmd]") {
 }
 
 
-TEST_CASE("bursts", "[.cmd]") {
-    Detector det;
-    CmdProxy proxy(&det);
-    auto det_type = det.getDetectorType().squash();
 
-    if (det_type == defs::GOTTHARD2) {
-        auto previous = det.getNumberOfBursts().squash(1);
-        auto previousTrigger = det.getNumberOfTriggers().squash(1);
-
-        std::ostringstream oss_set, oss_get;
-        proxy.Call("bursts", {"3"}, -1, PUT, oss_set);
-        REQUIRE(oss_set.str() == "bursts 3\n");
-
-        // change to trigger and back (bursts should still be same)
-        proxy.Call("timing", {"trigger"}, -1, PUT);
-        proxy.Call("triggers", {"2"}, -1, PUT);
-        proxy.Call("timing", {"auto"}, -1, PUT);
-
-
-        proxy.Call("bursts", {}, -1, GET, oss_get);
-        REQUIRE(oss_get.str() == "bursts 3\n");
-
-
-        det.setNumberOfBursts(previous);
-        det.setNumberOfTriggers(previousTrigger);
-    } else {
-        REQUIRE_THROWS(proxy.Call("bursts", {}, -1, GET));
-    }
-}
 
 TEST_CASE("burstperiod", "[.cmd]") {
     Detector det;
diff --git a/slsDetectorSoftware/tests/test-CmdProxy-rx.cpp b/slsDetectorSoftware/tests/test-CmdProxy-rx.cpp
index 690c1e327..05886e26f 100644
--- a/slsDetectorSoftware/tests/test-CmdProxy-rx.cpp
+++ b/slsDetectorSoftware/tests/test-CmdProxy-rx.cpp
@@ -19,7 +19,7 @@ python/scripts/list_tested_cmd.py to check if all commands are covered
 
 /* configuration */
 
-TEST_CASE("rx_version", "[.cmd][.rx]") {
+TEST_CASE("rx_version", "[.cmd][.rx][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     std::ostringstream oss;
@@ -33,7 +33,7 @@ TEST_CASE("rx_version", "[.cmd][.rx]") {
 
 /* acquisition */
 
-TEST_CASE("rx_start", "[.cmd][.rx]") {
+TEST_CASE("rx_start", "[.cmd][.rx][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     // PUT only command
@@ -50,7 +50,7 @@ TEST_CASE("rx_start", "[.cmd][.rx]") {
     }
 }
 
-TEST_CASE("rx_stop", "[.cmd][.rx]") {
+TEST_CASE("rx_stop", "[.cmd][.rx][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     // PUT only command
@@ -67,7 +67,7 @@ TEST_CASE("rx_stop", "[.cmd][.rx]") {
     }
 }
 
-TEST_CASE("rx_status", "[.cmd][.rx]") {
+TEST_CASE("rx_status", "[.cmd][.rx][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     det.startReceiver();
@@ -84,7 +84,7 @@ TEST_CASE("rx_status", "[.cmd][.rx]") {
     }
 }
 
-TEST_CASE("rx_framescaught", "[.cmd][.rx]") {
+TEST_CASE("rx_framescaught", "[.cmd][.rx][.new]") {
     Detector det;
     CmdProxy proxy(&det);
 
@@ -109,7 +109,7 @@ TEST_CASE("rx_framescaught", "[.cmd][.rx]") {
 
 }
 
-TEST_CASE("rx_missingpackets", "[.cmd][.rx]") {
+TEST_CASE("rx_missingpackets", "[.cmd][.rx][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     {
@@ -135,7 +135,7 @@ TEST_CASE("rx_missingpackets", "[.cmd][.rx]") {
 
 /* Network Configuration (Detector<->Receiver) */
 
-TEST_CASE("rx_printconfig", "[.cmd][.rx]") {
+TEST_CASE("rx_printconfig", "[.cmd][.rx][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     REQUIRE_NOTHROW(proxy.Call("rx_printconfig", {}, -1, GET));
@@ -144,7 +144,7 @@ TEST_CASE("rx_printconfig", "[.cmd][.rx]") {
 
 /* Receiver Config */ 
 
-TEST_CASE("rx_hostname", "[.cmd][.rx]") {
+TEST_CASE("rx_hostname", "[.cmd][.rx][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     auto prev_val = det.getRxHostname();
@@ -175,7 +175,7 @@ TEST_CASE("rx_hostname", "[.cmd][.rx]") {
     }
 }
 
-TEST_CASE("rx_tcpport", "[.cmd][.rx]") {
+TEST_CASE("rx_tcpport", "[.cmd][.rx][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     auto prev_val = det.getRxPort();
@@ -200,7 +200,7 @@ TEST_CASE("rx_tcpport", "[.cmd][.rx]") {
     }
 }
 
-TEST_CASE("rx_fifodepth", "[.cmd][.rx]") {
+TEST_CASE("rx_fifodepth", "[.cmd][.rx][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     auto prev_val = det.getRxFifoDepth();
@@ -224,7 +224,7 @@ TEST_CASE("rx_fifodepth", "[.cmd][.rx]") {
     }
 }
 
-TEST_CASE("rx_silent", "[.cmd][.rx]") {
+TEST_CASE("rx_silent", "[.cmd][.rx][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     auto prev_val = det.getRxSilentMode();
@@ -248,7 +248,7 @@ TEST_CASE("rx_silent", "[.cmd][.rx]") {
     }
 }
 
-TEST_CASE("rx_discardpolicy", "[.cmd][.rx]") {
+TEST_CASE("rx_discardpolicy", "[.cmd][.rx][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     auto prev_val = det.getRxFrameDiscardPolicy();
@@ -277,7 +277,7 @@ TEST_CASE("rx_discardpolicy", "[.cmd][.rx]") {
     }
 }
 
-TEST_CASE("rx_padding", "[.cmd][.rx]") {
+TEST_CASE("rx_padding", "[.cmd][.rx][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     auto prev_val = det.getPartialFramesPadding();
@@ -301,7 +301,7 @@ TEST_CASE("rx_padding", "[.cmd][.rx]") {
     }
 }
 
-TEST_CASE("rx_udpsocksize", "[.cmd][.rx]") {
+TEST_CASE("rx_udpsocksize", "[.cmd][.rx][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     int64_t prev_val = det.getRxUDPSocketBufferSize().tsquash("Need same udp socket buffer size to test");
@@ -319,7 +319,7 @@ TEST_CASE("rx_udpsocksize", "[.cmd][.rx]") {
     det.setRxUDPSocketBufferSize(prev_val);
 }
 
-TEST_CASE("rx_realudpsocksize", "[.cmd][.rx]") {
+TEST_CASE("rx_realudpsocksize", "[.cmd][.rx][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     uint64_t val = 0;
@@ -338,7 +338,7 @@ TEST_CASE("rx_realudpsocksize", "[.cmd][.rx]") {
     }
 }
 
-TEST_CASE("rx_lock", "[.cmd][.rx]") {
+TEST_CASE("rx_lock", "[.cmd][.rx][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     auto prev_val = det.getRxLock();
@@ -362,7 +362,7 @@ TEST_CASE("rx_lock", "[.cmd][.rx]") {
     }
 }
 
-TEST_CASE("rx_lastclient", "[.cmd][.rx]") {
+TEST_CASE("rx_lastclient", "[.cmd][.rx][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     std::ostringstream oss;
@@ -532,7 +532,7 @@ TEST_CASE("foverwrite", "[.cmd]") {
     }
 }
 
-TEST_CASE("rx_framesperfile", "[.cmd][.rx]") {
+TEST_CASE("rx_framesperfile", "[.cmd][.rx][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     auto prev_val = det.getFramesPerFile();
@@ -563,7 +563,7 @@ TEST_CASE("rx_framesperfile", "[.cmd][.rx]") {
 
 /* ZMQ Streaming Parameters (Receiver<->Client) */
 
-TEST_CASE("rx_datastream", "[.cmd][.rx]") {
+TEST_CASE("rx_datastream", "[.cmd][.rx][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     auto prev_val = det.getRxZmqDataStream();
@@ -589,7 +589,7 @@ TEST_CASE("rx_datastream", "[.cmd][.rx]") {
     }
 }
 
-TEST_CASE("rx_readfreq", "[.cmd][.rx]") {
+TEST_CASE("rx_readfreq", "[.cmd][.rx][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     auto prev_val = det.getRxZmqFrequency();
@@ -613,7 +613,7 @@ TEST_CASE("rx_readfreq", "[.cmd][.rx]") {
     }
 }
 
-TEST_CASE("rx_zmqport", "[.cmd][.rx]") {
+TEST_CASE("rx_zmqport", "[.cmd][.rx][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     auto prev_val_zmqport = det.getRxZmqPort();
@@ -653,7 +653,7 @@ TEST_CASE("rx_zmqport", "[.cmd][.rx]") {
     }
 }
 
-TEST_CASE("rx_zmqip", "[.cmd][.rx]") {
+TEST_CASE("rx_zmqip", "[.cmd][.rx][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     auto prev_val = det.getRxZmqIP();
@@ -675,7 +675,7 @@ TEST_CASE("rx_zmqip", "[.cmd][.rx]") {
 
 /* CTB Specific */
 
-TEST_CASE("rx_dbitlist", "[.cmd][.rx]") {
+TEST_CASE("rx_dbitlist", "[.cmd][.rx][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     auto det_type = det.getDetectorType().squash();
@@ -703,7 +703,7 @@ TEST_CASE("rx_dbitlist", "[.cmd][.rx]") {
     }
 }
 
-TEST_CASE("rx_dbitoffset", "[.cmd][.rx]") {
+TEST_CASE("rx_dbitoffset", "[.cmd][.rx][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     auto det_type = det.getDetectorType().squash();
@@ -744,7 +744,7 @@ TEST_CASE("rx_dbitoffset", "[.cmd][.rx]") {
 
 /* Insignificant */
 
-TEST_CASE("rx_frameindex", "[.cmd][.rx]") {
+TEST_CASE("rx_frameindex", "[.cmd][.rx][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     proxy.Call("rx_frameindex", {}, -1, GET);
diff --git a/slsDetectorSoftware/tests/test-CmdProxy.cpp b/slsDetectorSoftware/tests/test-CmdProxy.cpp
index 246c57d42..e0889d977 100644
--- a/slsDetectorSoftware/tests/test-CmdProxy.cpp
+++ b/slsDetectorSoftware/tests/test-CmdProxy.cpp
@@ -23,7 +23,7 @@ TEST_CASE("Unknown command", "[.cmd]") {
 
 /* configuration */
 
-TEST_CASE("config", "[.cmd][.common]") {
+TEST_CASE("config", "[.cmd][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     // put only
@@ -32,7 +32,7 @@ TEST_CASE("config", "[.cmd][.common]") {
 
 // free: not testing
 
-TEST_CASE("parameters", "[.cmd][.common]") {
+TEST_CASE("parameters", "[.cmd][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     // put only
@@ -57,7 +57,7 @@ TEST_CASE("parameters", "[.cmd][.common]") {
     */
 }
 
-TEST_CASE("hostname", "[.cmd][.common]") {
+TEST_CASE("hostname", "[.cmd][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     REQUIRE_NOTHROW(proxy.Call("hostname", {}, -1, GET));
@@ -65,49 +65,49 @@ TEST_CASE("hostname", "[.cmd][.common]") {
 
 // virtual: not testing
 
-TEST_CASE("versions", "[.cmd][.common]") {
+TEST_CASE("versions", "[.cmd][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     REQUIRE_NOTHROW(proxy.Call("versions", {}, -1, GET));
     REQUIRE_THROWS(proxy.Call("versions", {"0"}, -1, PUT));
 }
 
-TEST_CASE("packageversion", "[.cmd][.common]") {
+TEST_CASE("packageversion", "[.cmd][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     REQUIRE_NOTHROW(proxy.Call("packageversion", {}, -1, GET));
     REQUIRE_THROWS(proxy.Call("packageversion", {"0"}, -1, PUT));
 }
 
-TEST_CASE("clientversion", "[.cmd][.common]") {
+TEST_CASE("clientversion", "[.cmd][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     REQUIRE_NOTHROW(proxy.Call("clientversion", {}, -1, GET));
     REQUIRE_THROWS(proxy.Call("clientversion", {"0"}, -1, PUT));
 }
 
-TEST_CASE("firmwareversion", "[.cmd][.common]") {
+TEST_CASE("firmwareversion", "[.cmd][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     REQUIRE_NOTHROW(proxy.Call("firmwareversion", {}, -1, GET));
     REQUIRE_THROWS(proxy.Call("firmwareversion", {"0"}, -1, PUT));
 }
 
-TEST_CASE("detectorserverversion", "[.cmd][.common]") {
+TEST_CASE("detectorserverversion", "[.cmd][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     REQUIRE_NOTHROW(proxy.Call("detectorserverversion", {}, -1, GET));
     REQUIRE_THROWS(proxy.Call("detectorserverversion", {"0"}, -1, PUT));
 }
 
-TEST_CASE("detectornumber", "[.cmd][.common]") {
+TEST_CASE("detectornumber", "[.cmd][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     REQUIRE_NOTHROW(proxy.Call("detectornumber", {}, -1, GET));
     REQUIRE_THROWS(proxy.Call("detectornumber", {"0"}, -1, PUT));
 }
 
-TEST_CASE("type", "[.cmd][.common]"){
+TEST_CASE("type", "[.cmd][.new]"){
     Detector det;
     CmdProxy proxy(&det);
     auto dt = det.getDetectorType().squash();
@@ -119,7 +119,7 @@ TEST_CASE("type", "[.cmd][.common]"){
     REQUIRE(dt == test::type);
 }
 
-TEST_CASE("detsize", "[.cmd][.common]") {
+TEST_CASE("detsize", "[.cmd][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     auto prev_val = det.getDetectorSize();
@@ -136,7 +136,7 @@ TEST_CASE("detsize", "[.cmd][.common]") {
     det.setDetectorSize(prev_val);
 }
 
-TEST_CASE("settings", "[.cmd][.common]") {
+TEST_CASE("settings", "[.cmd][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     auto det_type = det.getDetectorType().squash();
@@ -205,7 +205,7 @@ TEST_CASE("settings", "[.cmd][.common]") {
 
 // acquire: not testing
 
-TEST_CASE("frames", "[.cmd]") {
+TEST_CASE("frames", "[.cmd][.new]") {
     Detector det;
     CmdProxy proxy(&det);
     auto prev_val = det.getNumberOfFrames().tsquash("#frames must be same to test");
@@ -228,6 +228,157 @@ TEST_CASE("frames", "[.cmd]") {
     det.setNumberOfFrames(prev_val);
 }
 
+TEST_CASE("triggers", "[.cmd][.new]") {
+    Detector det;
+    CmdProxy proxy(&det);
+    auto prev_val = det.getNumberOfTriggers().tsquash("#triggers must be same to test");
+    {
+        std::ostringstream oss;
+        proxy.Call("triggers", {"1000"}, -1, PUT, oss);
+        REQUIRE(oss.str() == "triggers 1000\n");
+    }
+    {
+        std::ostringstream oss;
+        proxy.Call("triggers", {}, -1, GET, oss);
+        REQUIRE(oss.str() == "triggers 1000\n");
+    }
+    {
+        std::ostringstream oss;
+        proxy.Call("triggers", {"1"}, -1, PUT, oss);
+        REQUIRE(oss.str() == "triggers 1\n");
+    }
+    REQUIRE_THROWS(proxy.Call("triggers", {"0"}, -1, PUT));
+    det.setNumberOfTriggers(prev_val);
+}
+
+TEST_CASE("exptime", "[.cmd][.new]") {
+    Detector det;
+    CmdProxy proxy(&det);
+    auto prev_val = det.getExptime();
+    {
+        std::ostringstream oss;
+        proxy.Call("exptime", {"0.05"}, -1, PUT, oss);
+        REQUIRE(oss.str() == "exptime 0.05\n");
+    }
+    {
+        std::ostringstream oss;
+        proxy.Call("exptime", {}, -1, GET, oss);
+        REQUIRE(oss.str() == "exptime 50ms\n");
+    }
+    {
+        std::ostringstream oss;
+        proxy.Call("exptime", {"1s"}, -1, PUT, oss);
+        REQUIRE(oss.str() == "exptime 1s\n");
+    }
+    {
+        std::ostringstream oss;
+        proxy.Call("exptime", {"0"}, -1, PUT, oss);
+        REQUIRE(oss.str() == "exptime 0\n");
+    }
+    for (int i = 0; i != det.size(); ++i) {
+        det.setExptime(prev_val[i], {i});
+    }
+}
+
+TEST_CASE("period", "[.cmd][.new]") {
+    Detector det;
+    CmdProxy proxy(&det);
+    auto prev_val = det.getPeriod();
+    {
+        std::ostringstream oss;
+        proxy.Call("period", {"1.25s"}, -1, PUT, oss);
+        REQUIRE(oss.str() == "period 1.25s\n");
+    }
+    {
+        std::ostringstream oss;
+        proxy.Call("period", {}, -1, GET, oss);
+        REQUIRE(oss.str() == "period 1.25s\n");
+    }
+    {
+        std::ostringstream oss;
+        proxy.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("delay", "[.cmd][.new]") {
+    Detector det;
+    CmdProxy proxy(&det);
+    auto det_type = det.getDetectorType().squash();
+    if (det_type == defs::EIGER) {
+        REQUIRE_THROWS(proxy.Call("delay", {"1"}, -1, PUT));
+        REQUIRE_THROWS(proxy.Call("delay", {}, -1, GET));
+    } else {
+        auto prev_val = det.getDelayAfterTrigger();
+        {
+            std::ostringstream oss;
+            proxy.Call("delay", {"1.25s"}, -1, PUT, oss);
+            REQUIRE(oss.str() == "delay 1.25s\n");
+        }
+        {
+            std::ostringstream oss;
+            proxy.Call("delay", {}, -1, GET, oss);
+            REQUIRE(oss.str() == "delay 1.25s\n");
+        }
+        {
+            std::ostringstream oss;
+            proxy.Call("delay", {"0s"}, -1, PUT, oss);
+            REQUIRE(oss.str() == "delay 0s\n");
+        }
+        for (int i = 0; i != det.size(); ++i) {
+            det.setDelayAfterTrigger(prev_val[i], {i});
+        }
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -2527,16 +2678,6 @@ TEST_CASE("timing", "[.cmd]") {
 //     }
 // }
 
-// TEST_CASE("triggers", "[.cmd]") {
-//     {
-//         REQUIRE_NOTHROW(multiSlsDetectorClient("triggers 10", PUT));
-//         std::ostringstream oss;
-//         REQUIRE_NOTHROW(multiSlsDetectorClient("triggers", GET, nullptr,
-//         oss)); REQUIRE(oss.str() == "triggers 10\n");
-//     }
-//     REQUIRE_NOTHROW(multiSlsDetectorClient("triggers 1", PUT));
-// }
-
 
 // TEST_CASE("threshold", "[.cmd]") {
 //     if (test::type == slsDetectorDefs::EIGER) {
@@ -2694,69 +2835,7 @@ TEST_CASE("lock", "[.cmd]") {
 //     REQUIRE_NOTHROW(multiSlsDetectorClient("lastclient", GET));
 // }
 
-TEST_CASE("exptime", "[.cmd]") {
-    Detector det;
-    CmdProxy proxy(&det);
 
-    {
-        std::ostringstream oss;
-        proxy.Call("exptime", {"0.05"}, -1, PUT, oss);
-        REQUIRE(oss.str() == "exptime 0.05\n");
-    }
-    {
-        std::ostringstream oss;
-        proxy.Call("exptime", {}, -1, GET, oss);
-        REQUIRE(oss.str() == "exptime 50ms\n");
-    }
-    {
-        std::ostringstream oss;
-        proxy.Call("exptime", {"1s"}, -1, PUT, oss);
-        REQUIRE(oss.str() == "exptime 1s\n");
-    }
-}
 
-TEST_CASE("period", "[.cmd]") {
-    Detector det;
-    CmdProxy proxy(&det);
-    {
-        std::ostringstream oss;
-        proxy.Call("period", {"1.25s"}, -1, PUT, oss);
-        REQUIRE(oss.str() == "period 1.25s\n");
-    }
-    {
-        std::ostringstream oss;
-        proxy.Call("period", {}, -1, GET, oss);
-        REQUIRE(oss.str() == "period 1.25s\n");
-    }
-    {
-        std::ostringstream oss;
-        proxy.Call("period", {"0"}, -1, PUT, oss);
-        REQUIRE(oss.str() == "period 0\n");
-    }
-}
 
-TEST_CASE("delay", "[.cmd]") {
-    Detector det;
-    CmdProxy proxy(&det);
-    auto det_type = det.getDetectorType().squash();
-    if (det_type == defs::EIGER) {
-        REQUIRE_THROWS(proxy.Call("delay", {"1"}, -1, PUT));
-        REQUIRE_THROWS(proxy.Call("delay", {}, -1, GET));
-    } else {
-        {
-            std::ostringstream oss;
-            proxy.Call("delay", {"1.25s"}, -1, PUT, oss);
-            REQUIRE(oss.str() == "delay 1.25s\n");
-        }
-        {
-            std::ostringstream oss;
-            proxy.Call("delay", {}, -1, GET, oss);
-            REQUIRE(oss.str() == "delay 1.25s\n");
-        }
-        {
-            std::ostringstream oss;
-            proxy.Call("delay", {"0s"}, -1, PUT, oss);
-            REQUIRE(oss.str() == "delay 0s\n");
-        }
-    }
-}
\ No newline at end of file
+