ChimeraTK-DeviceAccess 03.25.00
Loading...
Searching...
No Matches
testUtilities.cpp
Go to the documentation of this file.
1// SPDX-FileCopyrightText: Deutsches Elektronen-Synchrotron DESY, MSK, ChimeraTK Project <chimeratk-support@desy.de>
2// SPDX-License-Identifier: LGPL-3.0-or-later
3
4#define BOOST_TEST_DYN_LINK
5#define BOOST_TEST_MODULE DeviceTest
6#include <boost/test/unit_test.hpp>
7using namespace boost::unit_test_framework;
8#include "BackendFactory.h"
9#include "DeviceInfoMap.h"
10#include "Exception.h"
11#include "SupportedUserTypes.h"
12#include "Utilities.h"
13
14#include <cstdint>
15#include <limits>
16
17#define VALID_SDM "sdm://./pci:pcieunidummys6;undefined"
18#define VALID_SDM_WITH_PARAMS "sdm://./dummy=goodMapFile.map"
19#define INVALID_SDM "://./pci:pcieunidummys6;" // no sdm at the start
20#define INVALID_SDM_2 "sdm://./pci:pcieunidummys6;;" // more than one semi-colons(;)
21#define INVALID_SDM_3 "sdm://./pci::pcieunidummys6;" // more than one colons(:)
22#define INVALID_SDM_4 "sdm://./dummy=goodMapFile.map=MapFile.map" // more than one equals to(=)
23#define INVALID_SDM_5 "sdm://.pci:pcieunidummys6;" // no slash (/) after host.
24#define VALID_PCI_STRING "/dev/mtcadummys0"
25#define VALID_DUMMY_STRING "testfile.map"
26#define VALID_DUMMY_STRING_2 "testfile.mapp"
27#define INVALID_DEVICE_STRING "/mtcadummys0"
28#define INVALID_DEVICE_STRING_2 "/dev"
29#define INVALID_DEVICE_STRING_3 "testfile.mappp"
30
31using namespace ChimeraTK;
32
33/**********************************************************************************************************************/
34
35BOOST_AUTO_TEST_CASE(testParseCDD) {
36 {
37 // check standard case
38 auto r = Utilities::parseDeviceDesciptor("(myBackendType:some/weired*address 234?par1=someValue with "
39 "spaces&map=file)");
40 BOOST_CHECK_EQUAL(r.backendType, "myBackendType");
41 BOOST_CHECK_EQUAL(r.address, "some/weired*address 234");
42 BOOST_CHECK_EQUAL(r.parameters.size(), 2);
43 BOOST_CHECK_EQUAL(r.parameters["par1"], "someValue with spaces");
44 BOOST_CHECK_EQUAL(r.parameters["map"], "file");
45 }
46 {
47 // check proper trimming
48 auto r = Utilities::parseDeviceDesciptor(" ( myBackendType : some/weired*address 234 ? par1 = "
49 "someValue with spaces & map = file ) ");
50 BOOST_CHECK_EQUAL(r.backendType, "myBackendType");
51 BOOST_CHECK_EQUAL(r.address, "some/weired*address 234");
52 BOOST_CHECK_EQUAL(r.parameters.size(), 2);
53 BOOST_CHECK_EQUAL(r.parameters["par1"], "someValue with spaces");
54 BOOST_CHECK_EQUAL(r.parameters["map"], "file");
55 }
56 {
57 // check only backend type
58 auto r = Utilities::parseDeviceDesciptor("(someStrangeBackendType)");
59 BOOST_CHECK_EQUAL(r.backendType, "someStrangeBackendType");
60 BOOST_CHECK_EQUAL(r.address, "");
61 BOOST_CHECK_EQUAL(r.parameters.size(), 0);
62 }
63 {
64 // check only backend type with address
65 auto r = Utilities::parseDeviceDesciptor("(pci:pcieunis6)");
66 BOOST_CHECK_EQUAL(r.backendType, "pci");
67 BOOST_CHECK_EQUAL(r.address, "pcieunis6");
68 BOOST_CHECK_EQUAL(r.parameters.size(), 0);
69 }
70 {
71 // check explicitly empty parameter list
72 auto r = Utilities::parseDeviceDesciptor("(pci:pcieunis6?)");
73 BOOST_CHECK_EQUAL(r.backendType, "pci");
74 BOOST_CHECK_EQUAL(r.address, "pcieunis6");
75 BOOST_CHECK_EQUAL(r.parameters.size(), 0);
76 }
77 {
78 // check explicitly empty parameter list with more empty parameters
79 auto r = Utilities::parseDeviceDesciptor("(pci:pcieunis6?&&)");
80 BOOST_CHECK_EQUAL(r.backendType, "pci");
81 BOOST_CHECK_EQUAL(r.address, "pcieunis6");
82 BOOST_CHECK_EQUAL(r.parameters.size(), 0);
83 }
84 {
85 // check only backend type with parameters
86 auto r = Utilities::parseDeviceDesciptor("(logicalNameMapper?map=myMapFile.xlmap)");
87 BOOST_CHECK_EQUAL(r.backendType, "logicalNameMapper");
88 BOOST_CHECK_EQUAL(r.address, "");
89 BOOST_CHECK_EQUAL(r.parameters.size(), 1);
90 BOOST_CHECK_EQUAL(r.parameters["map"], "myMapFile.xlmap");
91 }
92 {
93 // check explicitly empty address
94 auto r = Utilities::parseDeviceDesciptor("(logicalNameMapper:?map=myMapFile.xlmap)");
95 BOOST_CHECK_EQUAL(r.backendType, "logicalNameMapper");
96 BOOST_CHECK_EQUAL(r.address, "");
97 BOOST_CHECK_EQUAL(r.parameters.size(), 1);
98 BOOST_CHECK_EQUAL(r.parameters["map"], "myMapFile.xlmap");
99 }
100 {
101 // check explicitly empty parameters
102 auto r = Utilities::parseDeviceDesciptor("(logicalNameMapper?&map=myMapFile.xlmap& &a=b&)");
103 BOOST_CHECK_EQUAL(r.backendType, "logicalNameMapper");
104 BOOST_CHECK_EQUAL(r.address, "");
105 BOOST_CHECK_EQUAL(r.parameters.size(), 2);
106 BOOST_CHECK_EQUAL(r.parameters["map"], "myMapFile.xlmap");
107 BOOST_CHECK_EQUAL(r.parameters["a"], "b");
108 }
109 {
110 // check parameter value with equal sign
111 auto r = Utilities::parseDeviceDesciptor("(x?a=b=c)");
112 BOOST_CHECK_EQUAL(r.backendType, "x");
113 BOOST_CHECK_EQUAL(r.address, "");
114 BOOST_CHECK_EQUAL(r.parameters.size(), 1);
115 BOOST_CHECK_EQUAL(r.parameters["a"], "b=c");
116 }
117 {
118 // check escaping special characters
119 auto r = Utilities::parseDeviceDesciptor("(x:address\\?withQuestionmark?para=value\\&with\\&ampersand\\&&x="
120 "y\\\\&y=\\))");
121 BOOST_CHECK_EQUAL(r.backendType, "x");
122 BOOST_CHECK_EQUAL(r.address, "address?withQuestionmark");
123 BOOST_CHECK_EQUAL(r.parameters.size(), 3);
124 BOOST_CHECK_EQUAL(r.parameters["para"], "value&with&ampersand&");
125 BOOST_CHECK_EQUAL(r.parameters["x"], "y\\");
126 BOOST_CHECK_EQUAL(r.parameters["y"], ")");
127 }
128 {
129 // check nesting CDDs
130 auto r = Utilities::parseDeviceDesciptor("(nested:(pci:pcieunis6?map=dummy.map)?"
131 "anotherCdd=with(dummycdd)otherText)");
132 BOOST_CHECK_EQUAL(r.backendType, "nested");
133 BOOST_CHECK_EQUAL(r.address, "(pci:pcieunis6?map=dummy.map)");
134 BOOST_CHECK_EQUAL(r.parameters.size(), 1);
135 BOOST_CHECK_EQUAL(r.parameters["anotherCdd"], "with(dummycdd)otherText");
136 }
137 // check exceptions
138 BOOST_CHECK_THROW(Utilities::parseDeviceDesciptor(""), ChimeraTK::logic_error);
139 BOOST_CHECK_THROW(Utilities::parseDeviceDesciptor("noParantheses"), ChimeraTK::logic_error);
140 BOOST_CHECK_THROW(Utilities::parseDeviceDesciptor("( )"), ChimeraTK::logic_error);
141 BOOST_CHECK_THROW(Utilities::parseDeviceDesciptor("(backend)ExtraChars"), ChimeraTK::logic_error);
142 BOOST_CHECK_THROW(Utilities::parseDeviceDesciptor("(:address)"), ChimeraTK::logic_error);
143 BOOST_CHECK_THROW(Utilities::parseDeviceDesciptor("(bad_backend_name)"), ChimeraTK::logic_error);
144 BOOST_CHECK_THROW(Utilities::parseDeviceDesciptor("(x?keyNoValue)"), ChimeraTK::logic_error);
145 BOOST_CHECK_THROW(Utilities::parseDeviceDesciptor("(x?=valueNoKey)"), ChimeraTK::logic_error);
146 BOOST_CHECK_THROW(Utilities::parseDeviceDesciptor("(x?bad*key=value)"), ChimeraTK::logic_error);
147 BOOST_CHECK_THROW(Utilities::parseDeviceDesciptor("(x?key=value&key=duplicateKey)"), ChimeraTK::logic_error);
148 BOOST_CHECK_THROW(Utilities::parseDeviceDesciptor("(unmatchedParentheses"), ChimeraTK::logic_error);
149 BOOST_CHECK_THROW(
150 Utilities::parseDeviceDesciptor("(another:Unmatched?parentheses=in(aValue)"), ChimeraTK::logic_error);
151 BOOST_CHECK_THROW(
152 Utilities::parseDeviceDesciptor("(another:Unmatched?parentheses=in)aValue)"), ChimeraTK::logic_error);
153 BOOST_CHECK_THROW(Utilities::parseDeviceDesciptor("(badEscaping:a\\bc)"), ChimeraTK::logic_error);
154}
155/**********************************************************************************************************************/
156
157BOOST_AUTO_TEST_CASE(testParseSdm) {
158 Sdm sdm = Utilities::parseSdm(VALID_SDM);
159 BOOST_CHECK(sdm.host == ".");
160 BOOST_CHECK(sdm.interface == "pci");
161 BOOST_CHECK(sdm.instance == "pcieunidummys6");
162 BOOST_CHECK(sdm.parameters.size() == 0);
163 BOOST_CHECK(sdm.protocol == "undefined");
164
165 sdm = Utilities::parseSdm(VALID_SDM_WITH_PARAMS);
166 BOOST_CHECK(sdm.host == ".");
167 BOOST_CHECK(sdm.interface == "dummy");
168 BOOST_CHECK(sdm.parameters.size() == 1);
169 BOOST_CHECK(sdm.parameters.front() == "goodMapFile.map");
170 BOOST_CHECK_THROW(Utilities::parseSdm(""),
171 ChimeraTK::logic_error); // Empty string
172 BOOST_CHECK_THROW(Utilities::parseSdm("sdm:"),
173 ChimeraTK::logic_error); // shorter than sdm:// signature
174 BOOST_CHECK_THROW(Utilities::parseSdm(INVALID_SDM), ChimeraTK::logic_error);
175 BOOST_CHECK_THROW(Utilities::parseSdm(INVALID_SDM_2), ChimeraTK::logic_error);
176 BOOST_CHECK_THROW(Utilities::parseSdm(INVALID_SDM_3), ChimeraTK::logic_error);
177 BOOST_CHECK_THROW(Utilities::parseSdm(INVALID_SDM_4), ChimeraTK::logic_error);
178 BOOST_CHECK_THROW(Utilities::parseSdm(INVALID_SDM_5), ChimeraTK::logic_error);
179}
180
181/**********************************************************************************************************************/
182
183BOOST_AUTO_TEST_CASE(testParseDeviceString) {
184 Sdm sdm = Utilities::parseDeviceString(VALID_PCI_STRING);
185 BOOST_CHECK(sdm.interface == "pci");
186 sdm = Utilities::parseDeviceString(VALID_DUMMY_STRING);
187 BOOST_CHECK(sdm.interface == "dummy");
188 sdm = Utilities::parseDeviceString(VALID_DUMMY_STRING_2);
189 BOOST_CHECK(sdm.interface == "dummy");
190 sdm = Utilities::parseDeviceString(INVALID_DEVICE_STRING);
191 BOOST_CHECK(sdm.interface == "");
192 sdm = Utilities::parseDeviceString(INVALID_DEVICE_STRING_2);
193 BOOST_CHECK(sdm.interface == "");
194 sdm = Utilities::parseDeviceString(INVALID_DEVICE_STRING_3);
195 BOOST_CHECK(sdm.interface == "");
196}
197
198/**********************************************************************************************************************/
199
200BOOST_AUTO_TEST_CASE(testcountOccurence) {
201 BOOST_CHECK(Utilities::countOccurence("this,is;a:test,string", ',') == 2); // 2 commas
202 BOOST_CHECK(Utilities::countOccurence("this,is;a:test,string", ';') == 1); // 1 semi-colon
203 BOOST_CHECK(Utilities::countOccurence("this,is;a:test,string", ':') == 1); // 1 colon
204}
205
206/**********************************************************************************************************************/
207
208BOOST_AUTO_TEST_CASE(testIsSdm) {
209 BOOST_CHECK(Utilities::isSdm(VALID_SDM) == true);
210 BOOST_CHECK(Utilities::isSdm(INVALID_SDM) == false);
211 BOOST_CHECK(Utilities::isSdm(VALID_PCI_STRING) == false);
212}
213
214/**********************************************************************************************************************/
215
216BOOST_AUTO_TEST_CASE(testAliasLookUp) {
217 std::string testFilePath = "./dummies.dmap";
218 BOOST_CHECK_THROW(Utilities::aliasLookUp("test", testFilePath), ChimeraTK::logic_error);
219 auto deviceInfo = Utilities::aliasLookUp("DUMMYD0", testFilePath);
220 BOOST_CHECK(deviceInfo.deviceName == "DUMMYD0");
221}
222
223/**********************************************************************************************************************/
224
225BOOST_AUTO_TEST_CASE(testgetAliasList) {
226 auto initialDmapFile = ChimeraTK::getDMapFilePath();
227
228 ChimeraTK::setDMapFilePath("");
229 BOOST_CHECK_THROW(Utilities::getAliasList(), ChimeraTK::logic_error);
230
231 // entries in dummies.dmap when this was written
232 std::vector<std::string> expectedListOfAliases{"PCIE1", "PCIE0", "PCIE2", "PCIE3", "PCIE0", "DUMMYD0", "DUMMYD1",
233 "DUMMYD2", "DUMMYD3", "DUMMYD9", "PERFTEST", "mskrebot", "mskrebot1", "OLD_PCIE", "SEQUENCES",
234 "INVALID_SEQUENCES", "PCIE_DOUBLEMAP", "REBOT_DOUBLEMAP", "REBOT_INVALID_HOST"};
235
236 ChimeraTK::setDMapFilePath("./dummies.dmap");
237 auto returnedListOfAliases = Utilities::getAliasList();
238 ChimeraTK::setDMapFilePath(initialDmapFile);
239
240 int index = 0;
241 BOOST_CHECK(returnedListOfAliases.size() == expectedListOfAliases.size());
242 for(auto alias : expectedListOfAliases) {
243 BOOST_CHECK(alias == returnedListOfAliases.at(index++));
244 }
245}
246
247/**********************************************************************************************************************/
248
249BOOST_AUTO_TEST_CASE(testUserTypeToUserType_Boolean) {
250 ChimeraTK::Boolean myBool{true};
251 BOOST_TEST(ChimeraTK::userTypeToUserType<std::string>(myBool) == "true");
252 BOOST_TEST(ChimeraTK::userTypeToUserType<int32_t>(myBool) == 1);
253
254 myBool = false;
255 BOOST_TEST(ChimeraTK::userTypeToUserType<std::string>(myBool) == "false");
256 BOOST_TEST(ChimeraTK::userTypeToUserType<int32_t>(myBool) == 0);
257
258 BOOST_TEST(ChimeraTK::userTypeToUserType<ChimeraTK::Boolean>(std::string("false")) == false);
259 BOOST_TEST(ChimeraTK::userTypeToUserType<ChimeraTK::Boolean>(std::string("False")) == false);
260 BOOST_TEST(ChimeraTK::userTypeToUserType<ChimeraTK::Boolean>(std::string("fAlSe")) == false);
261 BOOST_TEST(ChimeraTK::userTypeToUserType<ChimeraTK::Boolean>(std::string("0")) == false);
262 // BOOST_TEST(ChimeraTK::userTypeToUserType<ChimeraTK::Boolean>(std::string("00")) == false); //FIXME this should pass
263 BOOST_TEST(ChimeraTK::userTypeToUserType<ChimeraTK::Boolean>(std::string("")) == false);
264 BOOST_TEST(ChimeraTK::userTypeToUserType<ChimeraTK::Boolean>(std::string("true")) == true);
265 BOOST_TEST(ChimeraTK::userTypeToUserType<ChimeraTK::Boolean>(std::string("TRUE")) == true);
266 BOOST_TEST(ChimeraTK::userTypeToUserType<ChimeraTK::Boolean>(std::string("anyOtherString")) == true);
267}
268
269/**********************************************************************************************************************/
270
271BOOST_AUTO_TEST_CASE(testUserTypeToUserType_HexString) {
272 BOOST_CHECK_NO_THROW(ChimeraTK::userTypeToUserType<uint64_t>(std::string("banana"))); // invalid
273 BOOST_CHECK_NO_THROW(ChimeraTK::userTypeToUserType<uint64_t>(std::string("0xG"))); // invalid
274
275 BOOST_TEST(ChimeraTK::userTypeToUserType<ChimeraTK::Boolean>(std::string("0x0")) == false); // min, mid
276 BOOST_TEST(ChimeraTK::userTypeToUserType<ChimeraTK::Boolean>(std::string("0X1")) == true); // max, mid, big X
277 BOOST_TEST(ChimeraTK::userTypeToUserType<ChimeraTK::Boolean>(std::string("0x00BA0000F0cacc1a")) ==
278 true); // overflow, mixed case
279 BOOST_CHECK_NO_THROW(ChimeraTK::userTypeToUserType<ChimeraTK::Boolean>(std::string("0xDung"))); // invalid
280 BOOST_CHECK_NO_THROW(ChimeraTK::userTypeToUserType<ChimeraTK::Boolean>(std::string("0x"))); // empty test
281 // FIXME this should pass
282 // BOOST_TEST(ChimeraTK::userTypeToUserType<ChimeraTK::Boolean>(std::string("0x000")) == false); // odd extra zeros
283
284 BOOST_TEST(static_cast<int32_t>(ChimeraTK::userTypeToUserType<int8_t>(std::string("0x66"))) == 0x66); // mid+,
285 BOOST_TEST(
286 static_cast<int32_t>(ChimeraTK::userTypeToUserType<int8_t>(std::string("0X7F"))) == INT8_MAX); // max, big X
287 BOOST_TEST(static_cast<int32_t>(ChimeraTK::userTypeToUserType<int8_t>(std::string("0x00BA0000F0cacc1a"))) ==
288 INT8_MAX); // overflow, mixed case
289 BOOST_CHECK_NO_THROW(ChimeraTK::userTypeToUserType<int8_t>(std::string("0xDung"))); // invalid
290 BOOST_CHECK_NO_THROW(ChimeraTK::userTypeToUserType<int8_t>(std::string("0x"))); // empty test
291
292 BOOST_TEST(static_cast<uint32_t>(ChimeraTK::userTypeToUserType<uint8_t>(std::string("0x66"))) == 0x66); // mid+
293 BOOST_TEST(
294 static_cast<uint32_t>(ChimeraTK::userTypeToUserType<uint8_t>(std::string("0XFF"))) == UINT8_MAX); // max, big X
295 BOOST_TEST(static_cast<uint32_t>(ChimeraTK::userTypeToUserType<uint8_t>(std::string("0x0"))) == 0); // min
296 BOOST_TEST(static_cast<uint32_t>(ChimeraTK::userTypeToUserType<uint8_t>(std::string("0x00BA0000F0cacc1a"))) ==
297 UINT8_MAX); // overflow, mixed case
298 BOOST_CHECK_NO_THROW(ChimeraTK::userTypeToUserType<uint8_t>(std::string("0xDung"))); // invalid
299 BOOST_CHECK_NO_THROW(ChimeraTK::userTypeToUserType<uint8_t>(std::string("0x"))); // empty test
300
301 BOOST_TEST(ChimeraTK::userTypeToUserType<int16_t>(std::string("0x6666")) == 0x6666); // 0x6666 = 26214 mid+
302 BOOST_TEST(ChimeraTK::userTypeToUserType<int16_t>(std::string("0X7FFF")) == INT16_MAX); // max, big X
303 BOOST_TEST(
304 ChimeraTK::userTypeToUserType<int16_t>(std::string("0x00BA0000F0cacc1a")) == INT16_MAX); // overflow, mixed case
305 BOOST_CHECK_NO_THROW(ChimeraTK::userTypeToUserType<int16_t>(std::string("0xDung"))); // invalid
306 BOOST_CHECK_NO_THROW(ChimeraTK::userTypeToUserType<int16_t>(std::string("0x"))); // empty test
307
308 BOOST_TEST(ChimeraTK::userTypeToUserType<uint16_t>(std::string("0x6666")) == 0x6666); // mid+
309 BOOST_TEST(ChimeraTK::userTypeToUserType<uint16_t>(std::string("0XFFFF")) == UINT16_MAX); // max, big X
310 BOOST_TEST(ChimeraTK::userTypeToUserType<uint16_t>(std::string("0x0")) == 0); // min
311 BOOST_TEST(
312 ChimeraTK::userTypeToUserType<uint16_t>(std::string("0x00BA0000F0cacc1a")) == UINT16_MAX); // overflow, mixed case
313 BOOST_CHECK_NO_THROW(ChimeraTK::userTypeToUserType<uint16_t>(std::string("0xDung"))); // invalid
314 BOOST_CHECK_NO_THROW(ChimeraTK::userTypeToUserType<uint16_t>(std::string("0x"))); // empty test
315
316 BOOST_TEST(
317 ChimeraTK::userTypeToUserType<int32_t>(std::string("0x66666666")) == 0x6666'6666); // 0x6666'6666=1717986918 mid+
318 BOOST_TEST(ChimeraTK::userTypeToUserType<int32_t>(std::string("0X7FFFFFFF")) == INT32_MAX); // max, big X
319 BOOST_TEST(
320 ChimeraTK::userTypeToUserType<int32_t>(std::string("0x00BA0000F0cacc1a")) == INT32_MAX); // overflow, mixed case
321 BOOST_CHECK_NO_THROW(ChimeraTK::userTypeToUserType<int32_t>(std::string("0xDung"))); // invalid
322 BOOST_CHECK_NO_THROW(ChimeraTK::userTypeToUserType<int32_t>(std::string("0x"))); // empty test
323
324 BOOST_TEST(ChimeraTK::userTypeToUserType<uint32_t>(std::string("0x66666666")) == 0x6666'6666); // mid+
325 BOOST_TEST(ChimeraTK::userTypeToUserType<uint32_t>(std::string("0XFFFFFFFF")) == UINT32_MAX); // max, big X
326 BOOST_TEST(ChimeraTK::userTypeToUserType<uint32_t>(std::string("0x0")) == 0); // min
327 BOOST_TEST(
328 ChimeraTK::userTypeToUserType<uint32_t>(std::string("0x00BA0000F0cacc1a")) == UINT32_MAX); // overflow, mixed case
329 BOOST_CHECK_NO_THROW(ChimeraTK::userTypeToUserType<uint32_t>(std::string("0xDung"))); // invalid
330 BOOST_CHECK_NO_THROW(ChimeraTK::userTypeToUserType<uint32_t>(std::string("0x"))); // empty test
331
332 BOOST_TEST(ChimeraTK::userTypeToUserType<int64_t>(std::string("0x6666666666666666")) ==
333 0x6666'6666'6666'6666); // = 7378697629483820646 mid+
334 BOOST_TEST(ChimeraTK::userTypeToUserType<int64_t>(std::string("0X7FFFFFFFFFFFFFFF")) == INT64_MAX); // max, big X
335 BOOST_TEST(
336 ChimeraTK::userTypeToUserType<int64_t>(std::string("0x100BA0000F0cacc1a")) == INT64_MAX); // overflow, mixed case
337 // The previous two lines are likely to run out of room and report 0
338 BOOST_CHECK_NO_THROW(
339 ChimeraTK::userTypeToUserType<int64_t>(std::string("0xdung"))); // invalid, try lower case for a change.
340 BOOST_CHECK_NO_THROW(ChimeraTK::userTypeToUserType<int64_t>(std::string("0x"))); // empty test
341
342 BOOST_TEST(
343 ChimeraTK::userTypeToUserType<uint64_t>(std::string("0xC0CAC01AADD511FE")) == 0xC0CA'C01A'ADD5'11FE); // mid+
344 BOOST_TEST(ChimeraTK::userTypeToUserType<uint64_t>(std::string("0XFFFFFFFFFFFFFFFF")) == UINT64_MAX); // max, big X
345 BOOST_TEST(ChimeraTK::userTypeToUserType<uint64_t>(std::string("0x0")) == 0); // min
346 BOOST_TEST(ChimeraTK::userTypeToUserType<uint64_t>(std::string("0xFFFFFFFFFF0cacc1a")) ==
347 UINT64_MAX); // overflow, mixed case
348 BOOST_CHECK_NO_THROW(ChimeraTK::userTypeToUserType<uint64_t>(std::string("0xDung"))); // invalid
349 BOOST_CHECK_NO_THROW(ChimeraTK::userTypeToUserType<uint64_t>(std::string("0x"))); // empty test
350
351 BOOST_CHECK_CLOSE(ChimeraTK::userTypeToUserType<float>(std::string("0x66666666")), 1.71799e9, 1.71799e5);
352 BOOST_CHECK_NO_THROW(ChimeraTK::userTypeToUserType<float>(std::string("0xDung"))); // invalid
353 BOOST_CHECK_NO_THROW(ChimeraTK::userTypeToUserType<float>(std::string("0x"))); // empty test
354 //
355 BOOST_CHECK_CLOSE(
356 ChimeraTK::userTypeToUserType<double>(std::string("0x6666666666666666")), 7.3786976e18, 7.3786976e14); // mid+
357 BOOST_CHECK_NO_THROW(ChimeraTK::userTypeToUserType<double>(std::string("0xDung"))); // invalid
358 BOOST_CHECK_NO_THROW(ChimeraTK::userTypeToUserType<double>(std::string("0x"))); // empty test
359
360 BOOST_TEST(ChimeraTK::userTypeToUserType<std::string>(std::string("0xDung")) == "0xDung");
361}
362
363/**********************************************************************************************************************/
364
365BOOST_AUTO_TEST_CASE(testUserTypeToUserType_DecString) {
366 BOOST_TEST(ChimeraTK::userTypeToUserType<ChimeraTK::Boolean>(std::string("0")) == false); // mid+, min
367 BOOST_TEST(ChimeraTK::userTypeToUserType<ChimeraTK::Boolean>(std::string("1")) == true); // max
368 BOOST_TEST(ChimeraTK::userTypeToUserType<ChimeraTK::Boolean>(std::string("2")) == true); // overflow
369 BOOST_TEST(
370 ChimeraTK::userTypeToUserType<ChimeraTK::Boolean>(std::string("-7378697629483820646")) == true); // underflow
371 // invalid case is done in testUserTypeToUserType_Boolean
372
373 BOOST_TEST(static_cast<int32_t>(ChimeraTK::userTypeToUserType<int8_t>(std::string("102"))) == 102); // mid+
374 BOOST_TEST(static_cast<int32_t>(ChimeraTK::userTypeToUserType<int8_t>(std::string("-102"))) == -102); // mid-
375 BOOST_TEST(static_cast<int32_t>(ChimeraTK::userTypeToUserType<int8_t>(std::string("127"))) == INT8_MAX); // max
376 BOOST_TEST(static_cast<int32_t>(ChimeraTK::userTypeToUserType<int8_t>(std::string("-128"))) == INT8_MIN); // min
377 BOOST_TEST(static_cast<int32_t>(ChimeraTK::userTypeToUserType<int8_t>(std::string("300"))) == INT8_MAX); // overflow
378 BOOST_TEST(static_cast<int32_t>(ChimeraTK::userTypeToUserType<int8_t>(std::string("-300"))) == INT8_MIN); // underflow
379 // FIXME make this pass
380 // BOOST_TEST(
381 // static_cast<int32_t>(ChimeraTK::userTypeToUserType<int8_t>(std::string("73786976294838206460"))) == INT8_MAX);
382 // overflow
383
384 // FIXME make this pass
385 // BOOST_TEST(
386 // static_cast<int32_t>(ChimeraTK::userTypeToUserType<int8_t>(std::string("-73786976294838206460"))) == INT8_MIN);
387 // underflow
388
389 BOOST_CHECK_NO_THROW(ChimeraTK::userTypeToUserType<int8_t>(std::string("banana"))); // invalid
390
391 BOOST_TEST(static_cast<int32_t>(ChimeraTK::userTypeToUserType<uint8_t>(std::string("102"))) == 102); // mid+
392 BOOST_TEST(static_cast<int32_t>(ChimeraTK::userTypeToUserType<uint8_t>(std::string("255"))) == UINT8_MAX); // max
393 BOOST_TEST(static_cast<int32_t>(ChimeraTK::userTypeToUserType<uint8_t>(std::string("0"))) == 0); // min
394 BOOST_TEST(static_cast<int32_t>(ChimeraTK::userTypeToUserType<uint8_t>(std::string("300"))) == UINT8_MAX); // overflow
395 BOOST_TEST(static_cast<int32_t>(ChimeraTK::userTypeToUserType<uint8_t>(std::string("-5"))) == 0); // underflow pass
396 BOOST_CHECK_NO_THROW(ChimeraTK::userTypeToUserType<uint8_t>(std::string("banana"))); // invalid
397
398 BOOST_TEST(ChimeraTK::userTypeToUserType<int16_t>(std::string("26214")) == 26214); // mid+
399 BOOST_TEST(ChimeraTK::userTypeToUserType<int16_t>(std::string("-26214")) == -26214); // mid-
400 BOOST_TEST(ChimeraTK::userTypeToUserType<int16_t>(std::string("32767")) == INT16_MAX); // max
401 BOOST_TEST(ChimeraTK::userTypeToUserType<int16_t>(std::string("-32768")) == INT16_MIN); // min
402 BOOST_TEST(ChimeraTK::userTypeToUserType<int16_t>(std::string("73786976294838206460")) == INT16_MAX); // overflow
403 BOOST_TEST(ChimeraTK::userTypeToUserType<int16_t>(std::string("-73786976294838206460")) == INT16_MIN); // underflow
404 BOOST_CHECK_NO_THROW(ChimeraTK::userTypeToUserType<int16_t>(std::string("banana"))); // invalid
405
406 BOOST_TEST(ChimeraTK::userTypeToUserType<uint16_t>(std::string("26214")) == 26214); // mid+
407 BOOST_TEST(ChimeraTK::userTypeToUserType<uint16_t>(std::string("65535")) == UINT16_MAX); // max
408 BOOST_TEST(ChimeraTK::userTypeToUserType<uint16_t>(std::string("0")) == 0); // min
409 BOOST_TEST(ChimeraTK::userTypeToUserType<uint16_t>(std::string("73786976294838206460")) == UINT16_MAX); // overflow
410 // FIXME make this pass
411 // BOOST_TEST(ChimeraTK::userTypeToUserType<uint16_t>(std::string("-73786976294838206460")) == 0); // underflow
412 // FIXME make this pass
413 // BOOST_TEST(ChimeraTK::userTypeToUserType<uint16_t>(std::string("-5")) == 0); // underflow fail -5 = 65531.
414
415 BOOST_CHECK_NO_THROW(ChimeraTK::userTypeToUserType<uint16_t>(std::string("banana"))); // invalid
416
417 BOOST_TEST(ChimeraTK::userTypeToUserType<int32_t>(std::string("1717986918")) == 1717986918); // mid+
418 BOOST_TEST(ChimeraTK::userTypeToUserType<int32_t>(std::string("-1717986918")) == -1717986918); // mid-
419 BOOST_TEST(ChimeraTK::userTypeToUserType<int32_t>(std::string("2147483647")) == INT32_MAX); // max
420 BOOST_TEST(ChimeraTK::userTypeToUserType<int32_t>(std::string("-2147483648")) == INT32_MIN); // min
421 BOOST_TEST(ChimeraTK::userTypeToUserType<int32_t>(std::string("73786976294838206460")) == INT32_MAX); // overflow
422 BOOST_TEST(ChimeraTK::userTypeToUserType<int32_t>(std::string("-73786976294838206460")) == INT32_MIN); // underflow
423 BOOST_TEST(ChimeraTK::userTypeToUserType<int32_t>(std::string("banana")) == 0); // invalid
424
425 BOOST_TEST(ChimeraTK::userTypeToUserType<uint32_t>(std::string("1717986918")) == 1717986918); // mid+
426 BOOST_TEST(ChimeraTK::userTypeToUserType<uint32_t>(std::string("4294967295")) == UINT32_MAX); // max
427 BOOST_TEST(ChimeraTK::userTypeToUserType<uint32_t>(std::string("0")) == 0); // min
428 BOOST_TEST(ChimeraTK::userTypeToUserType<uint32_t>(std::string("73786976294838206460")) == UINT32_MAX); // overflow
429 // FIXME make this pass
430 // BOOST_TEST(ChimeraTK::userTypeToUserType<uint32_t>(std::string("-73786976294838206460")) == 0); // underflow
431 // FIXME make this pass
432 // BOOST_TEST(ChimeraTK::userTypeToUserType<uint32_t>(std::string("-5")) == 0); // underflow
433 BOOST_TEST(ChimeraTK::userTypeToUserType<uint32_t>(std::string("banana")) == 0); // invalid
434
435 BOOST_TEST(ChimeraTK::userTypeToUserType<int64_t>(std::string("7378697629483820646")) == 7378697629483820646); // mid+
436 BOOST_TEST(
437 ChimeraTK::userTypeToUserType<int64_t>(std::string("-7378697629483820646")) == -7378697629483820646); // mid-
438 BOOST_TEST(ChimeraTK::userTypeToUserType<int64_t>(std::string("9223372036854775807")) == INT64_MAX); // max
439 BOOST_TEST(ChimeraTK::userTypeToUserType<int64_t>(std::string("-9223372036854775808")) == INT64_MIN); // min
440 BOOST_TEST(ChimeraTK::userTypeToUserType<int64_t>(std::string("9223372036854775810")) == INT64_MAX); // overflow
441 BOOST_TEST(ChimeraTK::userTypeToUserType<int64_t>(std::string("-9223372036854775810")) == INT64_MIN); // underflow
442 // The previous two lines are likely to run out of room and report 0
443 BOOST_TEST(ChimeraTK::userTypeToUserType<int64_t>(std::string("banana")) == 0); // invalid
444
445 BOOST_TEST(
446 ChimeraTK::userTypeToUserType<uint64_t>(std::string("7378697629483820646")) == 7378697629483820646); // mid+
447 BOOST_TEST(ChimeraTK::userTypeToUserType<uint64_t>(std::string("18446744073709551615")) == UINT64_MAX); // max
448 BOOST_TEST(ChimeraTK::userTypeToUserType<uint64_t>(std::string("0")) == 0); // min
449 BOOST_TEST(ChimeraTK::userTypeToUserType<uint64_t>(std::string("18446744073709551625")) == UINT64_MAX); // overflow
450 // FIXME make this pass
451 // BOOST_TEST(ChimeraTK::userTypeToUserType<uint64_t>(std::string("-18446744073709551625")) == 0); // underflow
452 // FIXME make this pass
453 // BOOST_TEST(ChimeraTK::userTypeToUserType<uint64_t>(std::string("-5")) == 0); // underflow
454 BOOST_TEST(ChimeraTK::userTypeToUserType<uint64_t>(std::string("banana")) == 0); // invalid
455
456 BOOST_CHECK_CLOSE(ChimeraTK::userTypeToUserType<float>(std::string("3.14159")), 3.14159, 3.14159 / 1000.0); // mid+
457 BOOST_CHECK_CLOSE(
458 ChimeraTK::userTypeToUserType<float>(std::string("-3.14159e3")), -3.14159e3, 3.14159e3 / 1000.0); // mid-
459 BOOST_CHECK_CLOSE(ChimeraTK::userTypeToUserType<float>(std::string("3.40282e38")), std::numeric_limits<float>::max(),
460 std::numeric_limits<float>::max() / 1000.); // max
461 BOOST_CHECK_CLOSE(ChimeraTK::userTypeToUserType<float>(std::string("-3.40282e38")),
462 (-std::numeric_limits<float>::max()), std::numeric_limits<float>::max() / 1000.); // min
463 BOOST_CHECK_CLOSE(ChimeraTK::userTypeToUserType<float>(std::string("5.40282e39")), std::numeric_limits<float>::max(),
464 std::numeric_limits<float>::max() / 1000.); // overflow
465 BOOST_CHECK_CLOSE(ChimeraTK::userTypeToUserType<float>(std::string("-5.40282e39")),
466 (-std::numeric_limits<float>::max()), std::numeric_limits<float>::max() / 1000.); // underflow
467 BOOST_TEST(ChimeraTK::userTypeToUserType<float>(std::string("banana")) == 0.f); // invalid
468 BOOST_CHECK_CLOSE(
469 ChimeraTK::userTypeToUserType<float>(std::string("5")), 5.0f, 5.0 / 1000.); // float-int conversion good
470
471 BOOST_CHECK_CLOSE(ChimeraTK::userTypeToUserType<double>(std::string("2.718281828459")), 2.718281828459,
472 2.718281828459 / 1000.0); // mid+
473 BOOST_CHECK_CLOSE(ChimeraTK::userTypeToUserType<double>(std::string("-2.718281828459e3")), -2.718281828459e3,
474 2.718281828459e3 / 1000.0); // mid-
475 BOOST_CHECK_CLOSE(ChimeraTK::userTypeToUserType<double>(std::string("1.7976931e+308")),
476 std::numeric_limits<double>::max(), std::numeric_limits<double>::max() / 1000.); // max
477 BOOST_CHECK_CLOSE(ChimeraTK::userTypeToUserType<double>(std::string("-1.7976931e+308")),
478 (-std::numeric_limits<double>::max()), std::numeric_limits<double>::max() / 1000.); // min
479 BOOST_CHECK_CLOSE(ChimeraTK::userTypeToUserType<double>(std::string("1.8976931e+309")),
480 std::numeric_limits<double>::max(), std::numeric_limits<double>::max() / 1000.); // overflow
481 BOOST_CHECK_CLOSE(ChimeraTK::userTypeToUserType<double>(std::string("-1.8976931e+309")),
482 (-std::numeric_limits<double>::max()), std::numeric_limits<double>::max() / 1000.); // underflow
483 BOOST_CHECK_CLOSE(
484 ChimeraTK::userTypeToUserType<double>(std::string("5")), 5.0, 5.0 / 1000.); // double-int conversion good
485 BOOST_TEST(ChimeraTK::userTypeToUserType<double>(std::string("banana")) == 0.0); // invalid
486
487 BOOST_TEST(ChimeraTK::userTypeToUserType<std::string>(std::string("Any\r\nthing")) == "Any\r\nthing");
488}
ChimeraTK::Boolean
Wrapper Class to avoid vector<bool> problems.
Definition SupportedUserTypes.h:22
ChimeraTK::logic_error
Exception thrown when a logic error has occured.
Definition Exception.h:51
ChimeraTK::Utilities::parseDeviceDesciptor
DeviceDescriptor parseDeviceDesciptor(std::string cddString)
Parse a ChimeraTK device descriptor (CDD) and return the information in the DeviceDescriptor struct.
Definition Utilities.cpp:49
ChimeraTK::Utilities::getAliasList
std::vector< std::string > getAliasList()
Returns the list of device aliases from the DMap file set using BackendFactory::setDMapFilePath.
Definition Utilities.cpp:297
ChimeraTK::Utilities::aliasLookUp
DeviceInfoMap::DeviceInfo aliasLookUp(const std::string &aliasName, const std::string &dmapFilePath)
Search for an alias in a given DMap file and return the DeviceInfo entry.
Definition Utilities.cpp:288
ChimeraTK::Utilities::isSdm
bool isSdm(const std::string &theString)
Check wehter the given string seems to be an SDM.
Definition Utilities.cpp:30
ChimeraTK::Utilities::countOccurence
size_t countOccurence(std::string theString, char delimiter)
Check if the given string only contains alphanumeric characters.
Definition Utilities.cpp:23
ChimeraTK::Utilities::parseDeviceString
Sdm parseDeviceString(const std::string &deviceString)
Parse an old-style device string (either path to device node or map file name for dummies)
Definition Utilities.cpp:262
ChimeraTK::Utilities::parseSdm
Sdm parseSdm(const std::string &sdmString)
Parse an SDM URI and return the device information in the Sdm struct.
Definition Utilities.cpp:191
ChimeraTK::getDMapFilePath
std::string getDMapFilePath()
Returns the dmap file name which the library currently uses for looking up device(alias) names.
Definition Utilities.cpp:323
ChimeraTK::setDMapFilePath
void setDMapFilePath(std::string dmapFilePath)
Set the location of the dmap file.
Definition Utilities.cpp:329
ChimeraTK::Sdm
This structure holds the information of an SDM.
Definition Utilities.h:40
ChimeraTK::Sdm::parameters
std::list< std::string > parameters
Definition Utilities.h:46
ChimeraTK::Sdm::host
std::string host
Definition Utilities.h:42
ChimeraTK::Sdm::interface
std::string interface
Definition Utilities.h:43
ChimeraTK::Sdm::instance
std::string instance
Definition Utilities.h:44
ChimeraTK::Sdm::protocol
std::string protocol
Definition Utilities.h:45
INVALID_DEVICE_STRING_2
#define INVALID_DEVICE_STRING_2
Definition testUtilities.cpp:28
INVALID_SDM_2
#define INVALID_SDM_2
Definition testUtilities.cpp:20
INVALID_DEVICE_STRING_3
#define INVALID_DEVICE_STRING_3
Definition testUtilities.cpp:29
INVALID_DEVICE_STRING
#define INVALID_DEVICE_STRING
Definition testUtilities.cpp:27
VALID_DUMMY_STRING_2
#define VALID_DUMMY_STRING_2
Definition testUtilities.cpp:26
INVALID_SDM_5
#define INVALID_SDM_5
Definition testUtilities.cpp:23
VALID_SDM_WITH_PARAMS
#define VALID_SDM_WITH_PARAMS
Definition testUtilities.cpp:18
VALID_DUMMY_STRING
#define VALID_DUMMY_STRING
Definition testUtilities.cpp:25
INVALID_SDM_3
#define INVALID_SDM_3
Definition testUtilities.cpp:21
VALID_SDM
#define VALID_SDM
Definition testUtilities.cpp:17
INVALID_SDM
#define INVALID_SDM
Definition testUtilities.cpp:19
INVALID_SDM_4
#define INVALID_SDM_4
Definition testUtilities.cpp:22
VALID_PCI_STRING
#define VALID_PCI_STRING
Definition testUtilities.cpp:24
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(testParseCDD)
Definition testUtilities.cpp:35