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

make tests more like regresion tests

Browse Source
This commit is contained in:
Marty Kraimer
2012-08-17 14:13:18 -04:00
parent 66fb300873
commit fbfed5bab1
18 changed files with 695 additions and 398 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
documentation/pvDataCPP.html
View File

@@ -38,7 +38,7 @@
<h1>EPICS pvDataCPP</h1>
<!-- Maturity: Working Draft or Request for Comments, or Recommendation, and date. -->
<h2 class="nocount">EPICS v4 Working Group, Working Draft, 15-Aug-2012</h2>
<h2 class="nocount">EPICS v4 Working Group, Working Draft, 17-Aug-2012</h2>
<dl>
<dt>This version:</dt>
<dd><a
@@ -83,7 +83,7 @@ Control System.</a></p>
<h2 class="nocount">Status of this Document</h2>
<p>This is the 15-Aug-2012 version of the C++ implementation of pvData. It is a
<p>This is the 17-Aug-2012 version of the C++ implementation of pvData. It is a
complete implementation of pvData as currently defined. </p>
<h2 class="nocount">TODO</h2>
@@ -100,6 +100,8 @@ complete implementation of pvData as currently defined. </p>
2) create an example that makes it;s data available in chunks.</dd>
<dt>pvType Example</dt>
<dd>Create an example of how to use the array typedefs</dd>
<dt>Convert test</dt>
<dd>How can this be better tested?</dd>
</dl>
<div id="toc">

8
testApp/misc/testMessageQueue.cpp
View File

@@ -54,24 +54,26 @@ static void testBasic(FILE * fd,FILE *auxfd ) {
result = queue->put(messages[3],infoMessage,true);
assert(result==true);
messageNode = queue->get();
assert(messageNode.get()!=0);
assert(messageNode.get()!=NULL);
fprintf(fd,"message %s messageType %s\n",
messageNode->getMessage().c_str(),
getMessageTypeName(messageNode->getMessageType()).c_str());
assert(messageNode->getMessage().compare(messages[0])==0);
queue->release();
messageNode = queue->get();
assert(messageNode.get()!=0);
assert(messageNode.get()!=NULL);
assert(messageNode->getMessage().compare(messages[1])==0);
queue->release();
messageNode = queue->get();
assert(messageNode.get()!=0);
assert(messageNode.get()!=NULL);
fprintf(fd,"message %s messageType %s\n",
messageNode->getMessage().c_str(),
getMessageTypeName(messageNode->getMessageType()).c_str());
assert(messageNode->getMessage().compare(messages[3])==0);
queue->release();
result = queue->isEmpty();
assert(result);
fprintf(fd,"PASSED\n");
}
int main(int argc, char *argv[]) {

1
testApp/misc/testQueue.cpp
View File

@@ -152,6 +152,7 @@ static void testBasic(FILE * fd,FILE *auxfd ) {
sink->look();
}
sink->stop();
fprintf(fd,"PASSED\n");
}

3
testApp/misc/testThread.cpp
View File

@@ -53,6 +53,7 @@ static void testThreadRun(FILE *fd) {
ax.end.signal();
}
fprintf(fd, "Action is %s\n", ax.actuallyRan?"true":"false");
fprintf(fd,"testThreadRun PASSED\n");
}
class Basic :
@@ -101,6 +102,7 @@ static void testBasic(FILE *fd) {
ExecutorPtr executor( new Executor(String("basic"),middlePriority));
BasicPtr basic( new Basic(executor));
basic->run();
fprintf(fd,"testBasic PASSED\n");
}
class MyFunc : public TimeFunctionRequester {
@@ -131,6 +133,7 @@ static void testThreadContext(FILE *fd,FILE *auxFd) {
double perCall = timeFunction->timeCall();
perCall *= 1e6;
fprintf(auxFd,"time per call %f microseconds\n",perCall);
fprintf(fd,"testThreadContext PASSED\n");
}
int main(int argc, char *argv[]) {

20
testApp/misc/testTimeStamp.cpp
View File

@@ -25,6 +25,8 @@
using namespace epics::pvData;
static bool debug = false;
void testTimeStamp(FILE *fd,FILE *auxfd)
{
assert(nanoSecPerSec==1000000000);
@@ -39,7 +41,7 @@ void testTimeStamp(FILE *fd,FILE *auxfd)
struct tm ctm;
memcpy(&ctm,localtime(&tt),sizeof(struct tm));
fprintf(auxfd,
"%4.4d.%2.2d.%2.2d %2.2d:%2.2d:%2.2d %d nanoSeconds isDst %s\n",
"%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,
current.getNanoSeconds(),
@@ -53,7 +55,7 @@ void testTimeStamp(FILE *fd,FILE *auxfd)
current.toTime_t(tt);
memcpy(&ctm,localtime(&tt),sizeof(struct tm));
fprintf(auxfd,
"%4.4d.%2.2d.%2.2d %2.2d:%2.2d:%2.2d %d nanoSeconds isDst %s\n",
"%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,
current.getNanoSeconds(),
@@ -64,7 +66,7 @@ void testTimeStamp(FILE *fd,FILE *auxfd)
left.put(current.getSecondsPastEpoch(),current.getNanoSeconds());
double diff;
diff = TimeStamp::diff(left,right);
fprintf(fd,"diff %e\n",diff);
if(debug) fprintf(fd,"diff %e\n",diff);
assert(diff==0.0);
assert((left==right));
assert(!(left!=right));
@@ -74,7 +76,8 @@ void testTimeStamp(FILE *fd,FILE *auxfd)
assert(!(left>right));
left.put(current.getSecondsPastEpoch()+1,current.getNanoSeconds());
diff = TimeStamp::diff(left,right);
fprintf(fd,"diff %e\n",diff);
if(debug) fprintf(fd,"diff %e\n",diff);
assert(diff==1.0);
assert(!(left==right));
assert((left!=right));
assert(!(left<=right));
@@ -83,7 +86,7 @@ void testTimeStamp(FILE *fd,FILE *auxfd)
assert((left>right));
left.put(current.getSecondsPastEpoch()-1,current.getNanoSeconds());
diff = TimeStamp::diff(left,right);
fprintf(fd,"diff %e\n",diff);
if(debug) fprintf(fd,"diff %e\n",diff);
assert(diff==-1.0);
assert(!(left==right));
assert((left!=right));
@@ -93,7 +96,7 @@ void testTimeStamp(FILE *fd,FILE *auxfd)
assert(!(left>right));
left.put(current.getSecondsPastEpoch(),current.getNanoSeconds()-nanoSecPerSec);
diff = TimeStamp::diff(left,right);
fprintf(fd,"diff %e\n",diff);
if(debug) fprintf(fd,"diff %e\n",diff);
assert(diff==-1.0);
assert(!(left==right));
assert((left!=right));
@@ -103,7 +106,7 @@ void testTimeStamp(FILE *fd,FILE *auxfd)
assert(!(left>right));
left.put(current.getSecondsPastEpoch(),current.getNanoSeconds()-1);
diff = TimeStamp::diff(left,right);
fprintf(fd,"diff %e\n",diff);
if(debug) fprintf(fd,"diff %e\n",diff);
assert(diff<0.0);
assert(!(left==right));
assert((left!=right));
@@ -114,12 +117,13 @@ void testTimeStamp(FILE *fd,FILE *auxfd)
left.put(current.getSecondsPastEpoch(),current.getNanoSeconds());
left += .1;
diff = TimeStamp::diff(left,right);
fprintf(fd,"diff %e\n",diff);
if(debug) fprintf(fd,"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");
}
int main(int argc, char *argv[]) {

65
testApp/misc/testTimer.cpp
View File

@@ -30,6 +30,7 @@ static double oneDelay = 4.0;
static double twoDelay = 2.0;
static double threeDelay = 1.0;
static int ntimes = 3;
static bool debug = false;
class MyCallback;
typedef std::tr1::shared_ptr<MyCallback> MyCallbackPtr;
@@ -67,8 +68,10 @@ private:
static void testBasic(FILE *fd, FILE *auxfd)
{
printf("\n\ntestBasic oneDelay %lf twoDelay %lf threeDaley %lf\n",
oneDelay,twoDelay,threeDelay);
if(debug) {
printf("\n\ntestBasic oneDelay %lf twoDelay %lf threeDaley %lf\n",
oneDelay,twoDelay,threeDelay);
}
String one("one");
String two("two");
String three("three");
@@ -90,9 +93,11 @@ oneDelay,twoDelay,threeDelay);
if(oneDelay>.1) assert(timer->isScheduled(callbackOne));
if(twoDelay>.1) assert(timer->isScheduled(callbackTwo));
if(threeDelay>.1) assert(timer->isScheduled(callbackThree));
String builder;
timer->toString(&builder);
printf("timerQueue\n%s",builder.c_str());
if(debug) {
String builder;
timer->toString(&builder);
printf("timerQueue\n%s",builder.c_str());
}
eventOne->wait();
eventTwo->wait();
eventThree->wait();
@@ -101,28 +106,40 @@ oneDelay,twoDelay,threeDelay);
diff = TimeStamp::diff(
callbackOne->getTimeStamp(),currentTimeStamp);
delta = diff - oneDelay;
fprintf(auxfd,"one requested %f actual %f delta %f\n",oneDelay,diff,delta);
if(debug) {
fprintf(auxfd,"one requested %f actual %f delta %f\n",
oneDelay,diff,delta);
}
if(delta<0.0) delta = -delta;
assert(delta<.1);
diff = TimeStamp::diff(
callbackTwo->getTimeStamp(),currentTimeStamp);
delta = diff - twoDelay;
fprintf(auxfd,"two requested %f actual %f delta %f\n",twoDelay,diff,delta);
if(debug) {
fprintf(auxfd,"two requested %f actual %f delta %f\n",
twoDelay,diff,delta);
}
if(delta<0.0) delta = -delta;
assert(delta<.1);
diff = TimeStamp::diff(
callbackThree->getTimeStamp(),currentTimeStamp);
delta = diff - threeDelay;
fprintf(auxfd,"three requested %f actual %f delta %f\n",threeDelay,diff,delta);
if(debug) {
fprintf(auxfd,"three requested %f actual %f delta %f\n",
threeDelay,diff,delta);
}
if(delta<0.0) delta = -delta;
assert(delta<.1);
}
fprintf(fd,"testBasic PASSED\n");
}
static void testCancel(FILE *fd, FILE *auxfd)
{
printf("\n\ntestCancel oneDelay %lf twoDelay %lf threeDaley %lf\n",
oneDelay,twoDelay,threeDelay);
if(debug) {
printf("\n\ntestCancel oneDelay %lf twoDelay %lf threeDaley %lf\n",
oneDelay,twoDelay,threeDelay);
}
String one("one");
String two("two");
String three("three");
@@ -145,9 +162,11 @@ oneDelay,twoDelay,threeDelay);
if(oneDelay>.1) assert(timer->isScheduled(callbackOne));
assert(!timer->isScheduled(callbackTwo));
if(threeDelay>.1) assert(timer->isScheduled(callbackThree));
String builder;
timer->toString(&builder);
printf("timerQueue\n%s",builder.c_str());
if(debug) {
String builder;
timer->toString(&builder);
printf("timerQueue\n%s",builder.c_str());
}
eventOne->wait();
eventThree->wait();
double diff;
@@ -155,16 +174,23 @@ oneDelay,twoDelay,threeDelay);
diff = TimeStamp::diff(
callbackOne->getTimeStamp(),currentTimeStamp);
delta = diff - oneDelay;
fprintf(auxfd,"one requested %f actual %f delta %f\n",oneDelay,diff,delta);
if(debug) {
fprintf(auxfd,"one requested %f actual %f delta %f\n",
oneDelay,diff,delta);
}
if(delta<0.0) delta = -delta;
assert(delta<.1);
diff = TimeStamp::diff(
callbackThree->getTimeStamp(),currentTimeStamp);
delta = diff - threeDelay;
fprintf(auxfd,"three requested %f actual %f delta %f\n",threeDelay,diff,delta);
if(debug) {
fprintf(auxfd,"three requested %f actual %f delta %f\n",
threeDelay,diff,delta);
}
if(delta<0.0) delta = -delta;
assert(delta<.1);
}
fprintf(fd,"testCancel PASSED\n");
}
int main(int argc, char *argv[]) {
@@ -183,23 +209,30 @@ int main(int argc, char *argv[]) {
oneDelay = .4;
twoDelay = .2;
threeDelay = .1;
fprintf(fd,"oneDelay %f twoDelay %f threeDelay %f\n",
oneDelay,twoDelay,threeDelay);
testBasic(fd,auxfd);
testCancel(fd,auxfd);
oneDelay = .1;
twoDelay = .2;
threeDelay = .4;
fprintf(fd,"oneDelay %f twoDelay %f threeDelay %f\n",
oneDelay,twoDelay,threeDelay);
testBasic(fd,auxfd);
testCancel(fd,auxfd);
oneDelay = .1;
twoDelay = .4;
threeDelay = .2;
fprintf(fd,"oneDelay %f twoDelay %f threeDelay %f\n",
oneDelay,twoDelay,threeDelay);
testBasic(fd,auxfd);
testCancel(fd,auxfd);
oneDelay = .0;
twoDelay = .0;
threeDelay = .0;
fprintf(fd,"oneDelay %f twoDelay %f threeDelay %f\n",
oneDelay,twoDelay,threeDelay);
testBasic(fd,auxfd);
testCancel(fd,auxfd);
epicsExitCallAtExits();
return (0);
}

1
testApp/monitor/testMonitor.cpp
View File

@@ -66,6 +66,7 @@ static void testMonitor()
MonitorElementPtr monitorElement = monitor->poll();
monitor->release(monitorElement);
monitor->stop();
printf("PASSED\n");
}

71
testApp/property/testProperty.cpp
View File

@@ -34,6 +34,8 @@
using namespace epics::pvData;
static bool debug = false;
static FieldCreatePtr fieldCreate;
static PVDataCreatePtr pvDataCreate;
static StandardFieldPtr standardField;
@@ -49,9 +51,11 @@ static PVStructurePtr enumeratedRecord;
static void createRecords(FILE * fd,FILE *auxfd)
{
doubleRecord = standardPVField->scalar(pvDouble,allProperties);
builder.clear();
doubleRecord->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
if(debug) {
builder.clear();
doubleRecord->toString(&builder);
fprintf(fd,"doubleRecord\n%s\n",builder.c_str());
}
StringArray choices;
choices.reserve(4);
choices.push_back("1");
@@ -59,9 +63,11 @@ static void createRecords(FILE * fd,FILE *auxfd)
choices.push_back("3");
choices.push_back("4");
enumeratedRecord = standardPVField->enumerated(choices,alarmTimeStamp);
builder.clear();
enumeratedRecord->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
if(debug) {
builder.clear();
enumeratedRecord->toString(&builder);
fprintf(fd,"enumeratedRecord\n%s\n",builder.c_str());
}
}
static void printRecords(FILE * fd,FILE *auxfd)
@@ -78,7 +84,7 @@ static void printRecords(FILE * fd,FILE *auxfd)
static void testAlarm(FILE * fd,FILE *auxfd)
{
fprintf(fd,"testAlarm\n");
if(debug) fprintf(fd,"testAlarm\n");
Alarm alarm;
PVAlarm pvAlarm;
bool result;
@@ -102,12 +108,16 @@ static void testAlarm(FILE * fd,FILE *auxfd)
String message = alarm.getMessage();
String severity = AlarmSeverityFunc::getSeverityNames()[alarm.getSeverity()];
String status = AlarmStatusFunc::getStatusNames()[alarm.getStatus()];
fprintf(fd," message %s severity %s status %s\n",message.c_str(),severity.c_str(),status.c_str());
if(debug) {
fprintf(fd," message %s severity %s status %s\n",
message.c_str(),severity.c_str(),status.c_str());
}
fprintf(fd,"testAlarm PASSED\n");
}
static void testTimeStamp(FILE * fd,FILE *auxfd)
{
fprintf(fd,"testTimeStamp\n");
if(debug) fprintf(fd,"testTimeStamp\n");
TimeStamp timeStamp;
PVTimeStamp pvTimeStamp;
bool result;
@@ -131,20 +141,23 @@ static void testTimeStamp(FILE * fd,FILE *auxfd)
timeStamp.toTime_t(tt);
struct tm ctm;
memcpy(&ctm,localtime(&tt),sizeof(struct tm));
fprintf(auxfd,
"%4.4d.%2.2d.%2.2d %2.2d:%2.2d:%2.2d %d nanoSeconds isDst %s userTag %d\n",
ctm.tm_year+1900,ctm.tm_mon + 1,ctm.tm_mday,
ctm.tm_hour,ctm.tm_min,ctm.tm_sec,
timeStamp.getNanoSeconds(),
(ctm.tm_isdst==0) ? "false" : "true",
timeStamp.getUserTag());
if(debug) {
fprintf(auxfd,
"%4.4d.%2.2d.%2.2d %2.2d:%2.2d:%2.2d %d nanoSeconds isDst %s userTag %d\n",
ctm.tm_year+1900,ctm.tm_mon + 1,ctm.tm_mday,
ctm.tm_hour,ctm.tm_min,ctm.tm_sec,
timeStamp.getNanoSeconds(),
(ctm.tm_isdst==0) ? "false" : "true",
timeStamp.getUserTag());
}
timeStamp.put(0,0);
pvTimeStamp.set(timeStamp);
fprintf(fd,"testTimeStamp PASSED\n");
}
static void testControl(FILE * fd,FILE *auxfd)
{
fprintf(fd,"testControl\n");
if(debug) fprintf(fd,"testControl\n");
Control control;
PVControl pvControl;
bool result;
@@ -165,12 +178,13 @@ static void testControl(FILE * fd,FILE *auxfd)
assert(cl.getHigh()==control.getHigh());
double low = control.getLow();
double high = control.getHigh();
fprintf(fd," low %f high %f\n",low,high);
if(debug) fprintf(fd," low %f high %f\n",low,high);
fprintf(fd,"testControl PASSED\n");
}
static void testDisplay(FILE * fd,FILE *auxfd)
{
fprintf(fd,"testDisplay\n");
if(debug) fprintf(fd,"testDisplay\n");
Display display;
PVDisplay pvDisplay;
bool result;
@@ -197,12 +211,13 @@ static void testDisplay(FILE * fd,FILE *auxfd)
assert(dy.getUnits().compare(display.getUnits())==0);
double low = display.getLow();
double high = display.getHigh();
fprintf(fd," low %f high %f\n",low,high);
if(debug) fprintf(fd," low %f high %f\n",low,high);
fprintf(fd,"testDisplay PASSED\n");
}
static void testEnumerated(FILE * fd,FILE *auxfd)
{
fprintf(fd,"testEnumerated\n");
if(debug) fprintf(fd,"testEnumerated\n");
PVEnumerated pvEnumerated;
bool result;
PVFieldPtr pvField = enumeratedRecord->getSubField(String("value"));
@@ -216,13 +231,16 @@ static void testEnumerated(FILE * fd,FILE *auxfd)
String choice = pvEnumerated.getChoice();
StringArray choices = pvEnumerated.getChoices();
int32 numChoices = pvEnumerated.getNumberChoices();
fprintf(fd,"index %d choice %s choices",index,choice.c_str());
for(int i=0; i<numChoices; i++ ) fprintf(fd," %s",choices[i].c_str());
fprintf(fd,"\n");
if(debug) {
fprintf(fd,"index %d choice %s choices",index,choice.c_str());
for(int i=0; i<numChoices; i++ ) fprintf(fd," %s",choices[i].c_str());
fprintf(fd,"\n");
}
pvEnumerated.setIndex(2);
index = pvEnumerated.getIndex();
choice = pvEnumerated.getChoice();
fprintf(fd,"index %d choice %s\n",index,choice.c_str());
if(debug) fprintf(fd,"index %d choice %s\n",index,choice.c_str());
fprintf(fd,"testEnumerated PASSED\n");
}
int main(int argc,char *argv[])
@@ -250,7 +268,8 @@ int main(int argc,char *argv[])
testControl(fd,auxfd);
testDisplay(fd,auxfd);
testEnumerated(fd,auxfd);
printRecords(fd,auxfd);
if(debug) printRecords(fd,auxfd);
fprintf(fd,"ALL PASSED\n");
return(0);
}

598
testApp/pv/testConvert.cpp
View File

@@ -25,6 +25,8 @@
using namespace epics::pvData;
using std::tr1::static_pointer_cast;
static bool debug = false;
static FieldCreatePtr fieldCreate;
static PVDataCreatePtr pvDataCreate;
static StandardFieldPtr standardField;
@@ -44,262 +46,350 @@ static void testConvertScalar(FILE *fd) {
PVScalarPtr pvFloatPtr = pvDataCreate->createPVScalar(pvFloat);
PVScalarPtr pvDoublePtr = pvDataCreate->createPVScalar(pvDouble);
fprintf(fd,"\nfromByte\n");
fprintf(fd,"testConvertScalar\n");
if(debug) fprintf(fd,"\nfromByte\n");
int8 bval = 127;
for(int i=0; i<3; i++) {
convert->fromByte(pvBytePtr, bval);
builder.clear(); pvBytePtr->toString(&builder); fprintf(fd,"byte %s\n",builder.c_str());
builder.clear(); pvBytePtr->toString(&builder);
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
convert->fromByte(pvUBytePtr, bval);
builder.clear(); pvUBytePtr->toString(&builder); fprintf(fd,"ubyte %s\n",builder.c_str());
builder.clear(); pvUBytePtr->toString(&builder);
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
convert->fromByte(pvShortPtr, bval);
builder.clear(); pvShortPtr->toString(&builder); fprintf(fd,"short %s\n",builder.c_str());
builder.clear(); pvShortPtr->toString(&builder);
if(debug) fprintf(fd,"short %s\n",builder.c_str());
convert->fromByte(pvUShortPtr, bval);
builder.clear(); pvUShortPtr->toString(&builder); fprintf(fd,"ushort %s\n",builder.c_str());
builder.clear(); pvUShortPtr->toString(&builder);
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
convert->fromByte(pvIntPtr, bval);
builder.clear(); pvIntPtr->toString(&builder); fprintf(fd,"int %s\n",builder.c_str());
builder.clear(); pvIntPtr->toString(&builder);
if(debug) fprintf(fd,"int %s\n",builder.c_str());
convert->fromByte(pvUIntPtr, bval);
builder.clear(); pvUIntPtr->toString(&builder); fprintf(fd,"uint %s\n",builder.c_str());
builder.clear(); pvUIntPtr->toString(&builder);
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
convert->fromByte(pvLongPtr, bval);
builder.clear(); pvLongPtr->toString(&builder); fprintf(fd,"long %s\n",builder.c_str());
builder.clear(); pvLongPtr->toString(&builder);
if(debug) fprintf(fd,"long %s\n",builder.c_str());
convert->fromByte(pvULongPtr, bval);
builder.clear(); pvULongPtr->toString(&builder); fprintf(fd,"ulong %s\n",builder.c_str());
builder.clear(); pvULongPtr->toString(&builder);
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
convert->fromByte(pvFloatPtr, bval);
builder.clear(); pvFloatPtr->toString(&builder); fprintf(fd,"float %s\n",builder.c_str());
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float %s\n",builder.c_str());
convert->fromByte(pvDoublePtr, bval);
builder.clear(); pvDoublePtr->toString(&builder); fprintf(fd,"double %s\n",builder.c_str());
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalar(pvUBytePtr, pvFloatPtr);
builder.clear(); pvFloatPtr->toString(&builder);
fprintf(fd,"float from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalar(pvUBytePtr, pvDoublePtr);
builder.clear(); pvDoublePtr->toString(&builder);
fprintf(fd,"double from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
bval++;
}
fprintf(fd,"fromByte PASSED\n");
fprintf(fd,"\nfromShort\n");
if(debug) fprintf(fd,"\nfromShort\n");
int16 sval = 0x7fff;
for(int i=0; i<3; i++) {
convert->fromShort(pvBytePtr, sval);
builder.clear(); pvBytePtr->toString(&builder); fprintf(fd,"byte %s\n",builder.c_str());
builder.clear(); pvBytePtr->toString(&builder);
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
convert->fromShort(pvUBytePtr, sval);
builder.clear(); pvUBytePtr->toString(&builder); fprintf(fd,"ubyte %s\n",builder.c_str());
builder.clear(); pvUBytePtr->toString(&builder);
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
convert->fromShort(pvShortPtr, sval);
builder.clear(); pvShortPtr->toString(&builder); fprintf(fd,"short %s\n",builder.c_str());
builder.clear(); pvShortPtr->toString(&builder);
if(debug) fprintf(fd,"short %s\n",builder.c_str());
convert->fromShort(pvUShortPtr, sval);
builder.clear(); pvUShortPtr->toString(&builder); fprintf(fd,"ushort %s\n",builder.c_str());
builder.clear(); pvUShortPtr->toString(&builder);
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
convert->fromShort(pvIntPtr, sval);
builder.clear(); pvIntPtr->toString(&builder); fprintf(fd,"int %s\n",builder.c_str());
builder.clear(); pvIntPtr->toString(&builder);
if(debug) fprintf(fd,"int %s\n",builder.c_str());
convert->fromShort(pvUIntPtr, sval);
builder.clear(); pvUIntPtr->toString(&builder); fprintf(fd,"uint %s\n",builder.c_str());
builder.clear(); pvUIntPtr->toString(&builder);
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
convert->fromShort(pvLongPtr, sval);
builder.clear(); pvLongPtr->toString(&builder); fprintf(fd,"long %s\n",builder.c_str());
builder.clear(); pvLongPtr->toString(&builder);
if(debug) fprintf(fd,"long %s\n",builder.c_str());
convert->fromShort(pvULongPtr, sval);
builder.clear(); pvULongPtr->toString(&builder); fprintf(fd,"ulong %s\n",builder.c_str());
builder.clear(); pvULongPtr->toString(&builder);
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
convert->fromShort(pvFloatPtr, sval);
builder.clear(); pvFloatPtr->toString(&builder); fprintf(fd,"float %s\n",builder.c_str());
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float %s\n",builder.c_str());
convert->fromShort(pvDoublePtr, sval);
builder.clear(); pvDoublePtr->toString(&builder); fprintf(fd,"double %s\n",builder.c_str());
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalar(pvUShortPtr, pvFloatPtr);
builder.clear(); pvFloatPtr->toString(&builder);
fprintf(fd,"float from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalar(pvUShortPtr, pvDoublePtr);
builder.clear(); pvDoublePtr->toString(&builder);
fprintf(fd,"double from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
sval++;
}
fprintf(fd,"fromShort PASSED\n");
fprintf(fd,"\nfromInt\n");
if(debug) fprintf(fd,"\nfromInt\n");
int32 ival = 0x7fffffff;
for(int i=0; i<3; i++) {
convert->fromInt(pvBytePtr, ival);
builder.clear(); pvBytePtr->toString(&builder); fprintf(fd,"byte %s\n",builder.c_str());
builder.clear(); pvBytePtr->toString(&builder);
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
convert->fromInt(pvUBytePtr, ival);
builder.clear(); pvUBytePtr->toString(&builder); fprintf(fd,"ubyte %s\n",builder.c_str());
builder.clear(); pvUBytePtr->toString(&builder);
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
convert->fromInt(pvShortPtr, ival);
builder.clear(); pvShortPtr->toString(&builder); fprintf(fd,"short %s\n",builder.c_str());
builder.clear(); pvShortPtr->toString(&builder);
if(debug) fprintf(fd,"short %s\n",builder.c_str());
convert->fromInt(pvUShortPtr, ival);
builder.clear(); pvUShortPtr->toString(&builder); fprintf(fd,"ushort %s\n",builder.c_str());
builder.clear(); pvUShortPtr->toString(&builder);
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
convert->fromInt(pvIntPtr, ival);
builder.clear(); pvIntPtr->toString(&builder); fprintf(fd,"int %s\n",builder.c_str());
builder.clear(); pvIntPtr->toString(&builder);
if(debug) fprintf(fd,"int %s\n",builder.c_str());
convert->fromInt(pvUIntPtr, ival);
builder.clear(); pvUIntPtr->toString(&builder); fprintf(fd,"uint %s\n",builder.c_str());
builder.clear(); pvUIntPtr->toString(&builder);
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
convert->fromInt(pvLongPtr, ival);
builder.clear(); pvLongPtr->toString(&builder); fprintf(fd,"long %s\n",builder.c_str());
builder.clear(); pvLongPtr->toString(&builder);
if(debug) fprintf(fd,"long %s\n",builder.c_str());
convert->fromInt(pvULongPtr, ival);
builder.clear(); pvULongPtr->toString(&builder); fprintf(fd,"ulong %s\n",builder.c_str());
builder.clear(); pvULongPtr->toString(&builder);
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
convert->fromInt(pvFloatPtr, ival);
builder.clear(); pvFloatPtr->toString(&builder); fprintf(fd,"float %s\n",builder.c_str());
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float %s\n",builder.c_str());
convert->fromInt(pvDoublePtr, ival);
builder.clear(); pvDoublePtr->toString(&builder); fprintf(fd,"double %s\n",builder.c_str());
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalar(pvUIntPtr, pvFloatPtr);
builder.clear(); pvFloatPtr->toString(&builder);
fprintf(fd,"float from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalar(pvUIntPtr, pvDoublePtr);
builder.clear(); pvDoublePtr->toString(&builder);
fprintf(fd,"double from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
ival++;
}
fprintf(fd,"fromInt PASSED\n");
fprintf(fd,"\nfromLong\n");
if(debug) fprintf(fd,"\nfromLong\n");
int64 lval = 0x7fffffffffffffffL;
for(int i=0; i<3; i++) {
convert->fromLong(pvBytePtr, lval);
builder.clear(); pvBytePtr->toString(&builder); fprintf(fd,"byte %s\n",builder.c_str());
builder.clear(); pvBytePtr->toString(&builder);
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
convert->fromLong(pvUBytePtr, lval);
builder.clear(); pvUBytePtr->toString(&builder); fprintf(fd,"ubyte %s\n",builder.c_str());
builder.clear(); pvUBytePtr->toString(&builder);
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
convert->fromLong(pvShortPtr, lval);
builder.clear(); pvShortPtr->toString(&builder); fprintf(fd,"short %s\n",builder.c_str());
builder.clear(); pvShortPtr->toString(&builder);
if(debug) fprintf(fd,"short %s\n",builder.c_str());
convert->fromLong(pvUShortPtr, lval);
builder.clear(); pvUShortPtr->toString(&builder); fprintf(fd,"ushort %s\n",builder.c_str());
builder.clear(); pvUShortPtr->toString(&builder);
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
convert->fromLong(pvIntPtr, lval);
builder.clear(); pvIntPtr->toString(&builder); fprintf(fd,"int %s\n",builder.c_str());
builder.clear(); pvIntPtr->toString(&builder);
if(debug) fprintf(fd,"int %s\n",builder.c_str());
convert->fromLong(pvUIntPtr, lval);
builder.clear(); pvUIntPtr->toString(&builder); fprintf(fd,"uint %s\n",builder.c_str());
builder.clear(); pvUIntPtr->toString(&builder);
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
convert->fromLong(pvLongPtr, lval);
builder.clear(); pvLongPtr->toString(&builder); fprintf(fd,"long %s\n",builder.c_str());
builder.clear(); pvLongPtr->toString(&builder);
if(debug) fprintf(fd,"long %s\n",builder.c_str());
convert->fromLong(pvULongPtr, lval);
builder.clear(); pvULongPtr->toString(&builder); fprintf(fd,"ulong %s\n",builder.c_str());
builder.clear(); pvULongPtr->toString(&builder);
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
convert->fromLong(pvFloatPtr, lval);
builder.clear(); pvFloatPtr->toString(&builder); fprintf(fd,"float %s\n",builder.c_str());
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float %s\n",builder.c_str());
convert->fromLong(pvDoublePtr, lval);
builder.clear(); pvDoublePtr->toString(&builder); fprintf(fd,"double %s\n",builder.c_str());
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalar(pvULongPtr, pvFloatPtr);
builder.clear(); pvFloatPtr->toString(&builder);
fprintf(fd,"float from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalar(pvULongPtr, pvDoublePtr);
builder.clear(); pvDoublePtr->toString(&builder);
fprintf(fd,"double from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
lval++;
}
fprintf(fd,"fromLong PASSED\n");
fprintf(fd,"\nfromUByte\n");
if(debug) fprintf(fd,"\nfromUByte\n");
uint8 ubval = 127;
for(int i=0; i<3; i++) {
convert->fromUByte(pvBytePtr, ubval);
builder.clear(); pvBytePtr->toString(&builder); fprintf(fd,"byte %s\n",builder.c_str());
builder.clear(); pvBytePtr->toString(&builder);
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
convert->fromUByte(pvUBytePtr, ubval);
builder.clear(); pvUBytePtr->toString(&builder); fprintf(fd,"ubyte %s\n",builder.c_str());
builder.clear(); pvUBytePtr->toString(&builder);
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
convert->fromUByte(pvShortPtr, ubval);
builder.clear(); pvShortPtr->toString(&builder); fprintf(fd,"short %s\n",builder.c_str());
builder.clear(); pvShortPtr->toString(&builder);
if(debug) fprintf(fd,"short %s\n",builder.c_str());
convert->fromUByte(pvUShortPtr, ubval);
builder.clear(); pvUShortPtr->toString(&builder); fprintf(fd,"ushort %s\n",builder.c_str());
builder.clear(); pvUShortPtr->toString(&builder);
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
convert->fromUByte(pvIntPtr, ubval);
builder.clear(); pvIntPtr->toString(&builder); fprintf(fd,"int %s\n",builder.c_str());
builder.clear(); pvIntPtr->toString(&builder);
if(debug) fprintf(fd,"int %s\n",builder.c_str());
convert->fromUByte(pvUIntPtr, ubval);
builder.clear(); pvUIntPtr->toString(&builder); fprintf(fd,"uint %s\n",builder.c_str());
builder.clear(); pvUIntPtr->toString(&builder);
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
convert->fromUByte(pvLongPtr, ubval);
builder.clear(); pvLongPtr->toString(&builder); fprintf(fd,"long %s\n",builder.c_str());
builder.clear(); pvLongPtr->toString(&builder);
if(debug) fprintf(fd,"long %s\n",builder.c_str());
convert->fromUByte(pvULongPtr, ubval);
builder.clear(); pvULongPtr->toString(&builder); fprintf(fd,"ulong %s\n",builder.c_str());
builder.clear(); pvULongPtr->toString(&builder);
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
convert->fromUByte(pvFloatPtr, ubval);
builder.clear(); pvFloatPtr->toString(&builder); fprintf(fd,"float %s\n",builder.c_str());
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float %s\n",builder.c_str());
convert->fromUByte(pvDoublePtr, ubval);
builder.clear(); pvDoublePtr->toString(&builder); fprintf(fd,"double %s\n",builder.c_str());
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalar(pvUBytePtr, pvFloatPtr);
builder.clear(); pvFloatPtr->toString(&builder);
fprintf(fd,"float from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalar(pvUBytePtr, pvDoublePtr);
builder.clear(); pvDoublePtr->toString(&builder);
fprintf(fd,"double from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
ubval++;
}
fprintf(fd,"fromUByte PASSED\n");
fprintf(fd,"\nfromUShort\n");
if(debug) fprintf(fd,"\nfromUShort\n");
uint16 usval = 0x7fff;
for(int i=0; i<3; i++) {
convert->fromUShort(pvBytePtr, usval);
builder.clear(); pvBytePtr->toString(&builder); fprintf(fd,"byte %s\n",builder.c_str());
builder.clear(); pvBytePtr->toString(&builder);
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
convert->fromUShort(pvUBytePtr, usval);
builder.clear(); pvUBytePtr->toString(&builder); fprintf(fd,"ubyte %s\n",builder.c_str());
builder.clear(); pvUBytePtr->toString(&builder);
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
convert->fromUShort(pvShortPtr, usval);
builder.clear(); pvShortPtr->toString(&builder); fprintf(fd,"short %s\n",builder.c_str());
builder.clear(); pvShortPtr->toString(&builder);
if(debug) fprintf(fd,"short %s\n",builder.c_str());
convert->fromUShort(pvUShortPtr, usval);
builder.clear(); pvUShortPtr->toString(&builder); fprintf(fd,"ushort %s\n",builder.c_str());
builder.clear(); pvUShortPtr->toString(&builder);
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
convert->fromUShort(pvIntPtr, usval);
builder.clear(); pvIntPtr->toString(&builder); fprintf(fd,"int %s\n",builder.c_str());
builder.clear(); pvIntPtr->toString(&builder);
if(debug) fprintf(fd,"int %s\n",builder.c_str());
convert->fromUShort(pvUIntPtr, usval);
builder.clear(); pvUIntPtr->toString(&builder); fprintf(fd,"uint %s\n",builder.c_str());
builder.clear(); pvUIntPtr->toString(&builder);
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
convert->fromUShort(pvLongPtr, usval);
builder.clear(); pvLongPtr->toString(&builder); fprintf(fd,"long %s\n",builder.c_str());
builder.clear(); pvLongPtr->toString(&builder);
if(debug) fprintf(fd,"long %s\n",builder.c_str());
convert->fromUShort(pvULongPtr, usval);
builder.clear(); pvULongPtr->toString(&builder); fprintf(fd,"ulong %s\n",builder.c_str());
builder.clear(); pvULongPtr->toString(&builder);
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
convert->fromUShort(pvFloatPtr, usval);
builder.clear(); pvFloatPtr->toString(&builder); fprintf(fd,"float %s\n",builder.c_str());
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float %s\n",builder.c_str());
convert->fromUShort(pvDoublePtr, usval);
builder.clear(); pvDoublePtr->toString(&builder); fprintf(fd,"double %s\n",builder.c_str());
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalar(pvUShortPtr, pvFloatPtr);
builder.clear(); pvFloatPtr->toString(&builder);
fprintf(fd,"float from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalar(pvUShortPtr, pvDoublePtr);
builder.clear(); pvDoublePtr->toString(&builder);
fprintf(fd,"double from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
usval++;
}
fprintf(fd,"fromUShort PASSED\n");
fprintf(fd,"\nfromUInt\n");
if(debug) fprintf(fd,"\nfromUInt\n");
uint32 uival = 0x7fffffff;
for(int i=0; i<3; i++) {
convert->fromUInt(pvBytePtr, uival);
builder.clear(); pvBytePtr->toString(&builder); fprintf(fd,"byte %s\n",builder.c_str());
builder.clear(); pvBytePtr->toString(&builder);
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
convert->fromUInt(pvUBytePtr, uival);
builder.clear(); pvUBytePtr->toString(&builder); fprintf(fd,"ubyte %s\n",builder.c_str());
builder.clear(); pvUBytePtr->toString(&builder);
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
convert->fromUInt(pvShortPtr, uival);
builder.clear(); pvShortPtr->toString(&builder); fprintf(fd,"short %s\n",builder.c_str());
builder.clear(); pvShortPtr->toString(&builder);
if(debug) fprintf(fd,"short %s\n",builder.c_str());
convert->fromUInt(pvUShortPtr, uival);
builder.clear(); pvUShortPtr->toString(&builder); fprintf(fd,"ushort %s\n",builder.c_str());
builder.clear(); pvUShortPtr->toString(&builder);
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
convert->fromUInt(pvIntPtr, uival);
builder.clear(); pvIntPtr->toString(&builder); fprintf(fd,"int %s\n",builder.c_str());
builder.clear(); pvIntPtr->toString(&builder);
if(debug) fprintf(fd,"int %s\n",builder.c_str());
convert->fromUInt(pvUIntPtr, uival);
builder.clear(); pvUIntPtr->toString(&builder); fprintf(fd,"uint %s\n",builder.c_str());
builder.clear(); pvUIntPtr->toString(&builder);
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
convert->fromUInt(pvLongPtr, uival);
builder.clear(); pvLongPtr->toString(&builder); fprintf(fd,"long %s\n",builder.c_str());
builder.clear(); pvLongPtr->toString(&builder);
if(debug) fprintf(fd,"long %s\n",builder.c_str());
convert->fromUInt(pvULongPtr, uival);
builder.clear(); pvULongPtr->toString(&builder); fprintf(fd,"ulong %s\n",builder.c_str());
builder.clear(); pvULongPtr->toString(&builder);
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
convert->fromUInt(pvFloatPtr, uival);
builder.clear(); pvFloatPtr->toString(&builder); fprintf(fd,"float %s\n",builder.c_str());
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float %s\n",builder.c_str());
convert->fromUInt(pvDoublePtr, uival);
builder.clear(); pvDoublePtr->toString(&builder); fprintf(fd,"double %s\n",builder.c_str());
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalar(pvUIntPtr, pvFloatPtr);
builder.clear(); pvFloatPtr->toString(&builder);
fprintf(fd,"float from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalar(pvUIntPtr, pvDoublePtr);
builder.clear(); pvDoublePtr->toString(&builder);
fprintf(fd,"double from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
uival++;
}
fprintf(fd,"fromUInt PASSED\n");
fprintf(fd,"\nfromULong\n");
if(debug) fprintf(fd,"\nfromULong\n");
uint64 ulval = 0x7fffffffffffffffL;
for(int i=0; i<3; i++) {
convert->fromULong(pvBytePtr, ulval);
builder.clear(); pvBytePtr->toString(&builder); fprintf(fd,"byte %s\n",builder.c_str());
builder.clear(); pvBytePtr->toString(&builder);
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
convert->fromULong(pvUBytePtr, ulval);
builder.clear(); pvUBytePtr->toString(&builder); fprintf(fd,"ubyte %s\n",builder.c_str());
builder.clear(); pvUBytePtr->toString(&builder);
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
convert->fromULong(pvShortPtr, ulval);
builder.clear(); pvShortPtr->toString(&builder); fprintf(fd,"short %s\n",builder.c_str());
builder.clear(); pvShortPtr->toString(&builder);
if(debug) fprintf(fd,"short %s\n",builder.c_str());
convert->fromULong(pvUShortPtr, ulval);
builder.clear(); pvUShortPtr->toString(&builder); fprintf(fd,"ushort %s\n",builder.c_str());
builder.clear(); pvUShortPtr->toString(&builder);
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
convert->fromULong(pvIntPtr, ulval);
builder.clear(); pvIntPtr->toString(&builder); fprintf(fd,"int %s\n",builder.c_str());
builder.clear(); pvIntPtr->toString(&builder);
if(debug) fprintf(fd,"int %s\n",builder.c_str());
convert->fromULong(pvUIntPtr, ulval);
builder.clear(); pvUIntPtr->toString(&builder); fprintf(fd,"uint %s\n",builder.c_str());
builder.clear(); pvUIntPtr->toString(&builder);
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
convert->fromULong(pvLongPtr, ulval);
builder.clear(); pvLongPtr->toString(&builder); fprintf(fd,"long %s\n",builder.c_str());
builder.clear(); pvLongPtr->toString(&builder);
if(debug) fprintf(fd,"long %s\n",builder.c_str());
convert->fromULong(pvULongPtr, ulval);
builder.clear(); pvULongPtr->toString(&builder); fprintf(fd,"ulong %s\n",builder.c_str());
builder.clear(); pvULongPtr->toString(&builder);
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
convert->fromULong(pvFloatPtr, ulval);
builder.clear(); pvFloatPtr->toString(&builder); fprintf(fd,"float %s\n",builder.c_str());
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float %s\n",builder.c_str());
convert->fromULong(pvDoublePtr, ulval);
builder.clear(); pvDoublePtr->toString(&builder); fprintf(fd,"double %s\n",builder.c_str());
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalar(pvULongPtr, pvFloatPtr);
builder.clear(); pvFloatPtr->toString(&builder);
fprintf(fd,"float from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalar(pvULongPtr, pvDoublePtr);
builder.clear(); pvDoublePtr->toString(&builder);
fprintf(fd,"double from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
ulval++;
}
fprintf(fd,"fromULong PASSED\n");
}
static void testConvertScalarArray(FILE *fd) {
@@ -314,262 +404,351 @@ static void testConvertScalarArray(FILE *fd) {
PVScalarArrayPtr pvFloatPtr = pvDataCreate->createPVScalarArray(pvFloat);
PVScalarArrayPtr pvDoublePtr = pvDataCreate->createPVScalarArray(pvDouble);
fprintf(fd,"\nfromByte\n");
fprintf(fd,"testConvertScalarArray\n");
if(debug) fprintf(fd,"\nfromByte\n");
size_t length = 4;
int8 barray[length];
int8 bval = 127;
barray[0] = bval;
for(size_t i=1; i<length; i++) barray[i] = barray[i-1] + 1;
convert->fromByteArray(pvBytePtr,0,length,barray,0);
builder.clear(); pvBytePtr->toString(&builder); fprintf(fd,"byte %s\n",builder.c_str());
builder.clear(); pvBytePtr->toString(&builder);
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
convert->fromByteArray(pvUBytePtr,0,length,barray,0);
builder.clear(); pvUBytePtr->toString(&builder); fprintf(fd,"ubyte %s\n",builder.c_str());
builder.clear(); pvUBytePtr->toString(&builder);
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
convert->fromByteArray(pvShortPtr,0,length,barray,0);
builder.clear(); pvShortPtr->toString(&builder); fprintf(fd,"short %s\n",builder.c_str());
builder.clear(); pvShortPtr->toString(&builder);
if(debug) fprintf(fd,"short %s\n",builder.c_str());
convert->fromByteArray(pvUShortPtr,0,length,barray,0);
builder.clear(); pvUShortPtr->toString(&builder); fprintf(fd,"ushort %s\n",builder.c_str());
builder.clear(); pvUShortPtr->toString(&builder);
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
convert->fromByteArray(pvIntPtr,0,length,barray,0);
builder.clear(); pvIntPtr->toString(&builder); fprintf(fd,"int %s\n",builder.c_str());
builder.clear(); pvIntPtr->toString(&builder);
if(debug) fprintf(fd,"int %s\n",builder.c_str());
convert->fromByteArray(pvUIntPtr,0,length,barray,0);
builder.clear(); pvUIntPtr->toString(&builder); fprintf(fd,"uint %s\n",builder.c_str());
builder.clear(); pvUIntPtr->toString(&builder);
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
convert->fromByteArray(pvLongPtr,0,length,barray,0);
builder.clear(); pvLongPtr->toString(&builder); fprintf(fd,"long %s\n",builder.c_str());
builder.clear(); pvLongPtr->toString(&builder);
if(debug) fprintf(fd,"long %s\n",builder.c_str());
convert->fromByteArray(pvULongPtr,0,length,barray,0);
builder.clear(); pvULongPtr->toString(&builder); fprintf(fd,"ulong %s\n",builder.c_str());
builder.clear(); pvULongPtr->toString(&builder);
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
convert->fromByteArray(pvFloatPtr,0,length,barray,0);
builder.clear(); pvFloatPtr->toString(&builder); fprintf(fd,"float %s\n",builder.c_str());
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float %s\n",builder.c_str());
convert->fromByteArray(pvDoublePtr,0,length,barray,0);
builder.clear(); pvDoublePtr->toString(&builder); fprintf(fd,"double %s\n",builder.c_str());
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalarArray(pvUBytePtr,0, pvFloatPtr,0,length);
builder.clear(); pvFloatPtr->toString(&builder);
fprintf(fd,"float from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalarArray(pvUBytePtr,0, pvDoublePtr,0,length);
builder.clear(); pvDoublePtr->toString(&builder);
fprintf(fd,"double from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
fprintf(fd,"fromByte PASSED\n");
fprintf(fd,"\nfromShort\n");
if(debug) fprintf(fd,"\nfromShort\n");
int16 sarray[length];
int16 sval = 0x7fff;
sarray[0] = sval;
for(size_t i=1; i<length; i++) sarray[i] = sarray[i-1] + 1;
convert->fromShortArray(pvBytePtr,0,length,sarray,0);
builder.clear(); pvBytePtr->toString(&builder); fprintf(fd,"byte %s\n",builder.c_str());
builder.clear(); pvBytePtr->toString(&builder);
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
convert->fromShortArray(pvUBytePtr,0,length,sarray,0);
builder.clear(); pvUBytePtr->toString(&builder); fprintf(fd,"ubyte %s\n",builder.c_str());
builder.clear(); pvUBytePtr->toString(&builder);
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
convert->fromShortArray(pvShortPtr,0,length,sarray,0);
builder.clear(); pvShortPtr->toString(&builder); fprintf(fd,"short %s\n",builder.c_str());
builder.clear(); pvShortPtr->toString(&builder);
if(debug) fprintf(fd,"short %s\n",builder.c_str());
convert->fromShortArray(pvUShortPtr,0,length,sarray,0);
builder.clear(); pvUShortPtr->toString(&builder); fprintf(fd,"ushort %s\n",builder.c_str());
builder.clear(); pvUShortPtr->toString(&builder);
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
convert->fromShortArray(pvIntPtr,0,length,sarray,0);
builder.clear(); pvIntPtr->toString(&builder); fprintf(fd,"int %s\n",builder.c_str());
builder.clear(); pvIntPtr->toString(&builder);
if(debug) fprintf(fd,"int %s\n",builder.c_str());
convert->fromShortArray(pvUIntPtr,0,length,sarray,0);
builder.clear(); pvUIntPtr->toString(&builder); fprintf(fd,"uint %s\n",builder.c_str());
builder.clear(); pvUIntPtr->toString(&builder);
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
convert->fromShortArray(pvLongPtr,0,length,sarray,0);
builder.clear(); pvLongPtr->toString(&builder); fprintf(fd,"long %s\n",builder.c_str());
builder.clear(); pvLongPtr->toString(&builder);
if(debug) fprintf(fd,"long %s\n",builder.c_str());
convert->fromShortArray(pvULongPtr,0,length,sarray,0);
builder.clear(); pvULongPtr->toString(&builder); fprintf(fd,"ulong %s\n",builder.c_str());
builder.clear(); pvULongPtr->toString(&builder);
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
convert->fromShortArray(pvFloatPtr,0,length,sarray,0);
builder.clear(); pvFloatPtr->toString(&builder); fprintf(fd,"float %s\n",builder.c_str());
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float %s\n",builder.c_str());
convert->fromShortArray(pvDoublePtr,0,length,sarray,0);
builder.clear(); pvDoublePtr->toString(&builder); fprintf(fd,"double %s\n",builder.c_str());
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalarArray(pvUShortPtr,0, pvFloatPtr,0,length);
builder.clear(); pvFloatPtr->toString(&builder);
fprintf(fd,"float from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalarArray(pvUShortPtr,0, pvDoublePtr,0,length);
builder.clear(); pvDoublePtr->toString(&builder);
fprintf(fd,"double from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
fprintf(fd,"fromShort PASSED\n");
fprintf(fd,"\nfromInt\n");
if(debug) fprintf(fd,"\nfromInt\n");
int32 iarray[length];
int32 ival = 0x7fffffff;
iarray[0] = ival;
for(size_t i=1; i<length; i++) iarray[i] = iarray[i-1] + 1;
convert->fromIntArray(pvBytePtr,0,length,iarray,0);
builder.clear(); pvBytePtr->toString(&builder); fprintf(fd,"byte %s\n",builder.c_str());
builder.clear(); pvBytePtr->toString(&builder);
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
convert->fromIntArray(pvUBytePtr,0,length,iarray,0);
builder.clear(); pvUBytePtr->toString(&builder); fprintf(fd,"ubyte %s\n",builder.c_str());
builder.clear(); pvUBytePtr->toString(&builder);
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
convert->fromIntArray(pvShortPtr,0,length,iarray,0);
builder.clear(); pvShortPtr->toString(&builder); fprintf(fd,"short %s\n",builder.c_str());
builder.clear(); pvShortPtr->toString(&builder);
if(debug) fprintf(fd,"short %s\n",builder.c_str());
convert->fromIntArray(pvUShortPtr,0,length,iarray,0);
builder.clear(); pvUShortPtr->toString(&builder); fprintf(fd,"ushort %s\n",builder.c_str());
builder.clear(); pvUShortPtr->toString(&builder);
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
convert->fromIntArray(pvIntPtr,0,length,iarray,0);
builder.clear(); pvIntPtr->toString(&builder); fprintf(fd,"int %s\n",builder.c_str());
builder.clear(); pvIntPtr->toString(&builder);
if(debug) fprintf(fd,"int %s\n",builder.c_str());
convert->fromIntArray(pvUIntPtr,0,length,iarray,0);
builder.clear(); pvUIntPtr->toString(&builder); fprintf(fd,"uint %s\n",builder.c_str());
builder.clear(); pvUIntPtr->toString(&builder);
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
convert->fromIntArray(pvLongPtr,0,length,iarray,0);
builder.clear(); pvLongPtr->toString(&builder); fprintf(fd,"long %s\n",builder.c_str());
builder.clear(); pvLongPtr->toString(&builder);
if(debug) fprintf(fd,"long %s\n",builder.c_str());
convert->fromIntArray(pvULongPtr,0,length,iarray,0);
builder.clear(); pvULongPtr->toString(&builder); fprintf(fd,"ulong %s\n",builder.c_str());
builder.clear(); pvULongPtr->toString(&builder);
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
convert->fromIntArray(pvFloatPtr,0,length,iarray,0);
builder.clear(); pvFloatPtr->toString(&builder); fprintf(fd,"float %s\n",builder.c_str());
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float %s\n",builder.c_str());
convert->fromIntArray(pvDoublePtr,0,length,iarray,0);
builder.clear(); pvDoublePtr->toString(&builder); fprintf(fd,"double %s\n",builder.c_str());
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalarArray(pvUIntPtr,0, pvFloatPtr,0,length);
builder.clear(); pvFloatPtr->toString(&builder);
fprintf(fd,"float from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalarArray(pvUIntPtr,0, pvDoublePtr,0,length);
builder.clear(); pvDoublePtr->toString(&builder);
fprintf(fd,"double from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
fprintf(fd,"fromInt PASSED\n");
fprintf(fd,"\nfromLong\n");
if(debug) fprintf(fd,"\nfromLong\n");
int64 larray[length];
int64 lval = 0x7fffffffffffffff;
larray[0] = lval;
for(size_t i=1; i<length; i++) larray[i] = larray[i-1] + 1;
convert->fromLongArray(pvBytePtr,0,length,larray,0);
builder.clear(); pvBytePtr->toString(&builder); fprintf(fd,"byte %s\n",builder.c_str());
builder.clear(); pvBytePtr->toString(&builder);
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
convert->fromLongArray(pvUBytePtr,0,length,larray,0);
builder.clear(); pvUBytePtr->toString(&builder); fprintf(fd,"ubyte %s\n",builder.c_str());
builder.clear(); pvUBytePtr->toString(&builder);
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
convert->fromLongArray(pvShortPtr,0,length,larray,0);
builder.clear(); pvShortPtr->toString(&builder); fprintf(fd,"short %s\n",builder.c_str());
builder.clear(); pvShortPtr->toString(&builder);
if(debug) fprintf(fd,"short %s\n",builder.c_str());
convert->fromLongArray(pvUShortPtr,0,length,larray,0);
builder.clear(); pvUShortPtr->toString(&builder); fprintf(fd,"ushort %s\n",builder.c_str());
builder.clear(); pvUShortPtr->toString(&builder);
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
convert->fromLongArray(pvIntPtr,0,length,larray,0);
builder.clear(); pvIntPtr->toString(&builder); fprintf(fd,"int %s\n",builder.c_str());
builder.clear(); pvIntPtr->toString(&builder);
if(debug) fprintf(fd,"int %s\n",builder.c_str());
convert->fromLongArray(pvUIntPtr,0,length,larray,0);
builder.clear(); pvUIntPtr->toString(&builder); fprintf(fd,"uint %s\n",builder.c_str());
builder.clear(); pvUIntPtr->toString(&builder);
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
convert->fromLongArray(pvLongPtr,0,length,larray,0);
builder.clear(); pvLongPtr->toString(&builder); fprintf(fd,"long %s\n",builder.c_str());
builder.clear(); pvLongPtr->toString(&builder);
if(debug) fprintf(fd,"long %s\n",builder.c_str());
convert->fromLongArray(pvULongPtr,0,length,larray,0);
builder.clear(); pvULongPtr->toString(&builder); fprintf(fd,"ulong %s\n",builder.c_str());
builder.clear(); pvULongPtr->toString(&builder);
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
convert->fromLongArray(pvFloatPtr,0,length,larray,0);
builder.clear(); pvFloatPtr->toString(&builder); fprintf(fd,"float %s\n",builder.c_str());
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float %s\n",builder.c_str());
convert->fromLongArray(pvDoublePtr,0,length,larray,0);
builder.clear(); pvDoublePtr->toString(&builder); fprintf(fd,"double %s\n",builder.c_str());
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalarArray(pvULongPtr,0, pvFloatPtr,0,length);
builder.clear(); pvFloatPtr->toString(&builder);
fprintf(fd,"float from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalarArray(pvULongPtr,0, pvDoublePtr,0,length);
builder.clear(); pvDoublePtr->toString(&builder);
fprintf(fd,"double from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
fprintf(fd,"fromLong PASSED\n");
fprintf(fd,"\nfromUByte\n");
if(debug) fprintf(fd,"\nfromUByte\n");
uint8 ubarray[length];
uint8 ubval = 127;
ubarray[0] = ubval;
for(size_t i=1; i<length; i++) ubarray[i] = ubarray[i-1] + 1;
convert->fromUByteArray(pvBytePtr,0,length,ubarray,0);
builder.clear(); pvBytePtr->toString(&builder); fprintf(fd,"byte %s\n",builder.c_str());
builder.clear(); pvBytePtr->toString(&builder);
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
convert->fromUByteArray(pvUBytePtr,0,length,ubarray,0);
builder.clear(); pvUBytePtr->toString(&builder); fprintf(fd,"ubyte %s\n",builder.c_str());
builder.clear(); pvUBytePtr->toString(&builder);
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
convert->fromUByteArray(pvShortPtr,0,length,ubarray,0);
builder.clear(); pvShortPtr->toString(&builder); fprintf(fd,"short %s\n",builder.c_str());
builder.clear(); pvShortPtr->toString(&builder);
if(debug) fprintf(fd,"short %s\n",builder.c_str());
convert->fromUByteArray(pvUShortPtr,0,length,ubarray,0);
builder.clear(); pvUShortPtr->toString(&builder); fprintf(fd,"ushort %s\n",builder.c_str());
builder.clear(); pvUShortPtr->toString(&builder);
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
convert->fromUByteArray(pvIntPtr,0,length,ubarray,0);
builder.clear(); pvIntPtr->toString(&builder); fprintf(fd,"int %s\n",builder.c_str());
builder.clear(); pvIntPtr->toString(&builder);
if(debug) fprintf(fd,"int %s\n",builder.c_str());
convert->fromUByteArray(pvUIntPtr,0,length,ubarray,0);
builder.clear(); pvUIntPtr->toString(&builder); fprintf(fd,"uint %s\n",builder.c_str());
builder.clear(); pvUIntPtr->toString(&builder);
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
convert->fromUByteArray(pvLongPtr,0,length,ubarray,0);
builder.clear(); pvLongPtr->toString(&builder); fprintf(fd,"long %s\n",builder.c_str());
builder.clear(); pvLongPtr->toString(&builder);
if(debug) fprintf(fd,"long %s\n",builder.c_str());
convert->fromUByteArray(pvULongPtr,0,length,ubarray,0);
builder.clear(); pvULongPtr->toString(&builder); fprintf(fd,"ulong %s\n",builder.c_str());
builder.clear(); pvULongPtr->toString(&builder);
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
convert->fromUByteArray(pvFloatPtr,0,length,ubarray,0);
builder.clear(); pvFloatPtr->toString(&builder); fprintf(fd,"float %s\n",builder.c_str());
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float %s\n",builder.c_str());
convert->fromUByteArray(pvDoublePtr,0,length,ubarray,0);
builder.clear(); pvDoublePtr->toString(&builder); fprintf(fd,"double %s\n",builder.c_str());
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalarArray(pvUBytePtr,0, pvFloatPtr,0,length);
builder.clear(); pvFloatPtr->toString(&builder);
fprintf(fd,"float from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalarArray(pvUBytePtr,0, pvDoublePtr,0,length);
builder.clear(); pvDoublePtr->toString(&builder);
fprintf(fd,"double from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
fprintf(fd,"fromUByte PASSED\n");
fprintf(fd,"\nfromUShort\n");
if(debug) fprintf(fd,"\nfromUShort\n");
uint16 usarray[length];
uint16 usval = 0x7fff;
usarray[0] = usval;
for(size_t i=1; i<length; i++) usarray[i] = usarray[i-1] + 1;
convert->fromUShortArray(pvBytePtr,0,length,usarray,0);
builder.clear(); pvBytePtr->toString(&builder); fprintf(fd,"byte %s\n",builder.c_str());
builder.clear(); pvBytePtr->toString(&builder);
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
convert->fromUShortArray(pvUBytePtr,0,length,usarray,0);
builder.clear(); pvUBytePtr->toString(&builder); fprintf(fd,"ubyte %s\n",builder.c_str());
builder.clear(); pvUBytePtr->toString(&builder);
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
convert->fromUShortArray(pvShortPtr,0,length,usarray,0);
builder.clear(); pvShortPtr->toString(&builder); fprintf(fd,"short %s\n",builder.c_str());
builder.clear(); pvShortPtr->toString(&builder);
if(debug) fprintf(fd,"short %s\n",builder.c_str());
convert->fromUShortArray(pvUShortPtr,0,length,usarray,0);
builder.clear(); pvUShortPtr->toString(&builder); fprintf(fd,"ushort %s\n",builder.c_str());
builder.clear(); pvUShortPtr->toString(&builder);
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
convert->fromUShortArray(pvIntPtr,0,length,usarray,0);
builder.clear(); pvIntPtr->toString(&builder); fprintf(fd,"int %s\n",builder.c_str());
builder.clear(); pvIntPtr->toString(&builder);
if(debug) fprintf(fd,"int %s\n",builder.c_str());
convert->fromUShortArray(pvUIntPtr,0,length,usarray,0);
builder.clear(); pvUIntPtr->toString(&builder); fprintf(fd,"uint %s\n",builder.c_str());
builder.clear(); pvUIntPtr->toString(&builder);
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
convert->fromUShortArray(pvLongPtr,0,length,usarray,0);
builder.clear(); pvLongPtr->toString(&builder); fprintf(fd,"long %s\n",builder.c_str());
builder.clear(); pvLongPtr->toString(&builder);
if(debug) fprintf(fd,"long %s\n",builder.c_str());
convert->fromUShortArray(pvULongPtr,0,length,usarray,0);
builder.clear(); pvULongPtr->toString(&builder); fprintf(fd,"ulong %s\n",builder.c_str());
builder.clear(); pvULongPtr->toString(&builder);
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
convert->fromUShortArray(pvFloatPtr,0,length,usarray,0);
builder.clear(); pvFloatPtr->toString(&builder); fprintf(fd,"float %s\n",builder.c_str());
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float %s\n",builder.c_str());
convert->fromUShortArray(pvDoublePtr,0,length,usarray,0);
builder.clear(); pvDoublePtr->toString(&builder); fprintf(fd,"double %s\n",builder.c_str());
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalarArray(pvUShortPtr,0, pvFloatPtr,0,length);
builder.clear(); pvFloatPtr->toString(&builder);
fprintf(fd,"float from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalarArray(pvUShortPtr,0, pvDoublePtr,0,length);
builder.clear(); pvDoublePtr->toString(&builder);
fprintf(fd,"double from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
fprintf(fd,"fromUShort PASSED\n");
fprintf(fd,"\nfromUInt\n");
if(debug) fprintf(fd,"\nfromUInt\n");
uint32 uiarray[length];
uint32 uival = 0x7fffffff;
uiarray[0] = uival;
for(size_t i=1; i<length; i++) uiarray[i] = uiarray[i-1] + 1;
convert->fromUIntArray(pvBytePtr,0,length,uiarray,0);
builder.clear(); pvBytePtr->toString(&builder); fprintf(fd,"byte %s\n",builder.c_str());
builder.clear(); pvBytePtr->toString(&builder);
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
convert->fromUIntArray(pvUBytePtr,0,length,uiarray,0);
builder.clear(); pvUBytePtr->toString(&builder); fprintf(fd,"ubyte %s\n",builder.c_str());
builder.clear(); pvUBytePtr->toString(&builder);
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
convert->fromUIntArray(pvShortPtr,0,length,uiarray,0);
builder.clear(); pvShortPtr->toString(&builder); fprintf(fd,"short %s\n",builder.c_str());
builder.clear(); pvShortPtr->toString(&builder);
if(debug) fprintf(fd,"short %s\n",builder.c_str());
convert->fromUIntArray(pvUShortPtr,0,length,uiarray,0);
builder.clear(); pvUShortPtr->toString(&builder); fprintf(fd,"ushort %s\n",builder.c_str());
builder.clear(); pvUShortPtr->toString(&builder);
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
convert->fromUIntArray(pvIntPtr,0,length,uiarray,0);
builder.clear(); pvIntPtr->toString(&builder); fprintf(fd,"int %s\n",builder.c_str());
builder.clear(); pvIntPtr->toString(&builder);
if(debug) fprintf(fd,"int %s\n",builder.c_str());
convert->fromUIntArray(pvUIntPtr,0,length,uiarray,0);
builder.clear(); pvUIntPtr->toString(&builder); fprintf(fd,"uint %s\n",builder.c_str());
builder.clear(); pvUIntPtr->toString(&builder);
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
convert->fromUIntArray(pvLongPtr,0,length,uiarray,0);
builder.clear(); pvLongPtr->toString(&builder); fprintf(fd,"long %s\n",builder.c_str());
builder.clear(); pvLongPtr->toString(&builder);
if(debug) fprintf(fd,"long %s\n",builder.c_str());
convert->fromUIntArray(pvULongPtr,0,length,uiarray,0);
builder.clear(); pvULongPtr->toString(&builder); fprintf(fd,"ulong %s\n",builder.c_str());
builder.clear(); pvULongPtr->toString(&builder);
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
convert->fromUIntArray(pvFloatPtr,0,length,uiarray,0);
builder.clear(); pvFloatPtr->toString(&builder); fprintf(fd,"float %s\n",builder.c_str());
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float %s\n",builder.c_str());
convert->fromUIntArray(pvDoublePtr,0,length,uiarray,0);
builder.clear(); pvDoublePtr->toString(&builder); fprintf(fd,"double %s\n",builder.c_str());
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalarArray(pvUIntPtr,0, pvFloatPtr,0,length);
builder.clear(); pvFloatPtr->toString(&builder);
fprintf(fd,"float from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalarArray(pvUIntPtr,0, pvDoublePtr,0,length);
builder.clear(); pvDoublePtr->toString(&builder);
fprintf(fd,"double from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
fprintf(fd,"fromUInt PASSED\n");
fprintf(fd,"\nfromULong\n");
if(debug) fprintf(fd,"\nfromULong\n");
uint64 ularray[length];
uint64 ulval = 0x7fffffffffffffff;
ularray[0] = ulval;
for(size_t i=1; i<length; i++) ularray[i] = ularray[i-1] + 1;
convert->fromULongArray(pvBytePtr,0,length,ularray,0);
builder.clear(); pvBytePtr->toString(&builder); fprintf(fd,"byte %s\n",builder.c_str());
builder.clear(); pvBytePtr->toString(&builder);
if(debug) fprintf(fd,"byte %s\n",builder.c_str());
convert->fromULongArray(pvUBytePtr,0,length,ularray,0);
builder.clear(); pvUBytePtr->toString(&builder); fprintf(fd,"ubyte %s\n",builder.c_str());
builder.clear(); pvUBytePtr->toString(&builder);
if(debug) fprintf(fd,"ubyte %s\n",builder.c_str());
convert->fromULongArray(pvShortPtr,0,length,ularray,0);
builder.clear(); pvShortPtr->toString(&builder); fprintf(fd,"short %s\n",builder.c_str());
builder.clear(); pvShortPtr->toString(&builder);
if(debug) fprintf(fd,"short %s\n",builder.c_str());
convert->fromULongArray(pvUShortPtr,0,length,ularray,0);
builder.clear(); pvUShortPtr->toString(&builder); fprintf(fd,"ushort %s\n",builder.c_str());
builder.clear(); pvUShortPtr->toString(&builder);
if(debug) fprintf(fd,"ushort %s\n",builder.c_str());
convert->fromULongArray(pvIntPtr,0,length,ularray,0);
builder.clear(); pvIntPtr->toString(&builder); fprintf(fd,"int %s\n",builder.c_str());
builder.clear(); pvIntPtr->toString(&builder);
if(debug) fprintf(fd,"int %s\n",builder.c_str());
convert->fromULongArray(pvUIntPtr,0,length,ularray,0);
builder.clear(); pvUIntPtr->toString(&builder); fprintf(fd,"uint %s\n",builder.c_str());
builder.clear(); pvUIntPtr->toString(&builder);
if(debug) fprintf(fd,"uint %s\n",builder.c_str());
convert->fromULongArray(pvLongPtr,0,length,ularray,0);
builder.clear(); pvLongPtr->toString(&builder); fprintf(fd,"long %s\n",builder.c_str());
builder.clear(); pvLongPtr->toString(&builder);
if(debug) fprintf(fd,"long %s\n",builder.c_str());
convert->fromULongArray(pvULongPtr,0,length,ularray,0);
builder.clear(); pvULongPtr->toString(&builder); fprintf(fd,"ulong %s\n",builder.c_str());
builder.clear(); pvULongPtr->toString(&builder);
if(debug) fprintf(fd,"ulong %s\n",builder.c_str());
convert->fromULongArray(pvFloatPtr,0,length,ularray,0);
builder.clear(); pvFloatPtr->toString(&builder); fprintf(fd,"float %s\n",builder.c_str());
builder.clear(); pvFloatPtr->toString(&builder);
if(debug) fprintf(fd,"float %s\n",builder.c_str());
convert->fromULongArray(pvDoublePtr,0,length,ularray,0);
builder.clear(); pvDoublePtr->toString(&builder); fprintf(fd,"double %s\n",builder.c_str());
builder.clear(); pvDoublePtr->toString(&builder);
if(debug) fprintf(fd,"double %s\n",builder.c_str());
convert->copyScalarArray(pvULongPtr,0, pvFloatPtr,0,length);
builder.clear(); pvFloatPtr->toString(&builder);
fprintf(fd,"float from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"float from unsigned %s\n",builder.c_str());
convert->copyScalarArray(pvULongPtr,0, pvDoublePtr,0,length);
builder.clear(); pvDoublePtr->toString(&builder);
fprintf(fd,"double from unsigned %s\n",builder.c_str());
if(debug) fprintf(fd,"double from unsigned %s\n",builder.c_str());
fprintf(fd,"fromLong PASSED\n");
}
int main(int argc,char *argv[])
@@ -587,6 +766,7 @@ int main(int argc,char *argv[])
convert = getConvert();
testConvertScalar(fd);
testConvertScalarArray(fd);
fprintf(fd,"THIS NEEDS MANY MORE TESTS AND ASSERTS\n");
return(0);
}

28
testApp/pv/testIntrospect.cpp
View File

@@ -23,6 +23,8 @@
using namespace epics::pvData;
static bool debug = false;
static FieldCreatePtr fieldCreate;
static PVDataCreatePtr pvDataCreate;
static StandardFieldPtr standardField;
@@ -44,13 +46,11 @@ static void testScalarCommon(FILE * fd,ScalarType stype,
assert(ScalarTypeFunc::isPrimitive(scalarType)==isPrimitive);
builder.clear();
pscalar->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
// create tempory PVField so that memory can be released
PVFieldPtr pvField = pvDataCreate->createPVScalar(pscalar);
if(debug) fprintf(fd,"%s\n",builder.c_str());
}
static void testScalar(FILE * fd) {
fprintf(fd,"\ntestScalar\n");
if(debug) fprintf(fd,"\ntestScalar\n");
testScalarCommon(fd,pvBoolean,false,false,true);
testScalarCommon(fd,pvByte,true,true,true);
testScalarCommon(fd,pvShort,true,true,true);
@@ -59,6 +59,7 @@ static void testScalar(FILE * fd) {
testScalarCommon(fd,pvFloat,false,true,true);
testScalarCommon(fd,pvDouble,false,true,true);
testScalarCommon(fd,pvString,false,false,false);
fprintf(fd,"testScalar PASSED\n");
}
static void testScalarArrayCommon(FILE * fd,ScalarType stype,
@@ -77,13 +78,11 @@ static void testScalarArrayCommon(FILE * fd,ScalarType stype,
assert(ScalarTypeFunc::isPrimitive(scalarType)==isPrimitive);
builder.clear();
pscalar->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
// create tempory PVField so that memory can be released
PVFieldPtr pvField = pvDataCreate->createPVScalarArray(pscalar);
if(debug) fprintf(fd,"%s\n",builder.c_str());
}
static void testScalarArray(FILE * fd) {
fprintf(fd,"\ntestScalarArray\n");
if(debug) fprintf(fd,"\ntestScalarArray\n");
testScalarArrayCommon(fd,pvBoolean,false,false,true);
testScalarArrayCommon(fd,pvByte,true,true,true);
testScalarArrayCommon(fd,pvShort,true,true,true);
@@ -92,17 +91,17 @@ static void testScalarArray(FILE * fd) {
testScalarArrayCommon(fd,pvFloat,false,true,true);
testScalarArrayCommon(fd,pvDouble,false,true,true);
testScalarArrayCommon(fd,pvString,false,false,false);
fprintf(fd,"testScalarArray PASSED\n");
}
static void testSimpleStructure(FILE * fd) {
fprintf(fd,"\ntestSimpleStructure\n");
if(debug) fprintf(fd,"\ntestSimpleStructure\n");
String properties("alarm,timeStamp,display,control,valueAlarm");
StructureConstPtr ptop = standardField->scalar(pvDouble,properties);
builder.clear();
ptop->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
// create tempory PVField so that memory can be released
PVStructurePtr pvStructure = pvDataCreate->createPVStructure(ptop);
if(debug) fprintf(fd,"%s\n",builder.c_str());
fprintf(fd,"testSimpleStructure PASSED\n");
}
static StructureConstPtr createPowerSupply() {
@@ -122,14 +121,15 @@ static StructureConstPtr createPowerSupply() {
}
static void testStructureArray(FILE * fd) {
fprintf(fd,"\ntestStructureArray\n");
if(debug) fprintf(fd,"\ntestStructureArray\n");
String properties("alarm,timeStamp");
StructureConstPtr powerSupply = createPowerSupply();
StructureConstPtr top = standardField->structureArray(
powerSupply,properties);
builder.clear();
top->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
if(debug) fprintf(fd,"%s\n",builder.c_str());
fprintf(fd,"testStructureArray PASSED\n");
}
int main(int argc,char *argv[])

45
testApp/pv/testPVAppend.cpp
View File

@@ -26,6 +26,8 @@ using namespace epics::pvData;
using std::tr1::static_pointer_cast;
using std::size_t;
static bool debug = false;
static FieldCreatePtr fieldCreate;
static PVDataCreatePtr pvDataCreate;
static StandardFieldPtr standardField;
@@ -40,22 +42,26 @@ static void checkNameAndParent(
FILE *fd,PVStructurePtr & pvStructure, int indentLevel)
{
builder.clear();
// convert->newLine(&builder,indentLevel);
// fprintf(fd,"%s this %p indentLevel %d",
// builder.c_str(),pvStructure.get(),indentLevel);
if(debug) {
convert->newLine(&builder,indentLevel);
fprintf(fd,"%s this %p indentLevel %d",
builder.c_str(),pvStructure.get(),indentLevel);
}
PVFieldPtrArray pvFields = pvStructure->getPVFields();
StringArray fieldNames = pvStructure->getStructure()->getFieldNames();
for(size_t i = 0; i<pvFields.size(); i++) {
PVFieldPtr pvField = pvFields[i];
assert(pvField->getParent()==pvStructure.get());
assert(pvField->getFieldName().compare(fieldNames[i])==0);
// builder.clear();
// convert->newLine(&builder,indentLevel);
// fprintf(fd,"%s this %p name %s parent %p",
// builder.c_str(),
// pvField.get(),
// pvField->getFieldName().c_str(),
// pvField->getParent());
builder.clear();
if(debug) {
convert->newLine(&builder,indentLevel);
fprintf(fd,"%s this %p name %s parent %p",
builder.c_str(),
pvField.get(),
pvField->getFieldName().c_str(),
pvField->getParent());
}
if(pvField->getField()->getType()==structure) {
PVStructurePtr xxx = static_pointer_cast<PVStructure>(pvField);
checkNameAndParent(fd,xxx,indentLevel+1);
@@ -66,7 +72,7 @@ static void checkNameAndParent(
static void testAppendSimple(FILE * fd)
{
fprintf(fd,"\ntestAppendSimple\n");
if(debug) fprintf(fd,"\ntestAppendSimple\n");
PVFieldPtrArray fields;
StringArray names;
PVStructurePtr pvParent = pvDataCreate->createPVStructure(names,fields);
@@ -82,12 +88,13 @@ static void testAppendSimple(FILE * fd)
pvParent->appendPVField("extra",pvField);
builder.clear();
pvParent->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
if(debug) fprintf(fd,"%s\n",builder.c_str());
fprintf(fd,"testAppendSimple PASSED\n");
}
static void testAppendMore(FILE * fd)
{
fprintf(fd,"\ntestAppendMore\n");
if(debug) fprintf(fd,"\ntestAppendMore\n");
PVFieldPtrArray fields;
StringArray names;
PVStructurePtr pvStructure = pvDataCreate->createPVStructure(names,fields);
@@ -109,8 +116,9 @@ static void testAppendMore(FILE * fd)
pvStructure->appendPVField("child2",pvField);
builder.clear();
pvStructure->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
if(debug) fprintf(fd,"%s\n",builder.c_str());
checkNameAndParent(fd,pvStructure,0);
fprintf(fd,"testAppendMore PASSED\n");
}
static void append2(PVStructurePtr &pvStructure,
@@ -135,7 +143,7 @@ static void append2(PVStructurePtr &pvStructure,
}
static void testAppends(FILE * fd)
{
fprintf(fd,"\ntestAppends\n");
if(debug) fprintf(fd,"\ntestAppends\n");
PVFieldPtrArray emptyPVFields;
StringArray emptyNames;
PVFieldPtrArray pvFields;
@@ -156,19 +164,20 @@ static void testAppends(FILE * fd)
names,pvFields);
builder.clear();
pvStructure->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
if(debug) fprintf(fd,"%s\n",builder.c_str());
checkNameAndParent(fd,pvStructure,0);
PVFieldPtr pvField = pvStructure->getSubField("child2.Bill");
assert(pvField.get()!=NULL);
pvField->renameField("Joe");
builder.clear();
pvStructure->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
if(debug) fprintf(fd,"%s\n",builder.c_str());
pvField->getParent()->removePVField("Joe");
builder.clear();
pvStructure->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
if(debug) fprintf(fd,"%s\n",builder.c_str());
checkNameAndParent(fd,pvStructure,0);
fprintf(fd,"testAppends PASSED\n");
}
int main(int argc,char *argv[])

9
testApp/pv/testPVAuxInfo.cpp
View File

@@ -25,6 +25,8 @@
using namespace epics::pvData;
using std::tr1::static_pointer_cast;
static bool debug = false;
static FieldCreatePtr fieldCreate;
static PVDataCreatePtr pvDataCreate;
static StandardFieldPtr standardField;
@@ -57,7 +59,7 @@ static void printOffsets(PVStructurePtr pvStructure,FILE *fd)
}
static void testPVAuxInfo(FILE * fd) {
fprintf(fd,"\ntestPVAuxInfo\n");
if(debug) fprintf(fd,"\ntestPVAuxInfo\n");
PVStructurePtr pvStructure = standardPVField->scalar(
pvDouble,"alarm,timeStamp,display,control");
PVStructurePtr display
@@ -74,9 +76,10 @@ static void testPVAuxInfo(FILE * fd) {
convert->fromString(pscalar,"3.0");
buffer.clear();
pvStructure->toString(&buffer);
fprintf(fd,"%s\n",buffer.c_str());
if(debug) fprintf(fd,"%s\n",buffer.c_str());
// now show field offsets
printOffsets(pvStructure,fd);
if(debug) printOffsets(pvStructure,fd);
fprintf(fd,"testPVAuxInfo PASSED\n");
}
int main(int argc,char *argv[])

24
testApp/pv/testPVData.cpp
View File

@@ -25,6 +25,8 @@
using namespace epics::pvData;
using std::tr1::static_pointer_cast;
static bool debug = false;
static FieldCreatePtr fieldCreate;
static PVDataCreatePtr pvDataCreate;
static StandardFieldPtr standardField;
@@ -37,6 +39,7 @@ static String allProperties("alarm,timeStamp,display,control,valueAlarm");
static void testAppend(FILE * fd)
{
if(debug) fprintf(fd,"\ntestAppend\n");
PVFieldPtrArray pvFields;
StringArray fieldNames;
PVStructurePtr pvParent = pvDataCreate->createPVStructure(
@@ -48,11 +51,13 @@ static void testAppend(FILE * fd)
pvParent->appendPVField("request",pvField);
builder.clear();
pvParent->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
if(debug) fprintf(fd,"%s\n",builder.c_str());
fprintf(fd,"testAppend PASSED\n");
}
static void testCreatePVStructure(FILE * fd)
{
if(debug) fprintf(fd,"\ntestCreatePVStructure\n");
PVStructurePtr pv0 = standardPVField->scalar(
pvDouble,alarmTimeStampValueAlarm);
PVScalarPtr pv1 = pvDataCreate->createPVScalar(pvString);
@@ -68,7 +73,8 @@ static void testCreatePVStructure(FILE * fd)
fieldNames,pvFields);
builder.clear();
pvParent->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
if(debug) fprintf(fd,"%s\n",builder.c_str());
fprintf(fd,"testCreatePVStructure PASSED\n");
}
static void testPVScalarCommon(FILE * fd,String fieldName,ScalarType stype)
@@ -81,7 +87,7 @@ static void testPVScalarCommon(FILE * fd,String fieldName,ScalarType stype)
}
builder.clear();
pvScalar->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
if(debug) fprintf(fd,"%s\n",builder.c_str());
}
static void testPVScalarWithProperties(
@@ -295,12 +301,12 @@ static void testPVScalarWithProperties(
}
builder.clear();
pvStructure->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
if(debug) fprintf(fd,"%s\n",builder.c_str());
}
static void testPVScalar(FILE * fd) {
fprintf(fd,"\ntestScalar\n");
testPVScalarCommon(fd,String("boolean"),pvBoolean);
if(debug) fprintf(fd,"\ntestScalar\n");
testPVScalarCommon(fd,String("boolean"),pvByte);
testPVScalarCommon(fd,String("byte"),pvByte);
testPVScalarCommon(fd,String("short"),pvShort);
testPVScalarCommon(fd,String("int"),pvInt);
@@ -325,6 +331,7 @@ static void testPVScalar(FILE * fd) {
testPVScalarWithProperties(fd,String("float"),pvFloat);
testPVScalarWithProperties(fd,String("double"),pvDouble);
testPVScalarWithProperties(fd,String("string"),pvString);
fprintf(fd,"testScalar PASSED\n");
}
@@ -350,13 +357,13 @@ static void testScalarArrayCommon(FILE * fd,String fieldName,ScalarType stype)
}
builder.clear();
pvStructure->toString(&builder);
fprintf(fd,"%s\n",builder.c_str());
if(debug) fprintf(fd,"%s\n",builder.c_str());
PVFieldPtr pvField = pvStructure->getSubField("alarm.status");
pvField->message("this is a test",infoMessage);
}
static void testScalarArray(FILE * fd) {
fprintf(fd,"\ntestScalarArray\n");
if(debug) fprintf(fd,"\ntestScalarArray\n");
testScalarArrayCommon(fd,String("boolean"),pvBoolean);
testScalarArrayCommon(fd,String("byte"),pvByte);
testScalarArrayCommon(fd,String("short"),pvShort);
@@ -365,6 +372,7 @@ static void testScalarArray(FILE * fd) {
testScalarArrayCommon(fd,String("float"),pvFloat);
testScalarArrayCommon(fd,String("double"),pvDouble);
testScalarArrayCommon(fd,String("string"),pvString);
fprintf(fd,"testScalarArray PASSED\n");
}
int main(int argc,char *argv[])

174
testApp/pv/testPVScalarArray.cpp
View File

@@ -25,6 +25,8 @@
using namespace epics::pvData;
using std::tr1::static_pointer_cast;
static bool debug = false;
static FieldCreatePtr fieldCreate = getFieldCreate();
static PVDataCreatePtr pvDataCreate = getPVDataCreate();
static StandardFieldPtr standardField = getStandardField();
@@ -39,6 +41,7 @@ static size_t length = 4;
static void byteArray()
{
if(debug) fprintf(fd,"\nbyteArray\n");
PVScalarArrayPtr pvScalarArray = pvDataCreate->createPVScalarArray(pvByte);;
PVByteArrayPtr pvByteArray = static_pointer_cast<PVByteArray>(pvScalarArray);
ByteArray value;
@@ -48,36 +51,38 @@ static void byteArray()
pvByteArray->put(0,length,value,0);
builder.clear();
pvByteArray->toString(&builder);
fprintf(fd,"put\n%s\n",builder.c_str());
if(debug) fprintf(fd,"put\n%s\n",builder.c_str());
convert->fromByteArray(pvScalarArray,0,length,value,0);
builder.clear();
pvByteArray->toString(&builder);
fprintf(fd,"convert\n%s\n",builder.c_str());
if(debug) fprintf(fd,"convert\n%s\n",builder.c_str());
ByteArrayData data;
pvByteArray->get(0,length,data);
ByteArray_iterator iter = data.data.begin();
fprintf(fd,"iter [");
if(debug) fprintf(fd,"iter [");
for(iter=data.data.begin();iter!=data.data.end();++iter) {
fprintf(fd,"%d ",*iter);
if(debug) fprintf(fd,"%d ",*iter);
}
fprintf(fd,"]\n");
fprintf(fd,"raw [");
if(debug) fprintf(fd,"]\n");
if(debug) fprintf(fd,"raw [");
int8 * pdata = get(data.data);
for(size_t i=0; i<length; i++) {
int val = pdata[i];
fprintf(fd,"%d ",val);
if(debug) fprintf(fd,"%d ",val);
}
fprintf(fd,"]\n");
fprintf(fd,"direct[");
if(debug) fprintf(fd,"]\n");
if(debug) fprintf(fd,"direct[");
for(size_t i=0; i<length; i++) {
int val = data.data[i];
fprintf(fd,"%d ",val);
if(debug) fprintf(fd,"%d ",val);
}
fprintf(fd,"]\n");
if(debug) fprintf(fd,"]\n");
fprintf(fd,"byteArray PASSED\n");
}
static void ubyteArray()
{
if(debug) fprintf(fd,"\nubyteArray\n");
PVScalarArrayPtr pvScalarArray = pvDataCreate->createPVScalarArray(pvUByte);;
PVUByteArrayPtr pvUByteArray = static_pointer_cast<PVUByteArray>(pvScalarArray);
UByteArray value;
@@ -87,36 +92,38 @@ static void ubyteArray()
pvUByteArray->put(0,length,value,0);
builder.clear();
pvUByteArray->toString(&builder);
fprintf(fd,"put\n%s\n",builder.c_str());
if(debug) fprintf(fd,"put\n%s\n",builder.c_str());
convert->fromUByteArray(pvScalarArray,0,length,value,0);
builder.clear();
pvUByteArray->toString(&builder);
fprintf(fd,"convert\n%s\n",builder.c_str());
if(debug) fprintf(fd,"convert\n%s\n",builder.c_str());
UByteArrayData data;
pvUByteArray->get(0,length,data);
UByteArray_iterator iter = data.data.begin();
fprintf(fd,"iter [");
if(debug) fprintf(fd,"iter [");
for(iter=data.data.begin();iter!=data.data.end();++iter) {
fprintf(fd,"%u ",*iter);
if(debug) fprintf(fd,"%u ",*iter);
}
fprintf(fd,"]\n");
fprintf(fd,"raw [");
if(debug) fprintf(fd,"]\n");
if(debug) fprintf(fd,"raw [");
uint8 * pdata = get(data.data);
for(size_t i=0; i<length; i++) {
unsigned int val = pdata[i];
fprintf(fd,"%d ",val);
if(debug) fprintf(fd,"%d ",val);
}
fprintf(fd,"]\n");
fprintf(fd,"direct[");
if(debug) fprintf(fd,"]\n");
if(debug) fprintf(fd,"direct[");
for(size_t i=0; i<length; i++) {
unsigned int val = data.data[i];
fprintf(fd,"%d ",val);
if(debug) fprintf(fd,"%d ",val);
}
fprintf(fd,"]\n");
if(debug) fprintf(fd,"]\n");
fprintf(fd,"ubyteArray PASSED\n");
}
static void longArray()
{
if(debug) fprintf(fd,"\nlongArray\n");
PVScalarArrayPtr pvScalarArray = pvDataCreate->createPVScalarArray(pvLong);;
PVLongArrayPtr pvLongArray = static_pointer_cast<PVLongArray>(pvScalarArray);
LongArray value;
@@ -126,36 +133,38 @@ static void longArray()
pvLongArray->put(0,length,value,0);
builder.clear();
pvLongArray->toString(&builder);
fprintf(fd,"put\n%s\n",builder.c_str());
if(debug) fprintf(fd,"put\n%s\n",builder.c_str());
convert->fromLongArray(pvScalarArray,0,length,value,0);
builder.clear();
pvLongArray->toString(&builder);
fprintf(fd,"convert\n%s\n",builder.c_str());
if(debug) fprintf(fd,"convert\n%s\n",builder.c_str());
LongArrayData data;
pvLongArray->get(0,length,data);
LongArray_iterator iter = data.data.begin();
fprintf(fd,"iter [");
if(debug) fprintf(fd,"iter [");
for(iter=data.data.begin();iter!=data.data.end();++iter) {
fprintf(fd,"%lli ",*iter);
if(debug) fprintf(fd,"%lli ",*iter);
}
fprintf(fd,"]\n");
fprintf(fd,"raw [");
if(debug) fprintf(fd,"]\n");
if(debug) fprintf(fd,"raw [");
int64 * pdata = get(data.data);
for(size_t i=0; i<length; i++) {
int64 val = pdata[i];
fprintf(fd,"%lli ",val);
if(debug) fprintf(fd,"%lli ",val);
}
fprintf(fd,"]\n");
fprintf(fd,"direct[");
if(debug) fprintf(fd,"]\n");
if(debug) fprintf(fd,"direct[");
for(size_t i=0; i<length; i++) {
int64 val = data.data[i];
fprintf(fd,"%lli ",val);
if(debug) fprintf(fd,"%lli ",val);
}
fprintf(fd,"]\n");
if(debug) fprintf(fd,"]\n");
fprintf(fd,"longArray PASSED\n");
}
static void ulongArray()
{
if(debug) fprintf(fd,"\nulongArray\n");
PVScalarArrayPtr pvScalarArray = pvDataCreate->createPVScalarArray(pvULong);;
PVULongArrayPtr pvULongArray = static_pointer_cast<PVULongArray>(pvScalarArray);
ULongArray value;
@@ -165,36 +174,38 @@ static void ulongArray()
pvULongArray->put(0,length,value,0);
builder.clear();
pvULongArray->toString(&builder);
fprintf(fd,"put\n%s\n",builder.c_str());
if(debug) fprintf(fd,"put\n%s\n",builder.c_str());
convert->fromULongArray(pvScalarArray,0,length,value,0);
builder.clear();
pvULongArray->toString(&builder);
fprintf(fd,"convert\n%s\n",builder.c_str());
if(debug) fprintf(fd,"convert\n%s\n",builder.c_str());
ULongArrayData data;
pvULongArray->get(0,length,data);
ULongArray_iterator iter = data.data.begin();
fprintf(fd,"iter [");
if(debug) fprintf(fd,"iter [");
for(iter=data.data.begin();iter!=data.data.end();++iter) {
fprintf(fd,"%llu ",*iter);
if(debug) fprintf(fd,"%llu ",*iter);
}
fprintf(fd,"]\n");
fprintf(fd,"raw [");
if(debug) fprintf(fd,"]\n");
if(debug) fprintf(fd,"raw [");
uint64 * pdata = get(data.data);
for(size_t i=0; i<length; i++) {
uint64 val = pdata[i];
fprintf(fd,"%llu ",val);
if(debug) fprintf(fd,"%llu ",val);
}
fprintf(fd,"]\n");
fprintf(fd,"direct[");
if(debug) fprintf(fd,"]\n");
if(debug) fprintf(fd,"direct[");
for(size_t i=0; i<length; i++) {
uint64 val = data.data[i];
fprintf(fd,"%llu ",val);
if(debug) fprintf(fd,"%llu ",val);
}
fprintf(fd,"]\n");
if(debug) fprintf(fd,"]\n");
fprintf(fd,"ulongArray PASSED\n");
}
static void floatArray()
{
if(debug) fprintf(fd,"\nfloatArray\n");
PVScalarArrayPtr pvScalarArray = pvDataCreate->createPVScalarArray(pvFloat);;
PVFloatArrayPtr pvFloatArray = static_pointer_cast<PVFloatArray>(pvScalarArray);
FloatArray value;
@@ -203,36 +214,38 @@ static void floatArray()
pvFloatArray->put(0,length,value,0);
builder.clear();
pvFloatArray->toString(&builder);
fprintf(fd,"put\n%s\n",builder.c_str());
if(debug) fprintf(fd,"put\n%s\n",builder.c_str());
convert->fromFloatArray(pvScalarArray,0,length,value,0);
builder.clear();
pvFloatArray->toString(&builder);
fprintf(fd,"convert\n%s\n",builder.c_str());
if(debug) fprintf(fd,"convert\n%s\n",builder.c_str());
FloatArrayData data;
pvFloatArray->get(0,length,data);
FloatArray_iterator iter = data.data.begin();
fprintf(fd,"iter [");
if(debug) fprintf(fd,"iter [");
for(iter=data.data.begin();iter!=data.data.end();++iter) {
fprintf(fd,"%f ",*iter);
if(debug) fprintf(fd,"%f ",*iter);
}
fprintf(fd,"]\n");
fprintf(fd,"raw [");
if(debug) fprintf(fd,"]\n");
if(debug) fprintf(fd,"raw [");
float * pdata = get(data.data);
for(size_t i=0; i<length; i++) {
float val = pdata[i];
fprintf(fd,"%f ",val);
if(debug) fprintf(fd,"%f ",val);
}
fprintf(fd,"]\n");
fprintf(fd,"direct[");
if(debug) fprintf(fd,"]\n");
if(debug) fprintf(fd,"direct[");
for(size_t i=0; i<length; i++) {
float val = data.data[i];
fprintf(fd,"%f ",val);
if(debug) fprintf(fd,"%f ",val);
}
fprintf(fd,"]\n");
if(debug) fprintf(fd,"]\n");
fprintf(fd,"floatArray PASSED\n");
}
static void doubleArray()
{
if(debug) fprintf(fd,"\ndoubleArray\n");
PVScalarArrayPtr pvScalarArray = pvDataCreate->createPVScalarArray(pvDouble);;
PVDoubleArrayPtr pvDoubleArray = static_pointer_cast<PVDoubleArray>(pvScalarArray);
DoubleArray value;
@@ -241,36 +254,38 @@ static void doubleArray()
pvDoubleArray->put(0,length,value,0);
builder.clear();
pvDoubleArray->toString(&builder);
fprintf(fd,"put\n%s\n",builder.c_str());
if(debug) fprintf(fd,"put\n%s\n",builder.c_str());
convert->fromDoubleArray(pvScalarArray,0,length,value,0);
builder.clear();
pvDoubleArray->toString(&builder);
fprintf(fd,"convert\n%s\n",builder.c_str());
if(debug) fprintf(fd,"convert\n%s\n",builder.c_str());
DoubleArrayData data;
pvDoubleArray->get(0,length,data);
DoubleArray_iterator iter = data.data.begin();
fprintf(fd,"iter [");
if(debug) fprintf(fd,"iter [");
for(iter=data.data.begin();iter!=data.data.end();++iter) {
fprintf(fd,"%lf ",*iter);
if(debug) fprintf(fd,"%lf ",*iter);
}
fprintf(fd,"]\n");
fprintf(fd,"raw [");
if(debug) fprintf(fd,"]\n");
if(debug) fprintf(fd,"raw [");
double * pdata = get(data.data);
for(size_t i=0; i<length; i++) {
double val = pdata[i];
fprintf(fd,"%lf ",val);
if(debug) fprintf(fd,"%lf ",val);
}
fprintf(fd,"]\n");
fprintf(fd,"direct[");
if(debug) fprintf(fd,"]\n");
if(debug) fprintf(fd,"direct[");
for(size_t i=0; i<length; i++) {
double val = data.data[i];
fprintf(fd,"%lf ",val);
if(debug) fprintf(fd,"%lf ",val);
}
fprintf(fd,"]\n");
if(debug) fprintf(fd,"]\n");
fprintf(fd,"doubleArray PASSED\n");
}
static void stringArray()
{
if(debug) fprintf(fd,"\nstringArray\n");
PVScalarArrayPtr pvScalarArray = pvDataCreate->createPVScalarArray(pvString);;
PVStringArrayPtr pvStringArray = static_pointer_cast<PVStringArray>(pvScalarArray);
StringArray value;
@@ -283,37 +298,39 @@ static void stringArray()
pvStringArray->put(0,length,value,0);
builder.clear();
pvStringArray->toString(&builder);
fprintf(fd,"put\n%s\n",builder.c_str());
if(debug) fprintf(fd,"put\n%s\n",builder.c_str());
convert->fromStringArray(pvScalarArray,0,length,value,0);
builder.clear();
pvStringArray->toString(&builder);
fprintf(fd,"convert\n%s\n",builder.c_str());
if(debug) fprintf(fd,"convert\n%s\n",builder.c_str());
StringArrayData data;
pvStringArray->get(0,length,data);
StringArray_iterator iter = data.data.begin();
fprintf(fd,"iter [");
if(debug) fprintf(fd,"iter [");
for(iter=data.data.begin();iter!=data.data.end();++iter) {
String val = *iter;
fprintf(fd,"%s ",val.c_str());
if(debug) fprintf(fd,"%s ",val.c_str());
}
fprintf(fd,"]\n");
fprintf(fd,"raw [");
if(debug) fprintf(fd,"]\n");
if(debug) fprintf(fd,"raw [");
String* pdata = get(data.data);
for(size_t i=0; i<length; i++) {
String val = pdata[i];
fprintf(fd,"%s ",val.c_str());
if(debug) fprintf(fd,"%s ",val.c_str());
}
fprintf(fd,"]\n");
fprintf(fd,"direct[");
if(debug) fprintf(fd,"]\n");
if(debug) fprintf(fd,"direct[");
for(size_t i=0; i<length; i++) {
String val = data.data[i];
fprintf(fd,"%s ",val.c_str());
if(debug) fprintf(fd,"%s ",val.c_str());
}
fprintf(fd,"]\n");
if(debug) fprintf(fd,"]\n");
fprintf(fd,"stringArray PASSED\n");
}
static void shareArray()
{
if(debug) fprintf(fd,"\nshareArray\n");
PVScalarArrayPtr pvScalarArray = pvDataCreate->createPVScalarArray(pvDouble);;
PVDoubleArrayPtr pvDoubleArray = static_pointer_cast<PVDoubleArray>(pvScalarArray);
DoubleArray value;
@@ -334,7 +351,8 @@ static void shareArray()
assert(pvDoubleArray->get()==pvShareArray->get());
builder.clear();
pvShareArray->toString(&builder);
fprintf(fd,"pvShare\n%s\n",builder.c_str());
if(debug) fprintf(fd,"pvShare\n%s\n",builder.c_str());
fprintf(fd,"shareArray PASSED\n");
}
int main(int argc,char *argv[])

27
testApp/pv/testPVStructureArray.cpp
View File

@@ -24,6 +24,8 @@
using namespace epics::pvData;
static bool debug = false;
static FieldCreatePtr fieldCreate;
static PVDataCreatePtr pvDataCreate;
static StandardFieldPtr standardField;
@@ -31,7 +33,8 @@ static StandardPVFieldPtr standardPVField;
static ConvertPtr convert;
static String buffer;
void testPVStructureArray(FILE * fd) {
static void testPVStructureArray(FILE * fd) {
if(debug) fprintf(fd,"/ntestPVStructureArray\n");
StructureArrayConstPtr alarm(
fieldCreate->createStructureArray(standardField->alarm()));
PVStructureArrayPtr pvAlarmStructure(
@@ -46,15 +49,16 @@ void testPVStructureArray(FILE * fd) {
pvAlarmStructure->put(0,2,palarms,0);
buffer.clear();
pvAlarmStructure->toString(&buffer);
fprintf(fd,"pvAlarmStructure\n%s\n",buffer.c_str());
if(debug) fprintf(fd,"pvAlarmStructure\n%s\n",buffer.c_str());
PVStructureArrayPtr copy(pvDataCreate->createPVStructureArray(alarm));
convert->copyStructureArray(pvAlarmStructure,copy);
buffer.clear();
copy->toString(&buffer);
fprintf(fd,"copy\n%s\n",buffer.c_str());
if(debug) fprintf(fd,"copy\n%s\n",buffer.c_str());
fprintf(fd,"testPVStructureArray PASSED\n");
}
StructureConstPtr getPowerSupplyStructure() {
static StructureConstPtr getPowerSupplyStructure() {
String properties("alarm");
FieldConstPtrArray fields;
StringArray fieldNames;
@@ -67,32 +71,35 @@ StructureConstPtr getPowerSupplyStructure() {
fields.push_back(standardField->scalar(pvDouble,properties));
fields.push_back(standardField->scalar(pvDouble,properties));
StructureConstPtr structure = fieldCreate->createStructure(
fieldNames,fields);
"powerSupply_t",fieldNames,fields);
return structure;
}
void testPowerSupplyArray(FILE * fd) {
static void testPowerSupplyArray(FILE * fd) {
if(debug) fprintf(fd,"/ntestPowerSupplyArray\n");
PVStructurePtr powerSupplyArrayStruct = standardPVField->structureArray(
getPowerSupplyStructure(),String("alarm,timeStamp"));
PVStructureArrayPtr powerSupplyArray =
powerSupplyArrayStruct->getStructureArrayField(String("value"));
assert(powerSupplyArray.get()!=NULL);
int offset = powerSupplyArray->append(5);
if(debug) fprintf(fd,"offset %d\n",offset);
buffer.clear();
powerSupplyArrayStruct->toString(&buffer);
fprintf(fd,"after append 5\n%s\n",buffer.c_str());
if(debug) fprintf(fd,"after append 5\n%s\n",buffer.c_str());
powerSupplyArray->remove(0,2);
buffer.clear();
powerSupplyArrayStruct->toString(&buffer);
fprintf(fd,"after remove(0,2)\n%s\n",buffer.c_str());
if(debug) fprintf(fd,"after remove(0,2)\n%s\n",buffer.c_str());
powerSupplyArray->remove(2,1);
buffer.clear();
powerSupplyArrayStruct->toString(&buffer);
fprintf(fd,"after remove 2,1%s\n",buffer.c_str());
if(debug) fprintf(fd,"after remove 2,1%s\n",buffer.c_str());
powerSupplyArray->compress();
buffer.clear();
powerSupplyArrayStruct->toString(&buffer);
fprintf(fd,"after compress%s\n",buffer.c_str());
if(debug) fprintf(fd,"after compress%s\n",buffer.c_str());
fprintf(fd,"testPowerSupplyArray PASSED\n");
}
int main(int argc,char *argv[])

3
testApp/pv/testPVType.cpp
View File

@@ -66,7 +66,8 @@ int main(int argc,char *argv[])
longInt = intValue = 0x80000000;;
longInt <<= 32;
fprintf(fd," min %lli\n",longInt);
fprintf(fd,"PASSED\n");
return(0);
}

5
testApp/pv/testStandardField.cpp
View File

@@ -24,13 +24,15 @@
using namespace epics::pvData;
using std::tr1::static_pointer_cast;
static bool debug = false;
static FieldCreatePtr fieldCreate = getFieldCreate();
static StandardFieldPtr standardField = getStandardField();
static String builder("");
static void print(String name)
{
printf("\n%s\n%s\n",name.c_str(),builder.c_str());
if(debug) printf("\n%s\n%s\n",name.c_str(),builder.c_str());
}
int main(int argc,char *argv[])
@@ -63,6 +65,7 @@ int main(int argc,char *argv[])
builder.clear();
structureArrayValue->toString(&builder);
print("structureArrayValue");
printf("PASSED\n");
return(0);
}

5
testApp/pv/testStandardPVField.cpp
View File

@@ -25,6 +25,8 @@
using namespace epics::pvData;
using std::tr1::static_pointer_cast;
static bool debug = false;
static PVDataCreatePtr pvDataCreate = getPVDataCreate();
static StandardFieldPtr standardField = getStandardField();
static StandardPVFieldPtr standardPVField = getStandardPVField();
@@ -32,7 +34,7 @@ static String builder("");
static void print(String name)
{
printf("\n%s\n%s\n",name.c_str(),builder.c_str());
if(debug) printf("\n%s\n%s\n",name.c_str(),builder.c_str());
}
int main(int argc,char *argv[])
@@ -79,6 +81,7 @@ int main(int argc,char *argv[])
builder.clear();
pvStructure->toString(&builder);
print("structureArrayTest");
printf("PASSED\n");
return(0);
}