ChimeraTK-DeviceAccess 03.29.00
Loading...
Searching...
No Matches
testJsonMapFileParser.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
6#define BOOST_TEST_MODULE JsonMapFileParser
7
8#include "Device.h"
9#include "Exception.h"
10#include "MapFileParser.h"
11
12using namespace ChimeraTK;
13
14#include <boost/test/unit_test.hpp>
15using namespace boost::unit_test_framework;
16
17BOOST_AUTO_TEST_SUITE(JsonMapFileParserTestSuite)
18
19/**********************************************************************************************************************/
20/**********************************************************************************************************************/
21
22BOOST_AUTO_TEST_CASE(TestFileDoesNotExist) {
23 ChimeraTK::MapFileParser fileparser;
24 BOOST_CHECK_THROW(fileparser.parse("NonexistentFile.jmap"), ChimeraTK::logic_error);
25}
26
27/**********************************************************************************************************************/
28
29BOOST_AUTO_TEST_CASE(TestGoodMapFileParse) {
30 auto [regs, metas] = ChimeraTK::MapFileParser::parse("simpleJsonFile.jmap");
31
32 BOOST_TEST(regs.hasRegister("/SomeTopLevelRegister"));
33 BOOST_TEST(regs.hasRegister("BSP.VERSION"));
34 BOOST_TEST(regs.hasRegister("/BSP/VERSION"));
35 BOOST_TEST(regs.hasRegister("DAQ.SIMPLE2D.A"));
36
37 {
38 auto reg = regs.getBackendRegister("/SomeTopLevelRegister");
39 BOOST_TEST(reg.pathName == "/SomeTopLevelRegister");
40 BOOST_TEST(reg.nElements == 1);
41 BOOST_TEST(reg.elementPitchBits == 4 * 8);
42 BOOST_TEST(reg.bar == 0);
43 BOOST_TEST(reg.address == 32);
44 BOOST_CHECK(reg.registerAccess == NumericAddressedRegisterInfo::Access::READ_WRITE);
45 BOOST_REQUIRE(reg.channels.size() == 1);
46 BOOST_TEST(reg.channels[0].bitOffset == 0);
47 BOOST_CHECK(reg.channels[0].dataType == NumericAddressedRegisterInfo::Type::FIXED_POINT);
48 BOOST_TEST(reg.channels[0].width == 32);
49 BOOST_TEST(reg.channels[0].nFractionalBits == 8);
50 BOOST_TEST(reg.channels[0].signedFlag == true);
51 BOOST_TEST(reg.isBitRange == false);
52 BOOST_TEST(reg.description == "This is an example register");
53 BOOST_TEST(reg.engineeringUnit == "mV");
54 }
55 {
56 auto reg = regs.getBackendRegister("BSP.VERSION");
57 BOOST_TEST(reg.pathName == "/BSP/VERSION");
58 BOOST_TEST(reg.nElements == 1);
59 BOOST_TEST(reg.elementPitchBits == 4 * 8);
60 BOOST_TEST(reg.bar == 0);
61 BOOST_TEST(reg.address == 4);
62 BOOST_CHECK(reg.registerAccess == NumericAddressedRegisterInfo::Access::READ_ONLY);
63 BOOST_REQUIRE(reg.channels.size() == 1);
64 BOOST_TEST(reg.channels[0].bitOffset == 0);
65 BOOST_CHECK(reg.channels[0].dataType == NumericAddressedRegisterInfo::Type::FIXED_POINT);
66 BOOST_TEST(reg.channels[0].width == 32);
67 BOOST_TEST(reg.channels[0].nFractionalBits == 0);
68 BOOST_TEST(reg.channels[0].signedFlag == false);
69 BOOST_TEST(reg.isBitRange == false);
70 }
71 {
72 auto reg = regs.getBackendRegister("BSP");
73 BOOST_TEST(reg.pathName == "/BSP");
74 BOOST_TEST(reg.nElements == 19201);
75 BOOST_TEST(reg.elementPitchBits == 4 * 8);
76 BOOST_TEST(reg.bar == 0);
77 BOOST_TEST(reg.address == 0);
78 BOOST_CHECK(reg.registerAccess == NumericAddressedRegisterInfo::Access::READ_WRITE);
79 BOOST_REQUIRE(reg.channels.size() == 1);
80 BOOST_TEST(reg.channels[0].bitOffset == 0);
81 BOOST_CHECK(reg.channels[0].dataType == NumericAddressedRegisterInfo::Type::FIXED_POINT);
82 BOOST_TEST(reg.channels[0].width == 32);
83 BOOST_TEST(reg.channels[0].nFractionalBits == 0);
84 BOOST_TEST(reg.channels[0].signedFlag == false);
85 BOOST_TEST(reg.isBitRange == false);
86 }
87 {
88 auto reg = regs.getBackendRegister("APP.STATUS");
89 BOOST_TEST(reg.pathName == "/APP/STATUS");
90 BOOST_TEST(reg.nElements == 1);
91 BOOST_TEST(reg.elementPitchBits == 4 * 8);
92 BOOST_TEST(reg.bar == 2);
93 BOOST_TEST(reg.address == 0x8000);
94 BOOST_CHECK(reg.registerAccess == NumericAddressedRegisterInfo::Access::READ_ONLY);
95 BOOST_REQUIRE(reg.channels.size() == 1);
96 BOOST_TEST(reg.channels[0].bitOffset == 0);
97 BOOST_CHECK(reg.channels[0].dataType == NumericAddressedRegisterInfo::Type::FIXED_POINT);
98 BOOST_CHECK(reg.channels[0].rawType == DataType::int32);
99 BOOST_TEST(reg.channels[0].width == 32);
100 BOOST_TEST(reg.channels[0].nFractionalBits == 0);
101 BOOST_TEST(reg.channels[0].signedFlag == false);
102 BOOST_TEST(reg.isBitRange == false);
103 }
104 {
105 auto reg = regs.getBackendRegister("APP.STATUS.ProbeLimiter");
106 BOOST_TEST(reg.pathName == "/APP/STATUS/ProbeLimiter");
107 BOOST_TEST(reg.nElements == 1);
108 BOOST_TEST(reg.elementPitchBits == 4 * 8);
109 BOOST_TEST(reg.bar == 2);
110 BOOST_TEST(reg.address == 0x8000);
111 BOOST_CHECK(reg.registerAccess == NumericAddressedRegisterInfo::Access::READ_ONLY);
112 BOOST_TEST(reg.channels.size() == 1); // for the debug printout if failing
113 BOOST_REQUIRE(reg.channels.size() == 1);
114 BOOST_TEST(reg.channels[0].bitOffset == 0);
115 BOOST_CHECK(reg.channels[0].dataType == NumericAddressedRegisterInfo::Type::FIXED_POINT);
116 BOOST_CHECK(reg.channels[0].rawType == DataType::int32);
117 BOOST_TEST(reg.channels[0].width == 1);
118 BOOST_TEST(reg.channels[0].nFractionalBits == 0);
119 BOOST_TEST(reg.channels[0].signedFlag == false);
120 BOOST_TEST(reg.isBitRange == true);
121 }
122 {
123 auto reg = regs.getBackendRegister("APP.STATUS.ExternalInterlock");
124 BOOST_TEST(reg.pathName == "/APP/STATUS/ExternalInterlock");
125 BOOST_TEST(reg.nElements == 1);
126 BOOST_TEST(reg.elementPitchBits == 4 * 8);
127 BOOST_TEST(reg.bar == 2);
128 BOOST_TEST(reg.address == 0x8000);
129 BOOST_CHECK(reg.registerAccess == NumericAddressedRegisterInfo::Access::READ_ONLY);
130 BOOST_REQUIRE(reg.channels.size() == 1);
131 BOOST_TEST(reg.channels[0].bitOffset == 1);
132 BOOST_CHECK(reg.channels[0].dataType == NumericAddressedRegisterInfo::Type::FIXED_POINT);
133 BOOST_CHECK(reg.channels[0].rawType == DataType::int32);
134 BOOST_TEST(reg.channels[0].width == 1);
135 BOOST_TEST(reg.channels[0].nFractionalBits == 0);
136 BOOST_TEST(reg.channels[0].signedFlag == false);
137 BOOST_TEST(reg.isBitRange == true);
138 }
139 {
140 auto reg = regs.getBackendRegister("APP.STATUS.ErrorCounter");
141 BOOST_TEST(reg.pathName == "/APP/STATUS/ErrorCounter");
142 BOOST_TEST(reg.nElements == 1);
143 BOOST_TEST(reg.elementPitchBits == 4 * 8);
144 BOOST_TEST(reg.bar == 2);
145 BOOST_TEST(reg.address == 0x8000);
146 BOOST_CHECK(reg.registerAccess == NumericAddressedRegisterInfo::Access::READ_ONLY);
147 BOOST_REQUIRE(reg.channels.size() == 1);
148 BOOST_TEST(reg.channels[0].bitOffset == 2);
149 BOOST_CHECK(reg.channels[0].dataType == NumericAddressedRegisterInfo::Type::FIXED_POINT);
150 BOOST_CHECK(reg.channels[0].rawType == DataType::int32);
151 BOOST_TEST(reg.channels[0].width == 3);
152 BOOST_TEST(reg.channels[0].nFractionalBits == 0);
153 BOOST_TEST(reg.channels[0].signedFlag == false);
154 BOOST_TEST(reg.isBitRange == true);
155 }
156 {
157 auto reg = regs.getBackendRegister("APP.LARGE_STATUS");
158 BOOST_TEST(reg.pathName == "/APP/LARGE_STATUS");
159 BOOST_TEST(reg.nElements == 1);
160 BOOST_TEST(reg.elementPitchBits == 8 * 8);
161 BOOST_TEST(reg.bar == 2);
162 BOOST_TEST(reg.address == 0x8004);
163 BOOST_CHECK(reg.registerAccess == NumericAddressedRegisterInfo::Access::READ_ONLY);
164 BOOST_REQUIRE(reg.channels.size() == 1);
165 BOOST_TEST(reg.channels[0].bitOffset == 0);
166 BOOST_CHECK(reg.channels[0].dataType == NumericAddressedRegisterInfo::Type::FIXED_POINT);
167 BOOST_CHECK(reg.channels[0].rawType == DataType::int64);
168 BOOST_TEST(reg.channels[0].width == 64);
169 BOOST_TEST(reg.channels[0].nFractionalBits == 0);
170 BOOST_TEST(reg.channels[0].signedFlag == false);
171 BOOST_TEST(reg.isBitRange == false);
172 }
173 {
174 auto reg = regs.getBackendRegister("APP.LARGE_STATUS.ProbeLimiter");
175 BOOST_TEST(reg.pathName == "/APP/LARGE_STATUS/ProbeLimiter");
176 BOOST_TEST(reg.nElements == 1);
177 BOOST_TEST(reg.elementPitchBits == 8 * 8);
178 BOOST_TEST(reg.bar == 2);
179 BOOST_TEST(reg.address == 0x8004);
180 BOOST_CHECK(reg.registerAccess == NumericAddressedRegisterInfo::Access::READ_ONLY);
181 BOOST_TEST(reg.channels.size() == 1); // for the debug printout if failing
182 BOOST_REQUIRE(reg.channels.size() == 1);
183 BOOST_TEST(reg.channels[0].bitOffset == 0);
184 BOOST_CHECK(reg.channels[0].dataType == NumericAddressedRegisterInfo::Type::FIXED_POINT);
185 BOOST_CHECK(reg.channels[0].rawType == DataType::int64);
186 BOOST_TEST(reg.channels[0].width == 1);
187 BOOST_TEST(reg.channels[0].nFractionalBits == 0);
188 BOOST_TEST(reg.channels[0].signedFlag == false);
189 BOOST_TEST(reg.isBitRange == true);
190 }
191 {
192 auto reg = regs.getBackendRegister("APP.LARGE_STATUS.ExternalInterlock");
193 BOOST_TEST(reg.pathName == "/APP/LARGE_STATUS/ExternalInterlock");
194 BOOST_TEST(reg.nElements == 1);
195 BOOST_TEST(reg.elementPitchBits == 8 * 8);
196 BOOST_TEST(reg.bar == 2);
197 BOOST_TEST(reg.address == 0x8004);
198 BOOST_CHECK(reg.registerAccess == NumericAddressedRegisterInfo::Access::READ_ONLY);
199 BOOST_REQUIRE(reg.channels.size() == 1);
200 BOOST_TEST(reg.channels[0].bitOffset == 34);
201 BOOST_CHECK(reg.channels[0].dataType == NumericAddressedRegisterInfo::Type::FIXED_POINT);
202 BOOST_CHECK(reg.channels[0].rawType == DataType::int64);
203 BOOST_TEST(reg.channels[0].width == 1);
204 BOOST_TEST(reg.channels[0].nFractionalBits == 0);
205 BOOST_TEST(reg.channels[0].signedFlag == false);
206 BOOST_TEST(reg.isBitRange == true);
207 }
208 {
209 auto reg = regs.getBackendRegister("APP.LARGE_STATUS.ErrorCounter");
210 BOOST_TEST(reg.pathName == "/APP/LARGE_STATUS/ErrorCounter");
211 BOOST_TEST(reg.nElements == 1);
212 BOOST_TEST(reg.elementPitchBits == 8 * 8);
213 BOOST_TEST(reg.bar == 2);
214 BOOST_TEST(reg.address == 0x8004);
215 BOOST_CHECK(reg.registerAccess == NumericAddressedRegisterInfo::Access::READ_ONLY);
216 BOOST_REQUIRE(reg.channels.size() == 1);
217 BOOST_TEST(reg.channels[0].bitOffset == 2);
218 BOOST_CHECK(reg.channels[0].dataType == NumericAddressedRegisterInfo::Type::FIXED_POINT);
219 BOOST_CHECK(reg.channels[0].rawType == DataType::int64);
220 BOOST_TEST(reg.channels[0].width == 3);
221 BOOST_TEST(reg.channels[0].nFractionalBits == 0);
222 BOOST_TEST(reg.channels[0].signedFlag == false);
223 BOOST_TEST(reg.isBitRange == true);
224 }
225 {
226 auto reg = regs.getBackendRegister("APP.SomeTable");
227 BOOST_TEST(reg.pathName == "/APP/SomeTable");
228 BOOST_TEST(reg.nElements == 16384);
229 BOOST_TEST(reg.elementPitchBits == 2 * 8);
230 BOOST_TEST(reg.bar == 0);
231 BOOST_TEST(reg.address == 2048);
232 BOOST_CHECK(reg.registerAccess == NumericAddressedRegisterInfo::Access::WRITE_ONLY);
233 BOOST_REQUIRE(reg.channels.size() == 1);
234 BOOST_TEST(reg.channels[0].bitOffset == 0);
235 BOOST_CHECK(reg.channels[0].dataType == NumericAddressedRegisterInfo::Type::FIXED_POINT);
236 BOOST_TEST(reg.channels[0].width == 14);
237 BOOST_TEST(reg.channels[0].nFractionalBits == 10);
238 BOOST_TEST(reg.channels[0].signedFlag == true);
239 BOOST_TEST(!reg.doubleBuffer.has_value());
240 BOOST_TEST(reg.isBitRange == false);
241 }
242 {
243 auto reg = regs.getBackendRegister("DAQ.CTRL");
244 BOOST_TEST(reg.pathName == "/DAQ/CTRL");
245 BOOST_TEST(reg.nElements == 16384);
246 BOOST_TEST(reg.elementPitchBits == 64 * 8);
247 BOOST_TEST(reg.bar == 13);
248 BOOST_TEST(reg.address == 0x40000);
249 BOOST_CHECK(reg.registerAccess == NumericAddressedRegisterInfo::Access::INTERRUPT);
250 BOOST_TEST(reg.interruptId == std::vector<size_t>({3, 0, 1}), boost::test_tools::per_element());
251 BOOST_TEST(reg.doubleBuffer.has_value());
252 BOOST_TEST(reg.doubleBuffer->address == 0x40200);
253 BOOST_TEST(reg.doubleBuffer->inactiveBufferRegisterPath == "/DAQ.DOUBLE_BUF.INACTIVE_BUF_ID");
254 BOOST_TEST(reg.doubleBuffer->enableRegisterPath == "/DAQ.DOUBLE_BUF.ENA");
255
256 BOOST_REQUIRE(reg.channels.size() == 5);
257
258 BOOST_TEST(reg.channels[0].bitOffset == 0);
259 BOOST_CHECK(reg.channels[0].dataType == NumericAddressedRegisterInfo::Type::FIXED_POINT);
260 BOOST_TEST(reg.channels[0].width == 16);
261 BOOST_TEST(reg.channels[0].nFractionalBits == -2);
262 BOOST_TEST(reg.channels[0].signedFlag == true);
263
264 BOOST_TEST(reg.channels[1].bitOffset == 2 * 8);
265 BOOST_CHECK(reg.channels[1].dataType == NumericAddressedRegisterInfo::Type::FIXED_POINT);
266 BOOST_TEST(reg.channels[1].width == 16);
267 BOOST_TEST(reg.channels[1].nFractionalBits == -2);
268 BOOST_TEST(reg.channels[1].signedFlag == true);
269
270 BOOST_TEST(reg.channels[2].bitOffset == 4 * 8);
271 BOOST_CHECK(reg.channels[2].dataType == NumericAddressedRegisterInfo::Type::FIXED_POINT);
272 BOOST_TEST(reg.channels[2].width == 32);
273 BOOST_TEST(reg.channels[2].nFractionalBits == 0);
274 BOOST_TEST(reg.channels[2].signedFlag == false);
275 BOOST_TEST(reg.isBitRange == false);
276 }
277 // Named channel slices of the 2D register DAQ.CTRL: each is a read-only 1D register whose address
278 // already contains the channel's byte offset, keeps the full element pitch as stride, and stores a
279 // single ChannelInfo with bitOffset 0 and the channel's raw type.
280 {
281 auto reg = regs.getBackendRegister("DAQ.CTRL.errorI");
282 BOOST_TEST(reg.pathName == "/DAQ/CTRL/errorI");
283 BOOST_TEST(reg.engineeringUnit == "bits");
284 BOOST_TEST(reg.description == "Error signal in I");
285 BOOST_TEST(reg.nElements == 16384);
286 BOOST_TEST(reg.elementPitchBits == 64 * 8);
287 BOOST_TEST(reg.bar == 13);
288 BOOST_TEST(reg.address == 0x40000);
289 BOOST_CHECK(reg.registerAccess == NumericAddressedRegisterInfo::Access::INTERRUPT);
290 BOOST_CHECK(reg.getSupportedAccessModes().has(ChimeraTK::AccessMode::wait_for_new_data) == true);
291 BOOST_REQUIRE(reg.channels.size() == 1);
292 BOOST_TEST(reg.channels[0].bitOffset == 0);
293 BOOST_CHECK(reg.channels[0].dataType == NumericAddressedRegisterInfo::Type::FIXED_POINT);
294 BOOST_TEST(reg.channels[0].width == 16);
295 BOOST_TEST(reg.channels[0].nFractionalBits == -2);
296 BOOST_TEST(reg.channels[0].signedFlag == true);
297 BOOST_TEST(reg.channels[0].getRawType() == ChimeraTK::DataType("int16"));
298 }
299 {
300 auto reg = regs.getBackendRegister("DAQ.CTRL.errorQ");
301 BOOST_TEST(reg.pathName == "/DAQ/CTRL/errorQ");
302 BOOST_TEST(reg.engineeringUnit == "bits");
303 BOOST_TEST(reg.description == "Error signal in Q");
304 BOOST_TEST(reg.nElements == 16384);
305 BOOST_TEST(reg.elementPitchBits == 64 * 8);
306 BOOST_TEST(reg.bar == 13);
307 BOOST_TEST(reg.address == 0x40000 + 2);
308 BOOST_CHECK(reg.registerAccess == NumericAddressedRegisterInfo::Access::INTERRUPT);
309 BOOST_CHECK(reg.getSupportedAccessModes().has(ChimeraTK::AccessMode::wait_for_new_data) == true);
310 BOOST_REQUIRE(reg.channels.size() == 1);
311 BOOST_TEST(reg.channels[0].bitOffset == 0);
312 BOOST_TEST(reg.channels[0].width == 16);
313 BOOST_TEST(reg.channels[0].getRawType() == ChimeraTK::DataType("int16"));
314 }
315 // Named channel slice of a non-interrupt 2D register stays read-only and does not advertise
316 // wait_for_new_data.
317 {
318 auto reg = regs.getBackendRegister("DAQ.SIMPLE2D.A");
319 BOOST_TEST(reg.pathName == "/DAQ/SIMPLE2D/A");
320 BOOST_TEST(reg.bar == 13);
321 BOOST_CHECK(reg.registerAccess == NumericAddressedRegisterInfo::Access::READ_ONLY);
322 BOOST_CHECK(reg.getSupportedAccessModes().has(ChimeraTK::AccessMode::raw) == true);
323 BOOST_CHECK(reg.getSupportedAccessModes().has(ChimeraTK::AccessMode::wait_for_new_data) == false);
324 BOOST_REQUIRE(reg.channels.size() == 1);
325 BOOST_TEST(reg.channels[0].bitOffset == 0);
326 BOOST_CHECK(reg.channels[0].dataType == NumericAddressedRegisterInfo::Type::FIXED_POINT);
327 BOOST_TEST(reg.channels[0].width == 16);
328 BOOST_TEST(reg.channels[0].getRawType() == ChimeraTK::DataType("int16"));
329 }
330 {
331 auto reg = regs.getBackendRegister("DAQ.FD");
332 BOOST_TEST(reg.pathName == "/DAQ/FD");
333 BOOST_TEST(reg.nElements == 16384);
334 BOOST_TEST(reg.elementPitchBits == 64 * 8);
335 BOOST_TEST(reg.bar == 13);
336 BOOST_TEST(reg.address == 0x81000);
337 BOOST_CHECK(reg.registerAccess == NumericAddressedRegisterInfo::Access::INTERRUPT);
338 BOOST_TEST(reg.interruptId == std::vector<size_t>({0}), boost::test_tools::per_element());
339
340 BOOST_REQUIRE(reg.channels.size() == 2);
341
342 BOOST_TEST(reg.channels[0].bitOffset == 0);
343 BOOST_CHECK(reg.channels[0].dataType == NumericAddressedRegisterInfo::Type::FIXED_POINT);
344 BOOST_TEST(reg.channels[0].width == 16);
345 BOOST_TEST(reg.channels[0].nFractionalBits == -2);
346 BOOST_TEST(reg.channels[0].signedFlag == true);
347
348 BOOST_TEST(reg.channels[1].bitOffset == 2 * 8);
349 BOOST_CHECK(reg.channels[1].dataType == NumericAddressedRegisterInfo::Type::FIXED_POINT);
350 BOOST_TEST(reg.channels[1].width == 16);
351 BOOST_TEST(reg.channels[1].nFractionalBits == -2);
352 BOOST_TEST(reg.channels[1].signedFlag == true);
353 BOOST_TEST(reg.isBitRange == false);
354 }
355 {
356 auto reg = regs.getBackendRegister("DAQ.DOUBLE_BUF.ENA");
357 BOOST_TEST(reg.pathName == "/DAQ/DOUBLE_BUF/ENA");
358 BOOST_TEST(reg.nElements == 3);
359 BOOST_TEST(reg.elementPitchBits == 4 * 8);
360 BOOST_TEST(reg.bar == 0);
361 BOOST_TEST(reg.address == 1234);
362 BOOST_REQUIRE(reg.channels.size() == 1);
363 BOOST_TEST(reg.channels[0].bitOffset == 0);
364 BOOST_CHECK(reg.channels[0].dataType == NumericAddressedRegisterInfo::Type::FIXED_POINT);
365 BOOST_TEST(reg.channels[0].width == 1);
366 BOOST_TEST(reg.channels[0].nFractionalBits == 0);
367 BOOST_TEST(reg.channels[0].signedFlag == false);
368 BOOST_TEST(reg.isBitRange == false);
369 }
370 {
371 auto reg = regs.getBackendRegister("DAQ.DOUBLE_BUF.INACTIVE_BUF_ID");
372 BOOST_TEST(reg.pathName == "/DAQ/DOUBLE_BUF/INACTIVE_BUF_ID");
373 BOOST_TEST(reg.nElements == 3);
374 BOOST_TEST(reg.elementPitchBits == 4 * 8);
375 BOOST_TEST(reg.bar == 0);
376 BOOST_TEST(reg.address == 1238);
377 BOOST_REQUIRE(reg.channels.size() == 1);
378 BOOST_TEST(reg.channels[0].bitOffset == 0);
379 BOOST_CHECK(reg.channels[0].dataType == NumericAddressedRegisterInfo::Type::FIXED_POINT);
380 BOOST_TEST(reg.channels[0].width == 1);
381 BOOST_TEST(reg.channels[0].nFractionalBits == 0);
382 BOOST_TEST(reg.channels[0].signedFlag == false);
383 BOOST_TEST(reg.isBitRange == false);
384 }
385 {
386 auto reg = regs.getBackendRegister("DAQ.FD.BUF0");
387 BOOST_TEST(reg.pathName == "/DAQ/FD/BUF0");
388 BOOST_TEST(reg.nElements == 16384);
389 BOOST_TEST(reg.elementPitchBits == 64 * 8);
390 BOOST_TEST(reg.bar == 13);
391 BOOST_TEST(reg.address == 0x81000);
392
393 BOOST_REQUIRE(reg.channels.size() == 2);
394
395 BOOST_TEST(reg.channels[0].bitOffset == 0);
396 BOOST_CHECK(reg.channels[0].dataType == NumericAddressedRegisterInfo::Type::FIXED_POINT);
397 BOOST_TEST(reg.channels[0].width == 16);
398 BOOST_TEST(reg.channels[0].nFractionalBits == -2);
399 BOOST_TEST(reg.channels[0].signedFlag == true);
400
401 BOOST_TEST(reg.channels[1].bitOffset == 2 * 8);
402 BOOST_CHECK(reg.channels[1].dataType == NumericAddressedRegisterInfo::Type::FIXED_POINT);
403 BOOST_TEST(reg.channels[1].width == 16);
404 BOOST_TEST(reg.channels[1].nFractionalBits == -2);
405 BOOST_TEST(reg.channels[1].signedFlag == true);
406 BOOST_TEST(reg.isBitRange == false);
407 }
408 {
409 auto reg = regs.getBackendRegister("DAQ.FD.BUF1");
410 BOOST_TEST(reg.pathName == "/DAQ/FD/BUF1");
411 BOOST_TEST(reg.nElements == 16384);
412 BOOST_TEST(reg.elementPitchBits == 64 * 8);
413 BOOST_TEST(reg.bar == 13);
414
415 BOOST_REQUIRE(reg.channels.size() == 2);
416
417 BOOST_TEST(reg.channels[0].bitOffset == 0);
418 BOOST_CHECK(reg.channels[0].dataType == NumericAddressedRegisterInfo::Type::FIXED_POINT);
419 BOOST_TEST(reg.channels[0].width == 16);
420 BOOST_TEST(reg.channels[0].nFractionalBits == -2);
421 BOOST_TEST(reg.channels[0].signedFlag == true);
422
423 BOOST_TEST(reg.channels[1].bitOffset == 2 * 8);
424 BOOST_CHECK(reg.channels[1].dataType == NumericAddressedRegisterInfo::Type::FIXED_POINT);
425 BOOST_TEST(reg.channels[1].width == 16);
426 BOOST_TEST(reg.channels[1].nFractionalBits == -2);
427 BOOST_TEST(reg.channels[1].signedFlag == true);
428 BOOST_TEST(reg.isBitRange == false);
429 }
430 {
431 auto reg = regs.getBackendRegister("DAQ.MUX_SEL");
432 BOOST_TEST(reg.pathName == "/DAQ/MUX_SEL");
433 BOOST_TEST(reg.nElements == 1);
434 BOOST_TEST(reg.elementPitchBits == 4 * 8);
435 BOOST_TEST(reg.bar == 0);
436 BOOST_TEST(reg.address == 1242);
437 BOOST_REQUIRE(reg.channels.size() == 1);
438 BOOST_TEST(reg.channels[0].bitOffset == 0);
439 BOOST_CHECK(reg.channels[0].dataType == NumericAddressedRegisterInfo::Type::FIXED_POINT);
440 BOOST_TEST(reg.channels[0].width == 2);
441 BOOST_TEST(reg.channels[0].nFractionalBits == 0);
442 BOOST_TEST(reg.channels[0].signedFlag == false);
443 BOOST_TEST(reg.isBitRange == false);
444 }
445 {
446 auto reg = regs.getBackendRegister("DAQ.MACRO_PULSE_NUMBER");
447 BOOST_TEST(reg.pathName == "/DAQ/MACRO_PULSE_NUMBER");
448 BOOST_TEST(reg.nElements == 1);
449 BOOST_TEST(reg.elementPitchBits == 4 * 8);
450 BOOST_TEST(reg.bar == 13);
451 BOOST_TEST(reg.address == 0x8103C);
452 BOOST_REQUIRE(reg.channels.size() == 1);
453 BOOST_TEST(reg.channels[0].bitOffset == 0);
454 BOOST_CHECK(reg.channels[0].dataType == NumericAddressedRegisterInfo::Type::FIXED_POINT);
455 BOOST_TEST(reg.channels[0].width == 32);
456 BOOST_TEST(reg.channels[0].nFractionalBits == 0);
457 BOOST_TEST(reg.channels[0].signedFlag == false);
458 BOOST_TEST(reg.isBitRange == false);
459 }
460 {
461 auto reg = regs.getBackendRegister("BSP.SOME_INFO");
462 BOOST_TEST(reg.pathName == "/BSP/SOME_INFO");
463 BOOST_TEST(reg.nElements == 1);
464 BOOST_TEST(reg.elementPitchBits == 40 * 8);
465 BOOST_TEST(reg.bar == 0);
466 BOOST_TEST(reg.address == 8);
467 BOOST_REQUIRE(reg.channels.size() == 1);
468 BOOST_TEST(reg.channels[0].bitOffset == 0);
469 BOOST_CHECK(reg.channels[0].dataType == NumericAddressedRegisterInfo::Type::ASCII);
470 BOOST_TEST(reg.channels[0].width == 32);
471 BOOST_TEST(reg.channels[0].nFractionalBits == 0);
472 BOOST_TEST(reg.channels[0].signedFlag == false);
473 BOOST_TEST(reg.isBitRange == false);
474 }
475 {
476 auto reg = regs.getBackendRegister("APP.SomeFloat");
477 BOOST_TEST(reg.pathName == "/APP/SomeFloat");
478 BOOST_TEST(reg.nElements == 1);
479 BOOST_TEST(reg.elementPitchBits == 4 * 8);
480 BOOST_TEST(reg.bar == 0);
481 BOOST_TEST(reg.address == 4096);
482 BOOST_REQUIRE(reg.channels.size() == 1);
483 BOOST_TEST(reg.channels[0].bitOffset == 0);
484 BOOST_CHECK(reg.channels[0].dataType == NumericAddressedRegisterInfo::Type::IEEE754);
485 BOOST_TEST(reg.channels[0].width == 32);
486 BOOST_TEST(reg.channels[0].nFractionalBits == 0);
487 BOOST_TEST(reg.channels[0].signedFlag == true);
488 BOOST_TEST(reg.isBitRange == false);
489 }
490 {
491 auto reg = regs.getBackendRegister("BSP.VOID_INTERRUPT_0");
492 BOOST_TEST(reg.pathName == "/BSP/VOID_INTERRUPT_0");
493 BOOST_TEST(reg.nElements == 0);
494 BOOST_REQUIRE(reg.channels.size() == 1);
495 BOOST_TEST(reg.channels[0].bitOffset == 0);
496 BOOST_CHECK(reg.channels[0].dataType == NumericAddressedRegisterInfo::Type::VOID);
497 BOOST_TEST(reg.channels[0].width == 0);
498 BOOST_TEST(reg.channels[0].nFractionalBits == 0);
499 BOOST_TEST(reg.channels[0].signedFlag == false);
500 BOOST_TEST(reg.isBitRange == false);
501 }
502
503 BOOST_TEST(metas.getNumberOfMetadata() == 6);
504
505 BOOST_TEST(metas.getMetadata("mapfileRevision") == "1.8.3-0-gdeadbeef");
506 BOOST_TEST(metas.getMetadata("someRandomEntry") == "some random value");
507
508 BOOST_TEST(metas.getMetadata("![0]") == R"({"INTC":{"options":[],"path":"DAQ","version":1}})");
509 BOOST_TEST(metas.getMetadata("![3]") == R"({"INTC":{"options":["MER"],"path":"MY_INTC","version":1}})");
510 BOOST_TEST(metas.getMetadata("![3,0]") == R"({"INTC":{"options":[],"path":"MY_INTC.SUB0","version":1}})");
511 BOOST_TEST(metas.getMetadata("![3,1]") == R"({"INTC":{"options":["MER"],"path":"MY_INTC.SUB1","version":1}})");
512
513 auto loi = regs.getListOfInterrupts();
514 BOOST_TEST(loi.size() == 2);
515 BOOST_CHECK(loi.find({0}) != loi.end());
516 BOOST_CHECK(loi.find({3, 0, 1}) != loi.end());
517}
518
519/**********************************************************************************************************************/
520
521BOOST_AUTO_TEST_CASE(TestInterruptIntegration) {
522 ChimeraTK::Device dev("(dummy?map=simpleJsonFile.jmap)");
523
524 dev.open();
525
526 auto int0 = dev.getVoidRegisterAccessor("/BSP/VOID_INTERRUPT_0", {ChimeraTK::AccessMode::wait_for_new_data});
527 auto int301 = dev.getVoidRegisterAccessor("/BSP/VOID_INTERRUPT_3_0_1", {ChimeraTK::AccessMode::wait_for_new_data});
528 dev.activateAsyncRead();
529 BOOST_TEST(int0.readNonBlocking() == true);
530 BOOST_TEST(int301.readNonBlocking() == true);
531}
532/**********************************************************************************************************************/
533
534BOOST_AUTO_TEST_SUITE_END()
ChimeraTK::DataType
A class to describe which of the supported data types is used.
Definition SupportedUserTypes.h:560
ChimeraTK::DataType::int32
@ int32
Signed 32 bit integer.
Definition SupportedUserTypes.h:572
ChimeraTK::DataType::int64
@ int64
Signed 64 bit integer.
Definition SupportedUserTypes.h:574
ChimeraTK::Device
Class allows to read/write registers from device.
Definition Device.h:39
ChimeraTK::Device::getVoidRegisterAccessor
VoidRegisterAccessor getVoidRegisterAccessor(const RegisterPath &registerPathName, const AccessModeFlags &flags=AccessModeFlags({})) const
Get a VoidRegisterAccessor object for the given register.
Definition Device.cc:103
ChimeraTK::Device::activateAsyncRead
void activateAsyncRead() noexcept
Activate asyncronous read for all transfer elements where AccessMode::wait_for_new_data is set.
Definition Device.cc:91
ChimeraTK::Device::open
void open(std::string const &aliasName)
Open a device by the given alias name from the DMAP file.
Definition Device.cc:58
ChimeraTK::MapFileParser::parse
static std::pair< NumericAddressedRegisterCatalogue, MetadataCatalogue > parse(const std::string &fileName)
Performs parsing of specified MAP file, resulting in catalogue objects describing all registers and m...
Definition MapFileParser.cpp:15
ChimeraTK::logic_error
Exception thrown when a logic error has occured.
Definition Exception.h:51
ChimeraTK::AccessMode::wait_for_new_data
@ wait_for_new_data
Make any read blocking until new data has arrived since the last read.
ChimeraTK::AccessMode::raw
@ raw
Raw access: disable any possible conversion from the original hardware data type into the given UserT...
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(TestFileDoesNotExist)
Definition testJsonMapFileParser.cpp:22