ChimeraTK-DeviceAccess 03.27.00
Loading...
Searching...
No Matches
testDeviceInfoMap.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
6#include "boost_dynamic_init_test.h"
7#include "DeviceInfoMap.h"
8#include "Exception.h"
9#include "helperFunctions.h"
10
11using namespace boost::unit_test_framework;
12namespace ChimeraTK {
13 using namespace ChimeraTK;
14}
15
28
29class DeviceInfoMapTestSuite : public test_suite {
30 public:
31 DeviceInfoMapTestSuite() : test_suite("DeviceInfoMap test suite") {
32 boost::shared_ptr<DeviceInfoMapTest> deviceInfoMapTest(new DeviceInfoMapTest());
33
34 test_case* insertElementsTestCase = BOOST_CLASS_TEST_CASE(&DeviceInfoMapTest::testInsertElement, deviceInfoMapTest);
35 test_case* getDeviceInfoTestCase = BOOST_CLASS_TEST_CASE(&DeviceInfoMapTest::testGetDeviceInfo, deviceInfoMapTest);
36 test_case* checkForDuplicateElementEntries =
37 BOOST_CLASS_TEST_CASE(&DeviceInfoMapTest::testCheckForDuplicateElements, deviceInfoMapTest);
38 test_case* testGetDeviceFileAndMapFileName =
39 BOOST_CLASS_TEST_CASE(&DeviceInfoMapTest::testGetDeviceFileAndMapFileName, deviceInfoMapTest);
40 test_case* testErrorElemErrTypeStreamOperator =
41 BOOST_CLASS_TEST_CASE(&DeviceInfoMapTest::testErrorElemErrTypeStreamOperator, deviceInfoMapTest);
42 test_case* testDeviceInfoStreamOperator =
43 BOOST_CLASS_TEST_CASE(&DeviceInfoMapTest::testDeviceInfoStreamOperator, deviceInfoMapTest);
44 test_case* testDeviceInfoMapStreamOperator =
45 BOOST_CLASS_TEST_CASE(&DeviceInfoMapTest::testDeviceInfoMapStreamOperator, deviceInfoMapTest);
46 test_case* testErrorElemStreamOperator =
47 BOOST_CLASS_TEST_CASE(&DeviceInfoMapTest::testErrorElemStreamOperator, deviceInfoMapTest);
48
49 test_case* testErrorListStreamOperator =
50 BOOST_CLASS_TEST_CASE(&DeviceInfoMapTest::testErrorListStreamOperator, deviceInfoMapTest);
51 add(insertElementsTestCase);
52 add(getDeviceInfoTestCase);
53 add(checkForDuplicateElementEntries);
54 add(testGetDeviceFileAndMapFileName);
55 add(testErrorElemErrTypeStreamOperator);
56 add(testDeviceInfoStreamOperator);
57 add(testDeviceInfoMapStreamOperator);
58 add(testErrorElemStreamOperator);
59 add(testErrorListStreamOperator);
60 }
61};
62
63bool init_unit_test() {
64 framework::master_test_suite().p_name.value = "DeviceInfoMap test suite";
65 framework::master_test_suite().add(new DeviceInfoMapTestSuite());
66
67 return true;
68 ;
69}
70
71void DeviceInfoMapTest::testInsertElement() {
72 std::string dMapFileName = "dummy.map";
73 ChimeraTK::DeviceInfoMap deviceInfoMap(dMapFileName);
74
75 ChimeraTK::DeviceInfoMap::DeviceInfo deviceInfo1;
76 ChimeraTK::DeviceInfoMap::DeviceInfo deviceInfo2;
77 ChimeraTK::DeviceInfoMap::DeviceInfo deviceInfo3;
78
79 populateDummyDeviceInfo(deviceInfo1, dMapFileName);
80 populateDummyDeviceInfo(deviceInfo2, dMapFileName);
81 populateDummyDeviceInfo(deviceInfo3, dMapFileName);
82
83 deviceInfoMap.insert(deviceInfo1);
84 deviceInfoMap.insert(deviceInfo2);
85 deviceInfoMap.insert(deviceInfo3);
86
87 ChimeraTK::DeviceInfoMap::DeviceInfo* ptrList[3];
88 ptrList[0] = &deviceInfo1;
89 ptrList[1] = &deviceInfo2;
90 ptrList[2] = &deviceInfo3;
91 int index;
92
93 ChimeraTK::DeviceInfoMap::iterator it;
94 for(it = deviceInfoMap.begin(), index = 0; (it != deviceInfoMap.end()) && (index < 3); ++it, ++index) {
95 BOOST_CHECK((compareDeviceInfos(*ptrList[index], *it)) == true);
96 }
97 BOOST_CHECK(deviceInfoMap.getSize() == 3);
98}
99
100void DeviceInfoMapTest::testGetDeviceInfo() {
101 std::string dMapFileName = "dummy.map";
102 ChimeraTK::DeviceInfoMap RegisterInfoMap(dMapFileName);
103
104 ChimeraTK::DeviceInfoMap::DeviceInfo deviceInfo1;
105 ChimeraTK::DeviceInfoMap::DeviceInfo deviceInfo2;
106
107 populateDummyDeviceInfo(deviceInfo1, dMapFileName);
108 populateDummyDeviceInfo(deviceInfo2, dMapFileName);
109
110 RegisterInfoMap.insert(deviceInfo1);
111 RegisterInfoMap.insert(deviceInfo2);
112
113 ChimeraTK::DeviceInfoMap::DeviceInfo retrievedElement1;
114 ChimeraTK::DeviceInfoMap::DeviceInfo retrievedElement2;
115 ChimeraTK::DeviceInfoMap::DeviceInfo retrievedElement3;
116
117 RegisterInfoMap.getDeviceInfo(deviceInfo1.deviceName, retrievedElement1);
118 RegisterInfoMap.getDeviceInfo(deviceInfo2.deviceName, retrievedElement2);
119
120 BOOST_CHECK((compareDeviceInfos(retrievedElement1, deviceInfo1)) == true);
121 BOOST_CHECK((compareDeviceInfos(retrievedElement2, deviceInfo2)) == true);
122 BOOST_CHECK_THROW(RegisterInfoMap.getDeviceInfo("invalid_card_name", retrievedElement3), ChimeraTK::logic_error);
123}
124
125void DeviceInfoMapTest::testCheckForDuplicateElements() {
126 std::string dMapFileName = "dummy.map";
127 std::string commonCardName = "common_card";
128 ChimeraTK::DeviceInfoMap RegisterInfoMap(dMapFileName);
129
130 ChimeraTK::DeviceInfoMap::DeviceInfo deviceInfo1;
131 ChimeraTK::DeviceInfoMap::DeviceInfo deviceInfo2;
132 ChimeraTK::DeviceInfoMap::DeviceInfo deviceInfo3;
133 ChimeraTK::DeviceInfoMap::DeviceInfo deviceInfo4;
134
135 populateDummyDeviceInfo(deviceInfo1, dMapFileName);
136 populateDummyDeviceInfo(deviceInfo2, dMapFileName);
137 populateDummyDeviceInfo(deviceInfo3, dMapFileName);
138 populateDummyDeviceInfo(deviceInfo4, dMapFileName);
139
140 deviceInfo1.deviceName = commonCardName;
141 deviceInfo2.deviceName = commonCardName;
142 deviceInfo3.deviceName = commonCardName;
143
144 ChimeraTK::DeviceInfoMap::ErrorList elementDuplications;
145 RegisterInfoMap.insert(deviceInfo1);
146 BOOST_CHECK(
147 RegisterInfoMap.check(elementDuplications, ChimeraTK::DeviceInfoMap::ErrorList::ErrorElem::ERROR) == true);
148
149 RegisterInfoMap.insert(deviceInfo2);
150 RegisterInfoMap.insert(deviceInfo3);
151 RegisterInfoMap.insert(deviceInfo4);
152
153 RegisterInfoMap.check(elementDuplications, ChimeraTK::DeviceInfoMap::ErrorList::ErrorElem::ERROR);
154
155 int numberOfIncorrectLinesInFile = elementDuplications._errors.size();
156 BOOST_CHECK(numberOfIncorrectLinesInFile == 2);
157
158 std::list<ChimeraTK::DeviceInfoMap::ErrorList::ErrorElem>::iterator errorIterator;
159 for(errorIterator = elementDuplications._errors.begin(); errorIterator != elementDuplications._errors.end();
160 ++errorIterator) {
161 bool doesDetectedElementsHaveSameName =
162 (errorIterator->_errorDevice1.deviceName == errorIterator->_errorDevice2.deviceName);
163 BOOST_CHECK(doesDetectedElementsHaveSameName);
164 }
165}
166
167void DeviceInfoMapTest::testGetDeviceFileAndMapFileName() {
168 ChimeraTK::DeviceInfoMap::DeviceInfo deviceInfo1;
169 deviceInfo1.uri = "/dev/test";
170 deviceInfo1.mapFileName = "test_mapfile";
171
172 std::pair<std::string, std::string> expected_pair("/dev/test", "test_mapfile");
173 std::pair<std::string, std::string> actual_pair = deviceInfo1.getDeviceFileAndMapFileName();
174 BOOST_CHECK(expected_pair == actual_pair);
175}
176
177void DeviceInfoMapTest::testErrorElemErrTypeStreamOperator() {
178 std::stringstream file_stream1;
179 file_stream1 << ChimeraTK::DeviceInfoMap::ErrorList::ErrorElem::ERROR;
180 BOOST_CHECK(file_stream1.str() == "ERROR");
181
182 std::stringstream file_stream2;
183 file_stream2 << ChimeraTK::DeviceInfoMap::ErrorList::ErrorElem::WARNING;
184 BOOST_CHECK(file_stream2.str() == "WARNING");
185}
186
187void DeviceInfoMapTest::testDeviceInfoStreamOperator() {
188 ChimeraTK::DeviceInfoMap::DeviceInfo deviceInfo1;
189 deviceInfo1.uri = "/dev/dev1";
190 deviceInfo1.deviceName = "card1";
191 deviceInfo1.dmapFileLineNumber = 1;
192 deviceInfo1.dmapFileName = "dummy.dmap";
193 deviceInfo1.mapFileName = "mapped_file";
194
195 std::stringstream expected_file_stream;
196 expected_file_stream << "("
197 << "dummy.dmap"
198 << ") NAME: "
199 << "card1"
200 << " DEV : "
201 << "/dev/dev1"
202 << " MAP : "
203 << "mapped_file";
204
205 std::stringstream actual_file_stream;
206 actual_file_stream << deviceInfo1;
207
208 BOOST_CHECK(expected_file_stream.str() == actual_file_stream.str());
209}
210
211void DeviceInfoMapTest::testDeviceInfoMapStreamOperator() {
212 std::string dMapFileName = "dummy.dmap";
213 ChimeraTK::DeviceInfoMap deviceInfoMap(dMapFileName);
214
215 ChimeraTK::DeviceInfoMap::DeviceInfo deviceInfo1;
216 populateDummyDeviceInfo(deviceInfo1, dMapFileName, "card1", "/dev/dev1", "map_file");
217 deviceInfoMap.insert(deviceInfo1);
218
219 std::stringstream expected_file_stream;
220 expected_file_stream << "=======================================" << std::endl;
221 expected_file_stream << "MAP FILE NAME: "
222 << "dummy.dmap" << std::endl;
223 expected_file_stream << "---------------------------------------" << std::endl;
224
225 expected_file_stream << "("
226 << "dummy.dmap"
227 << ") NAME: "
228 << "card1"
229 << " DEV : "
230 << "/dev/dev1"
231 << " MAP : "
232 << "map_file" << std::endl;
233
234 expected_file_stream << "=======================================";
235
236 std::stringstream actual_file_stream;
237 actual_file_stream << deviceInfoMap;
238 BOOST_CHECK(expected_file_stream.str() == actual_file_stream.str());
239}
240
241void DeviceInfoMapTest::testErrorElemStreamOperator() {
242 std::string dMapFileName = "dummy.map";
243 // std::string commonCardName = "common_card";
244 ChimeraTK::DeviceInfoMap RegisterInfoMap(dMapFileName);
245
246 ChimeraTK::DeviceInfoMap::DeviceInfo deviceInfo1;
247 ChimeraTK::DeviceInfoMap::DeviceInfo deviceInfo2;
248
249 populateDummyDeviceInfo(deviceInfo1, "dummy.dmap", "card1", "/dev/dev1", "map_file");
250 populateDummyDeviceInfo(deviceInfo2, "dummy.dmap", "card1", "/dev/dev1", "map_file");
251
252 deviceInfo1.dmapFileLineNumber = 1;
253 deviceInfo2.dmapFileLineNumber = 2;
254
255 ChimeraTK::DeviceInfoMap::ErrorList::ErrorElem error_element(ChimeraTK::DeviceInfoMap::ErrorList::ErrorElem::ERROR,
256 ChimeraTK::DeviceInfoMap::ErrorList::ErrorElem::NONUNIQUE_DEVICE_NAME, deviceInfo1, deviceInfo2);
257 std::stringstream expected_file_stream;
258 expected_file_stream << ChimeraTK::DeviceInfoMap::ErrorList::ErrorElem::ERROR
259 << ": Found two devices with the same name but different properties: \""
260 << "card1"
261 << "\" in file \""
262 << "dummy.dmap"
263 << "\" in line " << 1 << " and \""
264 << "dummy.dmap"
265 << "\" in line " << 2;
266
267 std::stringstream actual_file_stream;
268 actual_file_stream << error_element;
269
270 BOOST_CHECK(expected_file_stream.str() == actual_file_stream.str());
271}
272
273void DeviceInfoMapTest::testErrorListStreamOperator() {
274 std::string dMapFileName = "dummy.dmap";
275 std::string commonCardName = "card1";
276 ChimeraTK::DeviceInfoMap RegisterInfoMap(dMapFileName);
277
278 ChimeraTK::DeviceInfoMap::DeviceInfo deviceInfo1;
279 ChimeraTK::DeviceInfoMap::DeviceInfo deviceInfo2;
280
281 populateDummyDeviceInfo(deviceInfo1, dMapFileName);
282 populateDummyDeviceInfo(deviceInfo2, dMapFileName);
283
284 deviceInfo1.deviceName = commonCardName;
285 deviceInfo2.deviceName = commonCardName;
286
287 deviceInfo1.dmapFileLineNumber = 1;
288 deviceInfo2.dmapFileLineNumber = 2;
289
290 ChimeraTK::DeviceInfoMap::ErrorList elementDuplications;
291 RegisterInfoMap.insert(deviceInfo1);
292 RegisterInfoMap.insert(deviceInfo2);
293
294 RegisterInfoMap.check(elementDuplications, ChimeraTK::DeviceInfoMap::ErrorList::ErrorElem::ERROR);
295 std::stringstream expected_file_stream;
296 expected_file_stream << ChimeraTK::DeviceInfoMap::ErrorList::ErrorElem::ERROR
297 << ": Found two devices with the same name but different properties: \""
298 << "card1"
299 << "\" in file \""
300 << "dummy.dmap"
301 << "\" in line " << 1 << " and \""
302 << "dummy.dmap"
303 << "\" in line " << 2 << std::endl;
304
305 std::stringstream actual_file_stream;
306 actual_file_stream << elementDuplications;
307
308 BOOST_CHECK(expected_file_stream.str() == actual_file_stream.str());
309}
boost_dynamic_init_test.h
ChimeraTK::DeviceInfoMap::DeviceInfo
Stores information about one device.
Definition DeviceInfoMap.h:30
ChimeraTK::DeviceInfoMap::DeviceInfo::uri
std::string uri
uri which describes the device (or name of the device file in /dev in backward compatibility mode)
Definition DeviceInfoMap.h:33
ChimeraTK::DeviceInfoMap::DeviceInfo::dmapFileName
std::string dmapFileName
name of the DMAP file
Definition DeviceInfoMap.h:37
ChimeraTK::DeviceInfoMap::DeviceInfo::mapFileName
std::string mapFileName
name of the MAP file storing information about PCIe registers mapping
Definition DeviceInfoMap.h:35
ChimeraTK::DeviceInfoMap::DeviceInfo::dmapFileLineNumber
uint32_t dmapFileLineNumber
line number in DMAP file storing listed above information
Definition DeviceInfoMap.h:38
ChimeraTK::DeviceInfoMap::DeviceInfo::getDeviceFileAndMapFileName
std::pair< std::string, std::string > getDeviceFileAndMapFileName() const
Convenience function to extract the device file name and the map file name as one object (a pair).
Definition DeviceInfoMap.cc:47
ChimeraTK::DeviceInfoMap::DeviceInfo::deviceName
std::string deviceName
logical name of the device
Definition DeviceInfoMap.h:32
ChimeraTK::DeviceInfoMap::ErrorList::ErrorElem
Stores detailed information about one error or warning.
Definition DeviceInfoMap.h:78
ChimeraTK::DeviceInfoMap::ErrorList::ErrorElem::NONUNIQUE_DEVICE_NAME
@ NONUNIQUE_DEVICE_NAME
Names of two devices are the same - treated as critical error.
Definition DeviceInfoMap.h:84
ChimeraTK::DeviceInfoMap::ErrorList::ErrorElem::TYPE::WARNING
@ WARNING
Non-critical error was detected.
ChimeraTK::DeviceInfoMap::ErrorList
Stores information about errors and warnings.
Definition DeviceInfoMap.h:68
ChimeraTK::DeviceInfoMap::ErrorList::_errors
std::list< ErrorElem > _errors
Lists of errors or warnings detected during MAP file correctness checking.
Definition DeviceInfoMap.h:123
ChimeraTK::DeviceInfoMap::check
bool check(ErrorList &err, ErrorList::ErrorElem::TYPE level)
Checks logical correctness of DMAP file.
Definition DeviceInfoMap.cc:58
ChimeraTK::DeviceInfoMap::getDeviceInfo
void getDeviceInfo(const std::string &deviceName, DeviceInfo &value)
Returns information about specified device.
Definition DeviceInfoMap.cc:36
ChimeraTK::DeviceInfoMap::iterator
std::vector< DeviceInfo >::iterator iterator
Definition DeviceInfoMap.h:60
ChimeraTK::DeviceInfoMap::end
iterator end()
Return iterator to element after last one in DMAP file.
Definition DeviceInfoMap.cc:141
ChimeraTK::DeviceInfoMap::getSize
size_t getSize()
Returns number of records in DMAP file.
Definition DeviceInfoMap.cc:16
ChimeraTK::DeviceInfoMap::insert
void insert(const DeviceInfo &elem)
Insert new element read from DMAP file.
Definition DeviceInfoMap.cc:32
ChimeraTK::DeviceInfoMap::begin
iterator begin()
Return iterator to first device described in DMAP file.
Definition DeviceInfoMap.cc:137
ChimeraTK::logic_error
Exception thrown when a logic error has occured.
Definition Exception.h:51
DeviceInfoMapTest::testErrorElemErrTypeStreamOperator
void testErrorElemErrTypeStreamOperator()
Definition testDeviceInfoMap.cpp:177
compareDeviceInfos
bool compareDeviceInfos(const ChimeraTK::DeviceInfoMap::DeviceInfo &deviceInfo1, const ChimeraTK::DeviceInfoMap::DeviceInfo &deviceInfo2)
Definition helperFunctions.cc:28
populateDummyDeviceInfo
void populateDummyDeviceInfo(ChimeraTK::DeviceInfoMap::DeviceInfo &deviceInfo, std::string dmapFileName, std::string deviceName="card", std::string dev_file="/dev/dummy_device_identifier", std::string map_file_name="/dev/dummy_map_file")
Definition helperFunctions.cc:8
init_unit_test
bool init_unit_test()
Definition testDeviceInfoMap.cpp:63