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