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_key (HNDLE hDB, HNDLE hROOT, const char *path)
bool	test_delete (HNDLE hDB, HNDLE hROOT, const char *path)
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_enum (const std::vector< HNDLE > &hlist, const std::vector< KEY > &klist)
bool	test_enum_links (const std::vector< HNDLE > &hlist, const std::vector< KEY > &klist)
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 448 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;
 
   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);
 
   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 37 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("]");
}

print_ia()

void print_ia

(

const std::vector< int > &

ia

)

Definition at line 25 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("]");
}

report_fail() [1/2]

bool report_fail

(

const char *

text

)

Definition at line 51 of file test_odb.cxx.

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

Here is the caller graph for this function:

report_fail() [2/2]

bool report_fail

(

const std::string &

text

)

Definition at line 58 of file test_odb.cxx.

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

rmdir()

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

Definition at line 65 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);
 
   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 253 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); -- 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 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;
}

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 111 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
	)

Definition at line 145 of file test_odb.cxx.

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

Here is the call graph for this function:

Here is the caller graph for this function:

test_delete_key()

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

Definition at line 123 of file test_odb.cxx.

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

Here is the call graph for this function:

Here is the caller graph for this function:

test_enum()

bool test_enum	(	const std::vector< HNDLE > &	hlist,
		const std::vector< KEY > &	klist
	)

Definition at line 209 of file test_odb.cxx.

{
   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 = 6;
 
   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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

test_enum_links()

bool test_enum_links	(	const std::vector< HNDLE > &	hlist,
		const std::vector< KEY > &	klist
	)

Definition at line 231 of file test_odb.cxx.

{
   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 = 6;
 
   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;
}

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 157 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 171 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 87 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 99 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 185 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 197 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 18 of file test_odb.cxx.

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

Variable Documentation

gCountFail

int gCountFail = 0

static

Definition at line 49 of file test_odb.cxx.