ChimeraTK-DeviceAccess 03.27.00
Loading...
Searching...
No Matches
testMapFileParser.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 MapFileParser
7#include <boost/test/unit_test.hpp>
8using namespace boost::unit_test_framework;
9
10#include "Exception.h"
11#include "MapFileParser.h"
12#include "NumericAddressedRegisterCatalogue.h"
13
14#include <sstream>
15
16using namespace ChimeraTK;
17using namespace boost::unit_test_framework;
18
19BOOST_AUTO_TEST_SUITE(MapFileParserTestSuite)
20
21/**********************************************************************************************************************/
22
23void printRegInfo(const ChimeraTK::NumericAddressedRegisterInfo& info, std::ostream& ostr = std::cout) {
24 ostr << "Register " << info.pathName << ": at " << info.bar << "," << info.address << " nElems = " << info.nElements
25 << " pitch = " << info.elementPitchBits << " access: " << int(info.registerAccess) << " int: [";
26 for(auto i : info.interruptId) {
27 ostr << i << ",";
28 }
29 ostr << "]" << std::endl;
30 size_t ich = 0;
31 for(const auto& c : info.channels) {
32 ostr << " channel " << ich << " at: " << c.bitOffset << " " << c.width << " " << c.nFractionalBits << " "
33 << c.signedFlag << " " << int(c.dataType) << std::endl;
34 ++ich;
35 }
36}
37
38/**********************************************************************************************************************/
39
40void compareCatalogue(const NumericAddressedRegisterCatalogue& regcat,
41 const std::vector<ChimeraTK::NumericAddressedRegisterInfo>& RegisterInfoents) {
42 // first check that size is equal
43 BOOST_CHECK_EQUAL(regcat.getNumberOfRegisters(), RegisterInfoents.size());
44
45 // compare and check for same order of elements
46 auto mapIter = regcat.begin();
47 auto elementsIter = RegisterInfoents.begin();
48 for(; mapIter != regcat.end() && elementsIter != RegisterInfoents.end(); ++mapIter, ++elementsIter) {
49 std::stringstream message;
50 message << "Failed comparison:" << std::endl;
51 printRegInfo(*mapIter, message);
52 printRegInfo(*elementsIter, message);
53 BOOST_CHECK_MESSAGE(*mapIter == *elementsIter, message.str());
54 }
55}
56
57/**********************************************************************************************************************/
58/**********************************************************************************************************************/
59
60BOOST_AUTO_TEST_CASE(testFileDoesNotExist) {
61 ChimeraTK::MapFileParser fileparser;
62 BOOST_CHECK_THROW(fileparser.parse("NonexistentFile.map"), ChimeraTK::logic_error);
63}
64
65/**********************************************************************************************************************/
66
67BOOST_AUTO_TEST_CASE(testInvalidMetadata) {
68 ChimeraTK::MapFileParser map_file_parser;
69 BOOST_CHECK_THROW(map_file_parser.parse("invalid_metadata.map"), ChimeraTK::logic_error);
70}
71
72/**********************************************************************************************************************/
73
74BOOST_AUTO_TEST_CASE(testMandatoryRegisterFieldMissing) {
75 ChimeraTK::MapFileParser map_file_parser;
76 BOOST_CHECK_THROW(map_file_parser.parse("MandatoryRegisterfIeldMissing.map"), ChimeraTK::logic_error);
77}
78
79/**********************************************************************************************************************/
80
81BOOST_AUTO_TEST_CASE(testIncorrectRegisterWidth) {
82 ChimeraTK::MapFileParser map_file_parser;
83 BOOST_CHECK_THROW(map_file_parser.parse("IncorrectRegisterWidth.map"), ChimeraTK::logic_error);
84 BOOST_CHECK_THROW(map_file_parser.parse("IncorrectRegisterWidth2.map"), ChimeraTK::logic_error);
85 BOOST_CHECK_THROW(map_file_parser.parse("IncorrectRegisterWidth3.map"), ChimeraTK::logic_error);
86 BOOST_CHECK_THROW(map_file_parser.parse("IncorrectRegisterWidth4.map"), ChimeraTK::logic_error);
87}
88
89/**********************************************************************************************************************/
90
91BOOST_AUTO_TEST_CASE(testFracBits) {
92 ChimeraTK::MapFileParser map_file_parser1;
93 ChimeraTK::MapFileParser map_file_parser2;
94 BOOST_CHECK_THROW(map_file_parser1.parse("IncorrectFracBits1.map"), ChimeraTK::logic_error);
95 BOOST_CHECK_THROW(map_file_parser2.parse("IncorrectFracBits2.map"), ChimeraTK::logic_error);
96}
97
98/**********************************************************************************************************************/
99BOOST_AUTO_TEST_CASE(test64BitSequence) {
100 ChimeraTK::MapFileParser map_file_parser;
101 auto [regcat, mdcat] = map_file_parser.parse("64BitSequence.map");
102
103 std::vector<ChimeraTK::NumericAddressedRegisterInfo> RegisterInfoents;
104 RegisterInfoents.emplace_back(ChimeraTK::NumericAddressedRegisterInfo("INT642D", 0x0, 0x0, 0x02, 192,
105 {{0, NumericAddressedRegisterInfo::Type::FIXED_POINT, 64, 0, false, DataType::int64},
106 {64, NumericAddressedRegisterInfo::Type::FIXED_POINT, 64, 0, false, DataType::int64},
107 {128, NumericAddressedRegisterInfo::Type::FIXED_POINT, 64, 0, false, DataType::int64}},
108 NumericAddressedRegisterInfo::Access::READ_WRITE, {}));
109
110 RegisterInfoents.emplace_back(
111 ChimeraTK::NumericAddressedRegisterInfo("INT642D.MULTIPLEXED_RAW", 0x06, 0x0, 0x30, 0x0, 64, 0, true,
112 NumericAddressedRegisterInfo::Access::READ_WRITE, NumericAddressedRegisterInfo::Type::FIXED_POINT, {}));
113
114 compareCatalogue(regcat, RegisterInfoents);
115}
116
117/**********************************************************************************************************************/
118
119BOOST_AUTO_TEST_CASE(testGoodMapFileParse) {
120 ChimeraTK::MapFileParser map_file_parser;
121 auto [regcat, mdcat] = map_file_parser.parse("goodMapFile_withoutModules.map");
122
123 std::string metaDataNameToRetrieve;
124 std::string retrievedValue;
125
126 metaDataNameToRetrieve = "HW_VERSION";
127 retrievedValue = mdcat.getMetadata(metaDataNameToRetrieve);
128 BOOST_CHECK(retrievedValue == "1.6");
129
130 metaDataNameToRetrieve = "FW_VERSION";
131 retrievedValue = mdcat.getMetadata(metaDataNameToRetrieve);
132 BOOST_CHECK(retrievedValue == "2.5");
133
134 /* TODO: remove default assignments to unused fields in the parse
135 * function and move it all to the constructor */
136
137 std::vector<ChimeraTK::NumericAddressedRegisterInfo> RegisterInfoents;
138 RegisterInfoents.emplace_back("WORD_FIRMWARE", 0x00000001, 0x00000000, 0x00000004, 0x0, 32, 0, true);
139 RegisterInfoents.emplace_back("WORD_COMPILATION", 0x00000001, 0x00000004, 0x00000004, 0x00000000, 32, 0, true);
140 RegisterInfoents.emplace_back("WORD_STATUS", 0x00000001, 0x00000008, 0x00000004, 0x00000000, 32, 0, true);
141 RegisterInfoents.emplace_back("WORD_USER1", 0x00000001, 0x0000000C, 0x00000004, 0x00000000, 32, 0, true);
142 RegisterInfoents.emplace_back("WORD_USER2", 0x00000001, 0x00000010, 0x00000004, 0x00000000, 32, 0, false);
143
144 RegisterInfoents.emplace_back(ChimeraTK::NumericAddressedRegisterInfo("INT2D", 0x0, 0x0, 0x05, 96,
145 {{0, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, 0, false, DataType::int32},
146 {32, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, 0, false, DataType::int32},
147 {64, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, 0, false, DataType::int32}},
148 NumericAddressedRegisterInfo::Access::READ_WRITE, {}));
149
150 RegisterInfoents.emplace_back(
151 ChimeraTK::NumericAddressedRegisterInfo("INT2D.MULTIPLEXED_RAW", 0x0f, 0x0, 0x3c, 0x0, 32, 0, true,
152 NumericAddressedRegisterInfo::Access::READ_WRITE, NumericAddressedRegisterInfo::Type::FIXED_POINT, {}));
153 compareCatalogue(regcat, RegisterInfoents);
154}
155
156/**********************************************************************************************************************/
157
158BOOST_AUTO_TEST_CASE(test64BitScalar) {
159 ChimeraTK::MapFileParser map_file_parser;
160 auto [regcat, mdcat] = map_file_parser.parse("64BitScalar.map");
161 BOOST_CHECK_EQUAL(regcat.getNumberOfRegisters(), 1);
162 std::vector<ChimeraTK::NumericAddressedRegisterInfo> RegisterInfoents(1);
163 RegisterInfoents[0] =
164 ChimeraTK::NumericAddressedRegisterInfo("WORD_64BitScalar", 0x01, 0x00, 0x08, 0x00, 64, 0, false);
165
166 compareCatalogue(regcat, RegisterInfoents);
167}
168/**********************************************************************************************************************/
169
170BOOST_AUTO_TEST_CASE(testGoodMappFileParse) {
171 ChimeraTK::MapFileParser map_file_parser;
172 auto [regcat, mdcat] = map_file_parser.parse("goodMapFile.map");
173
174 BOOST_CHECK_EQUAL(regcat.getNumberOfRegisters(), 22);
175
176 std::string metaDataNameToRetrieve;
177 std::string retrievedValue;
178
179 metaDataNameToRetrieve = "HW_VERSION";
180 retrievedValue = mdcat.getMetadata(metaDataNameToRetrieve);
181 BOOST_CHECK(retrievedValue == "1.6");
182
183 metaDataNameToRetrieve = "FW_VERSION";
184 retrievedValue = mdcat.getMetadata(metaDataNameToRetrieve);
185 BOOST_CHECK(retrievedValue == "2.5");
186
187 std::vector<ChimeraTK::NumericAddressedRegisterInfo> RegisterInfoents(22);
188
189 RegisterInfoents[0] =
190 ChimeraTK::NumericAddressedRegisterInfo("BOARD.WORD_FIRMWARE", 0x01, 0x0, 0x04, 0x0, 32, 0, true);
191 RegisterInfoents[1] =
192 ChimeraTK::NumericAddressedRegisterInfo("BOARD.WORD_COMPILATION", 0x01, 0x04, 0x04, 0x0, 32, 0, true);
193 RegisterInfoents[2] =
194 ChimeraTK::NumericAddressedRegisterInfo("APP0.WORD_STATUS", 0x01, 0x08, 0x04, 0x01, 32, 0, true);
195 RegisterInfoents[3] =
196 ChimeraTK::NumericAddressedRegisterInfo("APP0.WORD_SCRATCH", 0x01, 0x08, 0x04, 0x01, 16, 0, true);
197 RegisterInfoents[4] = ChimeraTK::NumericAddressedRegisterInfo("APP0.MODULE0", 0x03, 0x10, 0x0C, 0x01, 32, 0, true);
198 RegisterInfoents[5] = ChimeraTK::NumericAddressedRegisterInfo("APP0.MODULE1", 0x03, 0x20, 0x0C, 0x01, 32, 0, true);
199 RegisterInfoents[6] =
200 ChimeraTK::NumericAddressedRegisterInfo("MODULE0.WORD_USER1", 0x01, 0x10, 0x04, 0x01, 16, 3, true);
201 RegisterInfoents[7] =
202 ChimeraTK::NumericAddressedRegisterInfo("MODULE0.WORD_USER2", 0x01, 0x14, 0x04, 0x01, 18, 5, false);
203 RegisterInfoents[8] =
204 ChimeraTK::NumericAddressedRegisterInfo("MODULE0.WORD_USER3", 0x01, 0x18, 0x04, 0x01, 18, 5, false);
205 RegisterInfoents[9] =
206 ChimeraTK::NumericAddressedRegisterInfo("MODULE1.WORD_USER1", 0x01, 0x20, 0x04, 0x01, 16, 3, true);
207 RegisterInfoents[10] =
208 ChimeraTK::NumericAddressedRegisterInfo("MODULE1.WORD_USER2", 0x01, 0x24, 0x04, 0x01, 18, 5, false);
209 RegisterInfoents[11] = ChimeraTK::NumericAddressedRegisterInfo(
210 "MODULE1.WORD_USER3", 0x01, 0x28, 0x04, 0x01, 18, 5, false, NumericAddressedRegisterInfo::Access::READ_ONLY);
211 RegisterInfoents[12] =
212 ChimeraTK::NumericAddressedRegisterInfo("MODULE2.NO_OPTIONAL", 0x01, 0x2C, 0x04, 0x01, 32, 0, true);
213 RegisterInfoents[13] =
214 ChimeraTK::NumericAddressedRegisterInfo("MODULE.NAME.WITH.DOTS.REGISTER", 0x01, 0x00, 0x04, 0x02, 32, 0, true);
215 RegisterInfoents[14] =
216 ChimeraTK::NumericAddressedRegisterInfo("MODULE1.TEST_AREA", 0x0A, 0x025, 0x028, 0x01, 32, 0, false);
217 RegisterInfoents[15] = ChimeraTK::NumericAddressedRegisterInfo("FLOAT_TEST.SCALAR", 0x01, 0x060, 0x04, 0x01, 32, 0,
218 true, NumericAddressedRegisterInfo::Access::READ_WRITE, NumericAddressedRegisterInfo::Type::IEEE754);
219 RegisterInfoents[16] = ChimeraTK::NumericAddressedRegisterInfo("FLOAT_TEST.ARRAY", 0x04, 0x064, 0x010, 0x01, 32, 0,
220 true, NumericAddressedRegisterInfo::Access::READ_WRITE, NumericAddressedRegisterInfo::Type::IEEE754);
221 RegisterInfoents[17] =
222 ChimeraTK::NumericAddressedRegisterInfo("BOARD.NO_OPTIONAL", 0x01, 0x08, 0x04, 0x0, 32, 0, true);
223 RegisterInfoents[18] =
224 ChimeraTK::NumericAddressedRegisterInfo("LARGE_BAR.NUMBER", 0x01, 0x0, 0x04, 0x100000000, 32, 0, true);
225 RegisterInfoents[19] = ChimeraTK::NumericAddressedRegisterInfo("MODULE0.INTERRUPT_VOID1", 0x00, 0x0, 0x00, 0, 0, 0,
226 false, NumericAddressedRegisterInfo::Access::INTERRUPT, NumericAddressedRegisterInfo::Type::VOID, {3});
227 RegisterInfoents[20] = ChimeraTK::NumericAddressedRegisterInfo("MODULE0.INTERRUPT_VOID2", 0x00, 0x0, 0x00, 0, 0, 0,
228 false, NumericAddressedRegisterInfo::Access::INTERRUPT, NumericAddressedRegisterInfo::Type::VOID, {2});
229 RegisterInfoents[21] = ChimeraTK::NumericAddressedRegisterInfo("MODULE0.INTERRUPT_TYPE", 0x01, 0x68, 0x04, 1, 18, 5,
230 false, NumericAddressedRegisterInfo::Access::INTERRUPT, NumericAddressedRegisterInfo::Type::FIXED_POINT, {6});
231
232 compareCatalogue(regcat, RegisterInfoents);
233}
234
235/**********************************************************************************************************************/
236
237BOOST_AUTO_TEST_CASE(testMixedMapFileParse) {
238 ChimeraTK::MapFileParser map_file_parser;
239 auto [regcat, mdcat] = map_file_parser.parse("mixedMapFile.map");
240
241 std::vector<ChimeraTK::NumericAddressedRegisterInfo> RegisterInfoents(4);
242
243 RegisterInfoents[0] = ChimeraTK::NumericAddressedRegisterInfo("WORD_FIRMWARE_ID", 0x01, 0x0, 0x04, 0x0, 32, 0, true);
244 RegisterInfoents[1] = ChimeraTK::NumericAddressedRegisterInfo("WORD_USER", 0x01, 0x4, 0x04, 0x0, 32, 0, true);
245 RegisterInfoents[2] = ChimeraTK::NumericAddressedRegisterInfo("APP0.MODULE_ID", 0x01, 0x0, 0x04, 0x1, 32, 0, true);
246 RegisterInfoents[3] = ChimeraTK::NumericAddressedRegisterInfo("APP0.WORD_USER", 0x03, 0x4, 0x0C, 0x1, 18, 3, false);
247
248 compareCatalogue(regcat, RegisterInfoents);
249}
250
251/**********************************************************************************************************************/
252
253BOOST_AUTO_TEST_CASE(testInterruptBadMapFileParse) {
254 ChimeraTK::MapFileParser fileparser;
255
256 BOOST_CHECK_THROW(fileparser.parse("interruptMapFileWithError1.map"), ChimeraTK::logic_error);
257 BOOST_CHECK_THROW(fileparser.parse("interruptMapFileWithError2.map"), ChimeraTK::logic_error);
258 BOOST_CHECK_THROW(fileparser.parse("interruptMapFileWithError3.map"), ChimeraTK::logic_error);
259 BOOST_CHECK_THROW(fileparser.parse("interruptMapFileWithError4.map"), ChimeraTK::logic_error);
260}
261
262/**********************************************************************************************************************/
263
264BOOST_AUTO_TEST_CASE(testInterruptMapFileParse) {
265 ChimeraTK::MapFileParser fileparser;
266 auto [regcat, mdcat] = fileparser.parse("interruptMapFile.map");
267
268 std::vector<ChimeraTK::NumericAddressedRegisterInfo> RegisterInfoents(13);
269
270 RegisterInfoents[0] = ChimeraTK::NumericAddressedRegisterInfo("APP0.INTERRUPT_VOID_1", 0x00, 0x0, 0x00, 0x0, 0, 0,
271 false, NumericAddressedRegisterInfo::Access::INTERRUPT, NumericAddressedRegisterInfo::Type::VOID, {0});
272
273 RegisterInfoents[1] = ChimeraTK::NumericAddressedRegisterInfo("APP0.INTERRUPT_VOID_2", 0x00, 0x0, 0x00, 0x0, 0, 0,
274 false, NumericAddressedRegisterInfo::Access::INTERRUPT, NumericAddressedRegisterInfo::Type::VOID, {1, 1});
275
276 RegisterInfoents[2] = ChimeraTK::NumericAddressedRegisterInfo("APP0.INTERRUPT_VOID_3", 0x00, 0x0, 0x00, 0x0, 0, 0,
277 false, NumericAddressedRegisterInfo::Access::INTERRUPT, NumericAddressedRegisterInfo::Type::VOID, {2, 2, 2});
278
279 RegisterInfoents[3] = ChimeraTK::NumericAddressedRegisterInfo("APP0.INTERRUPT_UINT_1", 0x01, 0x100, 0x04, 0x0, 32, 0,
280 false, NumericAddressedRegisterInfo::Access::INTERRUPT, NumericAddressedRegisterInfo::Type::FIXED_POINT, {20});
281
282 RegisterInfoents[4] =
283 ChimeraTK::NumericAddressedRegisterInfo("APP0.SUB_INTERRUPT_INT_1", 0x01, 0x104, 0x04, 0x0, 32, 0, true,
284 NumericAddressedRegisterInfo::Access::INTERRUPT, NumericAddressedRegisterInfo::Type::FIXED_POINT, {21, 1});
285
286 RegisterInfoents[5] =
287 ChimeraTK::NumericAddressedRegisterInfo("APP0.SUB_SUB_INTERRUPT_INT_2", 0x01, 0x108, 0x04, 0x0, 32, 0, true,
288 NumericAddressedRegisterInfo::Access::INTERRUPT, NumericAddressedRegisterInfo::Type::FIXED_POINT, {22, 3, 4});
289
290 RegisterInfoents[6] =
291 ChimeraTK::NumericAddressedRegisterInfo("APP0.INTERRUPT_FIXPOINT_SIGNED", 0x01, 0x200, 0x04, 0x0, 32, 24, true,
292 NumericAddressedRegisterInfo::Access::INTERRUPT, NumericAddressedRegisterInfo::Type::FIXED_POINT, {3});
293
294 RegisterInfoents[7] =
295 ChimeraTK::NumericAddressedRegisterInfo("APP0.INTERRUPT_FIXPOINT_UNSIGNED", 0x01, 0x220, 0x04, 0x0, 32, 24, false,
296 NumericAddressedRegisterInfo::Access::INTERRUPT, NumericAddressedRegisterInfo::Type::FIXED_POINT, {3});
297
298 RegisterInfoents[8] = ChimeraTK::NumericAddressedRegisterInfo("APP0.INTERRUPT_ARRAY_UINT", 0x03, 0x300, 12, 0x0, 32,
299 0, false, NumericAddressedRegisterInfo::Access::INTERRUPT, NumericAddressedRegisterInfo::Type::FIXED_POINT, {4});
300
301 RegisterInfoents[9] = ChimeraTK::NumericAddressedRegisterInfo("APP0.INTERRUPT_ARRAY_INT", 0x03, 0x400, 12, 0x0, 32, 0,
302 true, NumericAddressedRegisterInfo::Access::INTERRUPT, NumericAddressedRegisterInfo::Type::FIXED_POINT, {4});
303
304 RegisterInfoents[10] =
305 ChimeraTK::NumericAddressedRegisterInfo("APP0.INTERRUPT_ARRAY_FIXPOINT", 0x03, 0x500, 12, 0x0, 32, 24, false,
306 NumericAddressedRegisterInfo::Access::INTERRUPT, NumericAddressedRegisterInfo::Type::FIXED_POINT, {4});
307
308 RegisterInfoents[11] = ChimeraTK::NumericAddressedRegisterInfo("APP0.INTERRUPT_AREA_INT", 0x0, 0x0, 0x05, 96,
309 {{0, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, 0, false, DataType::int32},
310 {32, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, 0, false, DataType::int32},
311 {64, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, 0, false, DataType::int32}},
312 NumericAddressedRegisterInfo::Access::INTERRUPT, {5});
313
314 RegisterInfoents[12] =
315 ChimeraTK::NumericAddressedRegisterInfo("APP0.INTERRUPT_AREA_INT.MULTIPLEXED_RAW", 0x0f, 0x0, 0x3c, 0x0, 32, 0,
316 true, NumericAddressedRegisterInfo::Access::INTERRUPT, NumericAddressedRegisterInfo::Type::FIXED_POINT, {5});
317
318 compareCatalogue(regcat, RegisterInfoents);
319}
320
321/**********************************************************************************************************************/
322
323BOOST_AUTO_TEST_CASE(testMapFileWithCommentsParse) {
324 ChimeraTK::MapFileParser map_file_parser;
325 auto [regcat, mdcat] = map_file_parser.parse("goodMapFileWithComments.map");
326
327 BOOST_CHECK_EQUAL(regcat.getNumberOfRegisters(), 22);
328
329 std::string metaDataNameToRetrieve;
330 std::string retrievedValue;
331
332 metaDataNameToRetrieve = "HW_VERSION";
333 retrievedValue = mdcat.getMetadata(metaDataNameToRetrieve);
334 BOOST_CHECK(retrievedValue == "1.6");
335
336 metaDataNameToRetrieve = "FW_VERSION";
337 retrievedValue = mdcat.getMetadata(metaDataNameToRetrieve);
338 BOOST_CHECK(retrievedValue == "2.5");
339
340 std::vector<ChimeraTK::NumericAddressedRegisterInfo> RegisterInfoents(22);
341
342 RegisterInfoents[0] =
343 ChimeraTK::NumericAddressedRegisterInfo("BOARD.WORD_FIRMWARE", 0x01, 0x0, 0x04, 0x0, 32, 0, true);
344 RegisterInfoents[1] =
345 ChimeraTK::NumericAddressedRegisterInfo("BOARD.WORD_COMPILATION", 0x01, 0x04, 0x04, 0x0, 32, 0, true);
346 RegisterInfoents[2] =
347 ChimeraTK::NumericAddressedRegisterInfo("APP0.WORD_STATUS", 0x01, 0x08, 0x04, 0x01, 32, 0, true);
348 RegisterInfoents[3] =
349 ChimeraTK::NumericAddressedRegisterInfo("APP0.WORD_SCRATCH", 0x01, 0x08, 0x04, 0x01, 16, 0, true);
350 RegisterInfoents[4] = ChimeraTK::NumericAddressedRegisterInfo("APP0.MODULE0", 0x03, 0x10, 0x0C, 0x01, 32, 0, true);
351 RegisterInfoents[5] = ChimeraTK::NumericAddressedRegisterInfo("APP0.MODULE1", 0x03, 0x20, 0x0C, 0x01, 32, 0, true);
352 RegisterInfoents[6] =
353 ChimeraTK::NumericAddressedRegisterInfo("MODULE0.WORD_USER1", 0x01, 0x10, 0x04, 0x01, 16, 3, true);
354 RegisterInfoents[7] =
355 ChimeraTK::NumericAddressedRegisterInfo("MODULE0.WORD_USER2", 0x01, 0x14, 0x04, 0x01, 18, 5, false);
356 RegisterInfoents[8] =
357 ChimeraTK::NumericAddressedRegisterInfo("MODULE0.WORD_USER3", 0x01, 0x18, 0x04, 0x01, 18, 5, false);
358 RegisterInfoents[9] =
359 ChimeraTK::NumericAddressedRegisterInfo("MODULE1.WORD_USER1", 0x01, 0x20, 0x04, 0x01, 16, 3, true);
360 RegisterInfoents[10] =
361 ChimeraTK::NumericAddressedRegisterInfo("MODULE1.WORD_USER2", 0x01, 0x24, 0x04, 0x01, 18, 5, false);
362 RegisterInfoents[11] = ChimeraTK::NumericAddressedRegisterInfo(
363 "MODULE1.WORD_USER3", 0x01, 0x28, 0x04, 0x01, 18, 5, false, NumericAddressedRegisterInfo::Access::READ_ONLY);
364 RegisterInfoents[12] =
365 ChimeraTK::NumericAddressedRegisterInfo("MODULE2.NO_OPTIONAL", 0x01, 0x2C, 0x04, 0x01, 32, 0, true);
366 RegisterInfoents[13] =
367 ChimeraTK::NumericAddressedRegisterInfo("MODULE.NAME.WITH.DOTS.REGISTER", 0x01, 0x00, 0x04, 0x02, 32, 0, true);
368 RegisterInfoents[14] =
369 ChimeraTK::NumericAddressedRegisterInfo("MODULE1.TEST_AREA", 0x0A, 0x025, 0x028, 0x01, 32, 0, false);
370 RegisterInfoents[15] = ChimeraTK::NumericAddressedRegisterInfo("FLOAT_TEST.SCALAR", 0x01, 0x060, 0x04, 0x01, 32, 0,
371 true, NumericAddressedRegisterInfo::Access::READ_WRITE, NumericAddressedRegisterInfo::Type::IEEE754);
372 RegisterInfoents[16] = ChimeraTK::NumericAddressedRegisterInfo("FLOAT_TEST.ARRAY", 0x04, 0x064, 0x010, 0x01, 32, 0,
373 true, NumericAddressedRegisterInfo::Access::READ_WRITE, NumericAddressedRegisterInfo::Type::IEEE754);
374 RegisterInfoents[17] =
375 ChimeraTK::NumericAddressedRegisterInfo("BOARD.NO_OPTIONAL", 0x01, 0x08, 0x04, 0x0, 32, 0, true);
376 RegisterInfoents[18] =
377 ChimeraTK::NumericAddressedRegisterInfo("LARGE_BAR.NUMBER", 0x01, 0x0, 0x04, 0x100000000, 32, 0, true);
378 RegisterInfoents[19] = ChimeraTK::NumericAddressedRegisterInfo("MODULE0.INTERRUPT_VOID1", 0x00, 0x0, 0x00, 0, 0, 0,
379 false, NumericAddressedRegisterInfo::Access::INTERRUPT, NumericAddressedRegisterInfo::Type::VOID, {1, 3});
380 RegisterInfoents[20] = ChimeraTK::NumericAddressedRegisterInfo("MODULE0.INTERRUPT_VOID2", 0x00, 0x0, 0x00, 0, 0, 0,
381 false, NumericAddressedRegisterInfo::Access::INTERRUPT, NumericAddressedRegisterInfo::Type::VOID, {1, 2});
382 RegisterInfoents[21] = ChimeraTK::NumericAddressedRegisterInfo("MODULE0.INTERRUPT_TYPE", 0x01, 0x68, 0x04, 1, 18, 5,
383 false, NumericAddressedRegisterInfo::Access::INTERRUPT, NumericAddressedRegisterInfo::Type::FIXED_POINT, {5, 6});
384
385 compareCatalogue(regcat, RegisterInfoents);
386}
387
388/**********************************************************************************************************************/
389
390BOOST_AUTO_TEST_CASE(testMapFileNewStyleMuxed) {
391 ChimeraTK::MapFileParser map_file_parser;
392 auto [regcat, mdcat] = map_file_parser.parse("newSequences.mapp");
393
394 BOOST_CHECK_EQUAL(regcat.getNumberOfRegisters(), 18);
395
396 std::vector<ChimeraTK::NumericAddressedRegisterInfo> RegisterInfoents(18);
397 RegisterInfoents[0] = ChimeraTK::NumericAddressedRegisterInfo("TEST.INT", 0x0, 0x0, 0x05, 96,
398 {{0, NumericAddressedRegisterInfo::Type::FIXED_POINT, 32, 0, true, ChimeraTK::DataType("int32")},
399 {32, NumericAddressedRegisterInfo::Type::FIXED_POINT, 32, 0, true, ChimeraTK::DataType("int32")},
400 {64, NumericAddressedRegisterInfo::Type::FIXED_POINT, 32, 0, true, ChimeraTK::DataType("int32")}},
401 NumericAddressedRegisterInfo::Access::READ_WRITE, {});
402
403 RegisterInfoents[1] = ChimeraTK::NumericAddressedRegisterInfo("TEST.INT.MULTIPLEXED_RAW", 0x0f, 0x0, 0x3c, 0x0, 32, 0,
404 true, NumericAddressedRegisterInfo::Access::READ_WRITE, NumericAddressedRegisterInfo::Type::FIXED_POINT, {});
405
406 RegisterInfoents[2] = ChimeraTK::NumericAddressedRegisterInfo("TEST.CHAR", 0x0, 0x40, 0x05, 24,
407 {{0, NumericAddressedRegisterInfo::Type::FIXED_POINT, 8, 0, true, ChimeraTK::DataType("int8")},
408 {8, NumericAddressedRegisterInfo::Type::FIXED_POINT, 8, 0, true, ChimeraTK::DataType("int8")},
409 {16, NumericAddressedRegisterInfo::Type::FIXED_POINT, 8, 0, true, ChimeraTK::DataType("int8")}},
410 NumericAddressedRegisterInfo::Access::READ_WRITE, {});
411
412 RegisterInfoents[3] = ChimeraTK::NumericAddressedRegisterInfo("TEST.CHAR.MULTIPLEXED_RAW", 0x04, 0x40, 0x10, 0x0, 32,
413 0, true, NumericAddressedRegisterInfo::Access::READ_WRITE, NumericAddressedRegisterInfo::Type::FIXED_POINT, {});
414
415 RegisterInfoents[4] = ChimeraTK::NumericAddressedRegisterInfo("TEST.SHORT", 0x0, 0x50, 0x05, 48,
416 {{0, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, 0, true, ChimeraTK::DataType("int16")},
417 {16, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, 0, true, ChimeraTK::DataType("int16")},
418 {32, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, 0, true, ChimeraTK::DataType("int16")}},
419 NumericAddressedRegisterInfo::Access::READ_WRITE, {});
420
421 RegisterInfoents[5] = ChimeraTK::NumericAddressedRegisterInfo("TEST.SHORT.MULTIPLEXED_RAW", 0x08, 0x50, 0x20, 0x0, 32,
422 0, true, NumericAddressedRegisterInfo::Access::READ_WRITE, NumericAddressedRegisterInfo::Type::FIXED_POINT, {});
423
424 RegisterInfoents[6] = ChimeraTK::NumericAddressedRegisterInfo("TEST.FRAC_INT", 0x1, 0x0, 0x05, 96,
425 {{0, NumericAddressedRegisterInfo::Type::FIXED_POINT, 8, 1, true, ChimeraTK::DataType("int32")},
426 {32, NumericAddressedRegisterInfo::Type::FIXED_POINT, 8, 2, true, ChimeraTK::DataType("int32")},
427 {64, NumericAddressedRegisterInfo::Type::FIXED_POINT, 8, 3, true, ChimeraTK::DataType("int32")}},
428 NumericAddressedRegisterInfo::Access::READ_WRITE, {});
429
430 RegisterInfoents[7] =
431 ChimeraTK::NumericAddressedRegisterInfo("TEST.FRAC_INT.MULTIPLEXED_RAW", 0x0f, 0x0, 0x3c, 0x01, 32, 0, true,
432 NumericAddressedRegisterInfo::Access::READ_WRITE, NumericAddressedRegisterInfo::Type::FIXED_POINT, {});
433
434 RegisterInfoents[8] = ChimeraTK::NumericAddressedRegisterInfo("TEST.FRAC_CHAR", 0x1, 0x40, 0x05, 24,
435 {{0, NumericAddressedRegisterInfo::Type::FIXED_POINT, 8, 1, true, ChimeraTK::DataType("int8")},
436 {8, NumericAddressedRegisterInfo::Type::FIXED_POINT, 8, 2, true, ChimeraTK::DataType("int8")},
437 {16, NumericAddressedRegisterInfo::Type::FIXED_POINT, 8, 3, true, ChimeraTK::DataType("int8")}},
438 NumericAddressedRegisterInfo::Access::READ_WRITE, {});
439
440 RegisterInfoents[9] =
441 ChimeraTK::NumericAddressedRegisterInfo("TEST.FRAC_CHAR.MULTIPLEXED_RAW", 0x04, 0x40, 0x10, 0x01, 32, 0, true,
442 NumericAddressedRegisterInfo::Access::READ_WRITE, NumericAddressedRegisterInfo::Type::FIXED_POINT, {});
443
444 RegisterInfoents[10] = ChimeraTK::NumericAddressedRegisterInfo("TEST.FRAC_SHORT", 0x1, 0x50, 0x05, 48,
445 {{0, NumericAddressedRegisterInfo::Type::FIXED_POINT, 8, 1, true, ChimeraTK::DataType("int16")},
446 {16, NumericAddressedRegisterInfo::Type::FIXED_POINT, 8, 2, true, ChimeraTK::DataType("int16")},
447 {32, NumericAddressedRegisterInfo::Type::FIXED_POINT, 8, 3, true, ChimeraTK::DataType("int16")}},
448 NumericAddressedRegisterInfo::Access::READ_WRITE, {});
449
450 RegisterInfoents[11] =
451 ChimeraTK::NumericAddressedRegisterInfo("TEST.FRAC_SHORT.MULTIPLEXED_RAW", 0x08, 0x50, 0x20, 0x01, 32, 0, true,
452 NumericAddressedRegisterInfo::Access::READ_WRITE, NumericAddressedRegisterInfo::Type::FIXED_POINT, {});
453
454 RegisterInfoents[12] = ChimeraTK::NumericAddressedRegisterInfo("TEST.DMA", 0x0d, 0x0, 0x04, 256,
455 {{0, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, -2, true, ChimeraTK::DataType("int16")},
456 {16, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, -2, true, ChimeraTK::DataType("int16")},
457 {32, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, -2, true, ChimeraTK::DataType("int16")},
458 {48, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, -2, true, ChimeraTK::DataType("int16")},
459 {64, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, -2, true, ChimeraTK::DataType("int16")},
460 {80, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, -2, true, ChimeraTK::DataType("int16")},
461 {96, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, -2, true, ChimeraTK::DataType("int16")},
462 {112, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, -2, true, ChimeraTK::DataType("int16")},
463 {128, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, -2, true, ChimeraTK::DataType("int16")},
464 {144, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, -2, true, ChimeraTK::DataType("int16")},
465 {160, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, -2, true, ChimeraTK::DataType("int16")},
466 {176, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, -2, true, ChimeraTK::DataType("int16")},
467 {192, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, -2, true, ChimeraTK::DataType("int16")},
468 {208, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, -2, true, ChimeraTK::DataType("int16")},
469 {224, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, -2, true, ChimeraTK::DataType("int16")},
470 {240, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, -2, true, ChimeraTK::DataType("int16")}},
471 NumericAddressedRegisterInfo::Access::READ_WRITE, {});
472
473 RegisterInfoents[13] = ChimeraTK::NumericAddressedRegisterInfo("TEST.DMA.MULTIPLEXED_RAW", 0x20, 0x00, 0x80, 0x0d, 32,
474 0, true, NumericAddressedRegisterInfo::Access::READ_WRITE, NumericAddressedRegisterInfo::Type::FIXED_POINT, {});
475
476 RegisterInfoents[14] = ChimeraTK::NumericAddressedRegisterInfo("TEST.MIXED", 0x3, 0x00, 0x03, 120,
477 {{0, NumericAddressedRegisterInfo::Type::FIXED_POINT, 8, 0, true, ChimeraTK::DataType("int8")},
478 {8, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, 0, true, ChimeraTK::DataType("int16")},
479 {24, NumericAddressedRegisterInfo::Type::FIXED_POINT, 32, 0, true, ChimeraTK::DataType("int32")},
480 {56, NumericAddressedRegisterInfo::Type::FIXED_POINT, 64, 0, true, ChimeraTK::DataType("int64")}},
481 NumericAddressedRegisterInfo::Access::READ_WRITE, {});
482
483 RegisterInfoents[15] =
484 ChimeraTK::NumericAddressedRegisterInfo("TEST.MIXED.MULTIPLEXED_RAW", 0x06, 0x00, 0x30, 0x03, 64, 0, true,
485 NumericAddressedRegisterInfo::Access::READ_WRITE, NumericAddressedRegisterInfo::Type::FIXED_POINT, {});
486
487 RegisterInfoents[16] = ChimeraTK::NumericAddressedRegisterInfo("APP0.DAQ0_BAM", 0x02, 0x0, 372, 352,
488 {{0, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, 0, true, ChimeraTK::DataType("int16")},
489 {16, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, 0, true, ChimeraTK::DataType("int16")},
490 {32, NumericAddressedRegisterInfo::Type::FIXED_POINT, 18, 0, true, ChimeraTK::DataType("int32")},
491 {64, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, 0, true, ChimeraTK::DataType("int16")},
492 {80, NumericAddressedRegisterInfo::Type::FIXED_POINT, 16, 0, true, ChimeraTK::DataType("int16")},
493 {96, NumericAddressedRegisterInfo::Type::FIXED_POINT, 8, 0, true, ChimeraTK::DataType("int16")},
494 {112, NumericAddressedRegisterInfo::Type::FIXED_POINT, 8, 0, true, ChimeraTK::DataType("int16")},
495 {128, NumericAddressedRegisterInfo::Type::FIXED_POINT, 8, 0, true, ChimeraTK::DataType("int8")},
496 {136, NumericAddressedRegisterInfo::Type::FIXED_POINT, 8, 0, true, ChimeraTK::DataType("int8")},
497 {144, NumericAddressedRegisterInfo::Type::FIXED_POINT, 8, 0, true, ChimeraTK::DataType("int8")},
498 {152, NumericAddressedRegisterInfo::Type::FIXED_POINT, 8, 0, true, ChimeraTK::DataType("int8")},
499 {160, NumericAddressedRegisterInfo::Type::FIXED_POINT, 8, 0, true, ChimeraTK::DataType("int32")},
500 {192, NumericAddressedRegisterInfo::Type::FIXED_POINT, 8, 0, true, ChimeraTK::DataType("int32")},
501 {224, NumericAddressedRegisterInfo::Type::FIXED_POINT, 32, 0, true, ChimeraTK::DataType("int32")},
502 {256, NumericAddressedRegisterInfo::Type::FIXED_POINT, 32, 0, false, ChimeraTK::DataType("int32")},
503 {288, NumericAddressedRegisterInfo::Type::FIXED_POINT, 32, 0, false, ChimeraTK::DataType("int32")},
504 {320, NumericAddressedRegisterInfo::Type::FIXED_POINT, 32, 0, false, ChimeraTK::DataType("int32")}},
505 NumericAddressedRegisterInfo::Access::READ_WRITE, {});
506
507 RegisterInfoents[17] =
508 ChimeraTK::NumericAddressedRegisterInfo("APP0.DAQ0_BAM.MULTIPLEXED_RAW", 0x1000, 0x00, 0x4000, 0x02, 32, 0, true,
509 NumericAddressedRegisterInfo::Access::READ_WRITE, NumericAddressedRegisterInfo::Type::FIXED_POINT, {});
510
511 compareCatalogue(regcat, RegisterInfoents);
512}
513
514/**********************************************************************************************************************/
515
516BOOST_AUTO_TEST_SUITE_END()
ChimeraTK::BackendRegisterCatalogue::getNumberOfRegisters
size_t getNumberOfRegisters() const override
Get number of registers in the catalogue.
Definition BackendRegisterCatalogue.h:330
ChimeraTK::BackendRegisterCatalogue::end
BackendRegisterCatalogueImplIterator< BackendRegisterInfo > end()
Return end iterator for iterating through the registers in the catalogue.
Definition BackendRegisterCatalogue.h:144
ChimeraTK::BackendRegisterCatalogue::begin
BackendRegisterCatalogueImplIterator< BackendRegisterInfo > begin()
Return begin iterator for iterating through the registers in the catalogue.
Definition BackendRegisterCatalogue.h:139
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::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
std
STL namespace.
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(testFileDoesNotExist)
Definition testMapFileParser.cpp:60
printRegInfo
void printRegInfo(const ChimeraTK::NumericAddressedRegisterInfo &info, std::ostream &ostr=std::cout)
Definition testMapFileParser.cpp:23
compareCatalogue
void compareCatalogue(const NumericAddressedRegisterCatalogue &regcat, const std::vector< ChimeraTK::NumericAddressedRegisterInfo > &RegisterInfoents)
Definition testMapFileParser.cpp:40