detectors/slsDetectorPackage
25
0
Fork 0
mirror of https://github.com/slsdetectorgroup/slsDetectorPackage.git synced 2025-04-23 15:00:02 +02:00
Code Issues Actions Packages Releases Activity

WIP

Browse Source
This commit is contained in:
maliakal_d 2020-06-04 15:21:53 +02:00
parent 9a8300ca08
commit 1e2a3f2767
7 changed files with 559 additions and 334 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
slsDetectorSoftware/include/Detector.h
View File

@ -1186,16 +1186,16 @@ class Detector {
/** [CTB][Moench][Mythen3] */
void savePattern(const std::string &fname);
/** [CTB][Moench][Mythen3] */
/** [CTB][Moench] */
Result<uint64_t> getPatternIOControl(Positions pos = {}) const;
/** [CTB][Moench][Mythen3] */
/** [CTB][Moench] */
void setPatternIOControl(uint64_t word, Positions pos = {});
/** [CTB][Moench][Mythen3] */
/** [CTB][Moench] */
Result<uint64_t> getPatternClockControl(Positions pos = {}) const;
/** [CTB][Moench][Mythen3] */
/** [CTB][Moench] */
void setPatternClockControl(uint64_t word, Positions pos = {});
/** [CTB][Moench][Mythen3] same as executing for ctb and moench */

2
slsDetectorSoftware/src/CmdProxy.cpp
View File

@ -1961,7 +1961,7 @@ std::string CmdProxy::Pattern(int action) {
std::ostringstream os;
os << cmd << ' ';
if (action == defs::HELP_ACTION) {
os << "[fname]\n\t[Mythen3][Moench][Ctb][Moench] Loads binary pattern "
os << "[fname]\n\t[Mythen3][Moench][Ctb] Loads binary pattern "
"file with only pattern "
"words"
<< '\n';

4
slsDetectorSoftware/src/CmdProxy.h
View File

@ -2027,12 +2027,12 @@ class CmdProxy {
INTEGER_COMMAND_HEX(patioctrl, getPatternIOControl, setPatternIOControl,
StringTo<uint64_t>,
"[64 bit mask]\n\t[Ctb][Moench][Mythen3] 64 bit mask "
"[64 bit mask]\n\t[Ctb][Moench] 64 bit mask "
"defining input (0) and output (1) signals.");
INTEGER_COMMAND_HEX(patclkctrl, getPatternClockControl,
setPatternClockControl, StringTo<uint64_t>,
"[64 bit mask]\n\t[Ctb][Moench][Mythen3] 64 bit mask "
"[64 bit mask]\n\t[Ctb][Moench] 64 bit mask "
"defining output clock enable.");
INTEGER_COMMAND_HEX(

1
slsDetectorSoftware/tests/CMakeLists.txt
View File

@ -3,6 +3,7 @@ target_sources(tests PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}/test-slsDetector.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test-CmdProxy.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test-CmdProxy-rx.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test-CmdProxy-pattern.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test-CmdProxy-eiger.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test-CmdProxy-jungfrau.cpp
${CMAKE_CURRENT_SOURCE_DIR}/test-CmdProxy-mythen3.cpp

16
slsDetectorSoftware/tests/test-CmdProxy-chiptestboard.cpp
View File

@ -116,8 +116,8 @@ TEST_CASE("samples", "[.cmd][.new]") {
}
{
std::ostringstream oss;
proxy.Call("samples", {"1"}, -1, PUT, oss);
REQUIRE(oss.str() == "samples 1\n");
proxy.Call("samples", {"25"}, -1, PUT, oss);
REQUIRE(oss.str() == "samples 25\n");
}
{
std::ostringstream oss;
@ -159,8 +159,8 @@ TEST_CASE("asamples", "[.cmd][.new]") {
auto prev_val = det.getNumberOfAnalogSamples();
{
std::ostringstream oss;
proxy.Call("asamples", {"1"}, -1, PUT, oss);
REQUIRE(oss.str() == "asamples 1\n");
proxy.Call("asamples", {"25"}, -1, PUT, oss);
REQUIRE(oss.str() == "asamples 25\n");
}
{
std::ostringstream oss;
@ -333,8 +333,8 @@ TEST_CASE("adcenable", "[.cmd][.new]") {
auto prev_val = det.getADCEnableMask();
{
std::ostringstream oss;
proxy.Call("adcenable", {"0x8d0a21d4"}, -1, PUT, oss);
REQUIRE(oss.str() == "adcenable 0x8d0a21d4\n");
proxy.Call("adcenable", {"0x8d0aa0d8"}, -1, PUT, oss);
REQUIRE(oss.str() == "adcenable 0x8d0aa0d8\n");
}
{
std::ostringstream oss;
@ -363,8 +363,8 @@ TEST_CASE("adcenable10g", "[.cmd][.new]") {
auto prev_val = det.getTenGigaADCEnableMask();
{
std::ostringstream oss;
proxy.Call("adcenable10g", {"0xff00f0f0"}, -1, PUT, oss);
REQUIRE(oss.str() == "adcenable10g 0xff00f0f0\n");
proxy.Call("adcenable10g", {"0xff0000ff"}, -1, PUT, oss);
REQUIRE(oss.str() == "adcenable10g 0xff0000ff\n");
}
{
std::ostringstream oss;

543
slsDetectorSoftware/tests/test-CmdProxy-pattern.cpp Normal file
View File

@ -0,0 +1,543 @@
#include "CmdProxy.h"
#include "Detector.h"
#include "catch.hpp"
#include "sls_detector_defs.h"
#include <sstream>
#include "Result.h"
#include "ToString.h"
#include "test-CmdProxy-global.h"
#include "tests/globals.h"
#include "versionAPI.h"
using sls::CmdProxy;
using sls::Detector;
using test::GET;
using test::PUT;
/* Pattern */
TEST_CASE("pattern", "[.cmd][.new]") {
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
det_type == defs::MYTHEN3) {
// no proper test for put
REQUIRE_THROWS(proxy.Call("pattern", {}, -1, GET));
} else {
REQUIRE_THROWS(proxy.Call("pattern", {}, -1, GET));
}
}
TEST_CASE("savepattern", "[.cmd][.new]") {
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
det_type == defs::MYTHEN3) {
REQUIRE_THROWS(
proxy.Call("savepattern", {"/tmp/pattern.txt"}, -1, GET));
REQUIRE_NOTHROW(
proxy.Call("savepattern", {"/tmp/pattern.txt"}, -1, PUT));
} else {
REQUIRE_THROWS(
proxy.Call("savepattern", {"/tmp/pattern.txt"}, -1, PUT));
}
}
TEST_CASE("patioctrl", "[.cmd][.new]") {
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH) {
auto prev_val = det.getPatternIOControl();
{
std::ostringstream oss;
proxy.Call("patioctrl", {"0xc15004808d0a21a4"}, -1, PUT, oss);
REQUIRE(oss.str() == "patioctrl 0xc15004808d0a21a4\n");
}
{
std::ostringstream oss;
proxy.Call("patioctrl", {"0x0"}, -1, PUT, oss);
REQUIRE(oss.str() == "patioctrl 0x0\n");
}
{
std::ostringstream oss;
proxy.Call("patioctrl", {}, -1, GET, oss);
REQUIRE(oss.str() == "patioctrl 0x0\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setPatternIOControl(prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("patioctrl", {}, -1, GET));
}
}
TEST_CASE("patclkctrl", "[.cmd][.new]") {
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH) {
auto prev_val = det.getPatternClockControl();
{
std::ostringstream oss;
proxy.Call("patclkctrl", {"0xc15004808d0a21a4"}, -1, PUT, oss);
REQUIRE(oss.str() == "patclkctrl 0xc15004808d0a21a4\n");
}
{
std::ostringstream oss;
proxy.Call("patclkctrl", {"0x0"}, -1, PUT, oss);
REQUIRE(oss.str() == "patclkctrl 0x0\n");
}
{
std::ostringstream oss;
proxy.Call("patclkctrl", {}, -1, GET, oss);
REQUIRE(oss.str() == "patclkctrl 0x0\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setPatternClockControl(prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("patclkctrl", {}, -1, GET));
}
}
TEST_CASE("patword", "[.cmd][.new]") {
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
det_type == defs::MYTHEN3) {
int addr = 0x23;
std::string saddr = sls::ToStringHex(addr);
auto prev_val = det.getPatternWord(addr);
{
std::ostringstream oss;
proxy.Call("patword", {saddr, "0xc15004808d0a21a4"}, -1, PUT, oss);
REQUIRE(oss.str() ==
"patword [" + saddr + ", 0xc15004808d0a21a4]\n");
}
{
std::ostringstream oss;
proxy.Call("patword", {saddr, "0x0"}, -1, PUT, oss);
REQUIRE(oss.str() == "patword [" + saddr + ", 0x0]\n");
}
{
std::ostringstream oss;
proxy.Call("patword", {saddr}, -1, GET, oss);
REQUIRE(oss.str() == "patword 0x0\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setPatternWord(addr, prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("patword", {"0x23"}, -1, GET));
}
}
TEST_CASE("patlimits", "[.cmd][.new]") {
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
det_type == defs::MYTHEN3) {
auto prev_val = det.getPatternLoopAddresses(-1);
{
std::ostringstream oss;
proxy.Call("patlimits", {"0x20", "0x5c"}, -1, PUT, oss);
REQUIRE(oss.str() == "patlimits [0x20, 0x5c]\n");
}
{
std::ostringstream oss;
proxy.Call("patlimits", {}, -1, GET, oss);
REQUIRE(oss.str() == "patlimits [0x20, 0x5c]\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setPatternLoopAddresses(-1, prev_val[i][0], prev_val[i][1],
{i});
}
} else {
REQUIRE_THROWS(proxy.Call("patlimits", {}, -1, GET));
}
}
TEST_CASE("patloop0", "[.cmd][.new]") {
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
det_type == defs::MYTHEN3) {
auto prev_val = det.getPatternLoopAddresses(0);
{
std::ostringstream oss;
proxy.Call("patloop0", {"0x20", "0x5c"}, -1, PUT, oss);
REQUIRE(oss.str() == "patloop0 [0x20, 0x5c]\n");
}
{
std::ostringstream oss;
proxy.Call("patloop0", {}, -1, GET, oss);
REQUIRE(oss.str() == "patloop0 [0x20, 0x5c]\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setPatternLoopAddresses(0, prev_val[i][0], prev_val[i][1], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("patloop0", {}, -1, GET));
}
}
TEST_CASE("patloop1", "[.cmd][.new]") {
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
det_type == defs::MYTHEN3) {
auto prev_val = det.getPatternLoopAddresses(1);
{
std::ostringstream oss;
proxy.Call("patloop1", {"0x20", "0x5c"}, -1, PUT, oss);
REQUIRE(oss.str() == "patloop1 [0x20, 0x5c]\n");
}
{
std::ostringstream oss;
proxy.Call("patloop1", {}, -1, GET, oss);
REQUIRE(oss.str() == "patloop1 [0x20, 0x5c]\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setPatternLoopAddresses(1, prev_val[i][0], prev_val[i][1], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("patloop1", {}, -1, GET));
}
}
TEST_CASE("patloop2", "[.cmd][.new]") {
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
det_type == defs::MYTHEN3) {
auto prev_val = det.getPatternLoopAddresses(2);
{
std::ostringstream oss;
proxy.Call("patloop2", {"0x20", "0x5c"}, -1, PUT, oss);
REQUIRE(oss.str() == "patloop2 [0x20, 0x5c]\n");
}
{
std::ostringstream oss;
proxy.Call("patloop2", {}, -1, GET, oss);
REQUIRE(oss.str() == "patloop2 [0x20, 0x5c]\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setPatternLoopAddresses(2, prev_val[i][0], prev_val[i][1], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("patloop2", {}, -1, GET));
}
}
TEST_CASE("patnloop0", "[.cmd][.new]") {
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
det_type == defs::MYTHEN3) {
auto prev_val = det.getPatternLoopCycles(0);
{
std::ostringstream oss;
proxy.Call("patnloop0", {"5"}, -1, PUT, oss);
REQUIRE(oss.str() == "patnloop0 5\n");
}
{
std::ostringstream oss;
proxy.Call("patnloop0", {}, -1, GET, oss);
REQUIRE(oss.str() == "patnloop0 5\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setPatternLoopCycles(0, prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("patnloop0", {}, -1, GET));
}
}
TEST_CASE("patnloop1", "[.cmd][.new]") {
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
det_type == defs::MYTHEN3) {
auto prev_val = det.getPatternLoopCycles(1);
{
std::ostringstream oss;
proxy.Call("patnloop1", {"5"}, -1, PUT, oss);
REQUIRE(oss.str() == "patnloop1 5\n");
}
{
std::ostringstream oss;
proxy.Call("patnloop1", {}, -1, GET, oss);
REQUIRE(oss.str() == "patnloop1 5\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setPatternLoopCycles(1, prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("patnloop1", {}, -1, GET));
}
}
TEST_CASE("patnloop2", "[.cmd][.new]") {
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
det_type == defs::MYTHEN3) {
auto prev_val = det.getPatternLoopCycles(2);
{
std::ostringstream oss;
proxy.Call("patnloop2", {"5"}, -1, PUT, oss);
REQUIRE(oss.str() == "patnloop2 5\n");
}
{
std::ostringstream oss;
proxy.Call("patnloop2", {}, -1, GET, oss);
REQUIRE(oss.str() == "patnloop2 5\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setPatternLoopCycles(2, prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("patnloop2", {}, -1, GET));
}
}
TEST_CASE("patwait0", "[.cmd][.new]") {
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
det_type == defs::MYTHEN3) {
auto prev_val = det.getPatternWaitAddr(0);
{
std::ostringstream oss;
proxy.Call("patwait0", {"0x5c"}, -1, PUT, oss);
REQUIRE(oss.str() == "patwait0 0x5c\n");
}
{
std::ostringstream oss;
proxy.Call("patwait0", {}, -1, GET, oss);
REQUIRE(oss.str() == "patwait0 0x5c\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setPatternWaitAddr(0, prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("patwait0", {}, -1, GET));
}
}
TEST_CASE("patwait1", "[.cmd][.new]") {
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
det_type == defs::MYTHEN3) {
auto prev_val = det.getPatternWaitAddr(1);
{
std::ostringstream oss;
proxy.Call("patwait1", {"0x5c"}, -1, PUT, oss);
REQUIRE(oss.str() == "patwait1 0x5c\n");
}
{
std::ostringstream oss;
proxy.Call("patwait1", {}, -1, GET, oss);
REQUIRE(oss.str() == "patwait1 0x5c\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setPatternWaitAddr(1, prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("patwait1", {}, -1, GET));
}
}
TEST_CASE("patwait2", "[.cmd][.new]") {
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
det_type == defs::MYTHEN3) {
auto prev_val = det.getPatternWaitAddr(2);
{
std::ostringstream oss;
proxy.Call("patwait2", {"0x5c"}, -1, PUT, oss);
REQUIRE(oss.str() == "patwait2 0x5c\n");
}
{
std::ostringstream oss;
proxy.Call("patwait2", {}, -1, GET, oss);
REQUIRE(oss.str() == "patwait2 0x5c\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setPatternWaitAddr(2, prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("patwait2", {}, -1, GET));
}
}
TEST_CASE("patwaittime0", "[.cmd][.new]") {
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
det_type == defs::MYTHEN3) {
auto prev_val = det.getPatternWaitTime(0);
{
std::ostringstream oss;
proxy.Call("patwaittime0", {"8589936640"}, -1, PUT, oss);
REQUIRE(oss.str() == "patwaittime0 8589936640\n");
}
{
std::ostringstream oss;
proxy.Call("patwaittime0", {}, -1, GET, oss);
REQUIRE(oss.str() == "patwaittime0 8589936640\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setPatternWaitTime(0, prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("patwaittime0", {}, -1, GET));
}
}
TEST_CASE("patwaittime1", "[.cmd][.new]") {
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
det_type == defs::MYTHEN3) {
auto prev_val = det.getPatternWaitTime(1);
{
std::ostringstream oss;
proxy.Call("patwaittime1", {"8589936640"}, -1, PUT, oss);
REQUIRE(oss.str() == "patwaittime1 8589936640\n");
}
{
std::ostringstream oss;
proxy.Call("patwaittime1", {}, -1, GET, oss);
REQUIRE(oss.str() == "patwaittime1 8589936640\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setPatternWaitTime(1, prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("patwaittime1", {}, -1, GET));
}
}
TEST_CASE("patwaittime2", "[.cmd][.new]") {
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
det_type == defs::MYTHEN3) {
auto prev_val = det.getPatternWaitTime(2);
{
std::ostringstream oss;
proxy.Call("patwaittime2", {"8589936640"}, -1, PUT, oss);
REQUIRE(oss.str() == "patwaittime2 8589936640\n");
}
{
std::ostringstream oss;
proxy.Call("patwaittime2", {}, -1, GET, oss);
REQUIRE(oss.str() == "patwaittime2 8589936640\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setPatternWaitTime(2, prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("patwaittime2", {}, -1, GET));
}
}
TEST_CASE("patmask", "[.cmd][.new]") {
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
det_type == defs::MYTHEN3) {
auto prev_val = det.getPatternMask();
{
std::ostringstream oss;
proxy.Call("patmask", {"0x842f020204200dc0"}, -1, PUT, oss);
REQUIRE(oss.str() == "patmask 0x842f020204200dc0\n");
}
{
std::ostringstream oss;
proxy.Call("patmask", {}, -1, GET, oss);
REQUIRE(oss.str() == "patmask 0x842f020204200dc0\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setPatternMask(prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("patmask", {}, -1, GET));
}
}
TEST_CASE("patsetbit", "[.cmd][.new]") {
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::CHIPTESTBOARD || det_type == defs::MOENCH ||
det_type == defs::MYTHEN3) {
auto prev_val = det.getPatternBitMask();
{
std::ostringstream oss;
proxy.Call("patsetbit", {"0x842f020204200dc0"}, -1, PUT, oss);
REQUIRE(oss.str() == "patsetbit 0x842f020204200dc0\n");
}
{
std::ostringstream oss;
proxy.Call("patsetbit", {}, -1, GET, oss);
REQUIRE(oss.str() == "patsetbit 0x842f020204200dc0\n");
}
for (int i = 0; i != det.size(); ++i) {
det.setPatternBitMask(prev_val[i], {i});
}
} else {
REQUIRE_THROWS(proxy.Call("patsetbit", {}, -1, GET));
}
}
TEST_CASE("patternstart", "[.cmd][.new]") {
Detector det;
CmdProxy proxy(&det);
auto det_type = det.getDetectorType().squash();
if (det_type == defs::MYTHEN3) {
REQUIRE_THROWS(proxy.Call("patternstart", {}, -1, PUT));
} else {
REQUIRE_THROWS(proxy.Call("patternstart", {}, -1, PUT));
}
}

319
slsDetectorSoftware/tests/test-CmdProxy.cpp
View File

@ -1951,325 +1951,6 @@ TEST_CASE("resetfpga", "[.cmd]") {
// REQUIRE_NOTHROW(multiSlsDetectorClient("rx_jsonaddheader \"\"", PUT));
// }
// TEST_CASE("patsetbit", "[.cmd][.ctb]") {
// if (test::type == defs::CHIPTESTBOARD) {
// uint64_t val = 0;
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("patsetbit", GET, nullptr,
// oss)); std::string s = (oss.str()).erase (0, strlen("patsetbit
// ")); val = stoul(s, 0, 16);
// }
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("patsetbit
// 0x842f020204200dc0", PUT, nullptr, oss)); REQUIRE(oss.str() ==
// "patsetbit 0x842f020204200dc0\n");
// }
// REQUIRE_NOTHROW(multiSlsDetectorClient("patsetbit " +
// sls::ToStringHex(val), PUT));
// } else {
// REQUIRE_THROWS(multiSlsDetectorClient("patsetbit", GET));
// }
// }
// TEST_CASE("patmask", "[.cmd][.ctb]") {
// if (test::type == defs::CHIPTESTBOARD) {
// uint64_t val = 0;
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("patmask", GET, nullptr,
// oss)); std::string s = (oss.str()).erase (0, strlen("patmask "));
// val = stoul(s, 0, 16);
// }
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("patmask
// 0x842f020204200dc0", PUT, nullptr, oss)); REQUIRE(oss.str() ==
// "patmask 0x842f020204200dc0\n");
// }
// REQUIRE_NOTHROW(multiSlsDetectorClient("patmask " +
// sls::ToStringHex(val), PUT));
// } else {
// REQUIRE_THROWS(multiSlsDetectorClient("patmask", GET));
// }
// }
// TEST_CASE("patwaittime", "[.cmd][.ctb]") {
// for (int loop = 0; loop < 3; ++loop) {
// if (test::type == defs::CHIPTESTBOARD) {
// uint64_t val = 0;
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("patwaittime" +
// std::to_string(loop), GET, nullptr, oss)); std::string s =
// (oss.str()).erase (0, strlen("patwaittime") + 2); val =
// std::stoul(s);
// }
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("patwaittime" +
// std::to_string(loop) + " 8589936640", PUT, nullptr, oss));
// REQUIRE(oss.str() == "patwaittime" + std::to_string(loop) + "
// 8589936640\n");
// }
// REQUIRE_NOTHROW(multiSlsDetectorClient("patwaittime" +
// std::to_string(loop) + ' ' + std::to_string(val), PUT));
// } else {
// REQUIRE_THROWS(multiSlsDetectorClient("patwaittime" +
// std::to_string(loop), GET));
// }
// }
// }
// TEST_CASE("patwait", "[.cmd][.ctb]") {
// for (int loop = 0; loop < 3; ++loop) {
// if (test::type == defs::CHIPTESTBOARD) {
// int val = 0;
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("patwait" +
// std::to_string(loop), GET, nullptr, oss)); std::string s =
// (oss.str()).erase (0, strlen("patwait") + 2); val = stoul(s,
// 0, 16);
// }
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("patwait" +
// std::to_string(loop) + " 0x5c", PUT, nullptr, oss));
// REQUIRE(oss.str() == "patwait" + std::to_string(loop) + "
// 0x5c\n");
// }
// REQUIRE_NOTHROW(multiSlsDetectorClient("patwait" +
// std::to_string(loop) + ' ' + sls::ToStringHex(val), PUT));
// } else {
// REQUIRE_THROWS(multiSlsDetectorClient("patwait" +
// std::to_string(loop), GET));
// }
// }
// }
// TEST_CASE("patnloop", "[.cmd][.ctb]") {
// for (int loop = 0; loop < 3; ++loop) {
// if (test::type == defs::CHIPTESTBOARD) {
// int val = 0;
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("patnloop" +
// std::to_string(loop), GET, nullptr, oss)); std::string s =
// (oss.str()).erase (0, strlen("patnloop") + 2); val =
// std::stoi(s);
// }
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("patnloop" +
// std::to_string(loop) + " 5", PUT, nullptr, oss));
// REQUIRE(oss.str() == "patnloop" + std::to_string(loop) + "
// 5\n");
// }
// REQUIRE_NOTHROW(multiSlsDetectorClient("patnloop" +
// std::to_string(loop) + ' ' + std::to_string(val), PUT));
// } else {
// REQUIRE_THROWS(multiSlsDetectorClient("patnloop" +
// std::to_string(loop), GET));
// }
// }
// }
// TEST_CASE("patloop", "[.cmd][.ctb]") {
// for (int loop = 0; loop < 3; ++loop) {
// if (test::type == defs::CHIPTESTBOARD) {
// uint32_t limit1 = 0, limit2 = 0;
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("patloop" +
// std::to_string(loop), GET, nullptr, oss)); std::string s =
// oss.str(); auto t = sls::split(s, ' '); s = t[1].erase (0,
// 1); limit1 = stoul(s, 0, 16); limit2 = stoul(t[2], 0, 16);
// }
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("patloop" +
// std::to_string(loop) + " 0x20 0x5c", PUT, nullptr, oss));
// REQUIRE(oss.str() == "patloop" + std::to_string(loop) + "
// [0x20, 0x5c]\n");
// }
// REQUIRE_NOTHROW(multiSlsDetectorClient("patloop" +
// std::to_string(loop) + ' ' + sls::ToStringHex(limit1) + ' ' +
// sls::ToStringHex(limit2), PUT));
// REQUIRE_THROWS(multiSlsDetectorClient("patloop" +
// std::to_string(loop) + " 0x3", PUT));
// } else {
// REQUIRE_THROWS(multiSlsDetectorClient("patloop" +
// std::to_string(loop), GET));
// }
// }
// }
// TEST_CASE("patlimits", "[.cmd][.ctb]") {
// if (test::type == defs::CHIPTESTBOARD) {
// uint32_t patlimit1 = 0, patlimit2 = 0;
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("patlimits", GET, nullptr,
// oss)); std::string s = oss.str(); auto t = sls::split(s, ' '); s
// = t[1].erase (0, 1); patlimit1 = stoul(s, 0, 16); patlimit2 =
// stoul(t[2], 0, 16);
// }
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("patlimits 0x20 0x5c",
// PUT, nullptr, oss)); REQUIRE(oss.str() == "patlimits [0x20,
// 0x5c]\n");
// }
// REQUIRE_NOTHROW(multiSlsDetectorClient("patlimits " +
// sls::ToStringHex(patlimit1) + ' ' + sls::ToStringHex(patlimit2),
// PUT));
// } else {
// REQUIRE_THROWS(multiSlsDetectorClient("patlimits", GET));
// }
// }
// TEST_CASE("patword", "[.cmd][.ctb]") {
// if (test::type == defs::CHIPTESTBOARD) {
// uint64_t prev_value = 0;
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("patword 0x23", GET,
// nullptr, oss)); std::string s = (oss.str()).erase (0,
// strlen("patword ")); prev_value = stoul(s, 0, 16);
// }
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("patword 0x23
// 0xc15004808d0a21a4", PUT, nullptr, oss)); REQUIRE(oss.str() ==
// "patword [0x23, 0xc15004808d0a21a4]\n");
// }
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("patword 0x23 0x0", PUT,
// nullptr, oss)); REQUIRE(oss.str() == "patword [0x23, 0x0]\n");
// }
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("patword 0x23", GET,
// nullptr, oss)); REQUIRE(oss.str() == "patword 0x0\n");
// }
// REQUIRE_NOTHROW(multiSlsDetectorClient("patword 0x23 " +
// std::to_string(prev_value), PUT));
// } else {
// REQUIRE_THROWS(multiSlsDetectorClient("patword 0x23", GET));
// }
// }
// TEST_CASE("patclkctrl", "[.cmd][.ctb]") {
// if (test::type == defs::CHIPTESTBOARD) {
// uint64_t prev_value = 0;
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("patclkctrl", GET,
// nullptr, oss)); std::string s = (oss.str()).erase (0,
// strlen("patclkctrl ")); prev_value = stoul(s, 0, 16);
// }
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("patclkctrl
// 0xc15004808d0a21a4", PUT, nullptr, oss)); REQUIRE(oss.str() ==
// "patclkctrl 0xc15004808d0a21a4\n");
// }
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("patclkctrl 0x0", PUT,
// nullptr, oss)); REQUIRE(oss.str() == "patclkctrl 0x0\n");
// }
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("patclkctrl", GET,
// nullptr, oss)); REQUIRE(oss.str() == "patclkctrl 0x0\n");
// }
// REQUIRE_NOTHROW(multiSlsDetectorClient("patclkctrl " +
// std::to_string(prev_value), PUT));
// } else {
// REQUIRE_THROWS(multiSlsDetectorClient("patclkctrl", GET));
// }
// }
// TEST_CASE("patioctrl", "[.cmd][.ctb]") {
// if (test::type == defs::CHIPTESTBOARD) {
// uint64_t prev_value = 0;
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("patioctrl", GET, nullptr,
// oss)); std::string s = (oss.str()).erase (0, strlen("patioctrl
// ")); prev_value = stoul(s, 0, 16);
// }
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("patioctrl
// 0xc15004808d0a21a4", PUT, nullptr, oss)); REQUIRE(oss.str() ==
// "patioctrl 0xc15004808d0a21a4\n");
// }
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("patioctrl 0x0", PUT,
// nullptr, oss)); REQUIRE(oss.str() == "patioctrl 0x0\n");
// }
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("patioctrl", GET, nullptr,
// oss)); REQUIRE(oss.str() == "patioctrl 0x0\n");
// }
// REQUIRE_NOTHROW(multiSlsDetectorClient("patioctrl " +
// std::to_string(prev_value), PUT));
// } else {
// REQUIRE_THROWS(multiSlsDetectorClient("patioctrl", GET));
// }
// }
// TEST_CASE("savepattern", "[.cmd][.ctb]") {
// REQUIRE_THROWS(multiSlsDetectorClient("savepattern", GET));
// if (test::type == defs::CHIPTESTBOARD) {
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("savepattern
// /tmp/pat.txt", PUT, nullptr, oss)); REQUIRE(oss.str() ==
// "savepattern /tmp/pat.txt\n");
// }
// } else {
// REQUIRE_THROWS(multiSlsDetectorClient("savepattern /tmp/pat.txt",
// PUT));
// }
// }
// TEST_CASE("pattern", "[.cmd][.ctb]") {
// REQUIRE_THROWS(multiSlsDetectorClient("pattern", GET));
// if (test::type == defs::CHIPTESTBOARD) {
// ;// todo test with real file?
// }
// }
// TEST_CASE("led", "[.cmd][.ctb]") {
// if (test::type == defs::CHIPTESTBOARD) {
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("led 1", PUT, nullptr,
// oss)); REQUIRE(oss.str() == "led 1\n");
// }
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("led 0", PUT, nullptr,
// oss)); REQUIRE(oss.str() == "led 0\n");
// }
// {
// std::ostringstream oss;
// REQUIRE_NOTHROW(multiSlsDetectorClient("led", GET, nullptr,
// oss)); REQUIRE(oss.str() == "led 0\n");
// }
// } else {
// REQUIRE_THROWS(multiSlsDetectorClient("led", GET));
// }
// }
// TEST_CASE("adcinvert", "[.cmd][.ctb]") {
// if (test::type == defs::CHIPTESTBOARD || test::type ==
// defs::JUNGFRAU) {