Instrument Neutral Distributed Interface INDI 2.2.5
TestIndiserverSingleDriver.cpp
Go to the documentation of this file.
1/*******************************************************************************
2 Copyright(c) 2022 Ludovic Pollet. All rights reserved.
3
4 This library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Library General Public
6 License version 2 as published by the Free Software Foundation.
7
8 This library is distributed in the hope that it will be useful,
9 but WITHOUT ANY WARRANTY; without even the implied warranty of
10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 Library General Public License for more details.
12
13 You should have received a copy of the GNU Library General Public License
14 along with this library; see the file COPYING.LIB. If not, write to
15 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
16 Boston, MA 02110-1301, USA.
17*******************************************************************************/
18
19#include <stdexcept>
20#include <stdio.h>
21#include <unistd.h>
22#include <sys/types.h>
23#include <system_error>
24
25#include "gtest/gtest.h"
26
27#include "utils.h"
28
29#include "SharedBuffer.h"
30#include "DriverMock.h"
31#include "IndiServerController.h"
32#include "IndiClientMock.h"
33
34// Repeat blob operation for more stress
35#define BLOB_REPEAT_COUNT 5
36
37TEST(IndiserverSingleDriver, MissingDriver)
38{
39 DriverMock fakeDriver;
40 IndiServerController indiServer;
41
42 setupSigPipe();
43
44 std::string fakeDriverPath = std::string(FAKEDRIVER_PATH) + "-not-existing";
45
46 // Start indiserver with one instance, repeat 0
47 indiServer.startDriver(fakeDriverPath);
48 fprintf(stderr, "indiserver started\n");
49
50 // Exit code 1 is expected when driver stopped
51 indiServer.waitProcessEnd(1);
52}
53
54TEST(IndiserverSingleDriver, ReplyToPing)
55{
56 DriverMock fakeDriver;
57 IndiServerController indiServer;
58
59 setupSigPipe();
60
61 fakeDriver.setup();
62
63 std::string fakeDriverPath = FAKEDRIVER_PATH;
64
65 // Start indiserver with one instance, repeat 0
66 indiServer.startDriver(fakeDriverPath);
67 fprintf(stderr, "indiserver started\n");
68
69 fakeDriver.waitEstablish();
70 fprintf(stderr, "fake driver started\n");
71
72 fakeDriver.cnx.expectXml("<getProperties version='1.7'/>");
73 fprintf(stderr, "getProperties received");
74
75 // Establish a client & send ping
76 IndiClientMock client;
77 client.connect(indiServer);
78
79 // Send ping from driver
80 fakeDriver.cnx.send("<pingRequest uid='1'/>\n");
81 fakeDriver.cnx.expectXml("<pingReply uid='1'/>");
82
83 client.cnx.send("<pingRequest uid='2'/>\n");
84 client.cnx.expectXml("<pingReply uid='2'/>\n");
85
86 fakeDriver.cnx.send("<pingRequest uid='3'/>\n");
87 fakeDriver.cnx.expectXml("<pingReply uid='3'/>\n");
88
89 client.cnx.send("<pingRequest uid='4'/>\n");
90 client.cnx.expectXml("<pingReply uid='4'/>\n");
91
92 fakeDriver.terminateDriver();
93
94 // Exit code 1 is expected when driver stopped
95 indiServer.waitProcessEnd(1);
96}
97
98
99static void startFakeDev(IndiServerController &indiServer)
100{
101 setupSigPipe();
102
103 std::string fakeDriverPath = FAKEDRIVER_PATH;
104
105 // Start indiserver with one instance, repeat 0
106 indiServer.startDriver(fakeDriverPath);
107 fprintf(stderr, "indiserver started\n");
108}
109
110
111static void establishDriver(IndiServerController &indiServer, DriverMock &fakeDriver, const std::string & name) {
112 (void)indiServer;
113 fakeDriver.waitEstablish();
114 fprintf(stderr, "fake driver started\n");
115
116 fakeDriver.cnx.expectXml("<getProperties version='1.7'/>");
117 fprintf(stderr, "getProperties received\n");
118
119 // Give one props to the driver
120 fakeDriver.cnx.send("<defBLOBVector device='" + name + "' name='testblob' label='test label' group='test_group' state='Idle' perm='ro' timeout='100' timestamp='2018-01-01T00:00:00'>\n");
121 fakeDriver.cnx.send("<defBLOB name='content' label='content'/>\n");
122 fakeDriver.cnx.send("</defBLOBVector>\n");
123}
124
125static void startFakeDev1(IndiServerController &indiServer, DriverMock &fakeDriver)
126{
127 fakeDriver.setup();
128 startFakeDev(indiServer);
129 establishDriver(indiServer, fakeDriver, "fakeDev1");
130}
131
132static void addDriver(IndiServerController &indiServer, DriverMock &fakeDriver, const std::string & name)
133{
134 fakeDriver.setup();
135
136 std::string fakeDriverPath = FAKEDRIVER_PATH;
137
138 indiServer.addDriver(fakeDriverPath);
139
140 establishDriver(indiServer, fakeDriver, name);
141}
142
143
144void connectFakeDev1Client(IndiServerController &, DriverMock &fakeDriver, IndiClientMock &indiClient)
145{
146 fprintf(stderr, "Client asks properties\n");
147 indiClient.cnx.send("<getProperties version='1.7'/>\n");
148 fakeDriver.cnx.expectXml("<getProperties version='1.7'/>");
149
150 fprintf(stderr, "Driver sends properties\n");
151 fakeDriver.cnx.send("<defBLOBVector device='fakedev1' name='testblob' label='test label' group='test_group' state='Idle' perm='ro' timeout='100' timestamp='2018-01-01T00:00:00'>\n");
152 fakeDriver.cnx.send("<defBLOB name='content' label='content'/>\n");
153 fakeDriver.cnx.send("</defBLOBVector>\n");
154
155 fprintf(stderr, "Client receive properties\n");
156 indiClient.cnx.expectXml("<defBLOBVector device=\"fakedev1\" name=\"testblob\" label=\"test label\" group=\"test_group\" state=\"Idle\" perm=\"ro\" timeout=\"100\" timestamp=\"2018-01-01T00:00:00\">");
157 indiClient.cnx.expectXml("<defBLOB name=\"content\" label=\"content\"/>");
158 indiClient.cnx.expectXml("</defBLOBVector>");
159}
160
161TEST(IndiserverSingleDriver, DontLeakFds)
162{
163 DriverMock fakeDriver;
164 IndiServerController indiServer;
165
166 startFakeDev1(indiServer, fakeDriver);
167
168 IndiClientMock indiClient;
169
170 fakeDriver.ping();
171 int fdCountIdle = indiServer.getOpenFdCount();
172#ifdef ENABLE_INDI_SHARED_MEMORY
173 indiClient.connectUnix(indiServer.getUnixSocketPath());
174 fakeDriver.ping();
175 indiServer.checkOpenFdCount(fdCountIdle + 1, "First unix connection");
176 indiClient.close();
177
178 // Make sur the server processed the close as well.
179 fakeDriver.ping();
180 indiServer.checkOpenFdCount(fdCountIdle, "First unix connection released");
181
182 indiClient.connectUnix(indiServer.getUnixSocketPath());
183 fakeDriver.ping();
184 indiServer.checkOpenFdCount(fdCountIdle + 1, "Second unix connection");
185 indiClient.close();
186
187 fakeDriver.ping();
188 indiServer.checkOpenFdCount(fdCountIdle, "Second unix connection released");
189
190#endif // ENABLE_INDI_SHARED_MEMORY
191
192 indiClient.connectTcp("127.0.0.1", indiServer.getTcpPort());
193 fakeDriver.ping();
194 indiServer.checkOpenFdCount(fdCountIdle + 1, "First tcp connection");
195 indiClient.close();
196
197 fakeDriver.ping();
198 indiServer.checkOpenFdCount(fdCountIdle, "First tcp connection released");
199
200 indiClient.connectTcp("127.0.0.1", indiServer.getTcpPort());
201 fakeDriver.ping();
202 indiServer.checkOpenFdCount(fdCountIdle + 1, "Second tcp connection");
203 indiClient.close();
204
205 fakeDriver.ping();
206 indiServer.checkOpenFdCount(fdCountIdle, "First tcp connection released");
207}
208
209
210TEST(IndiserverSingleDriver, DontForwardUnaskedBlobDefToClient)
211{
212 DriverMock fakeDriver;
213 IndiServerController indiServer;
214
215 startFakeDev1(indiServer, fakeDriver);
216
217 IndiClientMock indiClient;
218
219 indiClient.connect(indiServer);
220
221 connectFakeDev1Client(indiServer, fakeDriver, indiClient);
222
223 fprintf(stderr, "Driver send new blob value\n");
224 fakeDriver.cnx.send("<setBLOBVector device='fakedev1' name='testblob' timestamp='2018-01-01T00:01:00'>\n");
225 fakeDriver.cnx.send("<oneBLOB name='content' size='21' format='.fits' enclen='29'>\n");
226 fakeDriver.cnx.send("MDEyMzQ1Njc4OTAxMjM0NTY3ODkK\n");
227 fakeDriver.cnx.send("</oneBLOB>\n");
228 fakeDriver.cnx.send("</setBLOBVector>\n");
229 fakeDriver.ping();
230
231 fprintf(stderr, "Client don't receive blob\n");
232 indiClient.ping();
233
234 fakeDriver.terminateDriver();
235 // Exit code 1 is expected when driver stopped
236 indiServer.waitProcessEnd(1);
237}
238
239TEST(IndiserverSingleDriver, DontForwardOtherBlobDefToClient)
240{
241 DriverMock fakeDriver;
242 IndiServerController indiServer;
243
244 startFakeDev1(indiServer, fakeDriver);
245
246 IndiClientMock indiClient;
247
248 indiClient.connect(indiServer);
249
250 connectFakeDev1Client(indiServer, fakeDriver, indiClient);
251
252 fprintf(stderr, "Client ask blobs\n");
253 indiClient.cnx.send("<enableBLOB device='fakedev1' name='testblob2'>Also</enableBLOB>\n");
254 indiClient.ping();
255
256
257 fprintf(stderr, "Driver send new blob value\n");
258 fakeDriver.cnx.send("<setBLOBVector device='fakedev1' name='testblob' timestamp='2018-01-01T00:01:00'>\n");
259 fakeDriver.cnx.send("<oneBLOB name='content' size='21' format='.fits' enclen='29'>\n");
260 fakeDriver.cnx.send("MDEyMzQ1Njc4OTAxMjM0NTY3ODkK\n");
261 fakeDriver.cnx.send("</oneBLOB>\n");
262 fakeDriver.cnx.send("</setBLOBVector>\n");
263 fakeDriver.ping();
264
265 fprintf(stderr, "Client don't receive blob\n");
266 indiClient.ping();
267
268 fakeDriver.terminateDriver();
269 // Exit code 1 is expected when driver stopped
270 indiServer.waitProcessEnd(1);
271}
272
273TEST(IndiserverSingleDriver, DropMisbehavingDriver)
274{
275 DriverMock fakeDriver;
276 IndiServerController indiServer;
277
278 startFakeDev1(indiServer, fakeDriver);
279
280 IndiClientMock indiClient;
281
282 indiClient.connect(indiServer);
283
284 connectFakeDev1Client(indiServer, fakeDriver, indiClient);
285
286 fprintf(stderr, "Client ask blobs\n");
287 indiClient.cnx.send("<enableBLOB device='fakedev1' name='testblob'>Also</enableBLOB>\n");
288 indiClient.ping();
289
290 fprintf(stderr, "Driver send new blob value - without actual attachment\n");
291 fakeDriver.cnx.send("<setBLOBVector device='fakedev1' name='testblob' timestamp='2018-01-01T00:01:00'>\n");
292 fakeDriver.cnx.send("<oneBLOB name='content' size='21' format='.fits' attached='true'/>\n");
293 fakeDriver.cnx.send("</setBLOBVector>\n");
294
295 indiServer.waitProcessEnd(1);
296}
297
298TEST(IndiserverSingleDriver, ForwardBase64BlobToIPClient)
299{
300 // This tests decoding of base64 by driver
301 DriverMock fakeDriver;
302 IndiServerController indiServer;
303
304 startFakeDev1(indiServer, fakeDriver);
305
306 IndiClientMock indiClient;
307
308 indiClient.connectTcp(indiServer);
309
310 connectFakeDev1Client(indiServer, fakeDriver, indiClient);
311
312 fprintf(stderr, "Client ask blobs\n");
313 indiClient.cnx.send("<enableBLOB device='fakedev1' name='testblob'>Also</enableBLOB>\n");
314 indiClient.ping();
315
316 fprintf(stderr, "Driver send new blob value\n");
317 fakeDriver.cnx.send("<setBLOBVector device='fakedev1' name='testblob' timestamp='2018-01-01T00:01:00'>\n");
318 fakeDriver.cnx.send("<oneBLOB name='content' size='20' format='.fits' enclen='29'>\n");
319 fakeDriver.cnx.send("MDEyMzQ1Njc4OTAxMjM0NTY3ODkK\n");
320 fakeDriver.cnx.send("</oneBLOB>\n");
321 fakeDriver.cnx.send("</setBLOBVector>\n");
322 fakeDriver.ping();
323
324 fprintf(stderr, "Client receive blob\n");
325 indiClient.cnx.allowBufferReceive(true);
326 indiClient.cnx.expectXml("<setBLOBVector device='fakedev1' name='testblob' timestamp='2018-01-01T00:01:00'>");
327 indiClient.cnx.expectXml("<oneBLOB name='content' size='20' format='.fits' enclen='29'>");
328 indiClient.cnx.expect("\nMDEyMzQ1Njc4OTAxMjM0NTY3ODkK");
329 indiClient.cnx.expectXml("</oneBLOB>\n");
330 indiClient.cnx.expectXml("</setBLOBVector>");
331
332 fakeDriver.terminateDriver();
333 // Exit code 1 is expected when driver stopped
334 indiServer.waitProcessEnd(1);
335}
336
337
338TEST(IndiserverSingleDriver, SnoopDriverPropertie)
339{
340 // This tests snooping simple property from driver to driver
341 DriverMock fakeDriver;
342 IndiServerController indiServer;
343 indiServer.setFifo(true);
344 startFakeDev1(indiServer, fakeDriver);
345
346 DriverMock snoopDriver;
347 addDriver(indiServer, snoopDriver, "snoopDriver");
348
349 fakeDriver.ping();
350 snoopDriver.ping();
351
352 snoopDriver.cnx.send("<getProperties version='1.7' device='fakedev1' name='testnumber1'/>\n");
353
354 snoopDriver.ping();
355 fakeDriver.ping();
356
357 fakeDriver.cnx.send("<defNumberVector device='fakedev1' name='testnumber1' label='test label' group='test_group' state='Idle' perm='rw' timeout='100' timestamp='2018-01-01T00:00:00'>\n");
358 fakeDriver.cnx.send("<defNumber name='content' label='content' min='0' max='100' step='1'>50</defNumber>\n");
359 fakeDriver.cnx.send("</defNumberVector>\n");
360
361 snoopDriver.cnx.expectXml("<defNumberVector device='fakedev1' name='testnumber1' label='test label' group='test_group' state='Idle' perm='rw' timeout='100' timestamp='2018-01-01T00:00:00'>");
362 snoopDriver.cnx.expectXml("<defNumber name='content' label='content' min='0' max='100' step='1'>");
363 snoopDriver.cnx.expect("\n50");
364 snoopDriver.cnx.expectXml("</defNumber>");
365 snoopDriver.cnx.expectXml("</defNumberVector>");
366
367 fakeDriver.terminateDriver();
368 snoopDriver.terminateDriver();
369
370 indiServer.kill();
371 indiServer.join();
372}
373
374
375#define DUMMY_BLOB_SIZE 64
376
377#ifdef ENABLE_INDI_SHARED_MEMORY
378
379TEST(IndiserverSingleDriver, ForwardBase64BlobToUnixClient)
380{
381 // This tests decoding of base64 by driver
382 DriverMock fakeDriver;
383 IndiServerController indiServer;
384
385 startFakeDev1(indiServer, fakeDriver);
386
387 IndiClientMock indiClient;
388
389 indiClient.connectUnix(indiServer);
390
391 connectFakeDev1Client(indiServer, fakeDriver, indiClient);
392
393 fprintf(stderr, "Client ask blobs\n");
394 indiClient.cnx.send("<enableBLOB device='fakedev1' name='testblob'>Also</enableBLOB>\n");
395 indiClient.ping();
396
397 fprintf(stderr, "Driver send new blob value\n");
398 fakeDriver.cnx.send("<setBLOBVector device='fakedev1' name='testblob' timestamp='2018-01-01T00:01:00'>\n");
399 fakeDriver.cnx.send("<oneBLOB name='content' size='20' format='.fits' enclen='29'>\n");
400 fakeDriver.cnx.send("MDEyMzQ1Njc4OTAxMjM0NTY3ODkK\n");
401 fakeDriver.cnx.send("</oneBLOB>\n");
402 fakeDriver.cnx.send("</setBLOBVector>\n");
403 fakeDriver.ping();
404
405 fprintf(stderr, "Client receive blob\n");
406 indiClient.cnx.allowBufferReceive(true);
407 indiClient.cnx.expectXml("<setBLOBVector device='fakedev1' name='testblob' timestamp='2018-01-01T00:01:00'>");
408 indiClient.cnx.expectXml("<oneBLOB name='content' size='20' format='.fits' attached='true'/>");
409 indiClient.cnx.expectXml("</setBLOBVector>");
410
411 SharedBuffer receivedFd;
412 indiClient.cnx.expectBuffer(receivedFd);
413 indiClient.cnx.allowBufferReceive(false);
414
415 EXPECT_GE( receivedFd.getSize(), 20);
416
417 fakeDriver.terminateDriver();
418 // Exit code 1 is expected when driver stopped
419 indiServer.waitProcessEnd(1);
420}
421
422void driverSendAttachedBlob(DriverMock &fakeDriver, ssize_t size)
423{
424 fprintf(stderr, "Driver send new blob value as attachment\n");
425
426 // Allocate more memory than asked (simulate kernel BSD kernel rounding up)
427 ssize_t physical_size=0x10000;
428 if (physical_size < size) {
429 physical_size = size;
430 }
431
432 // The attachment must be done before EOF
433 SharedBuffer fd;
434 fd.allocate(physical_size);
435
436 char * buffer = (char*)malloc(physical_size);
437 for(auto i = 0; i < physical_size; ++i)
438 {
439 buffer[i] = {(char)('0' + (i % 10))};
440 }
441 fd.write(buffer, 0, physical_size);
442 free(buffer);
443
444 fakeDriver.cnx.send("<setBLOBVector device='fakedev1' name='testblob' timestamp='2018-01-01T00:01:00'>\n");
445 fakeDriver.cnx.send("<oneBLOB name='content' size='" + std::to_string(size) + "' format='.fits' attached='true'/>\n", fd);
446 fakeDriver.cnx.send("</setBLOBVector>");
447
448 fd.release();
449
450/*#else
451 fakeDriver.cnx.send("<setBLOBVector device='fakedev1' name='testblob' timestamp='2018-01-01T00:01:00'>\n");
452 fakeDriver.cnx.send("<oneBLOB name='content' size='" + std::to_string(size) + "' format='.fits'>\n");
453 fakeDriver.cnx.send("MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDE=\n");
454 fakeDriver.cnx.send("</oneBLOB>\n");
455 fakeDriver.cnx.send("</setBLOBVector>");
456#endif
457*/
458
459 fakeDriver.ping();
460}
461
462TEST(IndiserverSingleDriver, ForwardAttachedBlobToUnixClient)
463{
464 // This tests attached blob pass through
465 DriverMock fakeDriver;
466 IndiServerController indiServer;
467
468 startFakeDev1(indiServer, fakeDriver);
469
470 IndiClientMock indiClient;
471
472 indiClient.connectUnix(indiServer);
473
474 connectFakeDev1Client(indiServer, fakeDriver, indiClient);
475
476 fprintf(stderr, "Client ask blobs\n");
477 indiClient.cnx.send("<enableBLOB device='fakedev1' name='testblob'>Also</enableBLOB>\n");
478 // This ping ensures enableBLOB is handled before the blob is received
479
480 for(int i = 0; i < BLOB_REPEAT_COUNT; ++i) {
481 indiClient.ping();
482
483
484 ssize_t size = 32;
485 driverSendAttachedBlob(fakeDriver, size);
486
487 // Now receive on client side
488 fprintf(stderr, "Client receive blob\n");
489 indiClient.cnx.allowBufferReceive(true);
490 indiClient.cnx.expectXml("<setBLOBVector device='fakedev1' name='testblob' timestamp='2018-01-01T00:01:00'>");
491 indiClient.cnx.expectXml("<oneBLOB name='content' size='" + std::to_string(size) + "' format='.fits' attached='true'/>");
492 indiClient.cnx.expectXml("</setBLOBVector>");
493
494 SharedBuffer receivedFd;
495 indiClient.cnx.expectBuffer(receivedFd);
496 indiClient.cnx.allowBufferReceive(false);
497
498 EXPECT_GE( receivedFd.getSize(), size);
499 }
500
501 fakeDriver.terminateDriver();
502 // Exit code 1 is expected when driver stopped
503 indiServer.waitProcessEnd(1);
504}
505
506TEST(IndiserverSingleDriver, ForwardAttachedBlobToIPClient)
507{
508 // This tests base64 encoding by server
509 DriverMock fakeDriver;
510 IndiServerController indiServer;
511
512 startFakeDev1(indiServer, fakeDriver);
513
514 IndiClientMock indiClient;
515
516 indiClient.connectTcp(indiServer);
517
518 connectFakeDev1Client(indiServer, fakeDriver, indiClient);
519
520 fprintf(stderr, "Client ask blobs\n");
521 indiClient.cnx.send("<enableBLOB device='fakedev1' name='testblob'>Also</enableBLOB>\n");
522
523 for(int i = 0; i < BLOB_REPEAT_COUNT; ++i) {
524 indiClient.ping();
525
526 ssize_t size = 32;
527 driverSendAttachedBlob(fakeDriver, size);
528
529 // Now receive on client side
530 fprintf(stderr, "Client receive blob\n");
531 indiClient.cnx.expectXml("<setBLOBVector device='fakedev1' name='testblob' timestamp='2018-01-01T00:01:00'>");
532 indiClient.cnx.expectXml("<oneBLOB name='content' size='" + std::to_string(size) + "' format='.fits'>");
533 // FIXME: get this from size
534 indiClient.cnx.expect("\nMDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDE=");
535 indiClient.cnx.expectXml("</oneBLOB>");
536 indiClient.cnx.expectXml("</setBLOBVector>");
537 }
538 fakeDriver.terminateDriver();
539 // Exit code 1 is expected when driver stopped
540 indiServer.waitProcessEnd(1);
541}
542
543
544TEST(IndiserverSingleDriver, ForwardAttachedBlobToDriver)
545{
546 // This tests attached blob pass through
547 DriverMock fakeDriver;
548 IndiServerController indiServer;
549 indiServer.setFifo(true);
550 startFakeDev1(indiServer, fakeDriver);
551
552 DriverMock snoopDriver;
553 addDriver(indiServer, snoopDriver, "snoopDriver");
554
555 fakeDriver.ping();
556 snoopDriver.ping();
557
558 snoopDriver.cnx.send("<getProperties version='1.7' device='fakedev1' name='testblob'/>\n");
559 snoopDriver.cnx.send("<enableBLOB device='fakedev1' name='testblob'>Also</enableBLOB>\n");
560 snoopDriver.ping();
561
562 ssize_t size = 10000;
563 driverSendAttachedBlob(fakeDriver, size);
564
565#if 0
566 // Until proper support by drivers, indiserver converts to base64 for that path
567 snoopDriver.cnx.allowBufferReceive(true);
568 snoopDriver.cnx.expectXml("<setBLOBVector device='fakedev1' name='testblob' timestamp='2018-01-01T00:01:00'>");
569 snoopDriver.cnx.expectXml("<oneBLOB name='content' size='32' format='.fits' attached='true'/>\n");
570 snoopDriver.cnx.expectXml("</setBLOBVector>");
571
572 SharedBuffer receivedFd;
573 snoopDriver.cnx.expectBuffer(receivedFd);
574 snoopDriver.cnx.allowBufferReceive(false);
575 EXPECT_GE( receivedFd.getSize(), 32);
576#else
577 snoopDriver.cnx.expectXml("<setBLOBVector device='fakedev1' name='testblob' timestamp='2018-01-01T00:01:00'>");
578 snoopDriver.cnx.expectXml("<oneBLOB name='content' size='" + std::to_string(size) + "' format='.fits'>\n");
579 std::string base64 = snoopDriver.cnx.expectBase64();
580 EXPECT_EQ(base64.size(), static_cast<size_t>(size * 4 / 3 + 9 + (size / 800000)));
581 snoopDriver.cnx.expectXml("</oneBLOB>\n");
582 snoopDriver.cnx.expectXml("</setBLOBVector>");
583#endif
584
585 fakeDriver.terminateDriver();
586 snoopDriver.terminateDriver();
587 // fakeSnooper.terminateDriver();
588 // Exit code 1 is expected when driver stopped
589 indiServer.kill();
590 indiServer.join();
591}
592
593
594#endif
TEST
TEST(IndiserverSingleDriver, MissingDriver)
Definition TestIndiserverSingleDriver.cpp:37
BLOB_REPEAT_COUNT
#define BLOB_REPEAT_COUNT
Definition TestIndiserverSingleDriver.cpp:35
connectFakeDev1Client
void connectFakeDev1Client(IndiServerController &, DriverMock &fakeDriver, IndiClientMock &indiClient)
Definition TestIndiserverSingleDriver.cpp:144
ConnectionMock::allowBufferReceive
void allowBufferReceive(bool state)
Definition ConnectionMock.cpp:70
ConnectionMock::expectBuffer
void expectBuffer(SharedBuffer &fd)
Definition ConnectionMock.cpp:156
ConnectionMock::expect
void expect(const std::string &content)
Definition ConnectionMock.cpp:167
ConnectionMock::send
void send(const std::string &content)
Definition ConnectionMock.cpp:313
ConnectionMock::expectXml
void expectXml(const std::string &xml)
Definition ConnectionMock.cpp:286
ConnectionMock::expectBase64
std::string expectBase64()
Definition ConnectionMock.cpp:272
DriverMock::ping
void ping()
Definition DriverMock.cpp:68
DriverMock::terminateDriver
void terminateDriver()
Definition DriverMock.cpp:56
DriverMock::cnx
ConnectionMock cnx
Definition DriverMock.h:50
DriverMock::waitEstablish
void waitEstablish()
Definition DriverMock.cpp:49
DriverMock::setup
void setup()
Definition DriverMock.cpp:44
IndiClientMock::connectUnix
void connectUnix(const IndiServerController &server)
Definition IndiClientMock.cpp:51
IndiClientMock::connectTcp
void connectTcp(const IndiServerController &server)
Definition IndiClientMock.cpp:56
IndiClientMock::cnx
ConnectionMock cnx
Definition IndiClientMock.h:35
IndiClientMock::connect
void connect(const IndiServerController &server)
Definition IndiClientMock.cpp:42
IndiServerController::addDriver
void addDriver(const std::string &path)
Definition IndiServerController.cpp:75
IndiServerController::getUnixSocketPath
std::string getUnixSocketPath() const
Definition IndiServerController.cpp:96
IndiServerController::startDriver
void startDriver(const std::string &driver)
Definition IndiServerController.cpp:55
ProcessController::checkOpenFdCount
void checkOpenFdCount(int expected, const std::string &msg)
Definition ProcessController.cpp:52
ProcessController::waitProcessEnd
void waitProcessEnd(int expectedExitCode)
Definition ProcessController.cpp:101
SharedBuffer::allocate
void allocate(ssize_t size)
Definition SharedBuffer.cpp:130
SharedBuffer::getSize
ssize_t getSize() const
Definition SharedBuffer.h:39
fd
int fd
Definition intelliscope.c:43
Aux::buffer
std::vector< uint8_t > buffer
Definition celestronauxpacket.h:38
setupSigPipe
void setupSigPipe()
Definition utils.cpp:37
Generated on Thu Oct 22 2026 14:46:48 for Instrument Neutral Distributed Interface INDI by doxygen 1.9.8