epics/pvData
0
0
Fork 0
Code Issues Pull Requests Projects Wiki Activity

convert all tests to use epicsUnitTest

Browse Source
This commit is contained in:
Marty Kraimer
2013-11-25 15:46:00 -05:00
parent 86306740be
commit 4102deceb3
27 changed files with 643 additions and 974 deletions
Download Patch File Download Diff File Expand all files Collapse all files
testApp/misc/Makefile
+11 -3
View File
@@ -6,12 +6,15 @@ PROD_LIBS += pvData Com
PROD_HOST += testThread
testThread_SRCS += testThread.cpp
TESTS += testThread
PROD_HOST += testTimer
testTimer_SRCS += testTimer.cpp
TESTS += testTimer
PROD_HOST += testBitSet
testBitSet_SRCS += testBitSet.cpp
TESTS += testBitSet
PROD_HOST += testOverrunBitSet
testOverrunBitSet_SRCS += testOverrunBitSet.cpp
@@ -22,28 +25,33 @@ testByteOrder_SRCS += testByteOrder.cpp
PROD_HOST += testByteBuffer
testByteBuffer_SRCS += testByteBuffer.cpp
TESTS += testByteBuffer
PROD_HOST += testBaseException
testBaseException_SRCS += testBaseException.cpp
TESTS += testBaseException
TESTPROD += testSharedVector
PROD_HOST += testSharedVector
testSharedVector_SRCS += testSharedVector.cpp
TESTS += testSharedVector
TESTPROD += testSerialization
PROD_HOST += testSerialization
testSerialization_SRCS += testSerialization.cpp
TESTS += testSerialization
PROD_HOST += testTimeStamp
testTimeStamp_SRCS += testTimeStamp.cpp
TESTS += testTimeStamp
PROD_HOST += testQueue
testQueue_SRCS += testQueue.cpp
TESTS += testQueue
PROD_HOST += testMessageQueue
testMessageQueue_SRCS += testMessageQueue.cpp
TESTS += testMessageQueue
TESTPROD += testTypeCast
PROD_HOST += testTypeCast
testTypeCast_SRCS += testTypeCast.cpp
TESTS += testTypeCast
testApp/misc/testBaseException.cpp
+21 -23
View File
@@ -11,11 +11,12 @@
#include <stddef.h>
#include <string.h>
#include <stdio.h>
#include <epicsUnitTest.h>
#include <testMain.h>
#include <pv/epicsException.h>
#include <epicsAssert.h>
using namespace epics::pvData;
struct Unroller
@@ -41,13 +42,13 @@ void internalTestBaseException(int /*unused*/ = 0)
}
}
void testBaseException(FILE *fp) {
fprintf(fp,"testBaseException... ");
void testBaseException() {
printf("testBaseException... ");
try {
THROW_BASE_EXCEPTION("all is OK");
} catch (BaseException& be) {
fprintf(fp,"\n\n%s\n\n", be.what());
printf("\n\n%s\n\n", be.what());
}
try {
@@ -57,38 +58,35 @@ void testBaseException(FILE *fp) {
THROW_BASE_EXCEPTION_CAUSE("exception 2", be2);
}
} catch (BaseException& be) {
fprintf(fp,"\n\n%s\n\n", be.what());
printf("\n\n%s\n\n", be.what());
}
fprintf(fp,"PASSED\n");
testPass("testBaseException");
}
void testLogicException(FILE *fp) {
void testLogicException() {
try {
THROW_EXCEPTION(std::logic_error("There is a logic_error"));
} catch (std::logic_error& be) {
fprintf(fp,"\n\n%s\n\n", be.what());
PRINT_EXCEPTION2(be, fp);
printf("\n\n%s\n\n", be.what());
PRINT_EXCEPTION2(be, stdout);
}
try {
THROW_EXCEPTION2(std::logic_error, "There is another logic_error");
} catch (std::logic_error& be) {
fprintf(fp,"\n\n%s\n\n", be.what());
fprintf(fp,"%s\n", SHOW_EXCEPTION(be).c_str());
printf("\n\n%s\n\n", be.what());
printf("%s\n", SHOW_EXCEPTION(be).c_str());
}
testPass("testLogicException");
}
int main(int argc,char *argv[])
MAIN(testBaseException)
{
FILE *fp=NULL;
if(argc>1){
fp=fopen(argv[1], "w");
if(!fp) fprintf(stderr,"Failed to open test output file\n");
}
if(!fp) fp=stdout;
testLogicException(fp);
testBaseException(fp);
return(0);
testPlan(2);
testDiag("Tests base exception");
testLogicException();
testBaseException();
return testDone();
}
testApp/misc/testBitSet.cpp
+42 -50
View File
@@ -14,87 +14,87 @@
#include <stdio.h>
#include <pv/bitSet.h>
#include <epicsAssert.h>
#include <epicsExit.h>
#include <epicsUnitTest.h>
#include <testMain.h>
using namespace epics::pvData;
void testGetSetClearFlip(FILE *fd) {
fprintf(fd,"testGetSetClearFlip... ");
static void testGetSetClearFlip()
{
printf("testGetSetClearFlip... ");
// empty
BitSet* b1 = new BitSet();
assert(b1->isEmpty());
assert(b1->cardinality() == 0);
testOk1(b1->isEmpty());
testOk1(b1->cardinality() == 0);
// to string check
std::string str; b1->toString(&str);
assert(str == "{}");
testOk1(str == "{}");
// one
b1->set(3);
assert(b1->get(3));
assert(!b1->isEmpty());
assert(b1->cardinality() == 1);
testOk1(b1->get(3));
testOk1(!b1->isEmpty());
testOk1(b1->cardinality() == 1);
// to string check
str.clear(); b1->toString(&str);
assert(str == "{3}");
testOk1(str == "{3}");
// grow
b1->set(66);
b1->set(67);
b1->set(68);
assert(b1->cardinality() == 4);
testOk1(b1->cardinality() == 4);
str.clear(); b1->toString(&str);
assert(str == "{3, 66, 67, 68}");
testOk1(str == "{3, 66, 67, 68}");
// clear one
b1->clear(67);
assert(b1->cardinality() == 3);
testOk1(b1->cardinality() == 3);
str.clear(); b1->toString(&str);
assert(str == "{3, 66, 68}");
testOk1(str == "{3, 66, 68}");
// flip
b1->flip(66);
b1->flip(130);
assert(b1->cardinality() == 3);
testOk1(b1->cardinality() == 3);
str.clear(); b1->toString(&str);
assert(str == "{3, 68, 130}");
testOk1(str == "{3, 68, 130}");
// flip
b1->set(130, false);
b1->set(4, true);
assert(b1->cardinality() == 3);
testOk1(b1->cardinality() == 3);
str.clear(); b1->toString(&str);
assert(str == "{3, 4, 68}");
testOk1(str == "{3, 4, 68}");
// clear all
b1->clear();
assert(b1->isEmpty());
assert(b1->cardinality() == 0);
testOk1(b1->isEmpty());
testOk1(b1->cardinality() == 0);
str.clear(); b1->toString(&str);
assert(str == "{}");
testOk1(str == "{}");
delete b1;
fprintf(fd,"PASSED\n");
}
void testOperators(FILE *fd) {
fprintf(fd,"testOperators... ");
static void testOperators()
{
printf("testOperators... ");
BitSet b1;
assert(b1 == b1);
testOk1(b1 == b1);
BitSet b2;
assert(b1 == b2);
testOk1(b1 == b2);
b1.set(1);
assert(!(b1 == b2));
testOk1(!(b1 == b2));
// different internal length, but the same
b2.set(100);
b2.set(1);
b2.flip(100);
assert(b1 == b2);
testOk1(b1 == b2);
// OR test
b2.set(65);
@@ -102,32 +102,32 @@ void testOperators(FILE *fd) {
b2.set(105);
b1 |= b2;
std::string str; b1.toString(&str);
assert(str == "{1, 65, 105, 106}");
testOk1(str == "{1, 65, 105, 106}");
b1.clear();
b1 |= b2;
str.clear(); b1.toString(&str);
assert(str == "{1, 65, 105, 106}");
testOk1(str == "{1, 65, 105, 106}");
// AND test
b1.set(128);
b1 &= b2;
assert(b1 == b2);
testOk1(b1 == b2);
// XOR test
b1.set(128);
b1 ^= b2;
assert(b1.cardinality() == 1 && b1.get(128) == true);
testOk1((b1.cardinality() == 1 && b1.get(128) == true));
b1.clear();
b2.clear();
b1.set(1);
b2.set(256);
b1 ^= b2;
assert(b1.cardinality() == 2 && b1.get(1) == true && b1.get(256) == true);
testOk1((b1.cardinality() == 2 && b1.get(1) == true && b1.get(256) == true));
// assign
b1 = b2;
assert(b1 == b2);
testOk1(b1 == b2);
// or_and
b1.clear(); b1.set(2);
@@ -135,23 +135,15 @@ void testOperators(FILE *fd) {
BitSet b3; b3.set(128); b3.set(520);
b1.or_and(b2, b3);
str.clear(); b1.toString(&str);
assert(str == "{2, 128}");
fprintf(fd,"PASSED\n");
testOk1(str == "{2, 128}");
}
int main(int argc,char *argv[])
MAIN(testBitSet)
{
char *fileName = 0;
if(argc>1) fileName = argv[1];
FILE * fd = stdout;
if(fileName!=0 && fileName[0]!=0) {
fd = fopen(fileName,"w+");
}
testGetSetClearFlip(fd);
testOperators(fd);
return(0);
testPlan(29);
testGetSetClearFlip();
testOperators();
return testDone();
}
testApp/misc/testByteBuffer.cpp
+103 -114
View File
@@ -14,115 +14,115 @@
#include <fstream>
#include <cstring>
#include <epicsAssert.h>
#include <epicsEndian.h>
#include <epicsUnitTest.h>
#include <testMain.h>
#include <pv/byteBuffer.h>
#include <pv/pvIntrospect.h>
using namespace epics::pvData;
using std::cout;
void testBasicOperations(std::ostream& ofile) {
ofile<<"Basic operation tests...\n";
void testBasicOperations() {
ByteBuffer* buff = new ByteBuffer(32);
assert(buff->getSize()==32);
// assert(buff->getByteOrder()==EPICS_BYTE_ORDER);
assert(buff->getPosition()==0);
assert(buff->getLimit()==32);
assert(buff->getRemaining()==32);
testOk1(buff->getSize()==32);
// testOk1(buff->getByteOrder()==EPICS_BYTE_ORDER);
testOk1(buff->getPosition()==0);
testOk1(buff->getLimit()==32);
testOk1(buff->getRemaining()==32);
buff->putBoolean(true);
assert(buff->getPosition()==1);
assert(buff->getRemaining()==31);
testOk1(buff->getPosition()==1);
testOk1(buff->getRemaining()==31);
buff->putByte(-12);
assert(buff->getPosition()==2);
assert(buff->getRemaining()==30);
testOk1(buff->getPosition()==2);
testOk1(buff->getRemaining()==30);
buff->putShort(10516);
assert(buff->getPosition()==4);
assert(buff->getRemaining()==28);
testOk1(buff->getPosition()==4);
testOk1(buff->getRemaining()==28);
buff->putInt(0x1937628B);
assert(buff->getPosition()==8);
assert(buff->getRemaining()==24);
testOk1(buff->getPosition()==8);
testOk1(buff->getRemaining()==24);
buff->putLong(2345678123LL);
assert(buff->getPosition()==16);
assert(buff->getRemaining()==16);
testOk1(buff->getPosition()==16);
testOk1(buff->getRemaining()==16);
float testFloat = 34.67;
buff->putFloat(testFloat);
assert(buff->getPosition()==20);
assert(buff->getRemaining()==12);
testOk1(buff->getPosition()==20);
testOk1(buff->getRemaining()==12);
double testDouble = -512.23974;
buff->putDouble(testDouble);
assert(buff->getPosition()==28);
assert(buff->getRemaining()==4);
testOk1(buff->getPosition()==28);
testOk1(buff->getRemaining()==4);
// testing direct reads
assert(buff->getBoolean(0)==true);
assert(buff->getByte(1)==-12);
assert(buff->getShort(2)==10516);
assert(buff->getInt(4)==0x1937628B);
assert(buff->getLong(8)==2345678123LL);
assert(buff->getFloat(16)==testFloat);
assert(buff->getDouble(20)==testDouble);
testOk1(buff->getBoolean(0)==true);
testOk1(buff->getByte(1)==-12);
testOk1(buff->getShort(2)==10516);
testOk1(buff->getInt(4)==0x1937628B);
testOk1(buff->getLong(8)==2345678123LL);
testOk1(buff->getFloat(16)==testFloat);
testOk1(buff->getDouble(20)==testDouble);
/*
std::size_t sp = buff->getPosition();
buff->setPosition(0);
assert(buff->getBoolean()==true);
assert(buff->getByte()==-12);
assert(buff->getShort()==10516);
assert(buff->getInt()==0x1937628B);
assert(buff->getLong()==2345678123LL);
assert(buff->getFloat()==testFloat);
assert(buff->getDouble()==testDouble);
testOk1(buff->getBoolean()==true);
testOk1(buff->getByte()==-12);
testOk1(buff->getShort()==10516);
testOk1(buff->getInt()==0x1937628B);
testOk1(buff->getLong()==2345678123LL);
testOk1(buff->getFloat()==testFloat);
testOk1(buff->getDouble()==testDouble);
buff->setPosition(sp);
*/
buff->flip();
assert(buff->getLimit()==28);
assert(buff->getPosition()==0);
assert(buff->getRemaining()==28);
testOk1(buff->getLimit()==28);
testOk1(buff->getPosition()==0);
testOk1(buff->getRemaining()==28);
assert(buff->getBoolean()==true);
assert(buff->getPosition()==1);
testOk1(buff->getBoolean()==true);
testOk1(buff->getPosition()==1);
assert(buff->getByte()==-12);
assert(buff->getPosition()==2);
testOk1(buff->getByte()==-12);
testOk1(buff->getPosition()==2);
assert(buff->getShort()==10516);
assert(buff->getPosition()==4);
testOk1(buff->getShort()==10516);
testOk1(buff->getPosition()==4);
assert(buff->getInt()==0x1937628B);
assert(buff->getPosition()==8);
testOk1(buff->getInt()==0x1937628B);
testOk1(buff->getPosition()==8);
assert(buff->getLong()==2345678123LL);
assert(buff->getPosition()==16);
testOk1(buff->getLong()==2345678123LL);
testOk1(buff->getPosition()==16);
assert(buff->getFloat()==testFloat);
assert(buff->getPosition()==20);
testOk1(buff->getFloat()==testFloat);
testOk1(buff->getPosition()==20);
assert(buff->getDouble()==testDouble);
assert(buff->getPosition()==28);
testOk1(buff->getDouble()==testDouble);
testOk1(buff->getPosition()==28);
buff->clear();
assert(buff->getPosition()==0);
assert(buff->getLimit()==32);
assert(buff->getRemaining()==32);
testOk1(buff->getPosition()==0);
testOk1(buff->getLimit()==32);
testOk1(buff->getRemaining()==32);
buff->setPosition(4);
assert(buff->getPosition()==4);
assert(buff->getLimit()==32);
assert(buff->getRemaining()==(32-4));
testOk1(buff->getPosition()==4);
testOk1(buff->getLimit()==32);
testOk1(buff->getRemaining()==(32-4));
buff->setPosition(13);
assert(buff->getPosition()==13);
assert(buff->getLimit()==32);
assert(buff->getRemaining()==(32-13));
testOk1(buff->getPosition()==13);
testOk1(buff->getLimit()==32);
testOk1(buff->getRemaining()==(32-13));
// testing absolute puts
buff->clear();
@@ -148,35 +148,35 @@ void testBasicOperations(std::ostream& ofile) {
buff->setPosition(sp);
*/
buff->flip();
assert(buff->getLimit()==28);
assert(buff->getPosition()==0);
assert(buff->getRemaining()==28);
testOk1(buff->getLimit()==28);
testOk1(buff->getPosition()==0);
testOk1(buff->getRemaining()==28);
assert(buff->getBoolean()==true);
assert(buff->getPosition()==1);
testOk1(buff->getBoolean()==true);
testOk1(buff->getPosition()==1);
assert(buff->getByte()==-12);
assert(buff->getPosition()==2);
testOk1(buff->getByte()==-12);
testOk1(buff->getPosition()==2);
assert(buff->getShort()==10516);
assert(buff->getPosition()==4);
testOk1(buff->getShort()==10516);
testOk1(buff->getPosition()==4);
assert(buff->getInt()==0x1937628B);
assert(buff->getPosition()==8);
testOk1(buff->getInt()==0x1937628B);
testOk1(buff->getPosition()==8);
assert(buff->getLong()==2345678123LL);
assert(buff->getPosition()==16);
testOk1(buff->getLong()==2345678123LL);
testOk1(buff->getPosition()==16);
assert(buff->getFloat()==testFloat);
assert(buff->getPosition()==20);
testOk1(buff->getFloat()==testFloat);
testOk1(buff->getPosition()==20);
assert(buff->getDouble()==testDouble);
assert(buff->getPosition()==28);
testOk1(buff->getDouble()==testDouble);
testOk1(buff->getPosition()==28);
buff->clear();
assert(buff->getPosition()==0);
assert(buff->getLimit()==32);
assert(buff->getRemaining()==32);
testOk1(buff->getPosition()==0);
testOk1(buff->getLimit()==32);
testOk1(buff->getRemaining()==32);
char src[] = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
'm' };
@@ -184,28 +184,26 @@ void testBasicOperations(std::ostream& ofile) {
' ' };
buff->put(src, 2, 6);
assert(buff->getPosition()==6);
assert(strncmp(buff->getArray(),&src[2],6)==0);
testOk1(buff->getPosition()==6);
testOk1(strncmp(buff->getArray(),&src[2],6)==0);
buff->flip();
assert(buff->getLimit()==6);
assert(buff->getPosition()==0);
assert(buff->getRemaining()==6);
testOk1(buff->getLimit()==6);
testOk1(buff->getPosition()==0);
testOk1(buff->getRemaining()==6);
buff->get(dst, 2, 6);
assert(buff->getLimit()==6);
assert(buff->getPosition()==6);
assert(strncmp(&src[2],&dst[2],6)==0);
testOk1(buff->getLimit()==6);
testOk1(buff->getPosition()==6);
testOk1(strncmp(&src[2],&dst[2],6)==0);
ofile<<" First 10 characters of destination: >>"<<String(dst, 10)<<"<<\n";
cout<<" First 10 characters of destination: >>"<<String(dst, 10)<<"<<\n";
delete buff;
ofile<<"!!! PASSED\n";
}
void testInverseEndianness(std::ostream& ofile) {
ofile<<"Testing inverse endianness...\n";
void testInverseEndianness() {
#if EPICS_BYTE_ORDER==EPICS_ENDIAN_BIG
ByteBuffer* buff = new ByteBuffer(32,EPICS_ENDIAN_LITTLE);
@@ -220,30 +218,21 @@ void testInverseEndianness(std::ostream& ofile) {
buff->putShort(0x0102);
buff->putInt(0x0A0B0C0D);
assert(strncmp(buff->getArray(),refBuffer,6)==0);
testOk1(strncmp(buff->getArray(),refBuffer,6)==0);
buff->flip();
assert(buff->getShort()==0x0102);
assert(buff->getInt()==0x0A0B0C0D);
testOk1(buff->getShort()==0x0102);
testOk1(buff->getInt()==0x0A0B0C0D);
delete buff;
ofile<<"!!! PASSED\n";
}
int main(int argc, char *argv[]) {
std::ofstream outfile;
std::ostream *out=NULL;
if(argc>1) {
outfile.open(argv[1]);
if(outfile.is_open()){
out=&outfile;
}else{
fprintf(stderr, "Failed to open test output file\n");
}
}
if(!out) out=&std::cout;
testBasicOperations(*out);
testInverseEndianness(*out);
return (0);
MAIN(testByteBuffer)
{
testPlan(82);
testDiag("Tests byteBuffer");
testBasicOperations();
testInverseEndianness();
return testDone();
}
testApp/misc/testMessageQueue.cpp
+25 -34
View File
@@ -16,8 +16,8 @@
#include <string>
#include <cstdio>
#include <epicsAssert.h>
#include <epicsExit.h>
#include <epicsUnitTest.h>
#include <testMain.h>
#include <pv/lock.h>
#include <pv/timeStamp.h>
@@ -28,7 +28,7 @@
using namespace epics::pvData;
static void testBasic(FILE * fd,FILE *auxfd) {
static void testBasic() {
int queueSize = 3;
StringArray messages;
messages.reserve(5);
@@ -41,53 +41,44 @@ static void testBasic(FILE * fd,FILE *auxfd) {
bool result;
MessageNodePtr messageNode;
result = queue->isEmpty();
assert(result);
testOk1(result);
result = queue->put(messages[0],infoMessage,true);
assert(result);
testOk1(result);
result = queue->put(messages[1],infoMessage,true);
assert(result);
testOk1(result);
result = queue->put(messages[2],warningMessage,true);
assert(result);
assert(queue->isFull());
testOk1(result);
testOk1(queue->isFull());
result = queue->put(messages[3],infoMessage,true);
assert(result==true);
testOk1(result==true);
messageNode = queue->get();
assert(messageNode.get()!=NULL);
fprintf(fd,"message %s messageType %s\n",
testOk1(messageNode.get()!=NULL);
printf("message %s messageType %s\n",
messageNode->getMessage().c_str(),
getMessageTypeName(messageNode->getMessageType()).c_str());
assert(messageNode->getMessage().compare(messages[0])==0);
testOk1(messageNode->getMessage().compare(messages[0])==0);
queue->release();
messageNode = queue->get();
assert(messageNode.get()!=NULL);
assert(messageNode->getMessage().compare(messages[1])==0);
testOk1(messageNode.get()!=NULL);
testOk1(messageNode->getMessage().compare(messages[1])==0);
queue->release();
messageNode = queue->get();
assert(messageNode.get()!=NULL);
fprintf(fd,"message %s messageType %s\n",
testOk1(messageNode.get()!=NULL);
printf("message %s messageType %s\n",
messageNode->getMessage().c_str(),
getMessageTypeName(messageNode->getMessageType()).c_str());
assert(messageNode->getMessage().compare(messages[3])==0);
testOk1(messageNode->getMessage().compare(messages[3])==0);
queue->release();
result = queue->isEmpty();
assert(result);
fprintf(fd,"PASSED\n");
testOk1(result);
printf("PASSED\n");
}
int main(int argc, char *argv[]) {
char *fileName = 0;
if(argc>1) fileName = argv[1];
FILE * fd = stdout;
if(fileName!=0 && fileName[0]!=0) {
fd = fopen(fileName,"w+");
}
char *auxFileName = 0;
if(argc>2) auxFileName = argv[2];
FILE *auxfd = stdout;
if(auxFileName!=0 && auxFileName[0]!=0) {
auxfd = fopen(auxFileName,"w+");
}
testBasic(fd,auxfd);
return (0);
MAIN(testMessageQueue)
{
testPlan(13);
testDiag("Tests messageQueue");
testBasic();
return testDone();
}
testApp/misc/testQueue.cpp
+21 -31
View File
@@ -16,8 +16,9 @@
#include <string>
#include <cstdio>
#include <epicsAssert.h>
#include <epicsExit.h>
#include <epicsUnitTest.h>
#include <testMain.h>
#include <epicsThread.h>
#include <pv/lock.h>
@@ -44,15 +45,14 @@ typedef std::tr1::shared_ptr<Sink> SinkPtr;
class Sink : public epicsThreadRunable {
public:
static SinkPtr create(DataQueue &queue,FILE *auxfd);
Sink(DataQueue &queue,FILE *auxfd);
static SinkPtr create(DataQueue &queue);
Sink(DataQueue &queue);
~Sink();
void stop();
void look();
virtual void run();
private:
DataQueue &queue;
FILE *auxfd;
bool isStopped;
Event *wait;
Event *stopped;
@@ -61,14 +61,13 @@ private:
epicsThread *thread;
};
SinkPtr Sink::create(DataQueue &queue,FILE *auxfd)
SinkPtr Sink::create(DataQueue &queue)
{
return SinkPtr(new Sink(queue,auxfd));
return SinkPtr(new Sink(queue));
}
Sink::Sink(DataQueue &queue,FILE *auxfd)
Sink::Sink(DataQueue &queue)
: queue(queue),
auxfd(auxfd),
isStopped(false),
wait(new Event()),
stopped(new Event()),
@@ -111,14 +110,14 @@ void Sink::run()
waitEmpty->signal();
break;
}
fprintf(auxfd," sink a %d b %d\n",data->a,data->b);
printf(" sink a %d b %d\n",data->a,data->b);
queue.releaseUsed(data);
}
}
stopped->signal();
}
static void testBasic(FILE * fd,FILE *auxfd ) {
static void testBasic() {
DataPtrArray dataArray;
dataArray.reserve(numElements);
for(int i=0; i<numElements; i++) {
@@ -134,42 +133,33 @@ static void testBasic(FILE * fd,FILE *auxfd ) {
queue.setUsed(data);
data = queue.getFree();
}
SinkPtr sink = SinkPtr(new Sink(queue,auxfd));
SinkPtr sink = SinkPtr(new Sink(queue));
queue.clear();
while(true) {
data = queue.getFree();
if(data.get()==NULL) break;
fprintf(auxfd,"source a %d b %d\n",data->a,data->b);
printf("source a %d b %d\n",data->a,data->b);
queue.setUsed(data);
}
sink->look();
// now alternate
for(int i=0; i<numElements; i++) {
data = queue.getFree();
assert(data.get()!=NULL);
fprintf(auxfd,"source a %d b %d\n",data->a,data->b);
testOk1(data.get()!=NULL);
printf("source a %d b %d\n",data->a,data->b);
queue.setUsed(data);
sink->look();
}
sink->stop();
fprintf(fd,"PASSED\n");
printf("PASSED\n");
}
int main(int argc, char *argv[]) {
char *fileName = 0;
if(argc>1) fileName = argv[1];
FILE * fd = stdout;
if(fileName!=0 && fileName[0]!=0) {
fd = fopen(fileName,"w+");
}
char *auxFileName = 0;
if(argc>2) auxFileName = argv[2];
FILE *auxfd = stdout;
if(auxFileName!=0 && auxFileName[0]!=0) {
auxfd = fopen(auxFileName,"w+");
}
testBasic(fd,auxfd);
return (0);
MAIN(testQueue)
{
testPlan(5);
testDiag("Tests queue");
testBasic();
return testDone();
}
testApp/misc/testThread.cpp
+27 -33
View File
@@ -17,8 +17,9 @@
#include <cstdio>
#include <list>
#include <epicsAssert.h>
#include <epicsExit.h>
#include <epicsUnitTest.h>
#include <testMain.h>
#include <pv/event.h>
#include <pv/thread.h>
@@ -38,28 +39,29 @@ public:
FILE *out;
bool actuallyRan;
Event begin, end;
Action(FILE* fp): out(fp), actuallyRan(false) {}
Action(): actuallyRan(false) {}
virtual void run() {
fprintf(out, "Action waiting\n");
printf("Action waiting\n");
begin.signal();
bool waited=end.wait();
actuallyRan=true;
fprintf(out, "Action %s\n", waited?"true":"false");
printf("Action %s\n", waited?"true":"false");
}
};
static void testThreadRun(FILE *fd) {
static void testThreadRun() {
// show that we can control thread start and stop
ActionPtr ax(new Action(fd));
ActionPtr ax(new Action());
{
ThreadPtr tr(new Thread(actionName,lowPriority,ax.get()));
bool w=ax->begin.wait();
fprintf(fd, "main %s\n", w?"true":"false");
fprintf(fd, "Action is %s\n", ax->actuallyRan?"true":"false");
printf( "main %s\n", w?"true":"false");
printf( "Action is %s\n", ax->actuallyRan?"true":"false");
ax->end.signal();
}
fprintf(fd, "Action is %s\n", ax->actuallyRan?"true":"false");
fprintf(fd,"testThreadRun PASSED\n");
testOk1(ax->actuallyRan==true);
printf( "Action is %s\n", ax->actuallyRan?"true":"false");
printf("testThreadRun PASSED\n");
}
class Basic;
@@ -80,6 +82,7 @@ public:
{
executor->execute(getPtrSelf());
bool result = wait.wait();
testOk1(result==true);
if(result==false) printf("basic::run wait returned false\n");
}
virtual void command()
@@ -97,11 +100,11 @@ private:
typedef std::tr1::shared_ptr<Basic> BasicPtr;
static void testBasic(FILE *fd) {
static void testBasic() {
ExecutorPtr executor(new Executor(String("basic"),middlePriority));
BasicPtr basic( new Basic(executor));
basic->run();
fprintf(fd,"testBasic PASSED\n");
printf("testBasic PASSED\n");
}
class MyFunc : public TimeFunctionRequester {
@@ -126,35 +129,26 @@ typedef std::tr1::shared_ptr<MyFunc> MyFuncPtr;
#ifdef TESTTHREADCONTEXT
static void testThreadContext(FILE *fd,FILE *auxFd) {
static void testThreadContext() {
ExecutorPtr executor(new Executor(String("basic"),middlePriority));
BasicPtr basic(new Basic(executor));
MyFuncPtr myFunc(new MyFunc(basic));
TimeFunctionPtr timeFunction(new TimeFunction(myFunc));
double perCall = timeFunction->timeCall();
perCall *= 1e6;
fprintf(auxFd,"time per call %f microseconds\n",perCall);
fprintf(fd,"testThreadContext PASSED\n");
printf("time per call %f microseconds\n",perCall);
printf("testThreadContext PASSED\n");
}
#endif
int main(int argc, char *argv[]) {
char *fileName = 0;
if(argc>1) fileName = argv[1];
FILE * fd = stdout;
if(fileName!=0 && fileName[0]!=0) {
fd = fopen(fileName,"w+");
}
testThreadRun(fd);
testBasic(fd);
MAIN(testThread)
{
testPlan(2);
testDiag("Tests thread");
testThreadRun();
testBasic();
#ifdef TESTTHREADCONTEXT
char *auxFileName = 0;
if(argc>2) auxFileName = argv[2];
FILE *auxFd = stdout;
if(auxFileName!=0 && auxFileName[0]!=0) {
auxFd = fopen(auxFileName,"w+");
}
testThreadContext(fd,auxFd);
testThreadContext();
#endif
return 0;
return testDone();
}
testApp/misc/testTimeStamp.cpp
+57 -65
View File
@@ -19,7 +19,8 @@
#include <ctime>
#include <list>
#include <epicsAssert.h>
#include <epicsUnitTest.h>
#include <testMain.h>
#include <pv/timeStamp.h>
@@ -27,12 +28,12 @@ using namespace epics::pvData;
static bool debug = false;
void testTimeStamp(FILE *fd,FILE *auxfd)
void testTimeStamp()
{
assert(nanoSecPerSec==1000000000);
testOk1(nanoSecPerSec==1000000000);
TimeStamp current;
current.getCurrent();
fprintf(auxfd,"current %lli %i milliSec %lli\n",
printf("current %lli %i milliSec %lli\n",
(long long)current.getSecondsPastEpoch(),
current.getNanoSeconds(),
(long long)current.getMilliseconds());
@@ -40,7 +41,7 @@ void testTimeStamp(FILE *fd,FILE *auxfd)
current.toTime_t(tt);
struct tm ctm;
memcpy(&ctm,localtime(&tt),sizeof(struct tm));
fprintf(auxfd,
printf(
"%4.4d.%2.2d.%2.2d %2.2d:%2.2d:%2.2d %d isDst %s\n",
ctm.tm_year+1900,ctm.tm_mon + 1,ctm.tm_mday,
ctm.tm_hour,ctm.tm_min,ctm.tm_sec,
@@ -48,13 +49,13 @@ void testTimeStamp(FILE *fd,FILE *auxfd)
(ctm.tm_isdst==0) ? "false" : "true");
tt = time(&tt);
current.fromTime_t(tt);
fprintf(auxfd,"fromTime_t\ncurrent %lli %i milliSec %lli\n",
printf("fromTime_t\ncurrent %lli %i milliSec %lli\n",
(long long)current.getSecondsPastEpoch(),
current.getNanoSeconds(),
(long long)current.getMilliseconds());
current.toTime_t(tt);
memcpy(&ctm,localtime(&tt),sizeof(struct tm));
fprintf(auxfd,
printf(
"%4.4d.%2.2d.%2.2d %2.2d:%2.2d:%2.2d %d isDst %s\n",
ctm.tm_year+1900,ctm.tm_mon + 1,ctm.tm_mday,
ctm.tm_hour,ctm.tm_min,ctm.tm_sec,
@@ -66,79 +67,70 @@ void testTimeStamp(FILE *fd,FILE *auxfd)
left.put(current.getSecondsPastEpoch(),current.getNanoSeconds());
double diff;
diff = TimeStamp::diff(left,right);
if(debug) fprintf(fd,"diff %e\n",diff);
assert(diff==0.0);
assert((left==right));
assert(!(left!=right));
assert((left<=right));
assert(!(left<right));
assert((left>=right));
assert(!(left>right));
if(debug) printf("diff %e\n",diff);
testOk1(diff==0.0);
testOk1((left==right));
testOk1(!(left!=right));
testOk1((left<=right));
testOk1(!(left<right));
testOk1((left>=right));
testOk1(!(left>right));
left.put(current.getSecondsPastEpoch()+1,current.getNanoSeconds());
diff = TimeStamp::diff(left,right);
if(debug) fprintf(fd,"diff %e\n",diff);
assert(diff==1.0);
assert(!(left==right));
assert((left!=right));
assert(!(left<=right));
assert(!(left<right));
assert((left>=right));
assert((left>right));
if(debug) printf("diff %e\n",diff);
testOk1(diff==1.0);
testOk1(!(left==right));
testOk1((left!=right));
testOk1(!(left<=right));
testOk1(!(left<right));
testOk1((left>=right));
testOk1((left>right));
left.put(current.getSecondsPastEpoch()-1,current.getNanoSeconds());
diff = TimeStamp::diff(left,right);
if(debug) fprintf(fd,"diff %e\n",diff);
assert(diff==-1.0);
assert(!(left==right));
assert((left!=right));
assert((left<=right));
assert((left<right));
assert(!(left>=right));
assert(!(left>right));
if(debug) printf("diff %e\n",diff);
testOk1(diff==-1.0);
testOk1(!(left==right));
testOk1((left!=right));
testOk1((left<=right));
testOk1((left<right));
testOk1(!(left>=right));
testOk1(!(left>right));
left.put(current.getSecondsPastEpoch(),current.getNanoSeconds()-nanoSecPerSec);
diff = TimeStamp::diff(left,right);
if(debug) fprintf(fd,"diff %e\n",diff);
assert(diff==-1.0);
assert(!(left==right));
assert((left!=right));
assert((left<=right));
assert((left<right));
assert(!(left>=right));
assert(!(left>right));
if(debug) printf("diff %e\n",diff);
testOk1(diff==-1.0);
testOk1(!(left==right));
testOk1((left!=right));
testOk1((left<=right));
testOk1((left<right));
testOk1(!(left>=right));
testOk1(!(left>right));
left.put(current.getSecondsPastEpoch(),current.getNanoSeconds()-1);
diff = TimeStamp::diff(left,right);
if(debug) fprintf(fd,"diff %e\n",diff);
assert(diff<0.0);
assert(!(left==right));
assert((left!=right));
assert((left<=right));
assert((left<right));
assert(!(left>=right));
assert(!(left>right));
if(debug) printf("diff %e\n",diff);
testOk1(diff<0.0);
testOk1(!(left==right));
testOk1((left!=right));
testOk1((left<=right));
testOk1((left<right));
testOk1(!(left>=right));
testOk1(!(left>right));
left.put(current.getSecondsPastEpoch(),current.getNanoSeconds());
left += .1;
diff = TimeStamp::diff(left,right);
if(debug) fprintf(fd,"diff %e\n",diff);
if(debug) printf("diff %e\n",diff);
left.put(current.getSecondsPastEpoch(),current.getNanoSeconds());
int64 inc = -1;
left += inc;
diff = TimeStamp::diff(left,right);
assert(diff==-1.0);
fprintf(fd,"PASSED\n");
testOk1(diff==-1.0);
printf("PASSED\n");
}
int main(int argc, char *argv[]) {
char *fileName = 0;
if(argc>1) fileName = argv[1];
FILE * fd = stdout;
if(fileName!=0 && fileName[0]!=0) {
fd = fopen(fileName,"w+");
}
char *auxFileName = 0;
if(argc>2) auxFileName = argv[2];
FILE *auxfd = stdout;
if(auxFileName!=0 && auxFileName[0]!=0) {
auxfd = fopen(auxFileName,"w+");
}
testTimeStamp(fd,auxfd);
return (0);
MAIN(testTimeStamp)
{
testPlan(37);
testDiag("Tests timeStamp");
testTimeStamp();
return testDone();
}
testApp/misc/testTimer.cpp
+54 -66
View File
@@ -16,8 +16,9 @@
#include <string>
#include <cstdio>
#include <epicsAssert.h>
#include <epicsExit.h>
#include <epicsUnitTest.h>
#include <testMain.h>
#include <pv/timeStamp.h>
#include <pv/event.h>
#include <pv/timer.h>
@@ -38,10 +39,8 @@ typedef std::tr1::shared_ptr<MyCallback> MyCallbackPtr;
class MyCallback : public TimerCallback {
public:
POINTER_DEFINITIONS(MyCallback);
MyCallback(String name,FILE *fd,FILE *auxfd,EventPtr const & wait)
MyCallback(String name,EventPtr const & wait)
: name(name),
fd(fd),
auxfd(auxfd),
wait(wait)
{
}
@@ -55,18 +54,16 @@ public:
}
virtual void timerStopped()
{
fprintf(fd,"timerStopped %s\n",name.c_str());
printf("timerStopped %s\n",name.c_str());
}
TimeStamp &getTimeStamp() { return timeStamp;}
private:
String name;
FILE *fd;
FILE *auxfd;
EventPtr wait;
TimeStamp timeStamp;
};
static void testBasic(FILE *fd, FILE *auxfd)
static void testBasic()
{
if(debug) {
printf("\n\ntestBasic oneDelay %lf twoDelay %lf threeDaley %lf\n",
@@ -79,20 +76,20 @@ static void testBasic(FILE *fd, FILE *auxfd)
EventPtr eventTwo(new Event());
EventPtr eventThree(new Event());
TimerPtr timer(new Timer(String("timer"),middlePriority));
MyCallbackPtr callbackOne(new MyCallback(one,fd,auxfd,eventOne));
MyCallbackPtr callbackTwo(new MyCallback(two,fd,auxfd,eventTwo));
MyCallbackPtr callbackThree(new MyCallback(three,fd,auxfd,eventThree));
MyCallbackPtr callbackOne(new MyCallback(one,eventOne));
MyCallbackPtr callbackTwo(new MyCallback(two,eventTwo));
MyCallbackPtr callbackThree(new MyCallback(three,eventThree));
for(int n=0; n<ntimes; n++) {
currentTimeStamp.getCurrent();
assert(!timer->isScheduled(callbackOne));
assert(!timer->isScheduled(callbackTwo));
assert(!timer->isScheduled(callbackThree));
testOk1(!timer->isScheduled(callbackOne));
testOk1(!timer->isScheduled(callbackTwo));
testOk1(!timer->isScheduled(callbackThree));
timer->scheduleAfterDelay(callbackOne,oneDelay);
timer->scheduleAfterDelay(callbackTwo,twoDelay);
timer->scheduleAfterDelay(callbackThree,threeDelay);
if(oneDelay>.1) assert(timer->isScheduled(callbackOne));
if(twoDelay>.1) assert(timer->isScheduled(callbackTwo));
if(threeDelay>.1) assert(timer->isScheduled(callbackThree));
if(oneDelay>.1) testOk1(timer->isScheduled(callbackOne));
if(twoDelay>.1) testOk1(timer->isScheduled(callbackTwo));
if(threeDelay>.1) testOk1(timer->isScheduled(callbackThree));
if(debug) {
String builder;
timer->toString(&builder);
@@ -107,34 +104,34 @@ static void testBasic(FILE *fd, FILE *auxfd)
callbackOne->getTimeStamp(),currentTimeStamp);
delta = diff - oneDelay;
if(debug) {
fprintf(auxfd,"one requested %f actual %f delta %f\n",
printf("one requested %f actual %f delta %f\n",
oneDelay,diff,delta);
}
if(delta<0.0) delta = -delta;
assert(delta<.1);
testOk1(delta<.1);
diff = TimeStamp::diff(
callbackTwo->getTimeStamp(),currentTimeStamp);
delta = diff - twoDelay;
if(debug) {
fprintf(auxfd,"two requested %f actual %f delta %f\n",
printf("two requested %f actual %f delta %f\n",
twoDelay,diff,delta);
}
if(delta<0.0) delta = -delta;
assert(delta<.1);
testOk1(delta<.1);
diff = TimeStamp::diff(
callbackThree->getTimeStamp(),currentTimeStamp);
delta = diff - threeDelay;
if(debug) {
fprintf(auxfd,"three requested %f actual %f delta %f\n",
printf("three requested %f actual %f delta %f\n",
threeDelay,diff,delta);
}
if(delta<0.0) delta = -delta;
assert(delta<.1);
testOk1(delta<.1);
}
fprintf(fd,"testBasic PASSED\n");
printf("testBasic PASSED\n");
}
static void testCancel(FILE *fd, FILE *auxfd)
static void testCancel()
{
if(debug) {
printf("\n\ntestCancel oneDelay %lf twoDelay %lf threeDaley %lf\n",
@@ -147,21 +144,21 @@ static void testCancel(FILE *fd, FILE *auxfd)
EventPtr eventTwo(new Event());
EventPtr eventThree(new Event());
TimerPtr timer(new Timer(String("timer"),middlePriority));
MyCallbackPtr callbackOne(new MyCallback(one,fd,auxfd,eventOne));
MyCallbackPtr callbackTwo(new MyCallback(two,fd,auxfd,eventTwo));
MyCallbackPtr callbackThree(new MyCallback(three,fd,auxfd,eventThree));
MyCallbackPtr callbackOne(new MyCallback(one,eventOne));
MyCallbackPtr callbackTwo(new MyCallback(two,eventTwo));
MyCallbackPtr callbackThree(new MyCallback(three,eventThree));
for(int n=0; n<ntimes; n++) {
currentTimeStamp.getCurrent();
assert(!timer->isScheduled(callbackOne));
assert(!timer->isScheduled(callbackTwo));
assert(!timer->isScheduled(callbackThree));
testOk1(!timer->isScheduled(callbackOne));
testOk1(!timer->isScheduled(callbackTwo));
testOk1(!timer->isScheduled(callbackThree));
timer->scheduleAfterDelay(callbackOne,oneDelay);
timer->scheduleAfterDelay(callbackTwo,twoDelay);
timer->scheduleAfterDelay(callbackThree,threeDelay);
timer->cancel(callbackTwo);
if(oneDelay>.1) assert(timer->isScheduled(callbackOne));
assert(!timer->isScheduled(callbackTwo));
if(threeDelay>.1) assert(timer->isScheduled(callbackThree));
if(oneDelay>.1) testOk1(timer->isScheduled(callbackOne));
testOk1(!timer->isScheduled(callbackTwo));
if(threeDelay>.1) testOk1(timer->isScheduled(callbackThree));
if(debug) {
String builder;
timer->toString(&builder);
@@ -175,64 +172,55 @@ static void testCancel(FILE *fd, FILE *auxfd)
callbackOne->getTimeStamp(),currentTimeStamp);
delta = diff - oneDelay;
if(debug) {
fprintf(auxfd,"one requested %f actual %f delta %f\n",
printf("one requested %f actual %f delta %f\n",
oneDelay,diff,delta);
}
if(delta<0.0) delta = -delta;
assert(delta<.1);
testOk1(delta<.1);
diff = TimeStamp::diff(
callbackThree->getTimeStamp(),currentTimeStamp);
delta = diff - threeDelay;
if(debug) {
fprintf(auxfd,"three requested %f actual %f delta %f\n",
printf("three requested %f actual %f delta %f\n",
threeDelay,diff,delta);
}
if(delta<0.0) delta = -delta;
assert(delta<.1);
testOk1(delta<.1);
}
fprintf(fd,"testCancel PASSED\n");
printf("testCancel PASSED\n");
}
int main(int argc, char *argv[]) {
char *fileName = 0;
if(argc>1) fileName = argv[1];
FILE * fd = stdout;
if(fileName!=0 && fileName[0]!=0) {
fd = fopen(fileName,"w+");
}
char *auxFileName = 0;
if(argc>2) auxFileName = argv[2];
FILE *auxfd = stdout;
if(auxFileName!=0 && auxFileName[0]!=0) {
auxfd = fopen(auxFileName,"w+");
}
MAIN(testTimer)
{
testPlan(171);
testDiag("Tests timer");
oneDelay = .4;
twoDelay = .2;
threeDelay = .1;
fprintf(fd,"oneDelay %f twoDelay %f threeDelay %f\n",
printf("oneDelay %f twoDelay %f threeDelay %f\n",
oneDelay,twoDelay,threeDelay);
testBasic(fd,auxfd);
testCancel(fd,auxfd);
testBasic();
testCancel();
oneDelay = .1;
twoDelay = .2;
threeDelay = .4;
fprintf(fd,"oneDelay %f twoDelay %f threeDelay %f\n",
printf("oneDelay %f twoDelay %f threeDelay %f\n",
oneDelay,twoDelay,threeDelay);
testBasic(fd,auxfd);
testCancel(fd,auxfd);
testBasic();
testCancel();
oneDelay = .1;
twoDelay = .4;
threeDelay = .2;
fprintf(fd,"oneDelay %f twoDelay %f threeDelay %f\n",
printf("oneDelay %f twoDelay %f threeDelay %f\n",
oneDelay,twoDelay,threeDelay);
testBasic(fd,auxfd);
testCancel(fd,auxfd);
testBasic();
testCancel();
oneDelay = .0;
twoDelay = .0;
threeDelay = .0;
fprintf(fd,"oneDelay %f twoDelay %f threeDelay %f\n",
printf("oneDelay %f twoDelay %f threeDelay %f\n",
oneDelay,twoDelay,threeDelay);
testBasic(fd,auxfd);
testCancel(fd,auxfd);
return (0);
testBasic();
testCancel();
return testDone();
}
testApp/misc/testTypeCast.cpp
-1
View File
@@ -14,7 +14,6 @@
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <assert.h>
#include <stdio.h>
#include <float.h>
#include <epicsMath.h>