MIDAS
Loading...
Searching...
No Matches
test_mvodb.cxx
Go to the documentation of this file.
1//
2// test_mvodb.cxx --- test ODB access functions
3//
4// K.Olchanski
5//
6
7#undef NDEBUG // midas required assert() to be always enabled
8
9#include <stdio.h>
10#include <sys/time.h>
11#include <iostream>
12#include <assert.h>
13#include <signal.h>
14#include <string.h>
15#include <stdlib.h> // exit()
16
17#include "tmfe.h"
18#include "midasio.h"
19#include "mvodb.h"
20
21std::string toString(int i)
22{
23 char buf[256];
24 snprintf(buf, sizeof(buf), "%d", i);
25 return buf;
26}
27
28void print_ia(const std::vector<int> &ia)
29{
30 int size = ia.size();
31 printf("int[%d] has [", size);
32 for (int i=0; i<size; i++) {
33 if (i>0)
34 printf(", ");
35 printf("%d", ia[i]);
36 }
37 printf("]");
38}
39
40void print_da(const std::vector<double> &da)
41{
42 int size = da.size();
43 printf("int[%d] has [", size);
44 for (int i=0; i<size; i++) {
45 if (i>0)
46 printf(", ");
47 printf("%f", da[i]);
48 }
49 printf("]");
50}
51
52static int gCountFail = 0;
53
54void report_fail(const char* text)
55{
56 printf("FAIL: %s\n", text);
57 gCountFail++;
58}
59
60// Main function call
61
62int main(int argc, char *argv[])
63{
64 setbuf(stdout,NULL);
65 setbuf(stderr,NULL);
66
67 signal(SIGILL, SIG_DFL);
68 signal(SIGBUS, SIG_DFL);
69 signal(SIGSEGV, SIG_DFL);
70 signal(SIGPIPE, SIG_DFL);
71
72 const char* hostname = NULL;
73 const char* exptname = NULL;
74 const char* filename = argv[1];
75 bool online = false;
76 bool xmlfile = false;
77 bool jsonfile = false;
78 bool nullodb = false;
79
80 if (!filename)
81 online = true;
82 else if (strstr(filename, ".xml")!=0)
83 xmlfile = true;
84 else if (strstr(filename, ".json")!=0)
85 jsonfile = true;
86 else if (strstr(filename, "null")!=0)
87 nullodb = true;
88 else {
89 hostname = filename;
90 online = true;
91 }
92
93 TMFE* mfe = NULL;
94
95 MVOdb* odb = NULL;
96 MVOdbError odberror;
97
98 if (nullodb)
99 {
100 printf("Using NullOdb\n");
101 odb = MakeNullOdb();
102 }
103 else if (online)
104 {
105 printf("Using MidasOdb\n");
106 mfe = TMFE::Instance();
107
108 TMFeResult r;
109
110 r = mfe->Connect("test_mvodb", hostname, exptname);
111 if (r.error_flag) {
112 fprintf(stderr,"Cannot connect to MIDAS, error %s\n", r.error_message.c_str());
113 return -1;
114 }
115
116 odb = MakeMidasOdb(mfe->fDB, &odberror);
117 }
118 else if (xmlfile)
119 {
120 printf("Using XmlOdb\n");
121 odb = MakeXmlFileOdb(filename, &odberror);
122 }
123 else if (jsonfile)
124 {
125 printf("Using JsonOdb\n");
126 odb = MakeJsonFileOdb(filename, &odberror);
127 }
128 else
129 {
130 printf("Using FileDumpOdb\n");
131 TMReaderInterface* reader = TMNewReader(filename);
132
133 if (reader->fError) {
134 printf("Cannot open input file \"%s\"\n",filename);
135 delete reader;
136 return -1;
137 }
138
139 while (1) {
140 TMEvent* event = TMReadEvent(reader);
141
142 if (!event)
143 break;
144
145 int eventId = event->event_id;
146 //printf("Have an event of type %d\n", eventId);
147
148 if ((eventId & 0xFFFF) != 0x8000) {
149 delete event;
150 continue;
151 }
152
153 // begin run
154 //event.Print();
155
156 odb = MakeFileDumpOdb(event->GetEventData(), event->data_size, &odberror);
157 break;
158 }
159
160 reader->Close();
161 delete reader;
162
163 if (!odb) {
164 printf("Failed to load ODB from input file \"%s\"\n",filename);
165 return -1;
166 }
167 }
168
169 if (odberror.fError) {
170 fprintf(stderr, "Cannot make MVOdb object, error: %s\n", odberror.fErrorString.c_str());
171 exit(1);
172 }
173
174 printf("\n");
175 printf("Starting tests:\n");
176 printf("\n");
177
178 int runno = 1234;
179
180 odb->RI("runinfo/run number", &runno);
181
182 printf("read run number (RI): %d\n", runno);
183
184 odb->Delete("test_mvodb");
185
186 MVOdb* test = odb->Chdir("test_mvodb", true);
187
188 assert(test != NULL);
189
190 test->SetPrintError(true);
191
192 bool isreadonly = test->IsReadOnly();
193
194 if (isreadonly) {
195 printf("\n");
196 printf("This ODB is read-only!\n");
197 }
198
199 printf("\n");
200 printf("Test create-and-read of all data types (set default values):\n");
201 printf("\n");
202
203 int cycle = 1;
204 test->RI("cycle", &cycle, true);
205 printf("RI() cycle: %d\n", cycle);
206
207 int ivalue = 1;
208 test->RI("int", &ivalue, true);
209 printf("RI() int: %d\n", ivalue);
210
211 float fvalue = 2.2;
212 test->RF("float", &fvalue, true);
213 printf("RF() float: %f\n", fvalue);
214
215 double dvalue = 3.3;
216 test->RD("double", &dvalue, true);
217 printf("RD() double: %f\n", dvalue);
218
219 bool bvalue_a = false;
220 test->RB("bool_a", &bvalue_a, true);
221 printf("bool_a: %d\n", bvalue_a);
222
223 bool bvalue_b = true;
224 test->RB("bool_b", &bvalue_b, true);
225 printf("bool_b: %d\n", bvalue_b);
226
227 uint16_t u16value = 0xabcd;
228 test->RU16("u16", &u16value, true);
229 printf("RU16() u16: 0x%04x\n", u16value);
230
231 uint32_t u32value = 0x12345678;
232 test->RU32("u32", &u32value, true);
233 printf("RU32() u32: 0x%08x\n", u32value);
234
235 uint64_t u64value = 0x1122334455667788;
236 test->RU64("u64", &u64value, true);
237 printf("RU64() u64: 0x%016llx\n", (unsigned long long)u64value);
238
239 std::string svalue = "test string";
240 test->RS("string", &svalue, true);
241 printf("RS() string: \"%s\"\n", svalue.c_str());
242
243 printf("\n");
244 printf("Test write of all data types (overwrite default values):\n");
245 printf("\n");
246
247 test->WI("cycle", cycle+1);
248
249 int wi = 10 + 100*cycle;
250 test->WI("int", wi);
251 float wf = 11.1 + 100*cycle;
252 test->WF("float", wf);
253 double wd = 22.2 + 100*cycle;
254 test->WD("double", wd);
255 bool wba = true;
256 test->WB("bool_a", wba);
257 bool wbb = false;
258 test->WB("bool_b", wbb);
259 uint16_t wu16 = 0xcdef;
260 test->WU16("u16", wu16);
261 uint32_t wu32 = 0xdeadf00d;
262 test->WU32("u32", wu32);
263 uint64_t wu64 = 0xddeeaaddff0000dd;
264 test->WU64("u64", wu64);
265 std::string ws = "write test string cycle " + toString(cycle);
266 test->WS("string", ws.c_str());
267
268 printf("\n");
269 printf("Test read of new values for all data types:\n");
270 printf("\n");
271
272 int ri = 1;
273 test->RI("int", &ri);
274 printf("int: %d -> %d -> %d\n", ivalue, wi, ri);
275
276 float rf = 2.2;
277 test->RF("float", &rf);
278 printf("float: %f -> %f -> %f\n", fvalue, wf, rf);
279
280 double rd = 3.3;
281 test->RD("double", &rd);
282 printf("double: %f -> %f -> %f\n", dvalue, wd, rd);
283
284 bool rba = false;
285 test->RB("bool_a", &rba);
286 printf("bool_a: %d -> %d -> %d\n", bvalue_a, wba, rba);
287
288 bool rbb = false;
289 test->RB("bool_b", &rbb);
290 printf("bool_b: %d -> %d -> %d\n", bvalue_b, wbb, rbb);
291
292 uint16_t ru16 = 0x4444;
293 test->RU16("u16", &ru16);
294 printf("u16: 0x%04x -> 0x%04x -> 0x%04x\n", u16value, wu16, ru16);
295
296 uint32_t ru32 = 0x55555555;
297 test->RU32("u32", &ru32);
298 printf("u32: 0x%08x -> 0x%08x -> 0x%08x\n", u32value, wu32, ru32);
299
300 uint64_t ru64 = 0x1515151515151515;
301 test->RU64("u64", &ru64);
302 printf("u64: 0x%016llx -> 0x%016llx -> 0x%016llx\n", (unsigned long long)u64value, (unsigned long long)wu64, (unsigned long long)ru64);
303
304 std::string rs = "rs";
305 test->RS("string", &rs);
306 printf("string: \"%s\" -> \"%s\" -> \"%s\"\n", svalue.c_str(), ws.c_str(), rs.c_str());
307
308 printf("\n");
309 printf("Test read arrays of all data types:\n");
310 printf("\n");
311
312 {
313 printf("read int array ia:\n");
314 std::vector<int> ia;
315 ia.push_back(1);
316 ia.push_back(2);
317 ia.push_back(3);
318 test->RIA("ia", &ia, true);
319 printf("RIA() returned: ");
320 print_ia(ia);
321 printf("\n");
322 }
323
324 {
325 printf("read non-existant array ia-noexist:\n");
326 std::vector<int> ia;
327 ia.push_back(1);
328 ia.push_back(2);
329 ia.push_back(3);
330 test->RIA("ia-noexist", &ia);
331 printf("RIA() returned: ");
332 print_ia(ia);
333 printf("\n");
334 }
335
336 {
337 // create 10 element array, init to zero (ia is empty)
338 std::vector<int> ia;
339 test->RIA("ia10zero", &ia, true, 10);
340 // create 10 element array, init from ia
341 ia.clear();
342 ia.push_back(11);
343 ia.push_back(22);
344 test->RIA("ia10", &ia, true, 10);
345 }
346
347 {
348 // create 10 element array, init to zero (passed NULL instead of &ia)
349 test->RIA("createia10", NULL, true, 10);
350
351 std::vector<int> ia;
352 test->RIA("createia10", &ia);
353
354 if (!test->IsReadOnly()) {
355 if (ia.size() != 10)
356 report_fail("failed to create 'createia10' of size 10");
357 }
358 }
359
360 {
361 std::vector<uint32_t> u32a;
362 u32a.push_back(0x11110000);
363 u32a.push_back(0x22220000);
364 u32a.push_back(0x33330000);
365 u32a.push_back(0x44440000);
366 test->RU32A("dwa", &u32a, true);
367 }
368
369 {
370 std::vector<double> da;
371 da.push_back(1.1);
372 da.push_back(1.2);
373 da.push_back(1.3);
374 da.push_back(1.4);
375 test->RDA("da", &da, true, 0);
376 }
377
378 {
379 std::vector<float> fa;
380 fa.push_back(2.1);
381 fa.push_back(2.2);
382 fa.push_back(2.3);
383 fa.push_back(20.3);
384 fa.push_back(21.3);
385 test->RFA("fa", &fa, true, 0);
386 }
387
388 {
389 std::vector<bool> ba;
390 ba.push_back(true);
391 ba.push_back(false);
392 ba.push_back(true);
393 test->RBA("ba", &ba, true, 0);
394 }
395
396 {
397 std::vector<std::string> sa;
398 sa.push_back("line1");
399 sa.push_back("line2");
400 sa.push_back("line3");
401 sa.push_back("line4");
402 test->RSA("sa", &sa, true, 0, 32);
403
404 // create 10 element array, init from ia
405 sa.clear();
406 sa.push_back("xx1");
407 sa.push_back("xx2");
408 test->RSA("sa10", &sa, true, 10, 32);
409 // create 10 element array, init to zero (passed NULL instead of &sa)
410 test->RSA("createsa10", NULL, true, 10, 32);
411 }
412
413 printf("\n");
414 printf("Test string sizes:\n");
415 printf("\n");
416
417 {
418 test->WS("test_size", "12345");
419 std::string s;
420 test->RS("test_size", &s);
421 printf("read test_size [%s]\n", s.c_str());
422 }
423 {
424 test->WS("test_size_32", "1234567890", 32);
425 std::string s;
426 test->RS("test_size_32", &s);
427 printf("read test_size_32 [%s]\n", s.c_str());
428 }
429 {
430 test->WS("test_size_5", "1234567890", 5);
431 std::string s;
432 test->RS("test_size_5", &s);
433 printf("read test_size_5 [%s]\n", s.c_str());
434 }
435 {
436 std::string s = "1234567890";
437 test->RS("test_rsize", &s, true);
438 printf("read test_rsize [%s]\n", s.c_str());
439 }
440 {
441 std::string s = "123456";
442 test->RS("test_size_r32", &s, true, 32);
443 printf("read test_size_r32 [%s]\n", s.c_str());
444 }
445 {
446 std::string s = "1234567890";
447 test->RS("test_size_r8", &s, true, 8);
448 printf("read test_size_r8 [%s]\n", s.c_str());
449 }
450 {
451 test->RSA("test_size_a8", NULL, true, 2, 8);
452 std::string s = "1234567890";
453 test->WSAI("test_size_a8", 0, s.c_str());
454 test->RSAI("test_size_a8", 0, &s);
455 printf("read test_size_a8 [%s]\n", s.c_str());
456 }
457
458 printf("\n");
459 printf("Test creating and resizing arrays:\n");
460 printf("\n");
461
462 {
463 test->RIA("create_ia15", NULL, true, 15);
464 test->RBA("create_ba12", NULL, true, 12);
465 test->RSA("create_sa5", NULL, true, 5, 32);
466 }
467 {
468 test->RIA("resize_ia10", NULL, true, 5);
469 test->RIA("resize_ia10", NULL, true, 10);
470 test->RSA("resize_sa3", NULL, true, 5, 32);
471 test->WSAI("resize_sa3", 0, "00000000");
472 test->WSAI("resize_sa3", 1, "11111111");
473 test->WSAI("resize_sa3", 2, "22222222");
474 test->WSAI("resize_sa3", 3, "33333333");
475 test->WSAI("resize_sa3", 4, "44444444");
476 test->RSA("resize_sa3", NULL, true, 3, 5);
477 }
478
479 printf("\n");
480 printf("Test array index access:\n");
481 printf("\n");
482
483 {
484 std::vector<int> ia;
485 ia.push_back(10);
486 ia.push_back(11);
487 ia.push_back(12);
488 test->WIA("index_ia", ia);
489 for (int i=0; i<5; i++) {
490 int ivalue = 999;
491 test->RIAI("index_ia", i, &ivalue);
492 printf("index %d value %d\n", i, ivalue);
493 }
494 for (int i=0; i<4; i++) {
495 int ivalue = 20+i;
496 test->WIAI("index_ia", i, ivalue);
497 }
498 for (int i=0; i<5; i++) {
499 int ivalue = 999;
500 test->RIAI("index_ia", i, &ivalue);
501 printf("index %d value %d\n", i, ivalue);
502 }
503 }
504
505 printf("\n");
506 printf("Test string array index access:\n");
507 printf("\n");
508
509 {
510 std::vector<std::string> sa;
511 sa.push_back("sa0");
512 sa.push_back("sa1");
513 sa.push_back("sa2");
514 test->WSA("index_sa", sa, 32);
515 for (int i=0; i<5; i++) {
516 std::string s = "aaa";
517 test->RSAI("index_sa", i, &s);
518 printf("index %d value [%s]\n", i, s.c_str());
519 }
520 for (int i=0; i<4; i++) {
521 std::string s = "sa_qqq";
522 s += toString(i);
523 test->WSAI("index_sa", i, s.c_str());
524 }
525 for (int i=0; i<5; i++) {
526 std::string s = "bbb";
527 test->RSAI("index_sa", i, &s);
528 printf("index %d value [%s]\n", i, s.c_str());
529 }
530 }
531
532 printf("\n");
533 printf("Test string truncation:\n");
534 printf("\n");
535
536 {
537 std::vector<std::string> sa;
538 sa.push_back("1234567890");
539 sa.push_back("aaa1");
540 sa.push_back("aaa2");
541 test->WSA("trunc_sa5", sa, 5);
542 test->WSAI("trunc_sa5", 1, "1234567890");
543 for (int i=0; i<5; i++) {
544 std::string s = "bbb";
545 test->RSAI("trunc_sa5", i, &s);
546 printf("index %d value [%s]\n", i, s.c_str());
547 }
548 }
549
550 printf("\n");
551 printf("Test against subdirectory:\n");
552 printf("\n");
553
554 {
555 printf("Creating subdir\n");
556 MVOdb* subdir = test->Chdir("subdir", true);
557 printf("Creating subdir/i\n");
558 subdir->WI("i", 10); // write something into subdir
559 int i = 1111;
560 printf("RI(subdir)\n");
561 test->RI("subdir", &i); // invalid read from a non-int
562 printf("WI(subdir)\n");
563 test->WI("subdir", 10); // invalid write into existing subdir
564 std::vector<int> ia;
565 ia.push_back(111);
566 ia.push_back(222);
567 ia.push_back(333);
568 printf("WIA(subdir)\n");
569 test->WIA("subdir", ia); // invalid write into existing subdir
570 printf("RIA(subdir)\n");
571 test->RIA("subdir", &ia); // invalid read from non-int-array
572 printf("RIA() returned: ");
573 print_ia(ia);
574 printf("\n");
575 printf("RIA(subdir, create=true)\n");
576 test->RIA("subdir", &ia, true); // invalid read from non-int-array
577 printf("RIA() returned: ");
578 print_ia(ia);
579 printf("\n");
580 }
581
582 printf("\n");
583 printf("Test special cases:\n");
584 printf("\n");
585
586 {
587 printf("test RI() of non existant variable:\n");
588 int ivalue = 999;
589 test->RI("nonexistant", &ivalue);
590 printf("RI() returned ivalue %d\n", ivalue);
591 printf("\n");
592
593 {
594 std::vector<double> da;
595 printf("test RDA() of integer array:\n");
596 // wrong data type: ODB is INT, we ask for DOUBLE
597 test->RDA("ia10", &da, false, 0);
598 printf("RDA() returned: ");
599 print_da(da);
600 printf("\n");
601 }
602
603 {
604 printf("test RD() of integer array:\n");
605 // wrong data type: ODB is INT, we ask for DOUBLE
606 double v = 999.9;
607 test->RD("ia10", &v);
608 printf("RD() returned %f\n", v);
609 printf("\n");
610 }
611
612 {
613 printf("test RI() of array ia10:\n");
614 int ivalue = 999;
615 test->RI("ia10", &ivalue);
616 printf("RI() returned ivalue %d\n", ivalue);
617 printf("\n");
618 }
619
620 {
621 printf("test RIA() of non-array int:\n");
622 std::vector<int> ia;
623 test->RIA("int", &ia);
624 printf("RIA() returned: ");
625 print_ia(ia);
626 printf("\n");
627 }
628
629 {
630 printf("test index 0 of non-array int:\n");
631 int ivalue = 999;
632 test->RIAI("int", 0, &ivalue);
633 printf("RIAI() returned ivalue %d\n", ivalue);
634 printf("\n");
635 }
636
637 {
638 printf("test index of non-array int:\n");
639 int ivalue = 999;
640 test->RIAI("int", 10, &ivalue);
641 printf("RIAI() returned ivalue %d\n", ivalue);
642 printf("\n");
643 }
644
645 {
646 printf("test invalid index -1 of array ia10:\n");
647 int ivalue = 999;
648 test->RIAI("ia10", -1, &ivalue);
649 printf("RIAI() returned ivalue %d\n", ivalue);
650 printf("\n");
651 }
652
653 {
654 printf("test invalid index 999 of array ia10:\n");
655 int ivalue = 999;
656 test->RIAI("ia10", 999, &ivalue);
657 printf("RIAI() returned ivalue %d\n", ivalue);
658 printf("\n");
659 }
660
661 printf("test string array invalid index -1:\n");
662 svalue = "aaa";
663 test->RSAI("sa10", -1, &svalue);
664 printf("RSAI() returned [%s]\n", svalue.c_str());
665 printf("\n");
666
667 printf("test string array invalid index 999:\n");
668 svalue = "aaa";
669 test->RSAI("sa10", 999, &svalue);
670 printf("RSAI() returned [%s]\n", svalue.c_str());
671 printf("\n");
672
673 printf("test write invalid index -1:\n");
674 test->WIAI("ia10", -1, 10);
675 printf("\n");
676
677 printf("test string write invalid index -1:\n");
678 test->WSAI("sa10", -1, "aaa");
679 printf("\n");
680
681 printf("\n");
682 printf("Test Chdir():\n");
683 printf("\n");
684
685 {
686 printf("test Chdir(true):\n");
687 MVOdb* dir = test->Chdir("test_subdir", true);
688 //printf("Chdir() returned %p\n", dir);
689 if (dir == NULL) report_fail("Chdir(new directory, true)");
690 }
691
692 {
693 printf("test Chdir(false):\n");
694 MVOdb* dir = test->Chdir("non-existant-subdir", false);
695 //printf("Chdir() returned %p\n", dir);
696 if (dir != NULL) report_fail("Chdir(new directory, false)");
697 }
698
699 {
700 printf("test Chdir(\"not a dir\", true):\n");
701 MVOdb* dir = test->Chdir("ia10", true);
702 //printf("Chdir() returned %p\n", dir);
703 if (dir == NULL) report_fail("Chdir(not a directory, true)");
704 }
705
706 {
707 printf("test Chdir(\"not a dir\", false):\n");
708 MVOdb* dir = test->Chdir("ia10", false);
709 //printf(" returned %p\n", dir);
710 if (dir != NULL) report_fail("Chdir(not a directory, false)");
711 }
712
713 if (0) {
714 printf("\n");
715 printf("Test ReadKeyLastWritten():\n");
716 printf("\n");
717
718 {
719 const char* varname = "ia";
720 int last_written;
721
722 test->ReadKeyLastWritten(varname, &last_written);
723
724 printf("\"%s\" last_written is %d\n", varname, last_written);
725 }
726 }
727
728 printf("\n");
729 printf("Test ReadKey():\n");
730 printf("\n");
731
732 {
733 const char* varname = "ia";
734 int tid;
735 int num_values;
736 int total_size;
737 int item_size;
738
739 test->ReadKey(varname, &tid, &num_values, &total_size, &item_size);
740
741 printf(" : tid num size item name\n");
742 printf(" : %3d %3d %6d %6d \"%s\"\n", tid, num_values, total_size, item_size, varname);
743 }
744
745 printf("\n");
746 printf("Test ReadDir():\n");
747 printf("\n");
748
749 {
750 std::vector<std::string> varname;
751 std::vector<int> tid;
752 std::vector<int> num_values;
753 std::vector<int> total_size;
754 std::vector<int> item_size;
755
756 test->ReadDir(&varname, &tid, &num_values, &total_size, &item_size);
757
758 printf(" : tid num size item name\n");
759 for (size_t i=0; i<varname.size(); i++) {
760 printf("%3zu: %3d %3d %6d %6d \"%s\"\n", i, tid[i], num_values[i], total_size[i], item_size[i], varname[i].c_str());
761 }
762 }
763 }
764
765 if (mfe)
766 mfe->Disconnect();
767
768 printf("\n");
769 printf("Number of FAILED tests: %d\n", gCountFail);
770 printf("\n");
771
772 return 0;
773}
774
775//end
776/* emacs
777 * Local Variables:
778 * tab-width: 8
779 * c-basic-offset: 3
780 * indent-tabs-mode: nil
781 * End:
782 */
TMFE
Definition tmfe.h:383
TMFE::fDB
int fDB
ODB database handle.
Definition tmfe.h:396
TMFE::Connect
TMFeResult Connect(const char *progname=NULL, const char *hostname=NULL, const char *exptname=NULL)
Definition tmfe.cxx:65
TMFE::Instance
static TMFE * Instance()
Definition tmfe.cxx:57
TMFE::Disconnect
TMFeResult Disconnect()
Definition tmfe.cxx:154
TMFeResult::error_flag
bool error_flag
Definition tmfe.h:89
TMFeResult::error_message
std::string error_message
Definition tmfe.h:91
main
int main()
Definition hwtest.cxx:23
online
INT online
Definition mana.cxx:241
i
INT i
Definition mdump.cxx:32
test
program test
Definition miniana.f:6
print_da
void print_da(const std::vector< double > &da)
Definition test_mvodb.cxx:40
gCountFail
static int gCountFail
Definition test_mvodb.cxx:52
report_fail
void report_fail(const char *text)
Definition test_mvodb.cxx:54
print_ia
void print_ia(const std::vector< int > &ia)
Definition test_mvodb.cxx:28
toString
std::string toString(int i)
Definition test_mvodb.cxx:21