ChimeraTK-DeviceAccess-DoocsBackend 01.12.00
Loading...
Searching...
No Matches
testDoocsBackend.cpp
Go to the documentation of this file.
1/*
2 * testDoocsBackend.cpp
3 *
4 * Created on: Apr 27, 2016
5 * Author: Martin Hierholzer
6 */
7#define BOOST_TEST_MODULE testDoocsBackend
8
9#include "eq_dummy.h"
10
11#include <ChimeraTK/CopyRegisterDecorator.h>
12#include <ChimeraTK/Device.h>
13#include <ChimeraTK/MappedImage.h>
14#include <ChimeraTK/TransferGroup.h>
15
16#include <doocs-server-test-helper/doocsServerTestHelper.h>
17#include <doocs-server-test-helper/ThreadedDoocsServer.h>
18#include <doocs/EqCall.h>
19
20#include <boost/filesystem.hpp>
21#include <boost/test/included/unit_test.hpp>
22
23#include <unistd.h>
24
25#include <cstdlib>
26#include <fstream>
27#include <iostream>
28#include <random>
29#include <thread>
30
31using namespace boost::unit_test_framework;
32using namespace ChimeraTK;
33
34/**********************************************************************************************************************/
35
36static bool file_exists(const std::string& name);
37static void createCacheFileFromCdd(const std::string& cdd);
38static void deleteFile(const std::string& filename);
39
40class DoocsLauncher : public ThreadedDoocsServer {
41 public:
42 DoocsLauncher()
43 : ThreadedDoocsServer("testDoocsBackend.conf", boost::unit_test::framework::master_test_suite().argc,
44 boost::unit_test::framework::master_test_suite().argv, eq_dummy::createServer()) {
45 rpc_no = rpcNo();
46
47 // use different cache files for each run to avoid conflicts (RPC numbers are protected by lock)
48 cacheFile1 = "cache1_" + rpc_no + ".xml";
49 cacheFile2 = "cache2_" + rpc_no + ".xml";
50
51 // set CDDs for the two doocs addresses used in the test
52 DoocsServer1 = "(doocs:doocs://localhost:" + rpcNo() + "/F/D)";
53 DoocsServer1_cached = "(doocs:doocs://localhost:" + rpcNo() + "/F/D?cacheFile=" + cacheFile1 + "&updateCache=1)";
54 DoocsServer2 = "(doocs:doocs://localhost:" + rpcNo() + "/F/D/MYDUMMY)";
55 DoocsServer2_cached =
56 "(doocs:doocs://localhost:" + rpcNo() + "/F/D/MYDUMMY?cacheFile=" + cacheFile2 + "&updateCache=1)";
57
58 // wait until server has started (both the update thread and the rpc thread)
59 doocs::EqCall eq;
60 doocs::EqAdr ea;
61 doocs::EqData src, dst;
62 ea.adr("doocs://localhost:" + rpcNo() + "/F/D/MYDUMMY/SOME_ZMQINT");
63 while(eq.get(&ea, &src, &dst)) usleep(100000);
64 }
65
66 ~DoocsLauncher() override {
67 boost::filesystem::remove(cacheFile1);
68 boost::filesystem::remove(cacheFile2);
69 }
70
71 static std::string rpc_no;
72 static std::string DoocsServer1;
73 static std::string DoocsServer1_cached;
74 static std::string cacheFile1;
75
76 static std::string DoocsServer2;
77 static std::string DoocsServer2_cached;
78 static std::string cacheFile2;
79};
80
81std::string DoocsLauncher::rpc_no;
82std::string DoocsLauncher::DoocsServer1;
83std::string DoocsLauncher::DoocsServer1_cached;
84std::string DoocsLauncher::DoocsServer2;
85std::string DoocsLauncher::DoocsServer2_cached;
86std::string DoocsLauncher::cacheFile1;
87std::string DoocsLauncher::cacheFile2;
88
89BOOST_GLOBAL_FIXTURE(DoocsLauncher);
90
91/**********************************************************************************************************************/
92
93BOOST_AUTO_TEST_CASE(testScalarInt) {
94 ChimeraTK::Device device;
95
96 BOOST_TEST(device.isOpened() == false);
97 device.open(DoocsLauncher::DoocsServer1);
98 BOOST_TEST(device.isOpened() == true);
99
100 TwoDRegisterAccessor<int32_t> acc_someInt_as_int(device.getTwoDRegisterAccessor<int32_t>("MYDUMMY/SOME_INT"));
101 BOOST_TEST(acc_someInt_as_int.getVersionNumber() == VersionNumber{nullptr});
102
103 BOOST_TEST(acc_someInt_as_int.getNChannels() == 1);
104 BOOST_TEST(acc_someInt_as_int.getNElementsPerChannel() == 1);
105 acc_someInt_as_int.read();
106 BOOST_TEST(acc_someInt_as_int[0][0] == 42);
107
108 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_INT", 120);
109
110 BOOST_TEST(acc_someInt_as_int[0][0] == 42);
111 // auto oldVersion = acc_someInt_as_int.getVersionNumber();
112 acc_someInt_as_int.read();
113 BOOST_TEST(acc_someInt_as_int[0][0] == 120);
114 // BOOST_TEST(acc_someInt_as_int.getVersionNumber() == oldVersion); // DOOCS behaves differently, eventId == 0 for
115 // properties set through RPC call
116
117 acc_someInt_as_int[0][0] = 1234;
118 BOOST_TEST(DoocsServerTestHelper::doocsGet<int>("//MYDUMMY/SOME_INT") == 120);
119 VersionNumber nextVersion;
120 acc_someInt_as_int.write(nextVersion);
121 BOOST_TEST(DoocsServerTestHelper::doocsGet<int>("//MYDUMMY/SOME_INT") == 1234);
122 BOOST_TEST(acc_someInt_as_int.getVersionNumber() == nextVersion);
123
124 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_INT", 42);
125
126 TwoDRegisterAccessor<double> acc_someInt_as_double(device.getTwoDRegisterAccessor<double>("MYDUMMY/SOME_INT"));
127 BOOST_TEST(acc_someInt_as_double.getNChannels() == 1);
128 BOOST_TEST(acc_someInt_as_double.getNElementsPerChannel() == 1);
129 acc_someInt_as_double.read();
130 BOOST_CHECK_CLOSE(acc_someInt_as_double[0][0], 42, 0.001);
131
132 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_INT", 120);
133
134 BOOST_CHECK_CLOSE(acc_someInt_as_double[0][0], 42, 0.001);
135 acc_someInt_as_double.read();
136 BOOST_CHECK_CLOSE(acc_someInt_as_double[0][0], 120, 0.001);
137
138 acc_someInt_as_double[0][0] = 1234.3;
139 BOOST_TEST(DoocsServerTestHelper::doocsGet<int>("//MYDUMMY/SOME_INT") == 120);
140 acc_someInt_as_double.write();
141 BOOST_TEST(DoocsServerTestHelper::doocsGet<int>("//MYDUMMY/SOME_INT") == 1234);
142
143 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_INT", 42);
144
145 TwoDRegisterAccessor<float> acc_someInt_as_float(device.getTwoDRegisterAccessor<float>("MYDUMMY/SOME_INT"));
146 BOOST_TEST(acc_someInt_as_float.getNChannels() == 1);
147 BOOST_TEST(acc_someInt_as_float.getNElementsPerChannel() == 1);
148 acc_someInt_as_float.read();
149 BOOST_CHECK_CLOSE(acc_someInt_as_float[0][0], 42, 0.001);
150
151 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_INT", 120);
152
153 BOOST_CHECK_CLOSE(acc_someInt_as_float[0][0], 42, 0.001);
154 acc_someInt_as_float.read();
155 BOOST_CHECK_CLOSE(acc_someInt_as_float[0][0], 120, 0.001);
156
157 acc_someInt_as_float[0][0] = 1233.9;
158 BOOST_TEST(DoocsServerTestHelper::doocsGet<int>("//MYDUMMY/SOME_INT") == 120);
159 acc_someInt_as_float.write();
160 BOOST_TEST(DoocsServerTestHelper::doocsGet<int>("//MYDUMMY/SOME_INT") == 1234);
161
162 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_INT", 42);
163
164 TwoDRegisterAccessor<std::string> acc_someInt_as_string(
165 device.getTwoDRegisterAccessor<std::string>("MYDUMMY/SOME_INT"));
166 BOOST_TEST(acc_someInt_as_string.getNChannels() == 1);
167 BOOST_TEST(acc_someInt_as_string.getNElementsPerChannel() == 1);
168 acc_someInt_as_string.read();
169 BOOST_TEST(acc_someInt_as_string[0][0] == "42");
170
171 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_INT", 120);
172
173 BOOST_TEST(acc_someInt_as_string[0][0] == "42");
174 acc_someInt_as_string.read();
175 BOOST_TEST(acc_someInt_as_string[0][0] == "120");
176
177 acc_someInt_as_string[0][0] = "1234";
178 BOOST_TEST(DoocsServerTestHelper::doocsGet<int>("//MYDUMMY/SOME_INT") == 120);
179 acc_someInt_as_string.write();
180 BOOST_TEST(DoocsServerTestHelper::doocsGet<int>("//MYDUMMY/SOME_INT") == 1234);
181
182 device.close();
183 BOOST_TEST(device.isOpened() == false);
184}
185
186/**********************************************************************************************************************/
187
188BOOST_AUTO_TEST_CASE(testScalarFloat) {
189 ChimeraTK::Device device;
190 device.open(DoocsLauncher::DoocsServer1);
191
192 TwoDRegisterAccessor<float> acc_someFloat_as_float(device.getTwoDRegisterAccessor<float>("MYDUMMY/SOME_FLOAT"));
193 BOOST_TEST(acc_someFloat_as_float.getNChannels() == 1);
194 BOOST_TEST(acc_someFloat_as_float.getNElementsPerChannel() == 1);
195 acc_someFloat_as_float.read();
196 BOOST_CHECK_CLOSE(acc_someFloat_as_float[0][0], 3.1415, 0.00001);
197
198 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_FLOAT", 123.456);
199
200 BOOST_CHECK_CLOSE(acc_someFloat_as_float[0][0], 3.1415, 0.00001);
201 // auto oldVersion = acc_someFloat_as_float.getVersionNumber();
202 acc_someFloat_as_float.read();
203 BOOST_CHECK_CLOSE(acc_someFloat_as_float[0][0], 123.456, 0.00001);
204 // BOOST_TEST(acc_someFloat_as_float.getVersionNumber() == oldVersion);// DOOCS behaves differently, eventId == 0 for
205 // properties set through RPC call
206
207 acc_someFloat_as_float[0][0] = 666.333;
208 BOOST_CHECK_CLOSE(DoocsServerTestHelper::doocsGet<float>("//MYDUMMY/SOME_FLOAT"), 123.456, 0.00001);
209 VersionNumber nextVersion;
210 acc_someFloat_as_float.write(nextVersion);
211 BOOST_CHECK_CLOSE(DoocsServerTestHelper::doocsGet<float>("//MYDUMMY/SOME_FLOAT"), 666.333, 0.00001);
212 BOOST_TEST(acc_someFloat_as_float.getVersionNumber() == nextVersion);
213
214 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_FLOAT", 3.1415);
215
216 TwoDRegisterAccessor<double> acc_someFloat_as_double(device.getTwoDRegisterAccessor<double>("MYDUMMY/SOME_FLOAT"));
217 BOOST_TEST(acc_someFloat_as_double.getNChannels() == 1);
218 BOOST_TEST(acc_someFloat_as_double.getNElementsPerChannel() == 1);
219 acc_someFloat_as_double.read();
220 BOOST_CHECK_CLOSE(acc_someFloat_as_double[0][0], 3.1415, 0.00001);
221
222 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_FLOAT", 123.456);
223
224 BOOST_CHECK_CLOSE(acc_someFloat_as_double[0][0], 3.1415, 0.00001);
225 acc_someFloat_as_double.read();
226 BOOST_CHECK_CLOSE(acc_someFloat_as_double[0][0], 123.456, 0.00001);
227
228 acc_someFloat_as_double[0][0] = 1234.3;
229 BOOST_CHECK_CLOSE(DoocsServerTestHelper::doocsGet<float>("//MYDUMMY/SOME_FLOAT"), 123.456, 0.00001);
230 acc_someFloat_as_double.write();
231 BOOST_CHECK_CLOSE(DoocsServerTestHelper::doocsGet<float>("//MYDUMMY/SOME_FLOAT"), 1234.3, 0.00001);
232
233 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_FLOAT", 3.1415);
234
235 TwoDRegisterAccessor<int> acc_someFloat_as_int(device.getTwoDRegisterAccessor<int>("MYDUMMY/SOME_FLOAT"));
236 BOOST_TEST(acc_someFloat_as_int.getNChannels() == 1);
237 BOOST_TEST(acc_someFloat_as_int.getNElementsPerChannel() == 1);
238 acc_someFloat_as_int.read();
239 BOOST_TEST(acc_someFloat_as_int[0][0] == 3);
240
241 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_FLOAT", 119.9);
242
243 BOOST_TEST(acc_someFloat_as_int[0][0] == 3);
244 acc_someFloat_as_int.read();
245 BOOST_TEST(acc_someFloat_as_int[0][0] == 120);
246
247 acc_someFloat_as_int[0][0] = 1234;
248 BOOST_CHECK_CLOSE(DoocsServerTestHelper::doocsGet<float>("//MYDUMMY/SOME_FLOAT"), 119.9, 0.00001);
249 acc_someFloat_as_int.write();
250 BOOST_CHECK_CLOSE(DoocsServerTestHelper::doocsGet<float>("//MYDUMMY/SOME_FLOAT"), 1234.0, 0.00001);
251
252 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_FLOAT", 3.1415);
253
254 TwoDRegisterAccessor<std::string> acc_someFloat_as_string(
255 device.getTwoDRegisterAccessor<std::string>("MYDUMMY/SOME_FLOAT"));
256 BOOST_TEST(acc_someFloat_as_string.getNChannels() == 1);
257 BOOST_TEST(acc_someFloat_as_string.getNElementsPerChannel() == 1);
258 acc_someFloat_as_string.read();
259 BOOST_CHECK_CLOSE(std::stod(acc_someFloat_as_string[0][0]), 3.1415, 0.00001);
260
261 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_FLOAT", 120);
262
263 BOOST_CHECK_CLOSE(std::stod(acc_someFloat_as_string[0][0]), 3.1415, 0.00001);
264 acc_someFloat_as_string.read();
265 BOOST_TEST(acc_someFloat_as_string[0][0] == "120.000000");
266
267 acc_someFloat_as_string[0][0] = "1234.5678";
268 BOOST_CHECK_CLOSE(DoocsServerTestHelper::doocsGet<float>("//MYDUMMY/SOME_FLOAT"), 120, 0.00001);
269 acc_someFloat_as_string.write();
270 BOOST_CHECK_CLOSE(DoocsServerTestHelper::doocsGet<float>("//MYDUMMY/SOME_FLOAT"), 1234.5678, 0.00001);
271
272 device.close();
273}
274
275/**********************************************************************************************************************/
276
277BOOST_AUTO_TEST_CASE(testScalarDouble) {
278 ChimeraTK::Device device;
279 device.open(DoocsLauncher::DoocsServer1);
280
281 TwoDRegisterAccessor<float> acc_someDouble_as_float(device.getTwoDRegisterAccessor<float>("MYDUMMY/SOME_DOUBLE"));
282 BOOST_TEST(acc_someDouble_as_float.getNChannels() == 1);
283 BOOST_TEST(acc_someDouble_as_float.getNElementsPerChannel() == 1);
284 acc_someDouble_as_float.read();
285 BOOST_CHECK_CLOSE(acc_someDouble_as_float[0][0], 2.8, 0.00001);
286
287 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_DOUBLE", 123.456);
288
289 BOOST_CHECK_CLOSE(acc_someDouble_as_float[0][0], 2.8, 0.00001);
290 // auto oldVersion = acc_someDouble_as_float.getVersionNumber();
291 acc_someDouble_as_float.read();
292 BOOST_CHECK_CLOSE(acc_someDouble_as_float[0][0], 123.456, 0.00001);
293 // BOOST_TEST(acc_someDouble_as_float.getVersionNumber() == oldVersion); // DOOCS behaves differently, eventId == 0
294 // for properties set through RPC call
295
296 acc_someDouble_as_float[0][0] = 666.333;
297 BOOST_CHECK_CLOSE(DoocsServerTestHelper::doocsGet<float>("//MYDUMMY/SOME_DOUBLE"), 123.456, 0.00001);
298 VersionNumber nextVersion;
299 acc_someDouble_as_float.write(nextVersion);
300 BOOST_CHECK_CLOSE(DoocsServerTestHelper::doocsGet<float>("//MYDUMMY/SOME_DOUBLE"), 666.333, 0.00001);
301 BOOST_TEST(acc_someDouble_as_float.getVersionNumber() == nextVersion);
302
303 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_DOUBLE", 3.1415);
304
305 TwoDRegisterAccessor<double> acc_someDouble_as_double(device.getTwoDRegisterAccessor<double>("MYDUMMY/SOME_DOUBLE"));
306 BOOST_TEST(acc_someDouble_as_double.getNChannels() == 1);
307 BOOST_TEST(acc_someDouble_as_double.getNElementsPerChannel() == 1);
308 acc_someDouble_as_double.read();
309 BOOST_CHECK_CLOSE(acc_someDouble_as_double[0][0], 3.1415, 0.00001);
310
311 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_DOUBLE", 123.456);
312
313 BOOST_CHECK_CLOSE(acc_someDouble_as_double[0][0], 3.1415, 0.00001);
314 acc_someDouble_as_double.read();
315 BOOST_CHECK_CLOSE(acc_someDouble_as_double[0][0], 123.456, 0.00001);
316
317 acc_someDouble_as_double[0][0] = 1234.3;
318 BOOST_CHECK_CLOSE(DoocsServerTestHelper::doocsGet<float>("//MYDUMMY/SOME_DOUBLE"), 123.456, 0.00001);
319 acc_someDouble_as_double.write();
320 BOOST_CHECK_CLOSE(DoocsServerTestHelper::doocsGet<float>("//MYDUMMY/SOME_DOUBLE"), 1234.3, 0.00001);
321
322 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_FLOAT", 3.1415);
323
324 TwoDRegisterAccessor<int> acc_someDouble_as_int(device.getTwoDRegisterAccessor<int>("MYDUMMY/SOME_FLOAT"));
325 BOOST_TEST(acc_someDouble_as_int.getNChannels() == 1);
326 BOOST_TEST(acc_someDouble_as_int.getNElementsPerChannel() == 1);
327 acc_someDouble_as_int.read();
328 BOOST_TEST(acc_someDouble_as_int[0][0] == 3);
329
330 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_FLOAT", 119.9);
331
332 BOOST_TEST(acc_someDouble_as_int[0][0] == 3);
333 acc_someDouble_as_int.read();
334 BOOST_TEST(acc_someDouble_as_int[0][0] == 120);
335
336 acc_someDouble_as_int[0][0] = 1234;
337 BOOST_CHECK_CLOSE(DoocsServerTestHelper::doocsGet<float>("//MYDUMMY/SOME_FLOAT"), 119.9, 0.00001);
338 acc_someDouble_as_int.write();
339 BOOST_CHECK_CLOSE(DoocsServerTestHelper::doocsGet<float>("//MYDUMMY/SOME_FLOAT"), 1234.0, 0.00001);
340
341 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_FLOAT", 3.1415);
342
343 TwoDRegisterAccessor<std::string> acc_someDouble_as_string(
344 device.getTwoDRegisterAccessor<std::string>("MYDUMMY/SOME_FLOAT"));
345 BOOST_TEST(acc_someDouble_as_string.getNChannels() == 1);
346 BOOST_TEST(acc_someDouble_as_string.getNElementsPerChannel() == 1);
347 acc_someDouble_as_string.read();
348 BOOST_CHECK_CLOSE(std::stod(acc_someDouble_as_string[0][0]), 3.1415, 0.00001);
349
350 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_FLOAT", 120);
351
352 BOOST_CHECK_CLOSE(std::stod(acc_someDouble_as_string[0][0]), 3.1415, 0.00001);
353 acc_someDouble_as_string.read();
354 BOOST_TEST(acc_someDouble_as_string[0][0] == "120.000000");
355
356 acc_someDouble_as_string[0][0] = "1234.5678";
357 BOOST_CHECK_CLOSE(DoocsServerTestHelper::doocsGet<float>("//MYDUMMY/SOME_FLOAT"), 120, 0.00001);
358 acc_someDouble_as_string.write();
359 BOOST_CHECK_CLOSE(DoocsServerTestHelper::doocsGet<float>("//MYDUMMY/SOME_FLOAT"), 1234.5678, 0.00001);
360
361 device.close();
362}
363
364/**********************************************************************************************************************/
365
366BOOST_AUTO_TEST_CASE(testString) {
367 ChimeraTK::Device device;
368 device.open(DoocsLauncher::DoocsServer1);
369
370 TwoDRegisterAccessor<std::string> acc_someString(device.getTwoDRegisterAccessor<std::string>("MYDUMMY/SOME_STRING"));
371 BOOST_TEST(acc_someString.getNChannels() == 1);
372 BOOST_TEST(acc_someString.getNElementsPerChannel() == 1);
373 auto oldVersion = acc_someString.getVersionNumber();
374 acc_someString.read();
375 BOOST_TEST(acc_someString[0][0] == "The quick brown fox jumps over the lazy dog.");
376 BOOST_TEST(acc_someString.getVersionNumber() != oldVersion);
377
378 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_STRING", "Something else.");
379
380 BOOST_TEST(acc_someString[0][0] == "The quick brown fox jumps over the lazy dog.");
381 acc_someString.read();
382 BOOST_TEST(acc_someString[0][0] == "Something else.");
383
384 acc_someString[0][0] = "Even different!";
385 BOOST_TEST(DoocsServerTestHelper::doocsGet<std::string>("//MYDUMMY/SOME_STRING") == "Something else.");
386 VersionNumber nextVersion;
387 acc_someString.write(nextVersion);
388 BOOST_TEST(DoocsServerTestHelper::doocsGet<std::string>("//MYDUMMY/SOME_STRING") == "Even different!");
389 BOOST_TEST(acc_someString.getVersionNumber() == nextVersion);
390
391 device.close();
392}
393
394/**********************************************************************************************************************/
395
396BOOST_AUTO_TEST_CASE(testArrayInt) {
397 ChimeraTK::Device device;
398 device.open(DoocsLauncher::DoocsServer1);
399
400 TwoDRegisterAccessor<int> acc_someArray(device.getTwoDRegisterAccessor<int>("MYDUMMY/SOME_INT_ARRAY"));
401 BOOST_TEST(acc_someArray.getNChannels() == 1);
402 BOOST_TEST(acc_someArray.getNElementsPerChannel() == 42);
403 acc_someArray.read();
404 for(int i = 0; i < 42; i++) BOOST_TEST(acc_someArray[0][i] == 3 * i + 120);
405
406 std::vector<int> vals(42);
407 for(int i = 0; i < 42; i++) vals[i] = -55 * i;
408 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_INT_ARRAY", vals);
409
410 for(int i = 0; i < 42; i++) BOOST_TEST(acc_someArray[0][i] == 3 * i + 120);
411 // auto oldVersion = acc_someArray.getVersionNumber();
412 acc_someArray.read();
413 for(int i = 0; i < 42; i++) BOOST_TEST(acc_someArray[0][i] == -55 * i);
414 // BOOST_TEST(acc_someArray.getVersionNumber() == oldVersion); // DOOCS behaves differently, eventId == 0 for
415 // properties set through RPC call
416
417 for(int i = 0; i < 42; i++) acc_someArray[0][i] = i - 21;
418 vals = DoocsServerTestHelper::doocsGetArray<int>("//MYDUMMY/SOME_INT_ARRAY");
419 for(int i = 0; i < 42; i++) BOOST_TEST(vals[i] == -55 * i);
420 VersionNumber nextVersion;
421 acc_someArray.write(nextVersion);
422 vals = DoocsServerTestHelper::doocsGetArray<int>("//MYDUMMY/SOME_INT_ARRAY");
423 for(int i = 0; i < 42; i++) BOOST_TEST(vals[i] == i - 21);
424 BOOST_TEST(acc_someArray.getVersionNumber() == nextVersion);
425
426 // access via double
427 TwoDRegisterAccessor<double> acc_someArrayAsDouble(device.getTwoDRegisterAccessor<double>("MYDUMMY/SOME_INT_ARRAY"));
428 acc_someArrayAsDouble.read();
429 for(int i = 0; i < 5; i++) BOOST_CHECK_CLOSE(acc_someArrayAsDouble[0][i], i - 21, 0.00001);
430 for(int i = 0; i < 5; i++) acc_someArrayAsDouble[0][i] = 2.4 * i;
431 acc_someArrayAsDouble.write();
432 vals = DoocsServerTestHelper::doocsGetArray<int>("//MYDUMMY/SOME_INT_ARRAY");
433 for(int i = 0; i < 5; i++) BOOST_CHECK_CLOSE(vals[i], round(2.4 * i), 0.00001);
434
435 // access via string
436 TwoDRegisterAccessor<std::string> acc_someArrayAsString(
437 device.getTwoDRegisterAccessor<std::string>("MYDUMMY/SOME_INT_ARRAY"));
438 acc_someArrayAsString.read();
439 for(int i = 0; i < 5; i++) BOOST_CHECK_CLOSE(std::stod(acc_someArrayAsString[0][i]), round(2.4 * i), 0.00001);
440 for(int i = 0; i < 5; i++) acc_someArrayAsString[0][i] = std::to_string(3 * i);
441 acc_someArrayAsString.write();
442 vals = DoocsServerTestHelper::doocsGetArray<int>("//MYDUMMY/SOME_INT_ARRAY");
443 for(int i = 0; i < 5; i++) BOOST_TEST(vals[i] == 3 * i);
444
445 device.close();
446}
447
448/**********************************************************************************************************************/
449
450BOOST_AUTO_TEST_CASE(testArrayShort) {
451 ChimeraTK::Device device;
452 device.open(DoocsLauncher::DoocsServer1);
453
454 TwoDRegisterAccessor<int> acc_someArray(device.getTwoDRegisterAccessor<int>("MYDUMMY/SOME_SHORT_ARRAY"));
455 BOOST_TEST(acc_someArray.getNChannels() == 1);
456 BOOST_TEST(acc_someArray.getNElementsPerChannel() == 5);
457 acc_someArray.read();
458 for(int i = 0; i < 5; i++) BOOST_TEST(acc_someArray[0][i] == 10 + i);
459
460 std::vector<short> vals(5);
461 for(int i = 0; i < 5; i++) vals[i] = -55 * i;
462 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_SHORT_ARRAY", vals);
463
464 for(int i = 0; i < 5; i++) BOOST_TEST(acc_someArray[0][i] == 10 + i);
465 // auto oldVersion = acc_someArray.getVersionNumber();
466 acc_someArray.read();
467 for(int i = 0; i < 5; i++) BOOST_TEST(acc_someArray[0][i] == -55 * i);
468 // BOOST_TEST(acc_someArray.getVersionNumber() == oldVersion); // DOOCS behaves differently, eventId == 0 for
469 // properties set through RPC call
470
471 std::vector<int> vals2(5);
472 for(int i = 0; i < 5; i++) acc_someArray[0][i] = i - 21;
473 vals2 = DoocsServerTestHelper::doocsGetArray<int>("//MYDUMMY/SOME_SHORT_ARRAY");
474 for(int i = 0; i < 5; i++) BOOST_TEST(vals2[i] == -55 * i);
475 VersionNumber nextVersion;
476 acc_someArray.write(nextVersion);
477 vals2 = DoocsServerTestHelper::doocsGetArray<int>("//MYDUMMY/SOME_SHORT_ARRAY");
478 for(int i = 0; i < 5; i++) BOOST_TEST(vals2[i] == i - 21);
479 BOOST_TEST(acc_someArray.getVersionNumber() == nextVersion);
480
481 device.close();
482}
483
484/**********************************************************************************************************************/
485
486BOOST_AUTO_TEST_CASE(testArrayLong) {
487 ChimeraTK::Device device;
488 device.open(DoocsLauncher::DoocsServer1);
489
490 TwoDRegisterAccessor<int> acc_someArray(device.getTwoDRegisterAccessor<int>("MYDUMMY/SOME_LONG_ARRAY"));
491 BOOST_TEST(acc_someArray.getNChannels() == 1);
492 BOOST_TEST(acc_someArray.getNElementsPerChannel() == 5);
493 acc_someArray.read();
494 for(int i = 0; i < 5; i++) BOOST_TEST(acc_someArray[0][i] == 10 + i);
495
496 std::vector<int64_t> vals(5);
497 for(int i = 0; i < 5; i++) vals[i] = -55 * i;
498 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_LONG_ARRAY", vals);
499
500 for(int i = 0; i < 5; i++) BOOST_TEST(acc_someArray[0][i] == 10 + i);
501 // auto oldVersion = acc_someArray.getVersionNumber();
502 acc_someArray.read();
503 for(int i = 0; i < 5; i++) BOOST_TEST(acc_someArray[0][i] == -55 * i);
504 // BOOST_TEST(acc_someArray.getVersionNumber() == oldVersion); // DOOCS behaves differently, eventId == 0 for
505 // properties set through RPC call
506
507 std::vector<int> vals2(5);
508 for(int i = 0; i < 5; i++) acc_someArray[0][i] = i - 21;
509 vals2 = DoocsServerTestHelper::doocsGetArray<int>("//MYDUMMY/SOME_LONG_ARRAY");
510 for(int i = 0; i < 5; i++) BOOST_TEST(vals2[i] == -55 * i);
511 VersionNumber nextVersion;
512 acc_someArray.write(nextVersion);
513 vals2 = DoocsServerTestHelper::doocsGetArray<int>("//MYDUMMY/SOME_LONG_ARRAY");
514 for(int i = 0; i < 5; i++) BOOST_TEST(vals2[i] == i - 21);
515 BOOST_TEST(acc_someArray.getVersionNumber() == nextVersion);
516
517 device.close();
518}
519
520/**********************************************************************************************************************/
521
522BOOST_AUTO_TEST_CASE(testArrayFloat) {
523 ChimeraTK::Device device;
524 device.open(DoocsLauncher::DoocsServer1);
525
526 TwoDRegisterAccessor<float> acc_someArray(device.getTwoDRegisterAccessor<float>("MYDUMMY/SOME_FLOAT_ARRAY"));
527 BOOST_TEST(acc_someArray.getNChannels() == 1);
528 BOOST_TEST(acc_someArray.getNElementsPerChannel() == 5);
529 auto oldVersion = acc_someArray.getVersionNumber();
530 acc_someArray.read();
531 for(int i = 0; i < 5; i++) BOOST_CHECK_CLOSE(acc_someArray[0][i], i / 1000., 0.00001);
532 BOOST_TEST(acc_someArray.getVersionNumber() != oldVersion);
533
534 std::vector<float> vals(5);
535 for(int i = 0; i < 5; i++) vals[i] = -3.14159265 * i;
536 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_FLOAT_ARRAY", vals);
537
538 for(int i = 0; i < 5; i++) BOOST_CHECK_CLOSE(acc_someArray[0][i], i / 1000., 0.00001);
539 acc_someArray.read();
540 for(int i = 0; i < 5; i++) BOOST_CHECK_CLOSE(acc_someArray[0][i], -3.14159265 * i, 0.00001);
541
542 for(int i = 0; i < 5; i++) acc_someArray[0][i] = 2. / (i + 0.01);
543 vals = DoocsServerTestHelper::doocsGetArray<float>("//MYDUMMY/SOME_FLOAT_ARRAY");
544 for(int i = 0; i < 5; i++) BOOST_CHECK_CLOSE(vals[i], -3.14159265 * i, 0.00001);
545 VersionNumber nextVersion;
546 acc_someArray.write(nextVersion);
547 vals = DoocsServerTestHelper::doocsGetArray<float>("//MYDUMMY/SOME_FLOAT_ARRAY");
548 for(int i = 0; i < 5; i++) BOOST_CHECK_CLOSE(vals[i], 2. / (i + 0.01), 0.00001);
549 BOOST_TEST(acc_someArray.getVersionNumber() == nextVersion);
550
551 device.close();
552}
553
554/**********************************************************************************************************************/
555
556BOOST_AUTO_TEST_CASE(testArrayDouble) {
557 ChimeraTK::Device device;
558 device.open(DoocsLauncher::DoocsServer1);
559
560 TwoDRegisterAccessor<double> acc_someArray(device.getTwoDRegisterAccessor<double>("MYDUMMY/SOME_DOUBLE_ARRAY"));
561 BOOST_TEST(acc_someArray.getNChannels() == 1);
562 BOOST_TEST(acc_someArray.getNElementsPerChannel() == 5);
563 auto oldVersion = acc_someArray.getVersionNumber();
564 acc_someArray.read();
565 for(int i = 0; i < 5; i++) BOOST_CHECK_CLOSE(acc_someArray[0][i], i / 333., 0.00001);
566 BOOST_TEST(acc_someArray.getVersionNumber() != oldVersion);
567
568 std::vector<double> vals(5);
569 for(int i = 0; i < 5; i++) vals[i] = -3.14159265 * i;
570 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_DOUBLE_ARRAY", vals);
571
572 for(int i = 0; i < 5; i++) BOOST_CHECK_CLOSE(acc_someArray[0][i], i / 333., 0.00001);
573 acc_someArray.read();
574 for(int i = 0; i < 5; i++) BOOST_CHECK_CLOSE(acc_someArray[0][i], -3.14159265 * i, 0.00001);
575
576 for(int i = 0; i < 5; i++) acc_someArray[0][i] = 2. / (i + 0.01);
577 vals = DoocsServerTestHelper::doocsGetArray<double>("//MYDUMMY/SOME_DOUBLE_ARRAY");
578 for(int i = 0; i < 5; i++) BOOST_CHECK_CLOSE(vals[i], -3.14159265 * i, 0.00001);
579 VersionNumber nextVersion;
580 acc_someArray.write(nextVersion);
581 vals = DoocsServerTestHelper::doocsGetArray<double>("//MYDUMMY/SOME_DOUBLE_ARRAY");
582 for(int i = 0; i < 5; i++) BOOST_CHECK_CLOSE(vals[i], 2. / (i + 0.01), 0.00001);
583 BOOST_TEST(acc_someArray.getVersionNumber() == nextVersion);
584
585 // access via int
586 TwoDRegisterAccessor<int> acc_someArrayAsInt(device.getTwoDRegisterAccessor<int>("MYDUMMY/SOME_DOUBLE_ARRAY"));
587 acc_someArrayAsInt.read();
588 for(int i = 0; i < 5; i++) BOOST_TEST(acc_someArrayAsInt[0][i] == round(2. / (i + 0.01)));
589 for(int i = 0; i < 5; i++) acc_someArrayAsInt[0][i] = 2 * i;
590 acc_someArrayAsInt.write();
591 vals = DoocsServerTestHelper::doocsGetArray<double>("//MYDUMMY/SOME_DOUBLE_ARRAY");
592 for(int i = 0; i < 5; i++) BOOST_CHECK_CLOSE(vals[i], 2 * i, 0.00001);
593
594 // access via string
595 TwoDRegisterAccessor<std::string> acc_someArrayAsString(
596 device.getTwoDRegisterAccessor<std::string>("MYDUMMY/SOME_DOUBLE_ARRAY"));
597 acc_someArrayAsString.read();
598 for(int i = 0; i < 5; i++) BOOST_CHECK_CLOSE(std::stod(acc_someArrayAsString[0][i]), 2 * i, 0.00001);
599 for(int i = 0; i < 5; i++) acc_someArrayAsString[0][i] = std::to_string(2.1 * i);
600 acc_someArrayAsString.write();
601 vals = DoocsServerTestHelper::doocsGetArray<double>("//MYDUMMY/SOME_DOUBLE_ARRAY");
602 for(int i = 0; i < 5; i++) BOOST_CHECK_CLOSE(vals[i], 2.1 * i, 0.00001);
603
604 device.close();
605}
606
607/**********************************************************************************************************************/
608
609BOOST_AUTO_TEST_CASE(testSpectrum) {
610 ChimeraTK::Device device;
611 device.open(DoocsLauncher::DoocsServer1);
612
613 TwoDRegisterAccessor<float> acc_someArray(device.getTwoDRegisterAccessor<float>("MYDUMMY/SOME_SPECTRUM"));
614 BOOST_TEST(acc_someArray.getNChannels() == 1);
615 BOOST_TEST(acc_someArray.getNElementsPerChannel() == 100);
616 auto oldVersion = acc_someArray.getVersionNumber();
617 acc_someArray.read();
618 for(int i = 0; i < 100; i++) BOOST_CHECK_CLOSE(acc_someArray[0][i], i / 42., 0.00001);
619 BOOST_TEST(acc_someArray.getVersionNumber() != oldVersion);
620
621 device.close();
622}
623
624/**********************************************************************************************************************/
625
626BOOST_AUTO_TEST_CASE(testIIII) {
627 ChimeraTK::Device device;
628 device.open(DoocsLauncher::DoocsServer1);
629
630 TwoDRegisterAccessor<int> acc_someArray(device.getTwoDRegisterAccessor<int>("MYDUMMY/SOME_IIII"));
631 BOOST_TEST(acc_someArray.getNChannels() == 1);
632 BOOST_TEST(acc_someArray.getNElementsPerChannel() == 4);
633 acc_someArray.read();
634 for(int i = 0; i < 4; i++) BOOST_TEST(acc_someArray[0][i] == 10 + i);
635
636 std::vector<int> vals(4);
637 for(int i = 0; i < 4; i++) vals[i] = -55 * i;
638 DoocsServerTestHelper::doocsSetIIII("//MYDUMMY/SOME_IIII", vals);
639
640 for(int i = 0; i < 4; i++) BOOST_TEST(acc_someArray[0][i] == 10 + i);
641 // auto oldVersion = acc_someArray.getVersionNumber();
642 acc_someArray.read();
643 for(int i = 0; i < 4; i++) BOOST_TEST(acc_someArray[0][i] == -55 * i);
644 // BOOST_TEST(acc_someArray.getVersionNumber() == oldVersion); // DOOCS behaves differently, eventId == 0 for
645 // properties set through RPC call
646
647 for(int i = 0; i < 4; i++) acc_someArray[0][i] = i - 21;
648 vals = DoocsServerTestHelper::doocsGetArray<int>("//MYDUMMY/SOME_IIII");
649 for(int i = 0; i < 4; i++) BOOST_TEST(vals[i] == -55 * i);
650 VersionNumber nextVersion;
651 acc_someArray.write(nextVersion);
652 vals = DoocsServerTestHelper::doocsGetArray<int>("//MYDUMMY/SOME_IIII");
653 for(int i = 0; i < 4; i++) BOOST_TEST(vals[i] == i - 21);
654 BOOST_TEST(acc_someArray.getVersionNumber() == nextVersion);
655
656 // access via double
657 TwoDRegisterAccessor<double> acc_someArrayAsDouble(device.getTwoDRegisterAccessor<double>("MYDUMMY/SOME_IIII"));
658 acc_someArrayAsDouble.read();
659 for(int i = 0; i < 4; i++) BOOST_CHECK_CLOSE(acc_someArrayAsDouble[0][i], i - 21, 0.00001);
660 for(int i = 0; i < 4; i++) acc_someArrayAsDouble[0][i] = 2.4 * i;
661 acc_someArrayAsDouble.write();
662 vals = DoocsServerTestHelper::doocsGetArray<int>("//MYDUMMY/SOME_IIII");
663 for(int i = 0; i < 4; i++) BOOST_CHECK_CLOSE(vals[i], round(2.4 * i), 0.00001);
664
665 // access via string
666 TwoDRegisterAccessor<std::string> acc_someArrayAsString(
667 device.getTwoDRegisterAccessor<std::string>("MYDUMMY/SOME_IIII"));
668 acc_someArrayAsString.read();
669 for(int i = 0; i < 4; i++) BOOST_CHECK_CLOSE(std::stod(acc_someArrayAsString[0][i]), round(2.4 * i), 0.00001);
670 for(int i = 0; i < 4; i++) acc_someArrayAsString[0][i] = std::to_string(3 * i);
671 acc_someArrayAsString.write();
672 vals = DoocsServerTestHelper::doocsGetArray<int>("//MYDUMMY/SOME_IIII");
673 for(int i = 0; i < 4; i++) BOOST_TEST(vals[i] == 3 * i);
674
675 device.close();
676}
677
678/**********************************************************************************************************************/
679
680BOOST_AUTO_TEST_CASE(testIFFF) {
681 ChimeraTK::Device device;
682 device.open(DoocsLauncher::DoocsServer1);
683
684 // check catalogue
685 auto catalogue = device.getRegisterCatalogue();
686 auto regI = catalogue.getRegister("MYDUMMY/SOME_IFFF/I");
687 auto regF1 = catalogue.getRegister("MYDUMMY/SOME_IFFF/F1");
688 auto regF2 = catalogue.getRegister("MYDUMMY/SOME_IFFF/F2");
689 auto regF3 = catalogue.getRegister("MYDUMMY/SOME_IFFF/F3");
690 BOOST_TEST(regI.getDataDescriptor().isIntegral());
691 BOOST_TEST(regI.getDataDescriptor().isSigned());
692 BOOST_TEST(regI.getDataDescriptor().nDigits() == 11);
693 BOOST_TEST(!regF1.getDataDescriptor().isIntegral());
694 BOOST_TEST(regF1.getDataDescriptor().isSigned());
695 BOOST_TEST(!regF2.getDataDescriptor().isIntegral());
696 BOOST_TEST(regF2.getDataDescriptor().isSigned());
697 BOOST_TEST(!regF3.getDataDescriptor().isIntegral());
698 BOOST_TEST(regF3.getDataDescriptor().isSigned());
699
700 // read access via int/float
701 {
702 auto acc_I = device.getScalarRegisterAccessor<int>("MYDUMMY/SOME_IFFF/I");
703 auto acc_F1 = device.getScalarRegisterAccessor<float>("MYDUMMY/SOME_IFFF/F1");
704 auto acc_F2 = device.getScalarRegisterAccessor<float>("MYDUMMY/SOME_IFFF/F2");
705 auto acc_F3 = device.getScalarRegisterAccessor<float>("MYDUMMY/SOME_IFFF/F3");
706
707 acc_I.read();
708 BOOST_CHECK_EQUAL(int(acc_I), 10);
709 acc_F1.read();
710 BOOST_CHECK_CLOSE(float(acc_F1), 2.71828, 0.00001);
711 acc_F2.read();
712 BOOST_CHECK_CLOSE(float(acc_F2), 3.14159, 0.00001);
713 acc_F3.read();
714 BOOST_CHECK_CLOSE(float(acc_F3), 197.327, 0.00001);
715 }
716
717 // read access via strings
718 {
719 auto acc_I = device.getScalarRegisterAccessor<std::string>("MYDUMMY/SOME_IFFF/I");
720 auto acc_F1 = device.getScalarRegisterAccessor<std::string>("MYDUMMY/SOME_IFFF/F1");
721 auto acc_F2 = device.getScalarRegisterAccessor<std::string>("MYDUMMY/SOME_IFFF/F2");
722 auto acc_F3 = device.getScalarRegisterAccessor<std::string>("MYDUMMY/SOME_IFFF/F3");
723
724 acc_I.read();
725 BOOST_CHECK_EQUAL(std::string(acc_I), "10");
726 acc_F1.read();
727 BOOST_CHECK_CLOSE(std::stod(acc_F1), 2.71828, 0.00001);
728 acc_F2.read();
729 BOOST_CHECK_CLOSE(std::stod(acc_F2), 3.14159, 0.00001);
730 acc_F3.read();
731 BOOST_CHECK_CLOSE(std::stod(acc_F3), 197.327, 0.00001);
732 }
733
734 // write access via int/float
735 {
736 auto acc_I = device.getScalarRegisterAccessor<int>("MYDUMMY/SOME_IFFF/I");
737 auto acc_F1 = device.getScalarRegisterAccessor<float>("MYDUMMY/SOME_IFFF/F1");
738 auto acc_F2 = device.getScalarRegisterAccessor<float>("MYDUMMY/SOME_IFFF/F2");
739 auto acc_F3 = device.getScalarRegisterAccessor<float>("MYDUMMY/SOME_IFFF/F3");
740
741 acc_I = 42;
742 acc_I.write();
743
744 acc_I.read();
745 BOOST_CHECK_EQUAL(int(acc_I), 42);
746 acc_F1.read();
747 BOOST_CHECK_CLOSE(float(acc_F1), 2.71828, 0.00001);
748 acc_F2.read();
749 BOOST_CHECK_CLOSE(float(acc_F2), 3.14159, 0.00001);
750 acc_F3.read();
751 BOOST_CHECK_CLOSE(float(acc_F3), 197.327, 0.00001);
752
753 acc_F2 = 123.456;
754 acc_F2.write();
755
756 acc_F3 = -666.666;
757 acc_F3.write();
758
759 acc_I.read();
760 BOOST_CHECK_EQUAL(int(acc_I), 42);
761 acc_F1.read();
762 BOOST_CHECK_CLOSE(float(acc_F1), 2.71828, 0.00001);
763 acc_F2.read();
764 BOOST_CHECK_CLOSE(float(acc_F2), 123.456, 0.00001);
765 acc_F3.read();
766 BOOST_CHECK_CLOSE(float(acc_F3), -666.666, 0.00001);
767 }
768
769 device.close();
770}
771
772/**********************************************************************************************************************/
773
774BOOST_AUTO_TEST_CASE(testImage) {
775 ChimeraTK::Device device;
776 device.open(DoocsLauncher::DoocsServer1);
777
778 // obtain default array length, just fitting image on DOOCS server
779 OneDRegisterAccessor<std::uint8_t> acc_someImage(device.getOneDRegisterAccessor<std::uint8_t>("MYDUMMY/SOME_IMAGE"));
780 BOOST_TEST(acc_someImage.getNElements() == 640 * 460 + sizeof(ChimeraTK::ImgHeader));
781
782 acc_someImage.read();
783 ChimeraTK::MappedImage im(acc_someImage);
784 BOOST_TEST(im.header()->width == 200);
785 BOOST_TEST(im.header()->height == 100);
786 BOOST_CHECK(im.header()->image_format == ChimeraTK::ImgFormat::Gray16);
787 auto imv = im.interpretedView<std::uint16_t>();
788 BOOST_TEST(imv(0, 0) == 0x101);
789
790 // obtain accessor with larger than default array length
791 OneDRegisterAccessor<std::uint8_t> acc_someImage_padded(
792 device.getOneDRegisterAccessor<std::uint8_t>("MYDUMMY/SOME_IMAGE", 200 * 1000));
793 BOOST_TEST(acc_someImage_padded.getNElements() == 200 * 1000);
794 acc_someImage_padded.read();
795 // verify that image content is same
796 for(unsigned i = 0; i < im.header()->totalLength; i++) {
797 BOOST_TEST(acc_someImage[i] == acc_someImage_padded[i]);
798 }
799 // obtain accessor with smaller array length, so image must be truncated
800 OneDRegisterAccessor<std::uint8_t> acc_someImage_truncated(
801 device.getOneDRegisterAccessor<std::uint8_t>("MYDUMMY/SOME_IMAGE", 200 * 51 * 2));
802 acc_someImage_truncated.read();
803 ChimeraTK::MappedImage im1(acc_someImage_truncated);
804 BOOST_TEST(im1.header()->width == 200);
805 BOOST_TEST(im1.header()->height == 50); // one line less than 51 because of header
806 BOOST_CHECK(im1.header()->image_format == ChimeraTK::ImgFormat::Gray16);
807
808 device.close();
809}
810
811/**********************************************************************************************************************/
812
813BOOST_AUTO_TEST_CASE(testBit) {
814 ChimeraTK::Device device;
815 device.open(DoocsLauncher::DoocsServer1);
816
817 TwoDRegisterAccessor<int> acc_someBit(device.getTwoDRegisterAccessor<int>("MYDUMMY/SOME_BIT"));
818
819 BOOST_TEST(acc_someBit.getNChannels() == 1);
820 BOOST_TEST(acc_someBit.getNElementsPerChannel() == 1);
821
822 auto oldVersion = acc_someBit.getVersionNumber();
823 acc_someBit.read();
824 BOOST_TEST(acc_someBit[0][0] == 1);
825 BOOST_TEST(acc_someBit.getVersionNumber() != oldVersion);
826
827 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_BIT", 0);
828
829 BOOST_TEST(acc_someBit[0][0] == 1);
830 acc_someBit.read();
831 BOOST_TEST(acc_someBit[0][0] == 0);
832
833 // Get EqFct to access the _someValue wich is attached to D_bit accessed with acc_someBit
834 auto eqfct = dynamic_cast<eq_dummy*>(find_device("MYDUMMY"));
835 eqfct->_someValue = 0xFFFF;
836
837 BOOST_TEST(acc_someBit[0][0] == 0);
838 acc_someBit.read();
839 BOOST_TEST(acc_someBit[0][0] == 1);
840
841 acc_someBit[0][0] = 0;
842 VersionNumber nextVersion;
843 acc_someBit.write(nextVersion);
844 BOOST_TEST(eqfct->_someValue = 0xFFFE);
845 BOOST_TEST(acc_someBit.getVersionNumber() == nextVersion);
846
847 device.close();
848}
849/**********************************************************************************************************************/
850
851BOOST_AUTO_TEST_CASE(testPartialAccess) {
852 ChimeraTK::Device device;
853 device.open(DoocsLauncher::DoocsServer1);
854
855 // int array, 20 elements, offset of 1
856 {
857 OneDRegisterAccessor<int> acc_someArray(device.getOneDRegisterAccessor<int>("MYDUMMY/SOME_INT_ARRAY", 20, 1));
858 BOOST_TEST(acc_someArray.getNElements() == 20);
859
860 std::vector<int> vals(42);
861 for(int i = 0; i < 42; i++) vals[i] = -55 * i;
862 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_INT_ARRAY", vals);
863
864 acc_someArray.read();
865 for(int i = 0; i < 20; i++) BOOST_TEST(acc_someArray[i] == -55 * (i + 1));
866
867 for(int i = 0; i < 20; i++) acc_someArray[i] = i;
868 acc_someArray.write();
869 vals = DoocsServerTestHelper::doocsGetArray<int>("//MYDUMMY/SOME_INT_ARRAY");
870 for(int i = 0; i < 42; i++) {
871 if(i == 0 || i > 20) {
872 BOOST_TEST(vals[i] == -55 * i);
873 }
874 else {
875 BOOST_TEST(vals[i] == i - 1);
876 }
877 }
878 }
879
880 // int array, 1 elements, offset of 10
881 {
882 OneDRegisterAccessor<int> acc_someArray(device.getOneDRegisterAccessor<int>("MYDUMMY/SOME_INT_ARRAY", 1, 10));
883 BOOST_TEST(acc_someArray.getNElements() == 1);
884
885 std::vector<int> vals(42);
886 for(int i = 0; i < 42; i++) vals[i] = 33 * i;
887 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_INT_ARRAY", vals);
888
889 acc_someArray.read();
890 BOOST_TEST(acc_someArray[0] == 33 * 10);
891
892 acc_someArray[0] = 42;
893 acc_someArray.write();
894 vals = DoocsServerTestHelper::doocsGetArray<int>("//MYDUMMY/SOME_INT_ARRAY");
895 for(int i = 0; i < 42; i++) {
896 if(i == 10) {
897 BOOST_TEST(vals[i] == 42);
898 }
899 else {
900 BOOST_TEST(vals[i] == 33 * i);
901 }
902 }
903 }
904
905 // double array with float user type, 3 elements, offset of 2
906 {
907 OneDRegisterAccessor<float> acc_someArray(device.getOneDRegisterAccessor<float>("MYDUMMY/SOME_DOUBLE_ARRAY", 3, 2));
908 BOOST_TEST(acc_someArray.getNElements() == 3);
909
910 std::vector<double> vals(5);
911 for(int i = 0; i < 5; i++) vals[i] = 3.14 * i;
912 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_DOUBLE_ARRAY", vals);
913
914 acc_someArray.read();
915 for(int i = 0; i < 3; i++) BOOST_CHECK_CLOSE(acc_someArray[i], 3.14 * (i + 2), 0.00001);
916
917 for(int i = 0; i < 3; i++) acc_someArray[i] = 1.2 - i;
918 acc_someArray.write();
919 vals = DoocsServerTestHelper::doocsGetArray<double>("//MYDUMMY/SOME_DOUBLE_ARRAY");
920 for(int i = 0; i < 5; i++) {
921 if(i > 1) {
922 BOOST_CHECK_CLOSE(vals[i], 1.2 - (i - 2), 0.00001);
923 }
924 else {
925 BOOST_CHECK_CLOSE(vals[i], 3.14 * i, 0.00001);
926 }
927 }
928 }
929
930 // float array with string user type, 1 elements, offset of 0
931 {
932 ScalarRegisterAccessor<std::string> acc_someArray(
933 device.getScalarRegisterAccessor<std::string>("MYDUMMY/SOME_FLOAT_ARRAY", 0));
934
935 std::vector<float> vals(5);
936 for(int i = 0; i < 5; i++) vals[i] = 2.82 * (i + 1);
937 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_FLOAT_ARRAY", vals);
938
939 acc_someArray.read();
940 BOOST_CHECK_CLOSE(std::stod(acc_someArray), 2.82, 0.00001);
941
942 acc_someArray = "-11.111";
943 acc_someArray.write();
944 vals = DoocsServerTestHelper::doocsGetArray<float>("//MYDUMMY/SOME_FLOAT_ARRAY");
945 for(int i = 0; i < 5; i++) {
946 if(i == 0) {
947 BOOST_CHECK_CLOSE(vals[i], -11.111, 0.00001);
948 }
949 else {
950 BOOST_CHECK_CLOSE(vals[i], 2.82 * (i + 1), 0.00001);
951 }
952 }
953 }
954
955 device.close();
956}
957
958/**********************************************************************************************************************/
959
960BOOST_AUTO_TEST_CASE(testExceptions) {
961 ChimeraTK::Device device;
962 device.open(DoocsLauncher::DoocsServer1);
963
964 // unsupported data type
965 BOOST_CHECK_THROW(device.getTwoDRegisterAccessor<int>("MYDUMMY/UNSUPPORTED_DATA_TYPE"), // D_fiii
966 ChimeraTK::logic_error);
967
968 // non-existing DOOCS property
969 BOOST_CHECK_THROW(device.getTwoDRegisterAccessor<int>("MYDUMMY/NOT_EXISTING"), ChimeraTK::logic_error);
970
971 // read string with non-string user type
972 BOOST_CHECK_THROW(device.getTwoDRegisterAccessor<int>("MYDUMMY/SOME_STRING"), ChimeraTK::logic_error);
973
974 // access too many elements (double register)
975 BOOST_CHECK_THROW(device.getOneDRegisterAccessor<float>("MYDUMMY/SOME_DOUBLE_ARRAY", 10, 1), ChimeraTK::logic_error);
976
977 // access too many elements (int register)
978 BOOST_CHECK_THROW(device.getOneDRegisterAccessor<float>("MYDUMMY/SOME_INT_ARRAY", 100, 1), ChimeraTK::logic_error);
979
980 device.close();
981}
982
983/**********************************************************************************************************************/
984
985void createCacheFileFromCdd(const std::string& cdd) {
986 namespace ctk = ChimeraTK;
987 auto d = ctk::Device(cdd);
988 d.open();
989 auto discardedCatalogue = d.getRegisterCatalogue();
990}
991
992void deleteFile(const std::string& filename) {
993 errno = 0;
994 if(unlink(filename.c_str()) < 0) throw std::system_error(std::make_error_code(static_cast<std::errc>(errno)));
995}
996
997void deleteFileIfExisting(const std::string& filename) {
998 unlink(filename.c_str());
999}
1000
1001/**********************************************************************************************************************/
1002
1003BOOST_AUTO_TEST_CASE(testCatalogue) {
1004 {
1005 createCacheFileFromCdd(DoocsLauncher::DoocsServer1_cached);
1006 createCacheFileFromCdd(DoocsLauncher::DoocsServer2_cached);
1007
1008 ChimeraTK::Device device;
1009 device.open(DoocsLauncher::DoocsServer2);
1010
1011 ChimeraTK::Device device_cached;
1012 device_cached.open(DoocsLauncher::DoocsServer2_cached);
1013
1014 std::vector<ChimeraTK::RegisterCatalogue> catalogueList2;
1015 catalogueList2.push_back(device.getRegisterCatalogue());
1016 catalogueList2.push_back(device_cached.getRegisterCatalogue());
1017
1018 for(auto& catalogue : catalogueList2) {
1019 // check number of registers, but not with the exact number, since DOOCS adds some registers!
1020 BOOST_TEST(catalogue.getNumberOfRegisters() > 13);
1021
1022 // check for the presence of known registers
1023 BOOST_TEST(catalogue.hasRegister("SOME_INT"));
1024 BOOST_TEST(catalogue.hasRegister("SOME_FLOAT"));
1025 BOOST_TEST(catalogue.hasRegister("SOME_DOUBLE"));
1026 BOOST_TEST(catalogue.hasRegister("SOME_STRING"));
1027 BOOST_TEST(catalogue.hasRegister("SOME_BIT"));
1028 BOOST_TEST(catalogue.hasRegister("SOME_INT_ARRAY"));
1029 BOOST_TEST(catalogue.hasRegister("SOME_SHORT_ARRAY"));
1030 BOOST_TEST(catalogue.hasRegister("SOME_LONG_ARRAY"));
1031 BOOST_TEST(catalogue.hasRegister("SOME_FLOAT_ARRAY"));
1032 BOOST_TEST(catalogue.hasRegister("SOME_DOUBLE_ARRAY"));
1033 BOOST_TEST(catalogue.hasRegister("SOME_SPECTRUM"));
1034 BOOST_TEST(catalogue.hasRegister("SOME_IFFF/I"));
1035 BOOST_TEST(catalogue.hasRegister("SOME_IFFF/F1"));
1036 BOOST_TEST(catalogue.hasRegister("SOME_IFFF/F2"));
1037 BOOST_TEST(catalogue.hasRegister("SOME_IFFF/F3"));
1038
1039 // check the properties of some registers
1040 auto r1 = catalogue.getRegister("SOME_INT");
1041 BOOST_TEST(r1.getRegisterName() == "SOME_INT");
1042 BOOST_TEST(r1.getNumberOfElements() == 1);
1043 BOOST_TEST(r1.getNumberOfChannels() == 1);
1044 BOOST_TEST(r1.getNumberOfDimensions() == 0);
1045 BOOST_TEST(not r1.getSupportedAccessModes().has(ChimeraTK::AccessMode::wait_for_new_data));
1046
1047 auto r2 = catalogue.getRegister("SOME_STRING");
1048 BOOST_TEST(r2.getRegisterName() == "SOME_STRING");
1049 BOOST_TEST(r2.getNumberOfElements() == 1);
1050 BOOST_TEST(r2.getNumberOfChannels() == 1);
1051 BOOST_TEST(r2.getNumberOfDimensions() == 0);
1052 BOOST_TEST(not r2.getSupportedAccessModes().has(ChimeraTK::AccessMode::wait_for_new_data));
1053
1054 auto r3 = catalogue.getRegister("SOME_INT_ARRAY");
1055 BOOST_TEST(r3.getRegisterName() == "SOME_INT_ARRAY");
1056 BOOST_TEST(r3.getNumberOfElements() == 42);
1057 BOOST_TEST(r3.getNumberOfChannels() == 1);
1058 BOOST_TEST(r3.getNumberOfDimensions() == 1);
1059 BOOST_TEST(not r3.getSupportedAccessModes().has(ChimeraTK::AccessMode::wait_for_new_data));
1060
1061 auto r4 = catalogue.getRegister("SOME_FLOAT_ARRAY");
1062 BOOST_TEST(r4.getRegisterName() == "SOME_FLOAT_ARRAY");
1063 BOOST_TEST(r4.getNumberOfElements() == 5);
1064 BOOST_TEST(r4.getNumberOfChannels() == 1);
1065 BOOST_TEST(r4.getNumberOfDimensions() == 1);
1066 BOOST_TEST(not r4.getSupportedAccessModes().has(ChimeraTK::AccessMode::wait_for_new_data));
1067
1068 auto r5 = catalogue.getRegister("SOME_SPECTRUM");
1069 BOOST_TEST(r5.getRegisterName() == "SOME_SPECTRUM");
1070 BOOST_TEST(r5.getNumberOfElements() == 100);
1071 BOOST_TEST(r5.getNumberOfChannels() == 1);
1072 BOOST_TEST(r5.getNumberOfDimensions() == 1);
1073 BOOST_TEST(not r5.getSupportedAccessModes().has(ChimeraTK::AccessMode::wait_for_new_data));
1074
1075 auto r6 = catalogue.getRegister("SOME_ZMQINT");
1076 BOOST_TEST(r6.getRegisterName() == "SOME_ZMQINT");
1077 BOOST_TEST(r6.getNumberOfElements() == 1);
1078 BOOST_TEST(r6.getNumberOfChannels() == 1);
1079 BOOST_TEST(r6.getNumberOfDimensions() == 0);
1080 BOOST_TEST(r6.getSupportedAccessModes().has(ChimeraTK::AccessMode::wait_for_new_data));
1081
1082 auto r7 = catalogue.getRegister("SOME_IIII");
1083 BOOST_TEST(r7.getRegisterName() == "SOME_IIII");
1084 BOOST_TEST(r7.getNumberOfElements() == 4);
1085 BOOST_TEST(r7.getNumberOfChannels() == 1);
1086 BOOST_TEST(r7.getNumberOfDimensions() == 1);
1087 BOOST_TEST(not r7.getSupportedAccessModes().has(ChimeraTK::AccessMode::wait_for_new_data));
1088
1089 auto regI = catalogue.getRegister("SOME_IFFF/I");
1090 auto regF1 = catalogue.getRegister("SOME_IFFF/F1");
1091 auto regF2 = catalogue.getRegister("SOME_IFFF/F2");
1092 auto regF3 = catalogue.getRegister("SOME_IFFF/F3");
1093 BOOST_TEST(regI.getDataDescriptor().isIntegral());
1094 BOOST_TEST(regI.getDataDescriptor().isSigned());
1095 BOOST_TEST(regI.getDataDescriptor().nDigits() == 11);
1096 BOOST_TEST(!regF1.getDataDescriptor().isIntegral());
1097 BOOST_TEST(regF1.getDataDescriptor().isSigned());
1098 BOOST_TEST(!regF2.getDataDescriptor().isIntegral());
1099 BOOST_TEST(regF2.getDataDescriptor().isSigned());
1100 BOOST_TEST(!regF3.getDataDescriptor().isIntegral());
1101 BOOST_TEST(regF3.getDataDescriptor().isSigned());
1102 }
1103 device.close();
1104 device_cached.close();
1105
1106 // quick check with the other level (location is included in the register name)
1107 device.open(DoocsLauncher::DoocsServer1);
1108 device_cached.open(DoocsLauncher::DoocsServer1_cached);
1109
1110 std::vector<ChimeraTK::RegisterCatalogue> catalogueList1;
1111 catalogueList1.push_back(device.getRegisterCatalogue());
1112 catalogueList1.push_back(device_cached.getRegisterCatalogue());
1113
1114 for(auto& catalogue : catalogueList1) {
1115 // check number of registers, but not with the exact number, since DOOCS adds some registers!
1116 BOOST_TEST(catalogue.getNumberOfRegisters() > 13);
1117
1118 // check for the presence of known registers
1119 BOOST_TEST(catalogue.hasRegister("MYDUMMY/SOME_INT"));
1120 BOOST_TEST(catalogue.hasRegister("MYDUMMY/SOME_ZMQINT"));
1121 BOOST_TEST(catalogue.hasRegister("DUMMY._SVR/SVR.BPN"));
1122 BOOST_TEST(catalogue.hasRegister("MYDUMMY/SOME_IFFF/I"));
1123 BOOST_TEST(catalogue.hasRegister("MYDUMMY/SOME_IFFF/F1"));
1124 BOOST_TEST(catalogue.hasRegister("MYDUMMY/SOME_IFFF/F2"));
1125 BOOST_TEST(catalogue.hasRegister("MYDUMMY/SOME_IFFF/F3"));
1126
1127 // check the properties of some registers
1128 auto r8 = catalogue.getRegister("MYDUMMY/SOME_INT");
1129 BOOST_TEST(r8.getRegisterName() == "MYDUMMY/SOME_INT");
1130 BOOST_TEST(r8.getNumberOfElements() == 1);
1131 BOOST_TEST(r8.getNumberOfChannels() == 1);
1132 BOOST_TEST(r8.getNumberOfDimensions() == 0);
1133 BOOST_TEST(not r8.getSupportedAccessModes().has(ChimeraTK::AccessMode::wait_for_new_data));
1134
1135 auto r9 = catalogue.getRegister("DUMMY._SVR/SVR.BPN");
1136 BOOST_TEST(r9.getRegisterName() == "DUMMY._SVR/SVR.BPN");
1137 BOOST_TEST(r9.getNumberOfElements() == 1);
1138 BOOST_TEST(r9.getNumberOfChannels() == 1);
1139 BOOST_TEST(r9.getNumberOfDimensions() == 0);
1140 BOOST_TEST(not r9.getSupportedAccessModes().has(ChimeraTK::AccessMode::wait_for_new_data));
1141
1142 auto r10 = catalogue.getRegister("MYDUMMY/SOME_ZMQINT");
1143 BOOST_TEST(r10.getRegisterName() == "MYDUMMY/SOME_ZMQINT");
1144 BOOST_TEST(r10.getNumberOfElements() == 1);
1145 BOOST_TEST(r10.getNumberOfChannels() == 1);
1146 BOOST_TEST(r10.getNumberOfDimensions() == 0);
1147 BOOST_TEST(r10.getSupportedAccessModes().has(ChimeraTK::AccessMode::wait_for_new_data));
1148
1149 auto regI = catalogue.getRegister("MYDUMMY/SOME_IFFF/I");
1150 auto regF1 = catalogue.getRegister("MYDUMMY/SOME_IFFF/F1");
1151 auto regF2 = catalogue.getRegister("MYDUMMY/SOME_IFFF/F2");
1152 auto regF3 = catalogue.getRegister("MYDUMMY/SOME_IFFF/F3");
1153 BOOST_TEST(regI.getDataDescriptor().isIntegral());
1154 BOOST_TEST(regI.getDataDescriptor().isSigned());
1155 BOOST_TEST(regI.getDataDescriptor().nDigits() == 11);
1156 BOOST_TEST(!regF1.getDataDescriptor().isIntegral());
1157 BOOST_TEST(regF1.getDataDescriptor().isSigned());
1158 BOOST_TEST(!regF2.getDataDescriptor().isIntegral());
1159 BOOST_TEST(regF2.getDataDescriptor().isSigned());
1160 BOOST_TEST(!regF3.getDataDescriptor().isIntegral());
1161 BOOST_TEST(regF3.getDataDescriptor().isSigned());
1162 }
1163 device.close();
1164 device_cached.close();
1165 } // ensure we delete the cache file written on destruction
1166
1167 deleteFile(DoocsLauncher::cacheFile1);
1168 deleteFile(DoocsLauncher::cacheFile2);
1169}
1170
1171/**********************************************************************************************************************/
1172
1173BOOST_AUTO_TEST_CASE(testOther) {
1174 ChimeraTK::Device device;
1175 device.open(DoocsLauncher::DoocsServer1);
1176
1177 // device info string
1178 BOOST_TEST(device.readDeviceInfo() == "DOOCS server address: doocs://localhost:" + DoocsLauncher::rpc_no + "/F/D");
1179 // test in TransferGroup
1180 TwoDRegisterAccessor<int32_t> acc1(device.getTwoDRegisterAccessor<int32_t>("MYDUMMY/SOME_INT"));
1181 TwoDRegisterAccessor<int32_t> acc2(device.getTwoDRegisterAccessor<int32_t>("MYDUMMY/SOME_INT"));
1182
1183 BOOST_TEST(acc1.getHighLevelImplElement()->mayReplaceOther(acc2.getHighLevelImplElement()));
1184 BOOST_TEST(acc2.getHighLevelImplElement()->mayReplaceOther(acc1.getHighLevelImplElement()));
1185 BOOST_TEST(acc1.getHardwareAccessingElements().size() == 1);
1186 BOOST_TEST(acc2.getHardwareAccessingElements().size() == 1);
1187 BOOST_TEST(acc1.getHardwareAccessingElements().front() != acc2.getHardwareAccessingElements().front());
1188
1189 TransferGroup group;
1190 group.addAccessor(acc1);
1191 auto acc2impl = acc2.getHighLevelImplElement();
1192 group.addAccessor(acc2);
1193 BOOST_TEST(acc2impl != acc2.getHighLevelImplElement());
1194 BOOST_TEST(boost::dynamic_pointer_cast<ChimeraTK::CopyRegisterDecorator<int32_t>>(acc1.getHighLevelImplElement()) ==
1195 nullptr);
1196 BOOST_TEST(boost::dynamic_pointer_cast<ChimeraTK::CopyRegisterDecorator<int32_t>>(acc2.getHighLevelImplElement()) !=
1197 nullptr);
1198 BOOST_TEST(acc1.getHardwareAccessingElements().front() == acc2.getHardwareAccessingElements().front());
1199
1200 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_INT", 123);
1201 group.read();
1202 BOOST_CHECK_EQUAL(acc1[0][0], 123);
1203 BOOST_CHECK_EQUAL(acc2[0][0], 123);
1204 acc1[0][0] = 42;
1205
1206 device.close();
1207
1208 // compatibility with SDM syntax
1209 device.open("sdm://./doocs=TEST.DOOCS,NOT_EXISTING,SOME_LOCATION");
1210 BOOST_TEST(device.readDeviceInfo() == "DOOCS server address: TEST.DOOCS/NOT_EXISTING/SOME_LOCATION");
1211 device.close();
1212}
1213
1214/**********************************************************************************************************************/
1215
1216BOOST_AUTO_TEST_CASE(testDestruction) {
1217 auto server = find_device("MYDUMMY");
1218 server->lock();
1219 {
1220 auto d = ChimeraTK::Device(DoocsLauncher::DoocsServer2_cached);
1221 d.open();
1222 usleep(10000); // give it a chance to start filling the catalogue
1223 // should not block here on instance destruction.
1224 }
1225 server->unlock();
1226}
1227
1228/**********************************************************************************************************************/
1229
1230bool file_exists(const std::string& name) {
1231 std::ifstream f(name.c_str());
1232 return f.good();
1233}
1234
1235BOOST_AUTO_TEST_CASE(testCacheFileCreation) {
1236 {
1237 deleteFileIfExisting(DoocsLauncher::cacheFile1);
1238 deleteFileIfExisting(DoocsLauncher::cacheFile2);
1239 BOOST_TEST(file_exists(DoocsLauncher::cacheFile1) == false);
1240 BOOST_TEST(file_exists(DoocsLauncher::cacheFile2) == false);
1241
1242 auto d1 = ChimeraTK::Device(DoocsLauncher::DoocsServer1_cached);
1243 auto d2 = ChimeraTK::Device(DoocsLauncher::DoocsServer2_cached);
1244
1245 auto discardedCatalogue = d1.getRegisterCatalogue();
1246 discardedCatalogue = d2.getRegisterCatalogue();
1247
1248 BOOST_TEST(file_exists(DoocsLauncher::cacheFile1) == true);
1249 BOOST_TEST(file_exists(DoocsLauncher::cacheFile2) == true);
1250 }
1251 deleteFile(DoocsLauncher::cacheFile1);
1252 deleteFile(DoocsLauncher::cacheFile2);
1253}
1254
1255/**********************************************************************************************************************/
1256
1257std::time_t createDummyXml(const std::string& filename) {
1258 std::string xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
1259 "<catalogue version=\"1.0\">"
1260 " <register>\n"
1261 " <name>/DUMMY</name>\n"
1262 " <length>1</length>\n"
1263 " <access_mode></access_mode>\n"
1264 " <doocs_type_id>1</doocs_type_id>\n" // DATA_TEXT
1265 " <!--doocs id: INT-->\n"
1266 " </register>\n"
1267 "</catalogue>\n";
1268 std::ofstream o(filename);
1269 o << xml;
1270 o.close();
1271
1272 auto creation_time = boost::filesystem::last_write_time(DoocsLauncher::cacheFile2);
1273
1274 // boost::filesystem::last_write_time timestamp resolution is not high
1275 // enough to pick modifications without this wait.
1276 std::this_thread::sleep_for(std::chrono::seconds(1));
1277 return creation_time;
1278}
1279
1280/**********************************************************************************************************************/
1281
1282BOOST_AUTO_TEST_CASE(testCacheXmlReplacement) {
1283 // test local copy is replaced when catalogue fetching is complete.
1284 auto creation_time = createDummyXml(DoocsLauncher::cacheFile2);
1285 {
1286 auto d = ChimeraTK::Device(DoocsLauncher::DoocsServer2_cached);
1287 std::atomic<bool> cancelTimeOutTask{false};
1288
1289 std::future<void> timeoutTask = std::async(std::launch::async, [&]() {
1290 unsigned int count = 60;
1291 while(count > 0 && not cancelTimeOutTask) {
1292 std::this_thread::sleep_for(std::chrono::seconds(1));
1293 count--;
1294 }
1295 });
1296
1297 auto hasTimedOut = [&]() { return timeoutTask.wait_for(std::chrono::seconds(0)) == std::future_status::ready; };
1298
1299 auto modification_time = creation_time;
1300 while((modification_time <= creation_time) && not hasTimedOut()) {
1301 modification_time = boost::filesystem::last_write_time(DoocsLauncher::cacheFile2);
1302 std::this_thread::sleep_for(std::chrono::seconds(2));
1303 }
1304 // cancel timeout task
1305 cancelTimeOutTask = true;
1306 BOOST_TEST(modification_time > creation_time); // given the percondition,
1307 // this should fail if loop
1308 // times out.
1309 deleteFile(DoocsLauncher::cacheFile2);
1310 }
1311}
1312
1313/**********************************************************************************************************************/
1314
1315BOOST_AUTO_TEST_CASE(testCacheXmlReplacementBehaviorOnFailure) {
1316 // local copy unchanged if app exits before.
1317 auto creation_time = createDummyXml(DoocsLauncher::cacheFile2);
1318 auto server = find_device("MYDUMMY");
1319 server->lock();
1320 {
1321 auto d = ChimeraTK::Device(DoocsLauncher::DoocsServer2_cached);
1322 }
1323 server->unlock();
1324 auto modification_time = boost::filesystem::last_write_time(DoocsLauncher::cacheFile2);
1325 BOOST_TEST(creation_time == modification_time);
1326 deleteFile(DoocsLauncher::cacheFile2);
1327}
1328
1329/**********************************************************************************************************************/
1330
1331BOOST_AUTO_TEST_CASE(testAccessorForCachedMode) {
1332 createCacheFileFromCdd(DoocsLauncher::DoocsServer1_cached);
1333 auto d = ChimeraTK::Device(DoocsLauncher::DoocsServer1_cached);
1334
1335 DoocsServerTestHelper::doocsSet("//MYDUMMY/SOME_INT", 120);
1336 TwoDRegisterAccessor<int32_t> acc_someInt_as_int(d.getTwoDRegisterAccessor<int32_t>("MYDUMMY/SOME_INT"));
1337 BOOST_TEST(acc_someInt_as_int.getNChannels() == 1);
1338 BOOST_TEST(acc_someInt_as_int.getNElementsPerChannel() == 1);
1339
1340 d.open();
1341
1342 acc_someInt_as_int.read();
1343 BOOST_TEST(acc_someInt_as_int[0][0] == 120);
1344
1345 acc_someInt_as_int[0][0] = 50;
1346 acc_someInt_as_int.write();
1347 BOOST_TEST(DoocsServerTestHelper::doocsGet<int>("//MYDUMMY/SOME_INT") == 50);
1348 deleteFile(DoocsLauncher::cacheFile1);
1349}
1350
1351/**********************************************************************************************************************/
1352
1353BOOST_AUTO_TEST_CASE(testBlankXMLThrow) {
1354 std::string xml = "";
1355 std::ofstream o(DoocsLauncher::cacheFile2);
1356 o << xml;
1357 o.close();
1358
1359 BOOST_CHECK_THROW(ChimeraTK::Device x(DoocsLauncher::DoocsServer2_cached), ChimeraTK::logic_error);
1360 deleteFile(DoocsLauncher::cacheFile2);
1361}
1362
1363/**********************************************************************************************************************/
1364
1365BOOST_AUTO_TEST_CASE(testEventId) {
1366 ChimeraTK::Device device;
1367 device.open(DoocsLauncher::DoocsServer1);
1368 auto catalogue = device.getRegisterCatalogue();
1369
1370 // Run update once to have the ZMQ variable's mp number updated
1371 DoocsServerTestHelper::runUpdate();
1372
1373 // Get EqFct to access the mp counter for ZMQ
1374 auto eqfct = reinterpret_cast<eq_dummy*>(find_device("MYDUMMY"));
1375
1376 // device info string
1377 BOOST_TEST(device.readDeviceInfo() == "DOOCS server address: doocs://localhost:" + DoocsLauncher::rpc_no + "/F/D");
1378
1379 for(std::string param : {"SOME_INT", "SOME_FLOAT", "SOME_BIT", "SOME_INT_ARRAY", "SOME_SHORT_ARRAY",
1380 "SOME_LONG_ARRAY", "SOME_FLOAT_ARRAY", "SOME_DOUBLE_ARRAY", "SOME_SPECTRUM", "SOME_IIII", "SOME_IFFF"}) {
1381 auto path = RegisterPath("MYDUMMY/" + param + "/eventId");
1382 BOOST_TEST(catalogue.hasRegister(path));
1383
1384 auto regInfo = catalogue.getRegister(path);
1385 BOOST_TEST(regInfo.isReadable());
1386 BOOST_TEST(!regInfo.isWriteable());
1387 BOOST_CHECK_EQUAL(regInfo.getNumberOfElements(), 1);
1388 BOOST_CHECK_EQUAL(regInfo.getNumberOfChannels(), 1);
1389 BOOST_CHECK_EQUAL(regInfo.getNumberOfDimensions(), 0);
1390 auto descriptor = regInfo.getDataDescriptor();
1391 BOOST_TEST(descriptor.fundamentalType() == ChimeraTK::DataDescriptor::FundamentalType::numeric);
1392 BOOST_CHECK_EQUAL(descriptor.nDigits(), 20);
1393 BOOST_TEST(descriptor.isSigned());
1394 BOOST_TEST(descriptor.isIntegral());
1395
1396 auto acc1 = device.getScalarRegisterAccessor<int64_t>(path);
1397 acc1.read();
1398 BOOST_CHECK_EQUAL(static_cast<int64_t>(acc1), eqfct->counter - 1);
1399 BOOST_CHECK_EQUAL(acc1.isReadOnly(), true);
1400 BOOST_CHECK_EQUAL(acc1.isWriteable(), false);
1401 BOOST_CHECK_EQUAL(acc1.isReadable(), true);
1402 BOOST_CHECK_THROW(acc1.write(), ChimeraTK::logic_error);
1403
1404 auto acc2 = device.getScalarRegisterAccessor<std::string>(path);
1405 acc2.read();
1406 BOOST_CHECK_EQUAL(static_cast<std::string>(acc2), std::to_string(eqfct->counter - 1));
1407 BOOST_CHECK_EQUAL(acc2.isReadOnly(), true);
1408 BOOST_CHECK_EQUAL(acc2.isWriteable(), false);
1409 BOOST_CHECK_EQUAL(acc2.isReadable(), true);
1410 BOOST_CHECK_THROW(acc2.write(), ChimeraTK::logic_error);
1411
1412 // auto acc3 = device.getScalarRegisterAccessor<uint8_t>(path);
1413 // BOOST_CHECK_THROW(acc3.read(), boost::numeric::positive_overflow);
1414 }
1415
1416 // Check that we get the accessor for some unsupported type as well
1417 // Whether or not eventId retuns something usefull here is completely undefined
1418 auto acc1 = device.getScalarRegisterAccessor<int64_t>("MYDUMMY/UNSUPPORTED_DATA_TYPE/eventId");
1419 BOOST_TEST(acc1.isInitialised());
1420
1421 // Run update once to have the ZMQ variable's mp number updated
1422 DoocsServerTestHelper::runUpdate();
1423
1424 auto path = RegisterPath("MYDUMMY/SOME_ZMQINT/eventId");
1425 BOOST_TEST(catalogue.hasRegister(path));
1426 auto acc2 = device.getScalarRegisterAccessor<int64_t>(path);
1427 acc2.read();
1428 BOOST_CHECK_EQUAL(static_cast<int64_t>(acc2), eqfct->counter - 1);
1429 BOOST_CHECK_EQUAL(acc2.isReadOnly(), true);
1430 BOOST_CHECK_EQUAL(acc2.isWriteable(), false);
1431 BOOST_CHECK_EQUAL(acc2.isReadable(), true);
1432 BOOST_CHECK_THROW(acc2.write(), ChimeraTK::logic_error);
1433
1434 device.close();
1435}
1436
1437/**********************************************************************************************************************/
1438
1439BOOST_AUTO_TEST_CASE(testTimeStamp) {
1440 ChimeraTK::Device device;
1441 device.open(DoocsLauncher::DoocsServer1);
1442 auto catalogue = device.getRegisterCatalogue();
1443
1444 // Run update once to have the ZMQ variable's mp number updated
1445 DoocsServerTestHelper::runUpdate();
1446
1447 // Get EqFct to access the mp counter for ZMQ
1448 auto eqfct = reinterpret_cast<eq_dummy*>(find_device("MYDUMMY"));
1449
1450 // device info string
1451 BOOST_TEST(device.readDeviceInfo() == "DOOCS server address: doocs://localhost:" + DoocsLauncher::rpc_no + "/F/D");
1452
1453 for(std::string param : {"SOME_INT", "SOME_FLOAT", "SOME_BIT", "SOME_INT_ARRAY", "SOME_SHORT_ARRAY",
1454 "SOME_LONG_ARRAY", "SOME_FLOAT_ARRAY", "SOME_DOUBLE_ARRAY", "SOME_SPECTRUM", "SOME_IIII", "SOME_IFFF"}) {
1455 auto path = RegisterPath("MYDUMMY/" + param + "/timeStamp");
1456 BOOST_TEST(catalogue.hasRegister(path));
1457
1458 auto regInfo = catalogue.getRegister(path);
1459 BOOST_TEST(regInfo.isReadable());
1460 BOOST_TEST(!regInfo.isWriteable());
1461 BOOST_CHECK_EQUAL(regInfo.getNumberOfElements(), 1);
1462 BOOST_CHECK_EQUAL(regInfo.getNumberOfChannels(), 1);
1463 BOOST_CHECK_EQUAL(regInfo.getNumberOfDimensions(), 0);
1464 auto descriptor = regInfo.getDataDescriptor();
1465 BOOST_TEST(descriptor.fundamentalType() == ChimeraTK::DataDescriptor::FundamentalType::numeric);
1466 BOOST_CHECK_EQUAL(descriptor.nDigits(), 20);
1467 BOOST_TEST(descriptor.isSigned());
1468 BOOST_TEST(descriptor.isIntegral());
1469
1470 auto acc1 = device.getScalarRegisterAccessor<int64_t>(path);
1471 acc1.read();
1472 BOOST_CHECK_EQUAL(static_cast<int64_t>(acc1), eqfct->startTime - 1);
1473 BOOST_CHECK_EQUAL(acc1.isReadOnly(), true);
1474 BOOST_CHECK_EQUAL(acc1.isWriteable(), false);
1475 BOOST_CHECK_EQUAL(acc1.isReadable(), true);
1476 BOOST_CHECK_THROW(acc1.write(), ChimeraTK::logic_error);
1477
1478 auto acc2 = device.getScalarRegisterAccessor<std::string>(path);
1479 acc2.read();
1480 BOOST_CHECK_EQUAL(static_cast<std::string>(acc2), std::to_string(eqfct->startTime - 1));
1481 BOOST_CHECK_EQUAL(acc2.isReadOnly(), true);
1482 BOOST_CHECK_EQUAL(acc2.isWriteable(), false);
1483 BOOST_CHECK_EQUAL(acc2.isReadable(), true);
1484 BOOST_CHECK_THROW(acc2.write(), ChimeraTK::logic_error);
1485
1486 // auto acc3 = device.getScalarRegisterAccessor<uint8_t>(path);
1487 // BOOST_CHECK_THROW(acc3.read(), boost::numeric::positive_overflow);
1488 }
1489
1490 // Check that we get the accessor for some unsupported type as well
1491 // Whether or not eventId retuns something usefull here is completely undefined
1492 auto acc1 = device.getScalarRegisterAccessor<int64_t>("MYDUMMY/UNSUPPORTED_DATA_TYPE/timeStamp");
1493 BOOST_TEST(acc1.isInitialised());
1494
1495 // Run update once to have the ZMQ variable's mp number updated
1496 DoocsServerTestHelper::runUpdate();
1497
1498 auto path = RegisterPath("MYDUMMY/SOME_ZMQINT/timeStamp");
1499 BOOST_TEST(catalogue.hasRegister(path));
1500 auto acc2 = device.getScalarRegisterAccessor<int64_t>(path);
1501 acc2.read();
1502 BOOST_CHECK_EQUAL(static_cast<int64_t>(acc2), eqfct->startTime - 1);
1503 BOOST_CHECK_EQUAL(acc2.isReadOnly(), true);
1504 BOOST_CHECK_EQUAL(acc2.isWriteable(), false);
1505 BOOST_CHECK_EQUAL(acc2.isReadable(), true);
1506 BOOST_CHECK_THROW(acc2.write(), ChimeraTK::logic_error);
1507
1508 device.close();
1509}
1510
1511/**********************************************************************************************************************/
1512
1513BOOST_AUTO_TEST_CASE(testEventIdMapping) {
1514 ChimeraTK::Device device;
1515 device.open(DoocsLauncher::DoocsServer1);
1516 auto catalogue = device.getRegisterCatalogue();
1517 auto eqfct = reinterpret_cast<eq_dummy*>(find_device("MYDUMMY"));
1518
1519 auto acc1 = device.getScalarRegisterAccessor<int>("MYDUMMY/SOME_INT");
1520 auto acc2 = device.getScalarRegisterAccessor<float>("MYDUMMY/SOME_FLOAT");
1521 auto acc1_id = device.getScalarRegisterAccessor<int64_t>("MYDUMMY/SOME_INT/eventId");
1522 auto acc2_id = device.getScalarRegisterAccessor<int64_t>("MYDUMMY/SOME_FLOAT/eventId");
1523
1524 // Start with eventID 0 - even with that, we should not get VersionNumber{nullptr}
1525 auto id = eqfct->counter;
1526 eqfct->counter = 0;
1527
1528 // Run update once to have the ZMQ variable's mp number updated to 0 (before reading anything, i.e.
1529 // before having id in the EventID mapper
1530 DoocsServerTestHelper::runUpdate();
1531
1532 acc1.read();
1533 acc1_id.read();
1534 acc2.read();
1535 acc2_id.read();
1536
1537 BOOST_TEST(acc1.getVersionNumber() != ChimeraTK::VersionNumber{nullptr});
1538 BOOST_TEST(acc2.getVersionNumber() != ChimeraTK::VersionNumber{nullptr});
1539 // notice: The version numbers for acc1 and acc2 are not the same, and also
1540 // those of acc1_id and acc2_id do not match any of them. Data with eventId 0 cannot be correlated at all.
1541 BOOST_TEST(acc1_id == 0);
1542 BOOST_TEST(acc2_id == 0);
1543
1544 eqfct->counter = id;
1545
1546 // Run update once to have the ZMQ variable's mp number updated. As it was not in the mapper yet,
1547 // the according VersionNumber will be larger that the ones from the last reads with eventID 0, so the
1548 // correlation works. (see further test with eventID 0 at the end of the sequence).
1549 DoocsServerTestHelper::runUpdate();
1550
1551 acc1.read();
1552 acc2.read();
1553 acc1_id.read();
1554 acc2_id.read();
1555
1556 BOOST_CHECK_MESSAGE(acc1.getVersionNumber() == acc2.getVersionNumber(),
1557 static_cast<std::string>(acc1.getVersionNumber()) + " should be equal to " +
1558 static_cast<std::string>(acc2.getVersionNumber()));
1559 BOOST_CHECK_MESSAGE(acc1.getVersionNumber() == acc1_id.getVersionNumber(),
1560 static_cast<std::string>(acc1.getVersionNumber()) + " should be equal to " +
1561 static_cast<std::string>(acc1_id.getVersionNumber()));
1562 BOOST_CHECK_MESSAGE(acc2.getVersionNumber() == acc2_id.getVersionNumber(),
1563 static_cast<std::string>(acc2.getVersionNumber()) + " should be equal to " +
1564 static_cast<std::string>(acc2_id.getVersionNumber()));
1565 BOOST_CHECK_EQUAL(acc1_id, id);
1566 BOOST_CHECK_EQUAL(acc2_id, id);
1567
1568 // update() will set a new eventId
1569 DoocsServerTestHelper::runUpdate();
1570
1571 // After reading only one of the accessors, the version should now be different
1572 acc2.read();
1573 BOOST_CHECK_MESSAGE(acc1.getVersionNumber() != acc2.getVersionNumber(),
1574 static_cast<std::string>(acc1.getVersionNumber()) + " should not be equal to " +
1575 static_cast<std::string>(acc2.getVersionNumber()));
1576
1577 // After reading acc1 as well, they should match up now
1578 acc1.read();
1579 BOOST_CHECK_MESSAGE(acc1.getVersionNumber() == acc2.getVersionNumber(),
1580 static_cast<std::string>(acc1.getVersionNumber()) + " should be equal to " +
1581 static_cast<std::string>(acc2.getVersionNumber()));
1582
1583 // Check consistency accros two different DOOCS backend instances. Right after opening, the spec B.1.2.1 kicks in and
1584 // prevents that the version numbers are consistent.
1585 VersionNumber someVersionBeforeOpeningSecondDevice;
1586 ChimeraTK::Device device2;
1587 device2.open(DoocsLauncher::DoocsServer2);
1588 auto acc3 = device2.getScalarRegisterAccessor<int>("SOME_INT");
1589 acc3.read();
1590 BOOST_CHECK_MESSAGE(acc3.getVersionNumber() > someVersionBeforeOpeningSecondDevice,
1591 static_cast<std::string>(acc3.getVersionNumber()) + " should be greater than " +
1592 static_cast<std::string>(someVersionBeforeOpeningSecondDevice));
1593
1594 // update() will set a new eventId, hence a new version number. Now that both backends are already open, numbers must
1595 // be consistent.
1596 VersionNumber lastVersion = acc3.getVersionNumber();
1597 for(size_t i = 0; i < 3; ++i) {
1598 DoocsServerTestHelper::runUpdate();
1599 acc2.read();
1600 acc3.read();
1601 BOOST_CHECK_MESSAGE(acc3.getVersionNumber() > lastVersion,
1602 static_cast<std::string>(acc3.getVersionNumber()) + " should be greater than " +
1603 static_cast<std::string>(lastVersion));
1604 BOOST_CHECK_MESSAGE(acc3.getVersionNumber() == acc2.getVersionNumber(),
1605 static_cast<std::string>(acc3.getVersionNumber()) + " should be equal to " +
1606 static_cast<std::string>(acc2.getVersionNumber()));
1607 lastVersion = acc3.getVersionNumber();
1608 }
1609
1610 // Putting one device into an exception state and recovering it will break consistency for exactly one read again.
1611 device2.setException("Test Exception");
1612
1613 // device being in exception state should not affect the first device
1614 DoocsServerTestHelper::runUpdate();
1615 acc2.read();
1616 BOOST_CHECK_MESSAGE(acc2.getVersionNumber() > lastVersion,
1617 static_cast<std::string>(acc2.getVersionNumber()) + " should be greater than " +
1618 static_cast<std::string>(lastVersion));
1619 lastVersion = acc2.getVersionNumber();
1620
1621 // recover second device
1622 someVersionBeforeOpeningSecondDevice = {};
1623 device2.open();
1624 acc3.read();
1625 BOOST_CHECK_MESSAGE(acc3.getVersionNumber() > someVersionBeforeOpeningSecondDevice,
1626 static_cast<std::string>(acc3.getVersionNumber()) + " should be greater than " +
1627 static_cast<std::string>(someVersionBeforeOpeningSecondDevice));
1628
1629 // next update: numbers must be consistent again
1630 DoocsServerTestHelper::runUpdate();
1631 acc2.read();
1632 acc3.read();
1633 BOOST_CHECK_MESSAGE(acc3.getVersionNumber() > lastVersion,
1634 static_cast<std::string>(acc3.getVersionNumber()) + " should be greater than " +
1635 static_cast<std::string>(lastVersion));
1636 BOOST_CHECK_MESSAGE(acc3.getVersionNumber() == acc2.getVersionNumber(),
1637 static_cast<std::string>(acc3.getVersionNumber()) + " should be equal to " +
1638 static_cast<std::string>(acc2.getVersionNumber()));
1639 lastVersion = acc3.getVersionNumber();
1640
1641 //+++++++++++++++++++++++++++++++++
1642 // Check out-of-order updates
1643 //+++++++++++++++++++++++++++++++++
1644 // We use acc3 from device2 to fill two events in normal order, then read the two events in inverse order on acc1
1645 // and acc2 of device1.
1646 auto id1 = eqfct->counter; // eqfct->counter gets incremented at the end of update()...
1647 DoocsServerTestHelper::runUpdate();
1648 acc3.read();
1649 auto ver1 = acc3.getVersionNumber(); // this is the version number matching id1
1650 DoocsServerTestHelper::runUpdate();
1651 acc3.read();
1652 auto ver2 = acc3.getVersionNumber(); // this is the version number matching id2
1653
1654 acc1.read();
1655 BOOST_CHECK_MESSAGE(acc1.getVersionNumber() == ver2,
1656 static_cast<std::string>(acc1.getVersionNumber()) + " should be equal to " + static_cast<std::string>(ver2));
1657 BOOST_TEST(acc1.dataValidity() == DataValidity::ok);
1658
1659 eqfct->counter = id1;
1660 DoocsServerTestHelper::runUpdate();
1661
1662 acc2.read();
1663 BOOST_CHECK_MESSAGE(acc2.getVersionNumber() == ver1,
1664 static_cast<std::string>(acc2.getVersionNumber()) + " should be equal to " + static_cast<std::string>(ver1));
1665 BOOST_TEST(acc2.dataValidity() == DataValidity::ok);
1666
1667 // backwards going eventId on same accessor does not change VersionNumber. Data validity stays ok
1668 acc1.read();
1669 BOOST_CHECK_MESSAGE(acc1.getVersionNumber() == ver2,
1670 static_cast<std::string>(acc1.getVersionNumber()) + " should be equal to " + static_cast<std::string>(ver2));
1671 BOOST_TEST(acc1.dataValidity() == DataValidity::ok);
1672
1673 //++++++++++++++++++++++++++++++++++++++++++++++
1674 // Check eventID 0 mixed with regular updates
1675 //++++++++++++++++++++++++++++++++++++++++++++++
1676 // first do two update so we get out of the out-of-order sequence
1677 DoocsServerTestHelper::
1678 runUpdate(); // after the first update we are back to ID 2 from above. Just get a new one again..
1679 DoocsServerTestHelper::runUpdate();
1680
1681 acc1.read();
1682 auto lastRegularAcc1Version = acc1.getVersionNumber();
1683 acc1_id.read();
1684 int64_t lastRegularEventId = acc1_id;
1685 BOOST_CHECK_MESSAGE(acc1.getVersionNumber() == acc1_id.getVersionNumber(),
1686 static_cast<std::string>(acc1.getVersionNumber()) + " should be equal to " +
1687 static_cast<std::string>(acc1_id.getVersionNumber()));
1688
1689 // now process some data with event ID 0
1690 auto idAfterZero = eqfct->counter; // the id that would have been given out
1691 eqfct->counter = 0;
1692 DoocsServerTestHelper::runUpdate();
1693
1694 // the version number increases with event ID 0
1695 acc1.read();
1696 acc1_id.read();
1697 auto acc1VersionForId0 = acc1.getVersionNumber();
1698 auto acc1_idVersionForId0 = acc1_id.getVersionNumber();
1699 BOOST_TEST(acc1.getVersionNumber() > lastRegularAcc1Version);
1700 BOOST_TEST(acc1_id.getVersionNumber() > lastRegularAcc1Version);
1701 BOOST_CHECK_EQUAL(acc1_id, 0);
1702
1703 // Now send the same eventID again as we had it before the 0 (a new version has already been tested in the start
1704 // sequence, where id 0 was the first one to be received)
1705 eqfct->counter = lastRegularEventId;
1706 DoocsServerTestHelper::runUpdate();
1707
1708 acc1.read();
1709 acc1_id.read();
1710 BOOST_CHECK_MESSAGE(acc1.getVersionNumber() == acc1VersionForId0, // version has not changed
1711 static_cast<std::string>(acc1.getVersionNumber()) + " should be equal to " +
1712 static_cast<std::string>(acc1VersionForId0));
1713 BOOST_CHECK_MESSAGE(acc1_id.getVersionNumber() == acc1_idVersionForId0, // version has not changed
1714 static_cast<std::string>(acc1_id.getVersionNumber()) + " should be equal to " +
1715 static_cast<std::string>(acc1_idVersionForId0));
1716 BOOST_CHECK_EQUAL(acc1_id, lastRegularEventId); // the data content of acc1_id changed -> we lost the consistency
1717
1718 // acc2 has not seen the id 0 and still is consistent
1719 acc2.read();
1720 acc2_id.read();
1721 BOOST_CHECK_MESSAGE(acc2.getVersionNumber() == lastRegularAcc1Version, // version has not changed
1722 static_cast<std::string>(acc2.getVersionNumber()) + " should be equal to " +
1723 static_cast<std::string>(lastRegularAcc1Version));
1724 BOOST_CHECK_MESSAGE(acc2_id.getVersionNumber() == lastRegularAcc1Version, // version has not changed
1725 static_cast<std::string>(acc2_id.getVersionNumber()) + " should be equal to " +
1726 static_cast<std::string>(lastRegularAcc1Version));
1727 BOOST_CHECK_EQUAL(acc2_id, lastRegularEventId);
1728
1729 // after the next update, acc1 is back to consistent again
1730 DoocsServerTestHelper::runUpdate();
1731
1732 acc1.read();
1733 acc1_id.read();
1734 BOOST_TEST(acc1.getVersionNumber() > acc1VersionForId0);
1735
1736 BOOST_CHECK_MESSAGE(acc1.getVersionNumber() == acc1_id.getVersionNumber(),
1737 static_cast<std::string>(acc1.getVersionNumber()) + " should be equal to " +
1738 static_cast<std::string>(acc1_id.getVersionNumber()));
1739 BOOST_CHECK_EQUAL(acc1_id, idAfterZero);
1740}
1741
1742/**********************************************************************************************************************/
DoocsLauncher::~DoocsLauncher
~DoocsLauncher() override
Definition testDoocsBackend.cpp:66
DoocsLauncher::DoocsServer1_cached
static std::string DoocsServer1_cached
Definition testDoocsBackend.cpp:73
DoocsLauncher::DoocsServer1
static std::string DoocsServer1
Definition testDoocsBackend.cpp:72
DoocsLauncher::rpc_no
static std::string rpc_no
Definition testDoocsBackend.cpp:71
DoocsLauncher::DoocsServer2_cached
static std::string DoocsServer2_cached
Definition testDoocsBackend.cpp:77
DoocsLauncher::cacheFile1
static std::string cacheFile1
Definition testDoocsBackend.cpp:74
DoocsLauncher::cacheFile2
static std::string cacheFile2
Definition testDoocsBackend.cpp:78
DoocsLauncher::DoocsServer2
static std::string DoocsServer2
Definition testDoocsBackend.cpp:76
eq_dummy
Definition eq_dummy.h:8
eq_dummy::counter
int64_t counter
Definition eq_dummy.h:35
eq_dummy::_someValue
unsigned int _someValue
Definition eq_dummy.h:18
eq_dummy.h
BOOST_GLOBAL_FIXTURE
BOOST_GLOBAL_FIXTURE(DoocsLauncher)
deleteFileIfExisting
void deleteFileIfExisting(const std::string &filename)
Definition testDoocsBackend.cpp:997
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(testScalarInt)
Definition testDoocsBackend.cpp:93
createDummyXml
std::time_t createDummyXml(const std::string &filename)
Definition testDoocsBackend.cpp:1257