installed test codes for the ca server templates

src/cxxTemplates/test/resourceLibTest.cc

@@ -0,0 +1,110 @@
+
+
+#include <assert.h>
+#include <time.h>
+#include <stdio.h>
+#include <resourceLib.h>
+
+class uintId {
+public:
+	uintId (unsigned idIn) : id(idIn) {}
+
+	resourceTableID resourceHash(unsigned nBitsId) const
+	{
+		unsigned        src = this->id;
+		resourceTableID	hashid;
+	 
+		hashid = src;
+		src = src >> nBitsId;
+		while (src) {
+			hashid = hashid ^ src;
+			src = src >> nBitsId;
+		}
+		//
+		// the result here is always masked to the
+		// proper size after it is returned to the resource class
+		//
+		return hashid;
+	}
+
+	int operator == (const uintId &idIn)
+	{
+		return this->id == idIn.id;
+	}
+private:
+	unsigned const id;
+};
+
+class fred : public uintId, tsSLNode<fred> {
+public:
+	fred (const char *pNameIn, unsigned idIn) : 
+			pName(pNameIn), uintId(idIn) {}
+private:
+	const char * const pName;
+};
+
+main()
+{
+        unsigned        		i;
+        clock_t         		start, finish;
+        double          		duration;
+        const int       		LOOPS = 500000;
+	resourceTable<fred,uintId>	tbl;	
+	fred				fred1("fred1",0x1000a432);
+	fred				fred2("fred2",0x0000a432);
+	fred				*pFred;
+	uintId				id1(0x1000a432);
+	uintId				id2(0x0000a432);
+	int				status;
+ 
+	status = tbl.init(8);
+	if (status) {
+		return -1;
+	}
+ 
+        status = tbl.add(fred1);
+        assert (!status);
+        status = tbl.add(fred2);
+        assert (!status);
+ 
+        start = clock();
+        for(i=0; i<LOOPS; i++){
+		pFred = tbl.lookup(id1);	
+		assert(pFred==&fred1);
+		pFred = tbl.lookup(id1);	
+		assert(pFred==&fred1);
+		pFred = tbl.lookup(id1);	
+		assert(pFred==&fred1);
+		pFred = tbl.lookup(id1);	
+		assert(pFred==&fred1);
+		pFred = tbl.lookup(id1);	
+		assert(pFred==&fred1);
+		pFred = tbl.lookup(id1);	
+		assert(pFred==&fred1);
+		pFred = tbl.lookup(id1);	
+		assert(pFred==&fred1);
+		pFred = tbl.lookup(id1);	
+		assert(pFred==&fred1);
+		pFred = tbl.lookup(id1);	
+		assert(pFred==&fred1);
+		pFred = tbl.lookup(id2);	
+		assert(pFred==&fred2);
+        }
+        finish = clock();
+ 
+        duration = finish-start;
+        duration /= CLOCKS_PER_SEC;
+        printf("It took %15.10f total sec\n", duration);
+        duration /= LOOPS;
+        duration /= 10;
+	duration *= 1e6;
+        printf("It took %15.10f u sec per hash lookup\n", duration);
+ 
+	tbl.show(10u);
+
+	tbl.remove(id1);
+	tbl.remove(id2);
+ 
+        return 0;
+}
+

src/cxxTemplates/test/tsDLListBench.cc

@@ -0,0 +1,65 @@
+
+#ifndef CLOCKS_PER_SEC
+#define CLOCKS_PER_SEC 1000000
+#endif
+
+#include <tsDLList.h>
+#include <assert.h>
+#include <time.h>
+#include <stdio.h>
+
+class fred : public tsDLNode<fred> {
+public:
+	fred() : count(0) {}
+	void inc () {count++;}
+private:
+	unsigned count;
+};
+
+class jane : public fred, public tsDLNode<jane> {
+public:
+	jane() {}
+private:
+};
+
+#define LOOPCOUNT 100000
+
+main ()
+{
+	tsDLList<fred>	list;
+	tsDLIter<fred>	iter(list);
+	fred		*pFred;
+	unsigned 	i;
+	clock_t		clk;
+	clock_t		diff;
+	double 		delay;
+
+	for (i=0; i<LOOPCOUNT; i++) {
+		pFred = new fred();
+		list.add(*pFred);
+	}
+
+	clk = clock();
+	iter = list;
+	while (pFred = iter()) {
+		pFred->inc();
+	}
+	diff = clock() - clk;
+	delay = diff;
+	delay = delay/CLOCKS_PER_SEC;
+	delay = delay/LOOPCOUNT;
+	printf("delay = %15.10lf\n", delay);
+
+	pFred = new fred();
+	clk = clock();
+	iter = list;
+	for (i=0; i<LOOPCOUNT; i++) {
+		pFred->inc();
+	}
+	diff = clock() - clk;
+	delay = diff;
+	delay = delay/CLOCKS_PER_SEC;
+	delay = delay/LOOPCOUNT;
+	printf("delay = %15.10lf\n", delay);
+}
+

src/cxxTemplates/test/tsDLListTest.cc

@@ -0,0 +1,72 @@
+
+
+
+#include <tsDLList.h>
+#include <assert.h>
+#include <stdio.h>
+
+class fred : public tsDLNode<fred> {
+public:
+	fred(const char * const pNameIn) : pName(pNameIn){}
+	void show () {printf("%s\n", pName);}
+private:
+	const char * const pName;
+};
+
+class jane : public fred, public tsDLNode<jane> {
+public:
+	jane(const char * const pNameIn) : fred(pNameIn){}
+private:
+};
+
+main ()
+{
+	tsDLList<fred>	list;
+	tsDLIter<fred>	iter(list);
+	fred		*pFred;
+	fred		*pFredII;
+	fred		*pFredBack;
+	tsDLList<jane>	janeList;
+	tsDLIter<jane>	janeIter(janeList);
+	jane		*pJane;
+
+	pFred = new fred("A");
+	pFredII = new fred("B");
+
+	list.add(*pFred);
+	list.add(*pFredII);
+	pFredBack = list.first();
+	assert(pFredBack == pFred);
+	pFredBack = list.last();
+	assert(pFredBack == pFredII);
+	list.remove(*pFred);
+	list.add(*pFred);
+	pFredBack = list.get();
+	assert (pFredBack == pFredII);
+	pFredBack = list.get();
+	assert (pFredBack == pFred);
+	assert (list.count() == 0u);
+	list.add(*pFred);
+	list.add(*pFredII);
+	list.add(* new fred("C"));
+	list.add(* new fred("D"));
+
+	while (pFredBack = iter()) {
+		pFredBack->show();
+	}
+
+	pJane = new jane("JA");
+	janeList.add(*pJane);	
+	pJane = new jane("JB");
+	janeList.add(*pJane);	
+
+	while (pJane = janeIter()) {
+		pJane->show();
+	}
+
+	iter = list;
+	while (pFredBack = iter()) {
+		pFredBack->show();
+	}
+}
+

src/cxxTemplates/test/tsSLListBench.cc

@@ -0,0 +1,62 @@
+
+
+
+#include <tsSLList.h>
+#include <assert.h>
+#include <time.h>
+
+class fred : public tsSLNode<fred> {
+public:
+	fred() : count(0) {}
+	void inc () {count++;}
+private:
+	unsigned count;
+};
+
+class jane : public fred, public tsSLNode<jane> {
+public:
+	jane() {}
+private:
+};
+
+#define LOOPCOUNT 100000
+
+main ()
+{
+	tsSLList<fred>	list;
+	tsSLIter<fred>	iter(list);
+	fred		*pFred;
+	unsigned 	i;
+	clock_t		clk;
+	clock_t		diff;
+	double 		delay;
+
+	for (i=0; i<LOOPCOUNT; i++) {
+		pFred = new fred();
+		list.add(*pFred);
+	}
+
+	clk = clock();
+	iter = list;
+	while (pFred = iter()) {
+		pFred->inc();
+	}
+	diff = clock() - clk;
+	delay = diff;
+	delay = delay/CLOCKS_PER_SEC;
+	delay = delay/LOOPCOUNT;
+	printf("delay = %15.10lf\n", delay);
+
+	pFred = new fred();
+	clk = clock();
+	iter = list;
+	for (i=0; i<LOOPCOUNT; i++) {
+		pFred->inc();
+	}
+	diff = clock() - clk;
+	delay = diff;
+	delay = delay/CLOCKS_PER_SEC;
+	delay = delay/LOOPCOUNT;
+	printf("delay = %15.10lf\n", delay);
+}
+

src/cxxTemplates/test/tsSLListTest.cc

@@ -0,0 +1,67 @@
+
+
+
+#include <tsSLList.h>
+#include <assert.h>
+
+class fred : public tsSLNode<fred> {
+public:
+	fred(const char * const pNameIn) : pName(pNameIn){}
+	void show () {printf("%s\n", pName);}
+private:
+	const char * const pName;
+};
+
+class jane : public fred, public tsSLNode<jane> {
+public:
+	jane(const char * const pNameIn) : fred(pNameIn){}
+private:
+};
+
+main ()
+{
+	tsSLList<fred>	list;
+	tsSLIter<fred>	iter(list);
+	fred		*pFred;
+	fred		*pFredII;
+	fred		*pFredBack;
+	tsSLList<jane>	janeList;
+	tsSLIter<jane>	janeIter(janeList);
+	jane		*pJane;
+
+	pFred = new fred("A");
+	pFredII = new fred("B");
+
+	list.add(*pFred);
+	list.add(*pFredII);
+	pFredBack = list.first();
+	assert(pFredBack == pFredII);
+	list.remove(*pFred, *pFredII);
+	list.add(*pFred);
+	pFredBack = list.get();
+	assert (pFredBack == pFred);
+	pFredBack = list.get();
+	assert (pFredBack == pFredII);
+	list.add(*pFred);
+	list.add(*pFredII);
+	list.add(* new fred("C"));
+	list.add(* new fred("D"));
+
+	while (pFredBack = iter()) {
+		pFredBack->show();
+	}
+
+	pJane = new jane("JA");
+	janeList.add(*pJane);	
+	pJane = new jane("JB");
+	janeList.add(*pJane);	
+
+	while (pJane = janeIter()) {
+		pJane->show();
+	}
+
+	while (pFredBack = iter()) {
+		pFredBack->show();
+	}
+}
+

src/libCom/cxxTemplates/test/resourceLibTest.cc

@@ -0,0 +1,110 @@
+
+
+#include <assert.h>
+#include <time.h>
+#include <stdio.h>
+#include <resourceLib.h>
+
+class uintId {
+public:
+	uintId (unsigned idIn) : id(idIn) {}
+
+	resourceTableID resourceHash(unsigned nBitsId) const
+	{
+		unsigned        src = this->id;
+		resourceTableID	hashid;
+	 
+		hashid = src;
+		src = src >> nBitsId;
+		while (src) {
+			hashid = hashid ^ src;
+			src = src >> nBitsId;
+		}
+		//
+		// the result here is always masked to the
+		// proper size after it is returned to the resource class
+		//
+		return hashid;
+	}
+
+	int operator == (const uintId &idIn)
+	{
+		return this->id == idIn.id;
+	}
+private:
+	unsigned const id;
+};
+
+class fred : public uintId, tsSLNode<fred> {
+public:
+	fred (const char *pNameIn, unsigned idIn) : 
+			pName(pNameIn), uintId(idIn) {}
+private:
+	const char * const pName;
+};
+
+main()
+{
+        unsigned        		i;
+        clock_t         		start, finish;
+        double          		duration;
+        const int       		LOOPS = 500000;
+	resourceTable<fred,uintId>	tbl;	
+	fred				fred1("fred1",0x1000a432);
+	fred				fred2("fred2",0x0000a432);
+	fred				*pFred;
+	uintId				id1(0x1000a432);
+	uintId				id2(0x0000a432);
+	int				status;
+ 
+	status = tbl.init(8);
+	if (status) {
+		return -1;
+	}
+ 
+        status = tbl.add(fred1);
+        assert (!status);
+        status = tbl.add(fred2);
+        assert (!status);
+ 
+        start = clock();
+        for(i=0; i<LOOPS; i++){
+		pFred = tbl.lookup(id1);	
+		assert(pFred==&fred1);
+		pFred = tbl.lookup(id1);	
+		assert(pFred==&fred1);
+		pFred = tbl.lookup(id1);	
+		assert(pFred==&fred1);
+		pFred = tbl.lookup(id1);	
+		assert(pFred==&fred1);
+		pFred = tbl.lookup(id1);	
+		assert(pFred==&fred1);
+		pFred = tbl.lookup(id1);	
+		assert(pFred==&fred1);
+		pFred = tbl.lookup(id1);	
+		assert(pFred==&fred1);
+		pFred = tbl.lookup(id1);	
+		assert(pFred==&fred1);
+		pFred = tbl.lookup(id1);	
+		assert(pFred==&fred1);
+		pFred = tbl.lookup(id2);	
+		assert(pFred==&fred2);
+        }
+        finish = clock();
+ 
+        duration = finish-start;
+        duration /= CLOCKS_PER_SEC;
+        printf("It took %15.10f total sec\n", duration);
+        duration /= LOOPS;
+        duration /= 10;
+	duration *= 1e6;
+        printf("It took %15.10f u sec per hash lookup\n", duration);
+ 
+	tbl.show(10u);
+
+	tbl.remove(id1);
+	tbl.remove(id2);
+ 
+        return 0;
+}
+

src/libCom/cxxTemplates/test/tsDLListBench.cc

@@ -0,0 +1,65 @@
+
+#ifndef CLOCKS_PER_SEC
+#define CLOCKS_PER_SEC 1000000
+#endif
+
+#include <tsDLList.h>
+#include <assert.h>
+#include <time.h>
+#include <stdio.h>
+
+class fred : public tsDLNode<fred> {
+public:
+	fred() : count(0) {}
+	void inc () {count++;}
+private:
+	unsigned count;
+};
+
+class jane : public fred, public tsDLNode<jane> {
+public:
+	jane() {}
+private:
+};
+
+#define LOOPCOUNT 100000
+
+main ()
+{
+	tsDLList<fred>	list;
+	tsDLIter<fred>	iter(list);
+	fred		*pFred;
+	unsigned 	i;
+	clock_t		clk;
+	clock_t		diff;
+	double 		delay;
+
+	for (i=0; i<LOOPCOUNT; i++) {
+		pFred = new fred();
+		list.add(*pFred);
+	}
+
+	clk = clock();
+	iter = list;
+	while (pFred = iter()) {
+		pFred->inc();
+	}
+	diff = clock() - clk;
+	delay = diff;
+	delay = delay/CLOCKS_PER_SEC;
+	delay = delay/LOOPCOUNT;
+	printf("delay = %15.10lf\n", delay);
+
+	pFred = new fred();
+	clk = clock();
+	iter = list;
+	for (i=0; i<LOOPCOUNT; i++) {
+		pFred->inc();
+	}
+	diff = clock() - clk;
+	delay = diff;
+	delay = delay/CLOCKS_PER_SEC;
+	delay = delay/LOOPCOUNT;
+	printf("delay = %15.10lf\n", delay);
+}
+

src/libCom/cxxTemplates/test/tsDLListTest.cc

@@ -0,0 +1,72 @@
+
+
+
+#include <tsDLList.h>
+#include <assert.h>
+#include <stdio.h>
+
+class fred : public tsDLNode<fred> {
+public:
+	fred(const char * const pNameIn) : pName(pNameIn){}
+	void show () {printf("%s\n", pName);}
+private:
+	const char * const pName;
+};
+
+class jane : public fred, public tsDLNode<jane> {
+public:
+	jane(const char * const pNameIn) : fred(pNameIn){}
+private:
+};
+
+main ()
+{
+	tsDLList<fred>	list;
+	tsDLIter<fred>	iter(list);
+	fred		*pFred;
+	fred		*pFredII;
+	fred		*pFredBack;
+	tsDLList<jane>	janeList;
+	tsDLIter<jane>	janeIter(janeList);
+	jane		*pJane;
+
+	pFred = new fred("A");
+	pFredII = new fred("B");
+
+	list.add(*pFred);
+	list.add(*pFredII);
+	pFredBack = list.first();
+	assert(pFredBack == pFred);
+	pFredBack = list.last();
+	assert(pFredBack == pFredII);
+	list.remove(*pFred);
+	list.add(*pFred);
+	pFredBack = list.get();
+	assert (pFredBack == pFredII);
+	pFredBack = list.get();
+	assert (pFredBack == pFred);
+	assert (list.count() == 0u);
+	list.add(*pFred);
+	list.add(*pFredII);
+	list.add(* new fred("C"));
+	list.add(* new fred("D"));
+
+	while (pFredBack = iter()) {
+		pFredBack->show();
+	}
+
+	pJane = new jane("JA");
+	janeList.add(*pJane);	
+	pJane = new jane("JB");
+	janeList.add(*pJane);	
+
+	while (pJane = janeIter()) {
+		pJane->show();
+	}
+
+	iter = list;
+	while (pFredBack = iter()) {
+		pFredBack->show();
+	}
+}
+

src/libCom/cxxTemplates/test/tsSLListBench.cc

@@ -0,0 +1,62 @@
+
+
+
+#include <tsSLList.h>
+#include <assert.h>
+#include <time.h>
+
+class fred : public tsSLNode<fred> {
+public:
+	fred() : count(0) {}
+	void inc () {count++;}
+private:
+	unsigned count;
+};
+
+class jane : public fred, public tsSLNode<jane> {
+public:
+	jane() {}
+private:
+};
+
+#define LOOPCOUNT 100000
+
+main ()
+{
+	tsSLList<fred>	list;
+	tsSLIter<fred>	iter(list);
+	fred		*pFred;
+	unsigned 	i;
+	clock_t		clk;
+	clock_t		diff;
+	double 		delay;
+
+	for (i=0; i<LOOPCOUNT; i++) {
+		pFred = new fred();
+		list.add(*pFred);
+	}
+
+	clk = clock();
+	iter = list;
+	while (pFred = iter()) {
+		pFred->inc();
+	}
+	diff = clock() - clk;
+	delay = diff;
+	delay = delay/CLOCKS_PER_SEC;
+	delay = delay/LOOPCOUNT;
+	printf("delay = %15.10lf\n", delay);
+
+	pFred = new fred();
+	clk = clock();
+	iter = list;
+	for (i=0; i<LOOPCOUNT; i++) {
+		pFred->inc();
+	}
+	diff = clock() - clk;
+	delay = diff;
+	delay = delay/CLOCKS_PER_SEC;
+	delay = delay/LOOPCOUNT;
+	printf("delay = %15.10lf\n", delay);
+}
+

src/libCom/cxxTemplates/test/tsSLListTest.cc

@@ -0,0 +1,67 @@
+
+
+
+#include <tsSLList.h>
+#include <assert.h>
+
+class fred : public tsSLNode<fred> {
+public:
+	fred(const char * const pNameIn) : pName(pNameIn){}
+	void show () {printf("%s\n", pName);}
+private:
+	const char * const pName;
+};
+
+class jane : public fred, public tsSLNode<jane> {
+public:
+	jane(const char * const pNameIn) : fred(pNameIn){}
+private:
+};
+
+main ()
+{
+	tsSLList<fred>	list;
+	tsSLIter<fred>	iter(list);
+	fred		*pFred;
+	fred		*pFredII;
+	fred		*pFredBack;
+	tsSLList<jane>	janeList;
+	tsSLIter<jane>	janeIter(janeList);
+	jane		*pJane;
+
+	pFred = new fred("A");
+	pFredII = new fred("B");
+
+	list.add(*pFred);
+	list.add(*pFredII);
+	pFredBack = list.first();
+	assert(pFredBack == pFredII);
+	list.remove(*pFred, *pFredII);
+	list.add(*pFred);
+	pFredBack = list.get();
+	assert (pFredBack == pFred);
+	pFredBack = list.get();
+	assert (pFredBack == pFredII);
+	list.add(*pFred);
+	list.add(*pFredII);
+	list.add(* new fred("C"));
+	list.add(* new fred("D"));
+
+	while (pFredBack = iter()) {
+		pFredBack->show();
+	}
+
+	pJane = new jane("JA");
+	janeList.add(*pJane);	
+	pJane = new jane("JB");
+	janeList.add(*pJane);	
+
+	while (pJane = janeIter()) {
+		pJane->show();
+	}
+
+	while (pFredBack = iter()) {
+		pFredBack->show();
+	}
+}
+