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

Revert "tests add to namespace sls (#464)" (#465)

Browse Source 
This reverts commit f5745fcf18.
This commit is contained in:
Dhanya Thattil
2022-05-20 15:43:48 +02:00
committed by GitHub
parent f5745fcf18
commit 8656eeec25
44 changed files with 228 additions and 350 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
slsSupportLib/tests/test-Sockets.cpp
View File

@ -8,11 +8,9 @@
#include <iostream>
#include <thread>
namespace sls {
std::vector<char> server() {
std::cout << "starting server\n";
auto server = ServerSocket(1950);
auto server = sls::ServerSocket(1950);
auto s = server.accept();
std::vector<char> buffer(100, '\0');
s.Receive(buffer.data(), buffer.size());
@ -35,7 +33,7 @@ TEST_CASE("The server recive the same message as we send", "[support]") {
auto s = std::async(std::launch::async, server);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
auto client = DetectorSocket("localhost", 1950);
auto client = sls::DetectorSocket("localhost", 1950);
client.Send(sent_message.data(), sent_message.size());
client.Receive(received_message.data(), received_message.size());
client.close();
@ -47,7 +45,5 @@ TEST_CASE("The server recive the same message as we send", "[support]") {
}
TEST_CASE("throws on no server", "[support]") {
CHECK_THROWS(DetectorSocket("localhost", 1950));
}
} // namespace sls
CHECK_THROWS(sls::DetectorSocket("localhost", 1950));
}

17
slsSupportLib/tests/test-StaticVector.cpp
View File

@ -7,11 +7,10 @@
#include <array>
#include <sstream>
#include <vector>
namespace sls {
using sls::StaticVector;
TEST_CASE("StaticVector is a container") {
REQUIRE(is_container<StaticVector<int, 7>>::value == true);
REQUIRE(sls::is_container<StaticVector<int, 7>>::value == true);
}
TEST_CASE("Comparing StaticVector containers") {
@ -318,15 +317,15 @@ SCENARIO("Converting to vector", "[support]") {
}
}
TEST_CASE("StaticVector") {
StaticVector<int, 5> vec;
TEST_CASE("sls::StaticVector") {
sls::StaticVector<int, 5> vec;
vec.push_back(3);
vec.push_back(8);
REQUIRE(ToString(vec) == "[3, 8]");
REQUIRE(sls::ToString(vec) == "[3, 8]");
}
TEST_CASE("StaticVector stream") {
StaticVector<int, 5> vec;
TEST_CASE("sls::StaticVector stream") {
sls::StaticVector<int, 5> vec;
vec.push_back(33);
vec.push_back(85667);
vec.push_back(2);
@ -334,5 +333,3 @@ TEST_CASE("StaticVector stream") {
oss << vec;
REQUIRE(oss.str() == "[33, 85667, 2]");
}
} // namespace sls

10
slsSupportLib/tests/test-Timer.cpp
View File

@ -6,11 +6,9 @@
#include <chrono>
#include <thread>
namespace sls {
TEST_CASE("Time 1s restart then time 2s", "[.timer]") {
auto sleep_duration = std::chrono::seconds(1);
auto t = Timer();
auto t = sls::Timer();
std::this_thread::sleep_for(sleep_duration);
REQUIRE(t.elapsed_s() == Approx(1).epsilon(0.01));
@ -21,9 +19,7 @@ TEST_CASE("Time 1s restart then time 2s", "[.timer]") {
TEST_CASE("Return ms", "[.timer]") {
auto sleep_duration = std::chrono::milliseconds(1300);
auto t = Timer();
auto t = sls::Timer();
std::this_thread::sleep_for(sleep_duration);
REQUIRE(t.elapsed_ms() == Approx(1300).epsilon(0.5));
}
} // namespace sls
}

57
slsSupportLib/tests/test-ToString.cpp
View File

@ -12,8 +12,11 @@
#include <sstream>
#include <vector>
namespace sls {
// using namespace sls;
using sls::defs;
using sls::StringTo;
using sls::ToString;
using sls::ToStringHex;
using namespace sls::time;
TEST_CASE("Integer conversions", "[support]") {
@ -88,9 +91,9 @@ TEST_CASE("Array") {
}
TEST_CASE("Convert types with str method") {
IpAddr addr;
sls::IpAddr addr;
REQUIRE(ToString(addr) == "0.0.0.0");
REQUIRE(ToString(IpAddr{}) == "0.0.0.0");
REQUIRE(ToString(sls::IpAddr{}) == "0.0.0.0");
}
TEST_CASE("String to string", "[support]") {
@ -322,41 +325,39 @@ TEST_CASE("Printing c style arrays of double") {
}
TEST_CASE("Print a member of patternParameters") {
auto pat = make_unique<patternParameters>();
auto pat = sls::make_unique<sls::patternParameters>();
pat->limits[0] = 4;
pat->limits[1] = 100;
REQUIRE(ToString(pat->limits) == "[4, 100]");
}
TEST_CASE("streamingInterface") {
REQUIRE(ToString(defs::streamingInterface::NONE) == "none");
REQUIRE(ToString(defs::streamingInterface::ETHERNET_10GB) == "10gbe");
REQUIRE(ToString(defs::streamingInterface::LOW_LATENCY_LINK) == "lll");
REQUIRE(ToString(defs::streamingInterface::LOW_LATENCY_LINK |
defs::streamingInterface::ETHERNET_10GB) ==
REQUIRE(ToString(sls::defs::streamingInterface::NONE) == "none");
REQUIRE(ToString(sls::defs::streamingInterface::ETHERNET_10GB) == "10gbe");
REQUIRE(ToString(sls::defs::streamingInterface::LOW_LATENCY_LINK) == "lll");
REQUIRE(ToString(sls::defs::streamingInterface::LOW_LATENCY_LINK |
sls::defs::streamingInterface::ETHERNET_10GB) ==
"lll, 10gbe");
}
// Speed level
TEST_CASE("speedLevel to string") {
REQUIRE(ToString(defs::speedLevel::FULL_SPEED) == "full_speed");
REQUIRE(ToString(defs::speedLevel::HALF_SPEED) == "half_speed");
REQUIRE(ToString(defs::speedLevel::QUARTER_SPEED) == "quarter_speed");
REQUIRE(ToString(defs::speedLevel::G2_108MHZ) == "108");
REQUIRE(ToString(defs::speedLevel::G2_144MHZ) == "144");
REQUIRE(ToString(sls::defs::speedLevel::FULL_SPEED) == "full_speed");
REQUIRE(ToString(sls::defs::speedLevel::HALF_SPEED) == "half_speed");
REQUIRE(ToString(sls::defs::speedLevel::QUARTER_SPEED) == "quarter_speed");
REQUIRE(ToString(sls::defs::speedLevel::G2_108MHZ) == "108");
REQUIRE(ToString(sls::defs::speedLevel::G2_144MHZ) == "144");
}
TEST_CASE("string to speedLevel") {
REQUIRE(StringTo<defs::speedLevel>("full_speed") ==
defs::speedLevel::FULL_SPEED);
REQUIRE(StringTo<defs::speedLevel>("half_speed") ==
defs::speedLevel::HALF_SPEED);
REQUIRE(StringTo<defs::speedLevel>("quarter_speed") ==
defs::speedLevel::QUARTER_SPEED);
REQUIRE(StringTo<defs::speedLevel>("108") ==
defs::speedLevel::G2_108MHZ);
REQUIRE(StringTo<defs::speedLevel>("144") ==
defs::speedLevel::G2_144MHZ);
}
} // namespace sls
REQUIRE(StringTo<sls::defs::speedLevel>("full_speed") ==
sls::defs::speedLevel::FULL_SPEED);
REQUIRE(StringTo<sls::defs::speedLevel>("half_speed") ==
sls::defs::speedLevel::HALF_SPEED);
REQUIRE(StringTo<sls::defs::speedLevel>("quarter_speed") ==
sls::defs::speedLevel::QUARTER_SPEED);
REQUIRE(StringTo<sls::defs::speedLevel>("108") ==
sls::defs::speedLevel::G2_108MHZ);
REQUIRE(StringTo<sls::defs::speedLevel>("144") ==
sls::defs::speedLevel::G2_144MHZ);
}

34
slsSupportLib/tests/test-TypeTraits.cpp
View File

@ -8,8 +8,6 @@
#include <sstream>
#include <vector>
namespace sls {
// Dummy classes only used here for testing
class DummyWithStr {
public:
@ -21,37 +19,35 @@ class DummyNoStr {
std::string somethingelse();
};
TEST_CASE("is_container") {
TEST_CASE("sls::is_container") {
CHECK(is_container<std::vector<int>>::value == true);
CHECK(is_container<std::array<double, 3>>::value == true);
CHECK(sls::is_container<std::vector<int>>::value == true);
CHECK(sls::is_container<std::array<double, 3>>::value == true);
}
TEST_CASE("Check for str() method") {
REQUIRE(has_str<DummyWithStr>::value == true);
REQUIRE(has_str<DummyNoStr>::value == false);
REQUIRE(sls::has_str<DummyWithStr>::value == true);
REQUIRE(sls::has_str<DummyNoStr>::value == false);
}
TEST_CASE("Check for str() on ostream") {
REQUIRE(has_str<std::ostringstream>::value == true);
REQUIRE(sls::has_str<std::ostringstream>::value == true);
}
TEST_CASE("is_duration") {
REQUIRE(is_duration<std::chrono::nanoseconds>::value == true);
REQUIRE(is_duration<std::chrono::seconds>::value == true);
REQUIRE(is_duration<std::chrono::hours>::value == true);
TEST_CASE("sls::is_duration") {
REQUIRE(sls::is_duration<std::chrono::nanoseconds>::value == true);
REQUIRE(sls::is_duration<std::chrono::seconds>::value == true);
REQUIRE(sls::is_duration<std::chrono::hours>::value == true);
REQUIRE(is_duration<int>::value == false);
REQUIRE(is_duration<std::vector<int>>::value == false);
REQUIRE(sls::is_duration<int>::value == false);
REQUIRE(sls::is_duration<std::vector<int>>::value == false);
}
TEST_CASE("initializer list") {
REQUIRE(is_light_container<std::initializer_list<int>>::value == true);
REQUIRE(sls::is_light_container<std::initializer_list<int>>::value == true);
}
TEST_CASE("Check for emplace back") {
// we know vector should have this its the type trait that is tested
REQUIRE(has_emplace_back<std::vector<int>>::value == true);
}
} // namespace sls
REQUIRE(sls::has_emplace_back<std::vector<int>>::value == true);
}

22
slsSupportLib/tests/test-UdpRxSocket.cpp
View File

@ -15,8 +15,6 @@
#include <unistd.h>
#include <vector>
namespace sls {
constexpr int default_port = 50001;
int open_socket(int port) {
@ -33,16 +31,16 @@ int open_socket(int port) {
const std::string portname = std::to_string(port);
if (getaddrinfo(host, portname.c_str(), &hints, &res)) {
throw RuntimeError("Failed at getaddrinfo with " +
throw sls::RuntimeError("Failed at getaddrinfo with " +
std::string(host));
}
int fd = socket(res->ai_family, res->ai_socktype, res->ai_protocol);
if (fd == -1) {
throw RuntimeError("Failed to create UDP RX socket");
throw sls::RuntimeError("Failed to create UDP RX socket");
}
if (connect(fd, res->ai_addr, res->ai_addrlen)) {
throw RuntimeError("Failed to connect socket");
throw sls::RuntimeError("Failed to connect socket");
}
freeaddrinfo(res);
return fd;
@ -51,7 +49,7 @@ int open_socket(int port) {
TEST_CASE("Get packet size returns the packet size we set in the constructor") {
constexpr int port = 50001;
constexpr ssize_t packet_size = 8000;
UdpRxSocket s{port, packet_size};
sls::UdpRxSocket s{port, packet_size};
CHECK(s.getPacketSize() == packet_size);
}
@ -62,7 +60,7 @@ TEST_CASE("Receive data from a vector") {
ssize_t packet_size =
sizeof(decltype(data_to_send)::value_type) * data_to_send.size();
UdpRxSocket udpsock{port, packet_size};
sls::UdpRxSocket udpsock{port, packet_size};
int fd = open_socket(port);
auto n = write(fd, data_to_send.data(), packet_size);
@ -76,13 +74,13 @@ TEST_CASE("Receive data from a vector") {
TEST_CASE("Shutdown socket without hanging when waiting for data") {
constexpr int port = 50001;
constexpr ssize_t packet_size = 8000;
UdpRxSocket s{port, packet_size};
sls::UdpRxSocket s{port, packet_size};
char buff[packet_size];
// Start a thread and wait for package
// if the socket is left open we would block
std::future<bool> ret =
std::async(&UdpRxSocket::ReceivePacket, &s, (char *)&buff);
std::async(&sls::UdpRxSocket::ReceivePacket, &s, (char *)&buff);
s.Shutdown();
auto r = ret.get();
@ -92,7 +90,7 @@ TEST_CASE("Shutdown socket without hanging when waiting for data") {
TEST_CASE("Too small packet") {
constexpr int port = 50001;
UdpRxSocket s(port, 2 * sizeof(uint32_t));
sls::UdpRxSocket s(port, 2 * sizeof(uint32_t));
auto fd = open_socket(port);
uint32_t val = 10;
write(fd, &val, sizeof(val));
@ -105,10 +103,8 @@ TEST_CASE("Receive an int to an external buffer") {
int to_send = 5;
int received = -1;
auto fd = open_socket(default_port);
UdpRxSocket s(default_port, sizeof(int));
sls::UdpRxSocket s(default_port, sizeof(int));
write(fd, &to_send, sizeof(to_send));
CHECK(s.ReceivePacket(reinterpret_cast<char *>(&received)));
CHECK(received == to_send);
}
} // namespace sls

7
slsSupportLib/tests/test-ZmqSocket.cpp
View File

@ -3,9 +3,6 @@
#include "catch.hpp"
#include "sls/ZmqSocket.h"
namespace sls {
TEST_CASE("Throws when cannot create socket") {
REQUIRE_THROWS(ZmqSocket("sdiasodjajpvv", 5076001));
}
@ -116,6 +113,4 @@ TEST_CASE("Send header and data") {
for (size_t i = 0; i != data.size(); ++i) {
REQUIRE(data[i] == received_data[i]);
}
}
} //namespace
}

16
slsSupportLib/tests/test-bit_utils.cpp
View File

@ -4,27 +4,25 @@
#include "sls/bit_utils.h"
#include <vector>
namespace sls {
TEST_CASE("Get set bits from 0") {
auto vec = getSetBits(0);
auto vec = sls::getSetBits(0);
REQUIRE(vec.empty());
}
TEST_CASE("Get set bits from 1") {
auto vec = getSetBits(1);
auto vec = sls::getSetBits(1);
REQUIRE(vec.size() == 1);
REQUIRE(vec[0] == 0);
}
TEST_CASE("Get set bits from 2") {
auto vec = getSetBits(2ul);
auto vec = sls::getSetBits(2ul);
REQUIRE(vec.size() == 1);
REQUIRE(vec[0] == 1);
}
TEST_CASE("Get set bits from 3") {
auto vec = getSetBits(3u);
auto vec = sls::getSetBits(3u);
REQUIRE(vec.size() == 2);
REQUIRE(vec[0] == 0);
REQUIRE(vec[1] == 1);
@ -32,14 +30,12 @@ TEST_CASE("Get set bits from 3") {
TEST_CASE("All bits set") {
uint8_t val = -1;
auto vec = getSetBits(val);
auto vec = sls::getSetBits(val);
REQUIRE(vec == std::vector<int>{0, 1, 2, 3, 4, 5, 6, 7});
}
TEST_CASE("Get set bits from 523") {
// 0b1000001011 == 523
auto vec = getSetBits(523);
auto vec = sls::getSetBits(523);
REQUIRE(vec == std::vector<int>{0, 1, 3, 9});
}
} // namespace sls

18
slsSupportLib/tests/test-container_utils.cpp
View File

@ -6,7 +6,7 @@
#include <string>
#include <vector>
namespace sls {
using namespace sls;
TEST_CASE("Equality of an empty vector", "[support]") {
std::vector<int> v;
@ -64,36 +64,36 @@ TEST_CASE("A vector of double with different values", "[support]") {
TEST_CASE("Sum of empty vector", "[support]") {
std::vector<float> v;
REQUIRE(sum(v) == Approx(0));
REQUIRE(sls::sum(v) == Approx(0));
}
TEST_CASE("Sum of vector", "[support]") {
std::vector<double> v{1.2, 2., 4.2, 4, 1.13};
REQUIRE(sum(v) == Approx(12.53));
REQUIRE(sls::sum(v) == Approx(12.53));
}
TEST_CASE("Minus one if different", "[support]") {
std::vector<double> v;
REQUIRE(v.empty());
double d = -1;
REQUIRE(minusOneIfDifferent(v) == d);
REQUIRE(sls::minusOneIfDifferent(v) == d);
SECTION("single element") {
v.push_back(7.3);
REQUIRE(v.size() == 1);
REQUIRE(minusOneIfDifferent(v) == Approx(7.3));
REQUIRE(sls::minusOneIfDifferent(v) == Approx(7.3));
}
SECTION("different elements") {
v.push_back(7.3);
v.push_back(1.0);
v.push_back(62.1);
REQUIRE(minusOneIfDifferent(v) == Approx(-1.0));
REQUIRE(sls::minusOneIfDifferent(v) == Approx(-1.0));
}
}
TEST_CASE("minus one does not have side effects", "[support]") {
std::vector<int> v{1, 1, 1};
int i = minusOneIfDifferent(v);
int i = sls::minusOneIfDifferent(v);
REQUIRE(i == 1);
i = 5;
REQUIRE(v[0] == 1);
@ -134,6 +134,4 @@ TEST_CASE("compare a vector of arrays", "[support]") {
arr.fill(-1);
std::vector<std::array<uint64_t, 3>> vec1{{5, 90, 8}, {5, 6, 8}, {5, 6, 8}};
CHECK(minusOneIfDifferent(vec1) == arr);
}
} // namespace sls
}

8
slsSupportLib/tests/test-file_utils.cpp
View File

@ -7,12 +7,10 @@
#include <unistd.h>
#include <vector>
namespace sls {
TEST_CASE("Get size of empty file") {
char fname[] = "temfile_XXXXXX";
std::ifstream ifs(fname);
auto size = getFileSize(ifs);
auto size = sls::getFileSize(ifs);
REQUIRE(size <= 0); // -1 or zero
}
@ -24,9 +22,7 @@ TEST_CASE("Get size of file with data") {
write(fh, data.data(), n_bytes);
std::ifstream ifs(fname);
auto size = getFileSize(ifs);
auto size = sls::getFileSize(ifs);
REQUIRE(size == n_bytes);
REQUIRE(ifs.tellg() == 0); // getting size resets pos!
}
} // namespace sls

6
slsSupportLib/tests/test-logger.cpp
View File

@ -6,7 +6,7 @@
#include <fstream>
#include <iostream>
namespace sls {
using sls::Logger;
TEST_CASE("LogLevel to string") {
CHECK(Logger::ToString(logERROR) == "ERROR");
@ -48,6 +48,4 @@ TEST_CASE("Test output") {
auto r = local.str();
auto pos = r.find("This should be printed");
CHECK(pos != std::string::npos);
}
} // namespace sls
}

4
slsSupportLib/tests/test-network_utils.cpp
View File

@ -10,7 +10,7 @@
#include "sls/sls_detector_exceptions.h"
#include "sls/string_utils.h"
namespace sls {
using namespace sls;
TEST_CASE("Convert mac address using classes", "[support]") {
@ -128,5 +128,3 @@ TEST_CASE("udp dst struct basic properties") {
}
// TODO!(Erik) Look up a real hostname and verify the IP
} // namespace sls

6
slsSupportLib/tests/test-sls_detector_defs.cpp
View File

@ -3,8 +3,6 @@
#include "catch.hpp"
#include "sls/sls_detector_defs.h"
namespace sls {
using dt = slsDetectorDefs::detectorType;
TEST_CASE("sls_detector_module default construction", "[support][new]") {
@ -77,6 +75,4 @@ TEST_CASE("compare two scanParameters") {
p0.enable = 1;
CHECK_FALSE(p0 == p1);
}
} // namespace sls
}

40
slsSupportLib/tests/test-string_utils.cpp
View File

@ -7,8 +7,6 @@
#include "sls/string_utils.h"
namespace sls {
TEST_CASE("copy a string") {
char src[10] = "hej";
@ -16,7 +14,7 @@ TEST_CASE("copy a string") {
char dst[20];
strcpy_safe(dst, src);
sls::strcpy_safe(dst, src);
REQUIRE(dst[0] == 'h');
REQUIRE(dst[1] == 'e');
REQUIRE(dst[2] == 'j');
@ -28,7 +26,7 @@ TEST_CASE("copy a string") {
TEST_CASE("copy a long string") {
auto src = "some very very long sting that does not fit";
char dst[3];
strcpy_safe(dst, src);
sls::strcpy_safe(dst, src);
REQUIRE(dst[0] == 's');
REQUIRE(dst[1] == 'o');
REQUIRE(dst[2] == '\0');
@ -37,7 +35,7 @@ TEST_CASE("copy a long string") {
TEST_CASE("split a string with end delimiter") {
std::string s("abra+kadabra+");
auto r = split(s, '+');
auto r = sls::split(s, '+');
REQUIRE(r.size() == 2);
REQUIRE(r[0] == "abra");
REQUIRE(r[1] == "kadabra");
@ -45,7 +43,7 @@ TEST_CASE("split a string with end delimiter") {
TEST_CASE("split a string without end delimiter") {
std::string s("abra+kadabra+filibom");
auto r = split(s, '+');
auto r = sls::split(s, '+');
REQUIRE(r.size() == 3);
REQUIRE(r[0] == "abra");
REQUIRE(r[1] == "kadabra");
@ -54,60 +52,58 @@ TEST_CASE("split a string without end delimiter") {
TEST_CASE("Remove char from string") {
char str[] = "sometest";
removeChar(str, 'e');
sls::removeChar(str, 'e');
REQUIRE(std::string(str) == "somtst");
}
TEST_CASE("Remove char from empty string") {
char str[50] = {};
removeChar(str, 'e');
sls::removeChar(str, 'e');
REQUIRE(std::string(str).empty());
}
TEST_CASE("Many characters in a row") {
char str[] = "someeequitellll::ongstring";
removeChar(str, 'l');
sls::removeChar(str, 'l');
REQUIRE(std::string(str) == "someeequite::ongstring");
}
TEST_CASE("Check is string is integer") {
REQUIRE(is_int("75"));
REQUIRE(is_int("11675"));
REQUIRE_FALSE(is_int("7.5"));
REQUIRE_FALSE(is_int("hej"));
REQUIRE_FALSE(is_int("7a"));
REQUIRE_FALSE(is_int(""));
REQUIRE(sls::is_int("75"));
REQUIRE(sls::is_int("11675"));
REQUIRE_FALSE(sls::is_int("7.5"));
REQUIRE_FALSE(sls::is_int("hej"));
REQUIRE_FALSE(sls::is_int("7a"));
REQUIRE_FALSE(sls::is_int(""));
}
TEST_CASE("Replace substring in string") {
std::string s = "this string should be replaced";
auto r = replace_first(&s, "string ", "");
auto r = sls::replace_first(&s, "string ", "");
REQUIRE(r == true);
REQUIRE(s == "this should be replaced");
}
TEST_CASE("Replace --help in command") {
std::string s = "sls_detector_get --help exptime";
auto r = replace_first(&s, " --help", "");
auto r = sls::replace_first(&s, " --help", "");
REQUIRE(r == true);
REQUIRE(s == "sls_detector_get exptime");
}
TEST_CASE("Replace -h in command") {
std::string s = "sls_detector_get -h exptime";
auto r = replace_first(&s, " -h", "");
auto r = sls::replace_first(&s, " -h", "");
REQUIRE(r == true);
REQUIRE(s == "sls_detector_get exptime");
}
TEST_CASE("replace --help") {
std::string s = "list --help";
auto r = replace_first(&s, " --help", "");
auto r = sls::replace_first(&s, " --help", "");
REQUIRE(r == true);
REQUIRE(s == "list");
}
// TEST_CASE("concat things not being strings")
} // namespace sls
// TEST_CASE("concat things not being strings")