test_odb.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 "midas.h"

Include dependency graph for test_odb.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)
bool	report_fail (const char *text)
bool	report_fail (const std::string &text)
bool	rmdir (HNDLE hDB, HNDLE hROOT, const char *path)
bool	test_mkdir (HNDLE hDB, HNDLE hROOT, const char *path)
bool	test_mkdir_fail (HNDLE hDB, HNDLE hROOT, const char *path, int fail_status)
bool	test_chdir (HNDLE hDB, HNDLE hROOT, const char *path, HNDLE *phKey)
bool	test_delete (HNDLE hDB, HNDLE hROOT, const char *path, BOOL follow_links=FALSE)
bool	test_find_fail (HNDLE hDB, HNDLE hROOT, const char *path, int fail_status)
bool	test_find_key_fail (HNDLE hDB, HNDLE hROOT, const char *path, int fail_status)
bool	test_symlink (HNDLE hDB, HNDLE hROOT, const char *path, const char *link_target)
bool	test_symlink_fail (HNDLE hDB, HNDLE hROOT, const char *path, const char *link_target, int fail_status)
bool	test_all (HNDLE hDB)
int	main (int argc, char *argv[])

Variables
static int	gCountFail = 0

Function Documentation

main()

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

Definition at line 304 of file test_odb.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;
 
   //MVOdb* odb = NULL;
   //MVOdbError odberror;
 
   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);
 
#if 0
   int runno = 1234;
 
   odb->RI("runinfo/run number", &runno);
 
   printf("read run number (RI): %d\n", runno);
 
   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);
 
   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);
   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);
 
   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)");
      }
   }
#endif
 
   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;
}

Here is the call graph for this function:

print_da()

void print_da

(

const std::vector< double > &

da

)

Definition at line 39 of file test_odb.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 call graph for this function:

Here is the caller graph for this function:

print_ia()

void print_ia

(

const std::vector< int > &

ia

)

Definition at line 27 of file test_odb.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 call graph for this function:

Here is the caller graph for this function:

report_fail() [1/2]

bool report_fail

(

const char *

text

)

Definition at line 53 of file test_odb.cxx.

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

Here is the call graph for this function:

Here is the caller graph for this function:

report_fail() [2/2]

bool report_fail

(

const std::string &

text

)

Definition at line 60 of file test_odb.cxx.

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

Here is the call graph for this function:

rmdir()

bool rmdir	(	HNDLE	hDB,
		HNDLE	hROOT,
		const char *	path
	)

Definition at line 67 of file test_odb.cxx.

{
   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, FALSE);
 
   if (status == DB_SUCCESS)
      return true;
 
   return report_fail(msprintf("test_mkdir: Delete subdirectory \"%s\" failed, status %d\n", path, status));
}

Here is the call graph for this function:

Here is the caller graph for this function:

test_all()

bool test_all

(

HNDLE

hDB

)

Definition at line 199 of file test_odb.cxx.

{
   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);
 
   // test db_delete_key()
 
   ok &= test_mkdir(hDB, hROOT, "test_delete");
   ok &= test_delete(hDB, hROOT, "test_delete");
 
   ok &= test_mkdir(hDB, hROOT, "test_dir/test/test/test_mkdir"); // multi-level create and delete
   ok &= test_delete(hDB, hROOT, "test_dir");
 
   // 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 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
   
   return ok;
}

Here is the call graph for this function:

Here is the caller graph for this function:

test_chdir()

bool test_chdir	(	HNDLE	hDB,
		HNDLE	hROOT,
		const char *	path,
		HNDLE *	phKey
	)

Definition at line 113 of file test_odb.cxx.

{
   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));
}

Here is the call graph for this function:

Here is the caller graph for this function:

test_delete()

bool test_delete	(	HNDLE	hDB,
		HNDLE	hROOT,
		const char *	path,
		BOOL	follow_links = FALSE
	)

Definition at line 125 of file test_odb.cxx.

{
   HNDLE hKey;
 
   printf("delete(%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: Cannot delete \"%s\", db_find_link() status %d\n", path, status));
 
   status = db_delete_key(hDB, hKey, follow_links);
 
   if (status == DB_SUCCESS)
      return true;
 
   return report_fail(msprintf("test_delete: Delete \"%s\" failed, status %d\n", path, status));
}

Here is the call graph for this function:

Here is the caller graph for this function:

test_find_fail()

bool test_find_fail	(	HNDLE	hDB,
		HNDLE	hROOT,
		const char *	path,
		int	fail_status
	)

Definition at line 147 of file test_odb.cxx.

{
   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));
}

Here is the call graph for this function:

Here is the caller graph for this function:

test_find_key_fail()

bool test_find_key_fail	(	HNDLE	hDB,
		HNDLE	hROOT,
		const char *	path,
		int	fail_status
	)

Definition at line 161 of file test_odb.cxx.

{
   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));
}

Here is the call graph for this function:

Here is the caller graph for this function:

test_mkdir()

bool test_mkdir	(	HNDLE	hDB,
		HNDLE	hROOT,
		const char *	path
	)

Definition at line 89 of file test_odb.cxx.

{
   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));
}

Here is the call graph for this function:

Here is the caller graph for this function:

test_mkdir_fail()

bool test_mkdir_fail	(	HNDLE	hDB,
		HNDLE	hROOT,
		const char *	path,
		int	fail_status
	)

Definition at line 101 of file test_odb.cxx.

{
   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));
}

Here is the call graph for this function:

Here is the caller graph for this function:

test_symlink()

bool test_symlink	(	HNDLE	hDB,
		HNDLE	hROOT,
		const char *	path,
		const char *	link_target
	)

Definition at line 175 of file test_odb.cxx.

{
   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));
}

Here is the call graph for this function:

Here is the caller graph for this function:

test_symlink_fail()

bool test_symlink_fail	(	HNDLE	hDB,
		HNDLE	hROOT,
		const char *	path,
		const char *	link_target,
		int	fail_status
	)

Definition at line 187 of file test_odb.cxx.

{
   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));
}

Here is the call graph for this function:

Here is the caller graph for this function:

toString()

std::string toString

(

int

i

)

Definition at line 20 of file test_odb.cxx.

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

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

gCountFail

int gCountFail = 0

static

Definition at line 51 of file test_odb.cxx.