test_odb.cxx

Go to the documentation of this file.

//
// test_mvodb.cxx --- test ODB access functions
//
// K.Olchanski
//
 
#include <stdio.h>
#include <sys/time.h>
#include <iostream>
#include <assert.h>
#include <signal.h>
#include <string.h>
#include <stdlib.h> // exit()
 
#include "tmfe.h"
#include "midas.h"
 
std::string toString(int i)
{
   char buf[256];
   sprintf(buf, "%d", i);
   return buf;
}
 
void print_ia(const std::vector<int> &ia)
{
   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("]");
}
 
void print_da(const std::vector<double> &da)
{
   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("]");
}
 
static int gCountFail = 0;
 
bool report_fail(const char* text)
{
   printf("FAIL: %s\n", text);
   gCountFail++;
   return false;
}
 
bool report_fail(const std::string& text)
{
   printf("FAIL: %s\n", text.c_str());
   gCountFail++;
   return false;
}
 
bool rmdir(HNDLE hDB, HNDLE hROOT, const char* path)
{
   HNDLE hKey;
 
   printf("rmdir(%s)\n", path);
 
   int status = db_find_link(hDB, hROOT, path, &hKey);
 
   if (status == DB_NO_KEY)
      return true;
 
   if (status != DB_SUCCESS)
      return report_fail(msprintf("test_mkdir: Cannot delete subdirectory \"%s\", db_find_link() status %d\n", path, status));
 
   status = db_delete_key(hDB, hKey);
 
   if (status == DB_SUCCESS)
      return true;
 
   return report_fail(msprintf("test_mkdir: Delete subdirectory \"%s\" failed, status %d\n", path, status));
}
 
bool test_mkdir(HNDLE hDB, HNDLE hROOT, const char* path)
{
   printf("mkdir(%s)\n", path);
 
   int status = db_create_key(hDB, hROOT, path, TID_KEY);
 
   if (status == DB_SUCCESS)
      return true;
 
   return report_fail(msprintf("test_mkdir: Create subdirectory \"%s\" failed, status %d\n", path, status));
}
 
bool test_mkdir_fail(HNDLE hDB, HNDLE hROOT, const char* path, int fail_status)
{
   printf("mkdir_fail(%s)\n", path);
 
   int status = db_create_key(hDB, hROOT, path, TID_KEY);
 
   if (status == fail_status)
      return true;
 
   return report_fail(msprintf("test_mkdir_fail: Create subdirectory \"%s\" failed, unexpcted status %d instead of %d\n", path, status, fail_status));
}
 
bool test_chdir(HNDLE hDB, HNDLE hROOT, const char* path, HNDLE* phKey)
{
   printf("chdir(%s)\n", path);
 
   int status = db_find_link(hDB, hROOT, path, phKey);
 
   if (status == DB_SUCCESS)
      return true;
 
   return report_fail(msprintf("test_mkdir: Cannot find subdirectory \"%s\", db_find_link() status %d\n", path, status));
}
 
bool test_delete_key(HNDLE hDB, HNDLE hROOT, const char* path)
{
   HNDLE hKey;
 
   printf("delete_key(%s)\n", path);
 
   int status = db_find_link(hDB, hROOT, path, &hKey);
 
   if (status == DB_NO_KEY)
      return true;
 
   if (status != DB_SUCCESS)
      return report_fail(msprintf("test_delete_key: Cannot delete \"%s\", db_find_link() status %d\n", path, status));
 
   status = db_delete_key(hDB, hKey);
 
   if (status == DB_SUCCESS)
      return true;
 
   return report_fail(msprintf("test_delete_key: Delete \"%s\" failed, status %d\n", path, status));
}
 
bool test_delete(HNDLE hDB, HNDLE hROOT, const char* path)
{
   printf("delete(%s)\n", path);
 
   int status = db_delete(hDB, hROOT, path);
 
   if (status == DB_SUCCESS)
      return true;
 
   return report_fail(msprintf("test_delete: Delete \"%s\" failed, status %d\n", path, status));
}
 
bool test_find_fail(HNDLE hDB, HNDLE hROOT, const char* path, int fail_status)
{
   HNDLE hKey;
 
   printf("find_fail(%s)\n", path);
 
   int status = db_find_link(hDB, hROOT, path, &hKey);
 
   if (status == fail_status)
      return true;
 
   return report_fail(msprintf("test_find_fail: Unexpected db_find_link(%s) status %d instead of %d\n", path, status, fail_status));
}
 
bool test_find_key_fail(HNDLE hDB, HNDLE hROOT, const char* path, int fail_status)
{
   HNDLE hKey;
 
   printf("find_key_fail(%s)\n", path);
 
   int status = db_find_key(hDB, hROOT, path, &hKey);
 
   if (status == fail_status)
      return true;
 
   return report_fail(msprintf("test_find_key_fail: Unexpected db_find_key(%s) status %d instead of %d\n", path, status, fail_status));
}
 
bool test_symlink(HNDLE hDB, HNDLE hROOT, const char* path, const char* link_target)
{
   printf("symlink(%s) to \"%s\"\n", path, link_target);
 
   int status = db_create_link(hDB, hROOT, path, link_target);
 
   if (status == DB_SUCCESS)
      return true;
 
   return report_fail(msprintf("test_symlink: db_create_link(%s) status %d\n", path, status));
}
 
bool test_symlink_fail(HNDLE hDB, HNDLE hROOT, const char* path, const char* link_target, int fail_status)
{
   printf("symlink_fail(%s) to \"%s\"\n", path, link_target);
 
   int status = db_create_link(hDB, hROOT, path, link_target);
 
   if (status == fail_status)
      return true;
 
   return report_fail(msprintf("test_symlink_fail: db_create_link(%s) status %d instead of %d\n", path, status, fail_status));
}
 
bool test_enum(const std::vector<HNDLE>& hlist, const std::vector<KEY>& klist)
{
   printf("test_enum\n");
 
   if (hlist.size() != klist.size()) {
      return report_fail(msprintf("test_enum: hlist and klist size mismatch\n"));
   }
 
   bool ok = true;
 
   size_t expected_size = 9;
 
   if (klist.size() != expected_size)
      ok &= report_fail(msprintf("test_enum: klist size %zu different from expected %zu\n", klist.size(), expected_size));
 
   for (size_t i=0; i<klist.size(); i++) {
      printf("key %zu: \"%s\" tid %d, num_values %d\n", i, klist[i].name, klist[i].type, klist[i].num_values);
   }
 
   return ok;
}
 
bool test_enum_links(const std::vector<HNDLE>& hlist, const std::vector<KEY>& klist)
{
   printf("test_enum_links\n");
 
   if (hlist.size() != klist.size()) {
      return report_fail(msprintf("test_enum: hlist and klist size mismatch\n"));
   }
 
   bool ok = true;
 
   size_t expected_size = 9;
 
   if (klist.size() != expected_size)
      ok &= report_fail(msprintf("test_enum: klist size %zu different from expected %zu\n", klist.size(), expected_size));
 
   for (size_t i=0; i<klist.size(); i++) {
      printf("key %zu: \"%s\" tid %d, num_values %d\n", i, klist[i].name, klist[i].type, klist[i].num_values);
   }
 
   return ok;
}
 
bool test_symlink_to_array(HNDLE hDB, MVOdb* odb)
{
   printf("test_symlink_to_array\n");
 
   bool ok = true;
   int status;
 
   std::vector ia{ 10, 11, 12, 13, 14 };
 
   odb->WIA("test_odb/ia5", ia);
 
   int iii = 0;
 
   odb->RIAI("test_odb/ia5", 0, &iii); if (iii != 10) ok &= report_fail(msprintf("test_symlink_to_array: array read unexpected value %d\n", iii));
   odb->RIAI("test_odb/ia5", 1, &iii); if (iii != 11) ok &= report_fail(msprintf("test_symlink_to_array: array read unexpected value %d\n", iii));
   odb->RIAI("test_odb/ia5", 2, &iii); if (iii != 12) ok &= report_fail(msprintf("test_symlink_to_array: array read unexpected value %d\n", iii));
 
   ok &= test_symlink(hDB, 0, "/test_odb/symlink_to_ia5", "/test_odb/ia5");
 
   odb->RIAI("test_odb/symlink_to_ia5", 0, &iii); if (iii != 10) ok &= report_fail(msprintf("test_symlink_to_array: array read unexpected value %d\n", iii));
   odb->RIAI("test_odb/symlink_to_ia5", 1, &iii); if (iii != 11) ok &= report_fail(msprintf("test_symlink_to_array: array read unexpected value %d\n", iii));
   odb->RIAI("test_odb/symlink_to_ia5", 2, &iii); if (iii != 12) ok &= report_fail(msprintf("test_symlink_to_array: array read unexpected value %d\n", iii));
 
   ok &= test_symlink(hDB, 0, "/test_odb/symlink_to_ia5_2", "/test_odb/ia5[2]");
 
#if 0
   iii = 0;
   odb->RI("test_odb/symlink_to_ia5_2", &iii); if (iii != 12) ok &= report_fail(msprintf("test_symlink_to_array: symlink to array element read unexpected value %d\n", iii));
 
   iii = 0;
   odb->RIAI("test_odb/symlink_to_ia5_2", 0, &iii); if (iii != 12) ok &= report_fail(msprintf("test_symlink_to_array: symlink to array element read index 0 unexpected value %d\n", iii));
   iii = 0;
   odb->RIAI("test_odb/symlink_to_ia5_2", 1, &iii); if (iii != 12) ok &= report_fail(msprintf("test_symlink_to_array: symlink to array element read index 1 unexpected value %d\n", iii));
#endif
 
   int ibuf[256];
   int size = sizeof(ibuf);
 
#if 0
   status = db_get_value(hDB, 0, "/test_odb/symlink_to_ia5", ibuf, &size, TID_INT, FALSE);
 
   if (status != DB_SUCCESS) {
      ok &= report_fail(msprintf("test_symlink_to_array: db_get_value() status %d\n", status));
   } else if (size != 5*sizeof(int)) {
      ok &= report_fail(msprintf("test_symlink_to_array: db_get_value() returned wrong size %d\n", size));
   } else {
      for (int i=0; i<5; i++) {
         if (ibuf[i] != 10+i) {
            ok &= report_fail(msprintf("test_symlink_to_array: db_get_value() returned wrong value %d at %d\n", ibuf[i], i));
         }
      }
   }
#endif
 
   HNDLE hKey;
 
   status = db_find_key(hDB, 0, "/test_odb/symlink_to_ia5", &hKey);
 
   if (status != DB_SUCCESS) {
      ok &= report_fail(msprintf("test_symlink_to_array: symlink to array db_find_key() status %d\n", status));
   } else {
      size = sizeof(ibuf);
 
      status = db_get_data(hDB, hKey, ibuf, &size, TID_INT);
 
      if (status != DB_SUCCESS) {
         ok &= report_fail(msprintf("test_symlink_to_array: symlink to array db_get_data() status %d\n", status));
      } else if (size != 5*sizeof(int)) {
         ok &= report_fail(msprintf("test_symlink_to_array: symlink to array db_get_data() returned wrong size %d\n", size));
      } else {
         for (int i=0; i<5; i++) {
            if (ibuf[i] != 10+i) {
               ok &= report_fail(msprintf("test_symlink_to_array: symlink to array db_get_data() returned wrong value %d at %d\n", ibuf[i], i));
            }
         }
      }
   }
 
   status = db_find_key(hDB, 0, "/test_odb/symlink_to_ia5_2", &hKey);
 
   if (status != DB_SUCCESS) {
      ok &= report_fail(msprintf("test_symlink_to_array: symlink to array element db_find_key() status %d\n", status));
   } else {
      size = sizeof(ibuf);
 
      status = db_get_data(hDB, hKey, ibuf, &size, TID_INT);
 
      if (status != DB_SUCCESS) {
         ok &= report_fail(msprintf("test_symlink_to_array: symlink to array element db_get_data() status %d\n", status));
      } else if (size != sizeof(int)) {
         ok &= report_fail(msprintf("test_symlink_to_array: symlink to array element db_get_data() returned wrong size %d\n", size));
      } else if (ibuf[0] != 12) {
         ok &= report_fail(msprintf("test_symlink_to_array: symlink to array element db_get_data() returned wrong value %d\n", ibuf[0]));
      }
   }
 
#if 0
   size = sizeof(ibuf);
 
   status = db_get_value(hDB, 0, "/test_odb/symlink_to_ia5_2", ibuf, &size, TID_INT, FALSE);
 
   if (status != DB_SUCCESS) {
      ok &= report_fail(msprintf("test_symlink_to_array: symlink to array element db_get_value() status %d\n", status));
   } else if (size != 5*sizeof(int)) {
      ok &= report_fail(msprintf("test_symlink_to_array: symlink to array element db_get_value() returned wrong size %d\n", size));
   } else {
      for (int i=0; i<5; i++) {
         if (ibuf[i] != 10+i) {
            ok &= report_fail(msprintf("test_symlink_to_array: symlink to array element db_get_value() returned wrong value %d at %d\n", ibuf[i], i));
         }
      }
   }
#endif
 
   return ok;
}
 
bool test_all(HNDLE hDB, MVOdb* odb)
{
   bool ok = true;
 
   ok &= rmdir(hDB, 0, "test_odb");
 
   if (!ok)
      return false;
 
   ok &= test_mkdir(hDB, 0, "test_odb");
      
   if (!ok)
      return false;
 
   HNDLE hROOT = 0;
 
   ok &= test_chdir(hDB, 0, "test_odb", &hROOT);
 
   if (!ok)
      return false;
 
   ok &= test_find_fail(hDB, hROOT, "does-not-exist", DB_NO_KEY);
   ok &= test_find_fail(hDB, hROOT, "/does-not-exist", DB_NO_KEY);
 
   ok &= test_find_fail(hDB, 0, "/System", DB_SUCCESS); // exists at top level
   ok &= test_find_fail(hDB, hROOT, "/System", DB_NO_KEY); // but not in our subdirectory
 
   ok &= test_mkdir(hDB, hROOT, "test_mkdir");
   ok &= test_mkdir_fail(hDB, hROOT, "/test_mkdir", DB_KEY_EXIST); // unexpected, leading slash is ignored?
 
   // test db_create_key()
 
   ok &= test_mkdir_fail(hDB, hROOT, "invalid_name[", DB_INVALID_NAME);
   ok &= test_mkdir_fail(hDB, hROOT, "invalid_name]", DB_INVALID_NAME);
   ok &= test_mkdir_fail(hDB, hROOT, "", DB_INVALID_NAME);
   ok &= test_mkdir_fail(hDB, hROOT, "/", DB_INVALID_NAME);
   ok &= test_mkdir_fail(hDB, hROOT, "//", DB_INVALID_NAME);
   ok &= test_mkdir_fail(hDB, hROOT, "invalid//invalid", DB_INVALID_NAME);
   //ok &= test_mkdir_fail(hDB, hROOT, NULL, DB_INVALID_NAME); -- core dump if rpc_is_remote()
 
   // test db_delete_key()
 
   ok &= test_mkdir(hDB, hROOT, "test_delete_key");
   ok &= test_delete_key(hDB, hROOT, "test_delete_key");
   ok &= test_find_fail(hDB, hROOT, "test_delete_key", DB_NO_KEY); // deleted
 
   ok &= test_mkdir(hDB, hROOT, "test_delete_key_dir/test/test/test_mkdir"); // multi-level create and delete
   ok &= test_delete_key(hDB, hROOT, "test_delete_key_dir");
   ok &= test_find_fail(hDB, hROOT, "test_delete_key_dir", DB_NO_KEY); // deleted
 
   // test db_delete()
 
   ok &= test_mkdir(hDB, hROOT, "test_delete");
   ok &= test_delete(hDB, hROOT, "test_delete");
   ok &= test_find_fail(hDB, hROOT, "test_delete", DB_NO_KEY); // deleted
 
   ok &= test_mkdir(hDB, hROOT, "test_delete_dir/test/test/test_mkdir"); // multi-level create and delete
   ok &= test_delete(hDB, hROOT, "test_delete_dir");
   ok &= test_find_fail(hDB, hROOT, "test_delete_dir", DB_NO_KEY); // deleted
 
   // test symlinks
 
   ok &= test_symlink_fail(hDB, hROOT, "test_symlink_fail", "/does-not-exist", DB_NO_KEY);
   ok &= test_symlink_fail(hDB, hROOT, "test_symlink_fail", "no-leading-slash", DB_INVALID_NAME);
   ok &= test_symlink_fail(hDB, hROOT, "test_symlink", "/test_odb/test_mkdir", DB_NO_KEY); // unexpected
   ok &= test_symlink(hDB, 0, "/test_odb/test_symlink", "/test_odb/test_mkdir");
 
   // test symlink to symlink
 
   ok &= test_symlink(hDB, 0, "/test_odb/test_symlink_to_symlink", "/test_odb/test_symlink");
 
   //
   // test symlink to array elements
   //
 
   ok &= test_symlink_to_array(hDB, odb);
 
   //
   // test db_delete_key of symlink
   //
 
   ok &= test_mkdir(hDB, 0, "/test_odb/test_symlink1_target");
   ok &= test_symlink(hDB, 0, "/test_odb/test_symlink1", "/test_odb/test_symlink1_target");
   ok &= test_delete_key(hDB, hROOT, "test_symlink1"); // delete symlink
   ok &= test_find_fail(hDB, hROOT, "test_symlink1", DB_NO_KEY); // symlinks deleted
   ok &= test_find_fail(hDB, hROOT, "test_symlink1_target", DB_SUCCESS); // symlink target remains
 
   //
   // test db_delete_key of symlink
   //
 
   ok &= test_mkdir(hDB, 0, "/test_odb/test_symlink2_target");
   ok &= test_symlink(hDB, 0, "/test_odb/test_symlink2", "/test_odb/test_symlink2_target");
   ok &= test_delete(hDB, hROOT, "test_symlink2"); // delete symlink
   ok &= test_find_fail(hDB, hROOT, "test_symlink2", DB_NO_KEY); // symlinks deleted
   ok &= test_find_fail(hDB, hROOT, "test_symlink2_target", DB_SUCCESS); // symlink target remains
 
#if 0
   //
   // test db_delete_key with follow_links set to true
   //
 
   // delete(false) deletes the symlink,
   // delete(true) deletes the link target, and the link
 
   ok &= test_mkdir(hDB, 0, "/test_odb/test_symlink_target");
   ok &= test_symlink(hDB, 0, "/test_odb/test_symlink1", "/test_odb/test_symlink_target");
   ok &= test_symlink(hDB, 0, "/test_odb/test_symlink2", "/test_odb/test_symlink_target");
   ok &= test_delete(hDB, hROOT, "test_symlink1"); // delete symlink
   ok &= test_delete(hDB, hROOT, "test_symlink2", true); // delete symlink target
   ok &= test_find_fail(hDB, hROOT, "test_symlink_target", DB_NO_KEY); // deleted
   ok &= test_find_fail(hDB, hROOT, "test_symlink1", DB_NO_KEY); // deleted
   ok &= test_find_fail(hDB, hROOT, "test_symlink2", DB_NO_KEY); // dangling link
 
   // chained links, target of last link is deleted, intermediate link remain (dangling)
 
   ok &= test_mkdir(hDB, 0, "/test_odb/test_link_to_link");
   ok &= test_symlink(hDB, 0, "/test_odb/test_link_to_link1", "/test_odb/test_link_to_link");
   ok &= test_symlink(hDB, 0, "/test_odb/test_link_to_link2", "/test_odb/test_link_to_link1");
   ok &= test_delete(hDB, hROOT, "test_link_to_link2", true); // delete symlink target
   ok &= test_find_fail(hDB, hROOT, "test_link_to_link", DB_NO_KEY); // deleted
   ok &= test_find_fail(hDB, hROOT, "test_link_to_link1", DB_SUCCESS); // unexpectedly not deleted
   ok &= test_find_fail(hDB, hROOT, "test_link_to_link2", DB_NO_KEY); // deleted
   ok &= test_find_key_fail(hDB, hROOT, "test_link_to_link1", DB_INVALID_LINK); // dangling link
 
   // subdirectory has a link to something else, it is also deleted
 
   ok &= test_mkdir(hDB, 0, "/test_odb/test_symlink_dir1");
   ok &= test_mkdir(hDB, 0, "/test_odb/test_symlink_dir2");
   ok &= test_symlink(hDB, 0, "/test_odb/test_symlink_dir1/test_symlink", "/test_odb/test_symlink_dir2");
   ok &= test_delete(hDB, hROOT, "test_symlink_dir1", true); // delete symlink target
   ok &= test_find_fail(hDB, hROOT, "test_symlink_dir1", DB_NO_KEY); // deleted
   ok &= test_find_fail(hDB, hROOT, "test_symlink_dir2", DB_NO_KEY); // deleted
 
   // test delete of circular links
 
   ok &= test_mkdir(hDB, 0, "/test_odb/test_circular_link");
   ok &= test_symlink(hDB, 0, "/test_odb/test_circular_link/test_link",  "/test_odb/test_circular_link");
   ok &= test_symlink(hDB, 0, "/test_odb/test_circular_link1", "/test_odb/test_circular_link");
   ok &= test_delete(hDB, hROOT, "test_circular_link1", true); // delete symlink target
   ok &= test_find_fail(hDB, hROOT, "test_circular_link", DB_NO_KEY); // deleted
   ok &= test_find_fail(hDB, hROOT, "test_circular_link1", DB_NO_KEY); // deleted
#endif
 
 
   // test db_enum
 
   {
      int status;
      HNDLE hKeyRoot;
      std::vector<HNDLE> hlist;
      std::vector<KEY>   klist;
      
      status = db_enum(hDB, 0, "/test_odb", &hlist, &klist);
 
      if (status != DB_SUCCESS) {
         ok &= report_fail(msprintf("test_enum: db_enum(path) status %d\n", status));
      }
 
      ok &= test_enum(hlist, klist);
 
      status = db_find_key(hDB, 0, "/test_odb", &hKeyRoot);
 
      status = db_enum(hDB, hKeyRoot, &hlist, &klist);
 
      if (status != DB_SUCCESS) {
         ok &= report_fail(msprintf("test_enum: db_enum(hkey) status %d\n", status));
      }
 
      ok &= test_enum(hlist, klist);
   }
   
   {
      int status;
      HNDLE hKeyRoot;
      std::vector<HNDLE> hlist;
      std::vector<KEY>   klist;
      
      status = db_enum(hDB, 0, "/test_odb", &hlist, &klist, false);
 
      if (status != DB_SUCCESS) {
         ok &= report_fail(msprintf("test_enum: db_enum(path) status %d\n", status));
      }
 
      ok &= test_enum_links(hlist, klist);
 
      status = db_find_link(hDB, 0, "/test_odb", &hKeyRoot);
 
      status = db_enum(hDB, hKeyRoot, &hlist, &klist, false);
 
      if (status != DB_SUCCESS) {
         ok &= report_fail(msprintf("test_enum: db_enum(hkey) status %d\n", status));
      }
 
      ok &= test_enum_links(hlist, klist);
   }
   
   return ok;
}
 
// Main function call
 
int main(int argc, char *argv[])
{
   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;
 
   if (argc > 1)
      hostname = argv[1];
 
   TMFE* mfe = TMFE::Instance();
 
   TMFeResult r;
 
   r = mfe->Connect("test_odb", hostname, exptname);
 
   if (r.error_flag) {
      fprintf(stderr,"Cannot connect to MIDAS, error %s\n", r.error_message.c_str());
      return -1;
   }
 
   HNDLE hDB = mfe->fDB;
 
   bool ok = true;
 
   printf("\n");
   printf("Starting tests:\n");
   printf("\n");
 
   ok &= test_all(hDB, mfe->fOdbRoot);
 
   if (mfe)
      mfe->Disconnect();
 
   if (ok) {
      printf("\n");
      printf("Tests passed OK\n");
      printf("\n");
   } else {
      printf("\n");
      printf("Number of FAILED tests: %d\n", gCountFail);
      printf("\n");
   }
   
   return 0;
}
 
//end
 
/* emacs
 * Local Variables:
 * tab-width: 8
 * c-basic-offset: 3
 * indent-tabs-mode: nil
 * End:
 */