test_mvodb.cxx File Reference

#include <stdio.h>
#include <sys/time.h>
#include <iostream>
#include <assert.h>
#include <signal.h>
#include <string.h>
#include <stdlib.h>
#include "tmfe.h"
#include "midasio.h"
#include "mvodb.h"

Include dependency graph for test_mvodb.cxx:

Go to the source code of this file.

Functions
std::string	toString (int i)
void	print_ia (const std::vector< int > &ia)
void	print_da (const std::vector< double > &da)
void	report_fail (const char *text)
int	main (int argc, char *argv[])

Variables
static int	gCountFail = 0

Function Documentation

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 62 of file test_mvodb.cxx.

{
   setbuf(stdout,NULL);
   setbuf(stderr,NULL);
 
   signal(SIGILL,  SIG_DFL);
   signal(SIGBUS,  SIG_DFL);
   signal(SIGSEGV, SIG_DFL);
   signal(SIGPIPE, SIG_DFL);
 
   const char* hostname = NULL;
   const char* exptname = NULL;
   const char* filename = argv[1];
   bool online  = false;
   bool xmlfile = false;
   bool jsonfile = false;
   bool nullodb = false;
 
   if (!filename)
      online = true;
   else if (strstr(filename, ".xml")!=0)
      xmlfile = true;
   else if (strstr(filename, ".json")!=0)
      jsonfile = true;
   else if (strstr(filename, "null")!=0)
      nullodb = true;
   else {
      hostname = filename;
      online = true;
   }
 
   TMFE* mfe = NULL;
   
   MVOdb* odb = NULL;
   MVOdbError odberror;
 
   if (nullodb)
      {
         printf("Using NullOdb\n");
         odb = MakeNullOdb();
      }
   else if (online)
      {
         printf("Using MidasOdb\n");
         mfe = TMFE::Instance();
 
         TMFeResult r;
 
         r = mfe->Connect("test_mvodb", hostname, exptname);
         if (r.error_flag) {
            fprintf(stderr,"Cannot connect to MIDAS, error %s\n", r.error_message.c_str());
            return -1;
         }
 
         odb = MakeMidasOdb(mfe->fDB, &odberror);
      }
   else if (xmlfile)
      {
         printf("Using XmlOdb\n");
         odb = MakeXmlFileOdb(filename, &odberror);
      }
   else if (jsonfile)
      {
         printf("Using JsonOdb\n");
         odb = MakeJsonFileOdb(filename, &odberror);
      }
   else
      {
         printf("Using FileDumpOdb\n");
         TMReaderInterface* reader = TMNewReader(filename);
 
         if (reader->fError) {
            printf("Cannot open input file \"%s\"\n",filename);
            delete reader;
            return -1;
         }
 
         while (1) {
            TMEvent* event = TMReadEvent(reader);
 
            if (!event)
               break;
         
            int eventId = event->event_id;
            //printf("Have an event of type %d\n", eventId);
         
            if ((eventId & 0xFFFF) != 0x8000) {
               delete event;
               continue;
            }
         
            // begin run
            //event.Print();
         
            odb = MakeFileDumpOdb(event->GetEventData(), event->data_size, &odberror);
            break;
         }
 
         reader->Close();
         delete reader;
 
         if (!odb) {
            printf("Failed to load ODB from input file \"%s\"\n",filename);
            return -1;
         }
      }
 
   if (odberror.fError) {
      fprintf(stderr, "Cannot make MVOdb object, error: %s\n", odberror.fErrorString.c_str());
      exit(1);
   }
 
   printf("\n");
   printf("Starting tests:\n");
   printf("\n");
 
   int runno = 1234;
 
   odb->RI("runinfo/run number", &runno);
 
   printf("read run number (RI): %d\n", runno);
 
   odb->Delete("test_mvodb");
 
   MVOdb* test = odb->Chdir("test_mvodb", true);
 
   assert(test != NULL);
 
   test->SetPrintError(true);
 
   bool isreadonly = test->IsReadOnly();
 
   if (isreadonly) {
      printf("\n");
      printf("This ODB is read-only!\n");
   }
 
   printf("\n");
   printf("Test create-and-read of all data types (set default values):\n");
   printf("\n");
 
   int cycle  = 1;
   test->RI("cycle", &cycle, true);
   printf("RI() cycle: %d\n", cycle);
 
   int ivalue = 1;
   test->RI("int", &ivalue, true);
   printf("RI() int: %d\n", ivalue);
 
   float fvalue = 2.2;
   test->RF("float", &fvalue, true);
   printf("RF() float: %f\n", fvalue);
 
   double dvalue = 3.3;
   test->RD("double", &dvalue, true);
   printf("RD() double: %f\n", dvalue);
 
   bool bvalue_a = false;
   test->RB("bool_a", &bvalue_a, true);
   printf("bool_a: %d\n", bvalue_a);
 
   bool bvalue_b = true;
   test->RB("bool_b", &bvalue_b, true);
   printf("bool_b: %d\n", bvalue_b);
 
   uint16_t u16value = 0xabcd;
   test->RU16("u16", &u16value, true);
   printf("RU16() u16: 0x%04x\n", u16value);
 
   uint32_t u32value = 0x12345678;
   test->RU32("u32", &u32value, true);
   printf("RU32() u32: 0x%08x\n", u32value);
 
   uint64_t u64value = 0x1122334455667788;
   test->RU64("u64", &u64value, true);
   printf("RU64() u64: 0x%016llx\n", (unsigned long long)u64value);
 
   std::string svalue = "test string";
   test->RS("string", &svalue, true);
   printf("RS() string: \"%s\"\n", svalue.c_str());
 
   printf("\n");
   printf("Test write of all data types (overwrite default values):\n");
   printf("\n");
 
   test->WI("cycle", cycle+1);
 
   int wi = 10 + 100*cycle;
   test->WI("int", wi);
   float wf = 11.1 + 100*cycle;
   test->WF("float", wf);
   double wd = 22.2 + 100*cycle;
   test->WD("double", wd);
   bool wba = true;
   test->WB("bool_a", wba);
   bool wbb = false;
   test->WB("bool_b", wbb);
   uint16_t wu16 = 0xcdef;
   test->WU16("u16", wu16);
   uint32_t wu32 = 0xdeadf00d;
   test->WU32("u32", wu32);
   uint64_t wu64 = 0xddeeaaddff0000dd;
   test->WU64("u64", wu64);
   std::string ws = "write test string cycle " + toString(cycle);
   test->WS("string", ws.c_str());
 
   printf("\n");
   printf("Test read of new values for all data types:\n");
   printf("\n");
 
   int ri = 1;
   test->RI("int", &ri);
   printf("int: %d -> %d -> %d\n", ivalue, wi, ri);
 
   float rf = 2.2;
   test->RF("float", &rf);
   printf("float: %f -> %f -> %f\n", fvalue, wf, rf);
 
   double rd = 3.3;
   test->RD("double", &rd);
   printf("double: %f -> %f -> %f\n", dvalue, wd, rd);
 
   bool rba = false;
   test->RB("bool_a", &rba);
   printf("bool_a: %d -> %d -> %d\n", bvalue_a, wba, rba);
 
   bool rbb = false;
   test->RB("bool_b", &rbb);
   printf("bool_b: %d -> %d -> %d\n", bvalue_b, wbb, rbb);
 
   uint16_t ru16 = 0x4444;
   test->RU16("u16", &ru16);
   printf("u16: 0x%04x -> 0x%04x -> 0x%04x\n", u16value, wu16, ru16);
 
   uint32_t ru32 = 0x55555555;
   test->RU32("u32", &ru32);
   printf("u32: 0x%08x -> 0x%08x -> 0x%08x\n", u32value, wu32, ru32);
 
   uint64_t ru64 = 0x1515151515151515;
   test->RU64("u64", &ru64);
   printf("u64: 0x%016llx -> 0x%016llx -> 0x%016llx\n", (unsigned long long)u64value, (unsigned long long)wu64, (unsigned long long)ru64);
 
   std::string rs = "rs";
   test->RS("string", &rs);
   printf("string: \"%s\" -> \"%s\" -> \"%s\"\n", svalue.c_str(), ws.c_str(), rs.c_str());
 
   printf("\n");
   printf("Test read arrays of all data types:\n");
   printf("\n");
 
   {
      printf("read int array ia:\n");
      std::vector<int> ia;
      ia.push_back(1);
      ia.push_back(2);
      ia.push_back(3);
      test->RIA("ia", &ia, true);
      printf("RIA() returned: ");
      print_ia(ia);
      printf("\n");
   }
 
   {
      printf("read non-existant array ia-noexist:\n");
      std::vector<int> ia;
      ia.push_back(1);
      ia.push_back(2);
      ia.push_back(3);
      test->RIA("ia-noexist", &ia);
      printf("RIA() returned: ");
      print_ia(ia);
      printf("\n");
   }
 
   {
      // create 10 element array, init to zero (ia is empty)
      std::vector<int> ia;
      test->RIA("ia10zero", &ia, true, 10);
      // create 10 element array, init from ia
      ia.clear();
      ia.push_back(11);
      ia.push_back(22);
      test->RIA("ia10", &ia, true, 10);
   }
 
   {
      // create 10 element array, init to zero (passed NULL instead of &ia)
      test->RIA("createia10", NULL, true, 10);
   }
 
   {
      std::vector<uint32_t> u32a;
      u32a.push_back(0x11110000);
      u32a.push_back(0x22220000);
      u32a.push_back(0x33330000);
      u32a.push_back(0x44440000);
      test->RU32A("dwa", &u32a, true);
   }
 
   {
      std::vector<double> da;
      da.push_back(1.1);
      da.push_back(1.2);
      da.push_back(1.3);
      da.push_back(1.4);
      test->RDA("da", &da, true, 0);
   }
 
   {
      std::vector<float> fa;
      fa.push_back(2.1);
      fa.push_back(2.2);
      fa.push_back(2.3);
      fa.push_back(20.3);
      fa.push_back(21.3);
      test->RFA("fa", &fa, true, 0);
   }
 
   {
      std::vector<bool> ba;
      ba.push_back(true);
      ba.push_back(false);
      ba.push_back(true);
      test->RBA("ba", &ba, true, 0);
   }
 
   {
      std::vector<std::string> sa;
      sa.push_back("line1");
      sa.push_back("line2");
      sa.push_back("line3");
      sa.push_back("line4");
      test->RSA("sa", &sa, true, 0, 32);
 
      // create 10 element array, init from ia
      sa.clear();
      sa.push_back("xx1");
      sa.push_back("xx2");
      test->RSA("sa10", &sa, true, 10, 32);
      // create 10 element array, init to zero (passed NULL instead of &sa)
      test->RSA("createsa10", NULL, true, 10, 32);
   }
 
   printf("\n");
   printf("Test string sizes:\n");
   printf("\n");
 
   {
      test->WS("test_size", "12345");
      std::string s;
      test->RS("test_size", &s);
      printf("read test_size     [%s]\n", s.c_str());
   }
   {
      test->WS("test_size_32", "1234567890", 32);
      std::string s;
      test->RS("test_size_32", &s);
      printf("read test_size_32  [%s]\n", s.c_str());
   }
   {
      test->WS("test_size_5", "1234567890", 5);
      std::string s;
      test->RS("test_size_5", &s);
      printf("read test_size_5   [%s]\n", s.c_str());
   }
   {
      std::string s = "1234567890";
      test->RS("test_rsize", &s, true);
      printf("read test_rsize    [%s]\n", s.c_str());
   }
   {
      std::string s = "123456";
      test->RS("test_size_r32", &s, true, 32);
      printf("read test_size_r32 [%s]\n", s.c_str());
   }
   {
      std::string s = "1234567890";
      test->RS("test_size_r8", &s, true, 8);
      printf("read test_size_r8  [%s]\n", s.c_str());
   }
   {
      test->RSA("test_size_a8", NULL, true, 2, 8);
      std::string s = "1234567890";
      test->WSAI("test_size_a8", 0, s.c_str());
      test->RSAI("test_size_a8", 0, &s);
      printf("read test_size_a8  [%s]\n", s.c_str());
   }
 
   printf("\n");
   printf("Test creating and resizing arrays:\n");
   printf("\n");
 
   {
      test->RIA("create_ia15", NULL, true, 15);
      test->RBA("create_ba12", NULL, true, 12);
      test->RSA("create_sa5", NULL, true, 5, 32);
   }
   {
      test->RIA("resize_ia10", NULL, true, 5);
      test->RIA("resize_ia10", NULL, true, 10);
      test->RSA("resize_sa3", NULL, true, 5, 32);
      test->WSAI("resize_sa3", 0, "00000000");
      test->WSAI("resize_sa3", 1, "11111111");
      test->WSAI("resize_sa3", 2, "22222222");
      test->WSAI("resize_sa3", 3, "33333333");
      test->WSAI("resize_sa3", 4, "44444444");
      test->RSA("resize_sa3", NULL, true, 3, 5);
   }
 
   printf("\n");
   printf("Test array index access:\n");
   printf("\n");
 
   {
      std::vector<int> ia;
      ia.push_back(10);
      ia.push_back(11);
      ia.push_back(12);
      test->WIA("index_ia", ia);
      for (int i=0; i<5; i++) {
         int ivalue = 999;
         test->RIAI("index_ia", i, &ivalue);
         printf("index %d value %d\n", i, ivalue);
      }
      for (int i=0; i<4; i++) {
         int ivalue = 20+i;
         test->WIAI("index_ia", i, ivalue);
      }
      for (int i=0; i<5; i++) {
         int ivalue = 999;
         test->RIAI("index_ia", i, &ivalue);
         printf("index %d value %d\n", i, ivalue);
      }
   }
 
   printf("\n");
   printf("Test string array index access:\n");
   printf("\n");
 
   {
      std::vector<std::string> sa;
      sa.push_back("sa0");
      sa.push_back("sa1");
      sa.push_back("sa2");
      test->WSA("index_sa", sa, 32);
      for (int i=0; i<5; i++) {
         std::string s = "aaa";
         test->RSAI("index_sa", i, &s);
         printf("index %d value [%s]\n", i, s.c_str());
      }
      for (int i=0; i<4; i++) {
         std::string s = "sa_qqq";
         s += toString(i);
         test->WSAI("index_sa", i, s.c_str());
      }
      for (int i=0; i<5; i++) {
         std::string s = "bbb";
         test->RSAI("index_sa", i, &s);
         printf("index %d value [%s]\n", i, s.c_str());
      }
   }
 
   printf("\n");
   printf("Test string truncation:\n");
   printf("\n");
 
   {
      std::vector<std::string> sa;
      sa.push_back("1234567890");
      sa.push_back("aaa1");
      sa.push_back("aaa2");
      test->WSA("trunc_sa5", sa, 5);
      test->WSAI("trunc_sa5", 1, "1234567890");
      for (int i=0; i<5; i++) {
         std::string s = "bbb";
         test->RSAI("trunc_sa5", i, &s);
         printf("index %d value [%s]\n", i, s.c_str());
      }
   }
 
   printf("\n");
   printf("Test against subdirectory:\n");
   printf("\n");
 
   {
      printf("Creating subdir\n");
      MVOdb* subdir = test->Chdir("subdir", true);
      printf("Creating subdir/i\n");
      subdir->WI("i", 10); // write something into subdir
      int i = 1111;
      printf("RI(subdir)\n");
      test->RI("subdir", &i); // invalid read from a non-int
      printf("WI(subdir)\n");
      test->WI("subdir", 10); // invalid write into existing subdir
      std::vector<int> ia;
      ia.push_back(111);
      ia.push_back(222);
      ia.push_back(333);
      printf("WIA(subdir)\n");
      test->WIA("subdir", ia); // invalid write into existing subdir
      printf("RIA(subdir)\n");
      test->RIA("subdir", &ia); // invalid read from non-int-array
      printf("RIA() returned: ");
      print_ia(ia);
      printf("\n");
      printf("RIA(subdir, create=true)\n");
      test->RIA("subdir", &ia, true); // invalid read from non-int-array
      printf("RIA() returned: ");
      print_ia(ia);
      printf("\n");
   }
 
   printf("\n");
   printf("Test special cases:\n");
   printf("\n");
 
   {
      printf("test RI() of non existant variable:\n");
      int ivalue = 999;
      test->RI("nonexistant", &ivalue);
      printf("RI() returned ivalue %d\n", ivalue);
      printf("\n");
 
      {
         std::vector<double> da;
         printf("test RDA() of integer array:\n");
         // wrong data type: ODB is INT, we ask for DOUBLE
         test->RDA("ia10", &da, false, 0);
         printf("RDA() returned: ");
         print_da(da);
         printf("\n");
      }
       
      {
         printf("test RD() of integer array:\n");
         // wrong data type: ODB is INT, we ask for DOUBLE
         double v = 999.9;
         test->RD("ia10", &v);
         printf("RD() returned %f\n", v);
         printf("\n");
      }
 
      {
         printf("test RI() of array ia10:\n");
         int ivalue = 999;
         test->RI("ia10", &ivalue);
         printf("RI() returned ivalue %d\n", ivalue);
         printf("\n");
      }
 
      {
         printf("test RIA() of non-array int:\n");
         std::vector<int> ia;
         test->RIA("int", &ia);
         printf("RIA() returned: ");
         print_ia(ia);
         printf("\n");
      }
 
      {
         printf("test index 0 of non-array int:\n");
         int ivalue = 999;
         test->RIAI("int", 0, &ivalue);
         printf("RIAI() returned ivalue %d\n", ivalue);
         printf("\n");
      }
 
      {
         printf("test index of non-array int:\n");
         int ivalue = 999;
         test->RIAI("int", 10, &ivalue);
         printf("RIAI() returned ivalue %d\n", ivalue);
         printf("\n");
      }
 
      {
         printf("test invalid index -1 of array ia10:\n");
         int ivalue = 999;
         test->RIAI("ia10", -1, &ivalue);
         printf("RIAI() returned ivalue %d\n", ivalue);
         printf("\n");
      }
 
      {
         printf("test invalid index 999 of array ia10:\n");
         int ivalue = 999;
         test->RIAI("ia10", 999, &ivalue);
         printf("RIAI() returned ivalue %d\n", ivalue);
         printf("\n");
      }
 
      printf("test string array invalid index -1:\n");
      svalue = "aaa";
      test->RSAI("sa10", -1, &svalue);
      printf("RSAI() returned [%s]\n", svalue.c_str());
      printf("\n");
 
      printf("test string array invalid index 999:\n");
      svalue = "aaa";
      test->RSAI("sa10", 999, &svalue);
      printf("RSAI() returned [%s]\n", svalue.c_str());
      printf("\n");
 
      printf("test write invalid index -1:\n");
      test->WIAI("ia10", -1, 10);
      printf("\n");
 
      printf("test string write invalid index -1:\n");
      test->WSAI("sa10", -1, "aaa");
      printf("\n");
 
      printf("\n");
      printf("Test Chdir():\n");
      printf("\n");
 
      {
         printf("test Chdir(true):\n");
         MVOdb* dir = test->Chdir("test_subdir", true);
         //printf("Chdir() returned %p\n", dir);
         if (dir == NULL) report_fail("Chdir(new directory, true)");
      }
 
      {
         printf("test Chdir(false):\n");
         MVOdb* dir = test->Chdir("non-existant-subdir", false);
         //printf("Chdir() returned %p\n", dir);
         if (dir != NULL) report_fail("Chdir(new directory, false)");
      }
 
      {
         printf("test Chdir(\"not a dir\", true):\n");
         MVOdb* dir = test->Chdir("ia10", true);
         //printf("Chdir() returned %p\n", dir);
         if (dir == NULL) report_fail("Chdir(not a directory, true)");
      }
 
      {
         printf("test Chdir(\"not a dir\", false):\n");
         MVOdb* dir = test->Chdir("ia10", false);
         //printf(" returned %p\n", dir);
         if (dir != NULL) report_fail("Chdir(not a directory, false)");
      }
      
      if (0) {
      printf("\n");
      printf("Test ReadKeyLastWritten():\n");
      printf("\n");
 
      {
         const char* varname = "ia";
         int last_written;
 
         test->ReadKeyLastWritten(varname, &last_written);
 
         printf("\"%s\" last_written is %d\n", varname, last_written);
      }
      }
 
      printf("\n");
      printf("Test ReadKey():\n");
      printf("\n");
 
      {
         const char* varname = "ia";
         int tid;
         int num_values;
         int total_size;
         int item_size;
 
         test->ReadKey(varname, &tid, &num_values, &total_size, &item_size);
 
         printf("   : tid num   size   item  name\n");
         printf("   : %3d %3d %6d %6d \"%s\"\n", tid, num_values, total_size, item_size, varname);
      }
 
      printf("\n");
      printf("Test ReadDir():\n");
      printf("\n");
 
      {
         std::vector<std::string> varname;
         std::vector<int> tid;
         std::vector<int> num_values;
         std::vector<int> total_size;
         std::vector<int> item_size;
 
         test->ReadDir(&varname, &tid, &num_values, &total_size, &item_size);
 
         printf("   : tid num   size   item  name\n");
         for (size_t i=0; i<varname.size(); i++) {
            printf("%3zu: %3d %3d %6d %6d \"%s\"\n", i, tid[i], num_values[i], total_size[i], item_size[i], varname[i].c_str());
         }
      }
   }
 
   if (mfe)
      mfe->Disconnect();
 
   printf("\n");
   printf("Number of FAILED tests: %d\n", gCountFail);
   printf("\n");
   
   return 0;
}

Here is the call graph for this function:

print_da()

void print_da

(

const std::vector< double > &

da

)

Definition at line 40 of file test_mvodb.cxx.

{
   int size = da.size();
   printf("int[%d] has [", size);
   for (int i=0; i<size; i++) {
      if (i>0)
         printf(", ");
      printf("%f", da[i]);
   }
   printf("]");
}

Here is the caller graph for this function:

print_ia()

void print_ia

(

const std::vector< int > &

ia

)

Definition at line 28 of file test_mvodb.cxx.

{
   int size = ia.size();
   printf("int[%d] has [", size);
   for (int i=0; i<size; i++) {
      if (i>0)
         printf(", ");
      printf("%d", ia[i]);
   }
   printf("]");
}

Here is the caller graph for this function:

report_fail()

void report_fail

(

const char *

text

)

Definition at line 54 of file test_mvodb.cxx.

{
   printf("FAIL: %s\n", text);
   gCountFail++;
}

Here is the caller graph for this function:

toString()

std::string toString

(

int

i

)

Definition at line 21 of file test_mvodb.cxx.

{
   char buf[256];
   snprintf(buf, sizeof(buf), "%d", i);
   return buf;
}

Here is the caller graph for this function:

Variable Documentation

gCountFail

int gCountFail = 0

static

Definition at line 52 of file test_mvodb.cxx.