From 3c08834377297576260f6306a9cc9b8f9ba01444 Mon Sep 17 00:00:00 2001 From: Michael Davidsaver Date: Wed, 8 May 2013 14:18:29 -0400 Subject: [PATCH] update testSerialization --- testApp/misc/Makefile | 3 +- testApp/misc/testSerialization.cpp | 564 +++++++++-------------------- 2 files changed, 165 insertions(+), 402 deletions(-) diff --git a/testApp/misc/Makefile b/testApp/misc/Makefile index a9fceba..f627433 100644 --- a/testApp/misc/Makefile +++ b/testApp/misc/Makefile @@ -22,8 +22,9 @@ testByteBuffer_SRCS += testByteBuffer.cpp PROD_HOST += testBaseException testBaseException_SRCS += testBaseException.cpp -PROD_HOST += testSerialization +TESTPROD += testSerialization testSerialization_SRCS += testSerialization.cpp +TESTS += testSerialization PROD_HOST += testTimeStamp testTimeStamp_SRCS += testTimeStamp.cpp diff --git a/testApp/misc/testSerialization.cpp b/testApp/misc/testSerialization.cpp index a1fd98f..50e4266 100644 --- a/testApp/misc/testSerialization.cpp +++ b/testApp/misc/testSerialization.cpp @@ -12,7 +12,9 @@ #include #include -#include +#include +#include +#include // for NELEMENTS #include #include @@ -45,6 +47,8 @@ using namespace epics::pvData; +namespace { + static SerializableControl* flusher; static DeserializableControl* control; static ByteBuffer* buffer; @@ -122,14 +126,13 @@ void serializationTest(PVFieldPtr const & field) { deserializedField->deserialize(buffer, control); // must equal - bool isEqual = getConvert()->equals(*field,*deserializedField); - assert(isEqual); + testOk1(*field==*deserializedField); } -void testEquals(std::ostream& ofile) { - ofile<<"Testing equals...\n"; +void testEquals() { + testDiag("Testing equals..."); PVDataCreatePtr factory = getPVDataCreate(); - assert(factory.get()!=NULL); + testOk1(factory.get()!=NULL); // be sure all is covered for (int i = pvBoolean; i < pvString; i++) @@ -138,32 +141,63 @@ void testEquals(std::ostream& ofile) { PVScalarPtr scalar1 = factory->createPVScalar(scalarType); PVScalarPtr scalar2 = factory->createPVScalar(scalarType); - assert((*scalar1)==(*scalar2)); + testOk1((*scalar1)==(*scalar2)); PVScalarArrayPtr array1 = factory->createPVScalarArray(scalarType); PVScalarArrayPtr array2 = factory->createPVScalarArray(scalarType); - assert((*array1)==(*array2)); + testOk1((*array1)==(*array2)); } // and a structure PVStructurePtr structure1 = factory->createPVStructure(getStandardField()->timeStamp()); PVStructurePtr structure2 = factory->createPVStructure(getStandardField()->timeStamp()); - assert((*structure1)==(*structure2)); + testOk1((*structure1)==(*structure2)); // and a structure array PVStructureArrayPtr structureArray1 = factory->createPVStructureArray(getFieldCreate()->createStructureArray(structure1->getStructure())); PVStructureArrayPtr structureArray2 = factory->createPVStructureArray(getFieldCreate()->createStructureArray(structure2->getStructure())); - assert((*structureArray1)==(*structureArray2)); - - ofile<<"!!! PASSED\n\n"; + testOk1((*structureArray1)==(*structureArray2)); } -void testScalar(std::ostream& ofile) { - ofile<<"Testing scalars...\n"; - PVDataCreatePtr factory = getPVDataCreate(); - assert(factory.get()!=NULL); +template +void testScalarType() +{ + typedef typename PVT::value_type value_type; - ofile<<"\tPVBoolean\n"; + testDiag("type %s", ScalarTypeFunc::name(PVT::typeCode)); + + typename PVT::shared_pointer pv = std::tr1::static_pointer_cast(getPVDataCreate()->createPVScalar(PVT::typeCode)); + + pv->put(0); + serializationTest(pv); + pv->put(42); + serializationTest(pv); + pv->put(std::numeric_limits::max()-1); + serializationTest(pv); + pv->put(std::numeric_limits::max()); + serializationTest(pv); + + if(std::numeric_limits::min()!=0) { + pv->put(-42); + serializationTest(pv); + pv->put(std::numeric_limits::min()+1); + serializationTest(pv); + pv->put(std::numeric_limits::min()); + serializationTest(pv); + } + + if(std::numeric_limits::has_infinity) { + pv->put(std::numeric_limits::infinity()); + serializationTest(pv); + } +} + +void testScalar() { + testDiag("Testing scalars..."); + PVDataCreatePtr factory = getPVDataCreate(); + testOk1(factory.get()!=NULL); + + testDiag("type %s", ScalarTypeFunc::name(pvBoolean)); PVBooleanPtr pvBoolean = std::tr1::static_pointer_cast(factory->createPVScalar(epics::pvData::pvBoolean)); pvBoolean->put(false); @@ -171,196 +205,19 @@ void testScalar(std::ostream& ofile) { pvBoolean->put(true); serializationTest(pvBoolean); - ofile<<"\tPVByte\n"; - PVBytePtr pvByte = - std::tr1::static_pointer_cast(factory->createPVScalar(epics::pvData::pvByte)); - pvByte->put(0); - serializationTest(pvByte); - pvByte->put(12); - serializationTest(pvByte); - pvByte->put(BYTE_MAX_VALUE); - serializationTest(pvByte); - pvByte->put(BYTE_MIN_VALUE); - serializationTest(pvByte); - - ofile<<"\tPVShort\n"; - PVShortPtr pvShort = - std::tr1::static_pointer_cast(factory->createPVScalar(epics::pvData::pvShort)); - pvShort->put(0); - serializationTest(pvShort); - pvShort->put(123); - serializationTest(pvShort); - pvShort->put(BYTE_MAX_VALUE); - serializationTest(pvShort); - pvShort->put(BYTE_MIN_VALUE); - serializationTest(pvShort); - pvShort->put(SHORT_MAX_VALUE); - serializationTest(pvShort); - pvShort->put(SHORT_MIN_VALUE); - serializationTest(pvShort); - - ofile<<"\tPVInt\n"; - PVIntPtr pvInt = - std::tr1::static_pointer_cast(factory->createPVScalar(epics::pvData::pvInt)); - pvInt->put(0); - serializationTest(pvInt); - pvInt->put(123456); - serializationTest(pvInt); - pvInt->put(BYTE_MAX_VALUE); - serializationTest(pvInt); - pvInt->put(BYTE_MIN_VALUE); - serializationTest(pvInt); - pvInt->put(SHORT_MAX_VALUE); - serializationTest(pvInt); - pvInt->put(SHORT_MIN_VALUE); - serializationTest(pvInt); - pvInt->put(INT_MAX_VALUE); - serializationTest(pvInt); - pvInt->put(INT_MIN_VALUE); - serializationTest(pvInt); - - ofile<<"\tPVLong\n"; - PVLongPtr pvLong = - std::tr1::static_pointer_cast(factory->createPVScalar(epics::pvData::pvLong)); - pvLong->put(0); - serializationTest(pvLong); - pvLong->put(12345678901LL); - serializationTest(pvLong); - pvLong->put(BYTE_MAX_VALUE); - serializationTest(pvLong); - pvLong->put(BYTE_MIN_VALUE); - serializationTest(pvLong); - pvLong->put(SHORT_MAX_VALUE); - serializationTest(pvLong); - pvLong->put(SHORT_MIN_VALUE); - serializationTest(pvLong); - pvLong->put(INT_MAX_VALUE); - serializationTest(pvLong); - pvLong->put(INT_MIN_VALUE); - serializationTest(pvLong); - pvLong->put(LONG_MAX_VALUE); - serializationTest(pvLong); - pvLong->put(LONG_MIN_VALUE); - serializationTest(pvLong); + testScalarType(); + testScalarType(); + testScalarType(); + testScalarType(); + testScalarType(); + testScalarType(); + testScalarType(); + testScalarType(); + testScalarType(); + testScalarType(); - ofile<<"\tPVUByte\n"; - PVUBytePtr pvUByte = - std::tr1::static_pointer_cast(factory->createPVScalar(epics::pvData::pvUByte)); - pvUByte->put(0); - serializationTest(pvUByte); - pvUByte->put(12); - serializationTest(pvUByte); - pvUByte->put(UBYTE_MAX_VALUE); - serializationTest(pvUByte); - pvUByte->put(BYTE_MAX_VALUE); - serializationTest(pvUByte); - pvUByte->put(BYTE_MIN_VALUE); - serializationTest(pvUByte); - - ofile<<"\tPVUShort\n"; - PVUShortPtr pvUShort = - std::tr1::static_pointer_cast(factory->createPVScalar(epics::pvData::pvUShort)); - pvUShort->put(0); - serializationTest(pvUShort); - pvUShort->put(1234); - serializationTest(pvUShort); - pvUShort->put(BYTE_MAX_VALUE); - serializationTest(pvUShort); - pvUShort->put(BYTE_MIN_VALUE); - serializationTest(pvUShort); - pvUShort->put(UBYTE_MAX_VALUE); - serializationTest(pvUShort); - pvUShort->put(SHORT_MAX_VALUE); - serializationTest(pvUShort); - pvUShort->put(SHORT_MIN_VALUE); - serializationTest(pvUShort); - pvUShort->put(USHORT_MAX_VALUE); - serializationTest(pvUShort); - - ofile<<"\tPVInt\n"; - PVIntPtr pvUInt = - std::tr1::static_pointer_cast(factory->createPVScalar(epics::pvData::pvUInt)); - pvUInt->put(0); - serializationTest(pvUInt); - pvUInt->put(123456); - serializationTest(pvUInt); - pvUInt->put(BYTE_MAX_VALUE); - serializationTest(pvUInt); - pvUInt->put(BYTE_MIN_VALUE); - serializationTest(pvUInt); - pvUInt->put(UBYTE_MAX_VALUE); - serializationTest(pvUInt); - pvUInt->put(SHORT_MAX_VALUE); - serializationTest(pvUInt); - pvUInt->put(SHORT_MIN_VALUE); - serializationTest(pvUInt); - pvUInt->put(USHORT_MAX_VALUE); - serializationTest(pvUInt); - pvUInt->put(INT_MAX_VALUE); - serializationTest(pvUInt); - pvUInt->put(INT_MIN_VALUE); - serializationTest(pvUInt); - pvUInt->put(UINT_MAX_VALUE); - serializationTest(pvUInt); - - ofile<<"\tPVLong\n"; - PVLongPtr pvULong = - std::tr1::static_pointer_cast(factory->createPVScalar(epics::pvData::pvULong)); - pvULong->put(0); - serializationTest(pvULong); - pvULong->put(12345678901LL); - serializationTest(pvULong); - pvULong->put(BYTE_MAX_VALUE); - serializationTest(pvULong); - pvULong->put(BYTE_MIN_VALUE); - serializationTest(pvULong); - pvULong->put(UBYTE_MAX_VALUE); - serializationTest(pvULong); - pvULong->put(SHORT_MAX_VALUE); - serializationTest(pvULong); - pvULong->put(SHORT_MIN_VALUE); - serializationTest(pvULong); - pvULong->put(USHORT_MAX_VALUE); - serializationTest(pvULong); - pvULong->put(INT_MAX_VALUE); - serializationTest(pvULong); - pvULong->put(INT_MIN_VALUE); - serializationTest(pvULong); - pvULong->put(UINT_MAX_VALUE); - serializationTest(pvULong); - pvULong->put(LONG_MAX_VALUE); - serializationTest(pvULong); - pvULong->put(LONG_MIN_VALUE); - serializationTest(pvULong); - pvULong->put(ULONG_MAX_VALUE); - serializationTest(pvULong); - - ofile<<"\tPVFloat\n"; - PVFloatPtr pvFloat = - std::tr1::static_pointer_cast(factory->createPVScalar(epics::pvData::pvFloat)); - pvFloat->put(0); - serializationTest(pvFloat); - pvFloat->put(12.345); - serializationTest(pvFloat); - pvFloat->put(FLOAT_MAX_VALUE); - serializationTest(pvFloat); - pvFloat->put(FLOAT_MIN_VALUE); - serializationTest(pvFloat); - - ofile<<"\tPVDouble\n"; - PVDoublePtr pvDouble = - std::tr1::static_pointer_cast(factory->createPVScalar(epics::pvData::pvDouble)); - pvDouble->put(0); - serializationTest(pvDouble); - pvDouble->put(12.345); - serializationTest(pvDouble); - pvDouble->put(DOUBLE_MAX_VALUE); - serializationTest(pvDouble); - pvDouble->put(DOUBLE_MIN_VALUE); - serializationTest(pvDouble); - - ofile<<"\tPVString\n"; + testDiag("type %s", ScalarTypeFunc::name(pvString)); PVStringPtr pvString = std::tr1::static_pointer_cast(factory->createPVScalar(epics::pvData::pvString)); pvString->put(""); @@ -377,167 +234,88 @@ void testScalar(std::ostream& ofile) { // huge string test pvString->put(String(10000, 'a')); serializationTest(pvString); - - // TODO unsigned test - - ofile<<"!!! PASSED\n\n"; } -void testArray(std::ostream& ofile) { - ofile<<"Testing arrays...\n"; +template +void testArrayType(const typename PVT::value_type* rdata, size_t len) +{ + typedef typename PVT::value_type value_type; - PVDataCreatePtr factory = getPVDataCreate(); - assert(factory.get()!=NULL); + typename PVT::svector empty(0), data(len); - ofile<<"\tPVBooleanArray\n"; - //bool boolEmpty[] = { false }; - //bool bv[] = { false, true, false, true, true }; - PVBooleanArrayPtr pvBoolean = - std::tr1::static_pointer_cast(factory->createPVScalarArray(epics::pvData::pvBoolean)); - //pvBoolean->put(0, 0, boolEmpty, 0); - serializationTest(pvBoolean); - //pvBoolean->put(0, 5, bv, 0); - serializationTest(pvBoolean); + std::copy(rdata, rdata+len, data.begin()); - ofile<<"\tPVByteArray\n"; - int8 byteEmpty[] = { 0 }; - int8 byv[] = { 0, 1, 2, -1, BYTE_MAX_VALUE, BYTE_MAX_VALUE-1, - BYTE_MIN_VALUE+1, BYTE_MIN_VALUE }; - PVByteArrayPtr pvByte = - std::tr1::static_pointer_cast(factory->createPVScalarArray(epics::pvData::pvByte)); - pvByte->put(0, 0, byteEmpty, 0); - serializationTest(pvByte); - pvByte->put(0, 8, byv, 0); - serializationTest(pvByte); + testDiag("type %s", ScalarTypeFunc::name(PVT::typeCode)); - ofile<<"\tPVShortArray\n"; - int16 shortEmpty[] = { 0 }; - int16 sv[] = { 0, 1, 2, -1, SHORT_MAX_VALUE, SHORT_MAX_VALUE-1, - SHORT_MIN_VALUE+1, SHORT_MIN_VALUE }; - PVShortArrayPtr pvShort = - std::tr1::static_pointer_cast(factory->createPVScalarArray(epics::pvData::pvShort)); - pvShort->put(0, 0, shortEmpty, 0); - serializationTest(pvShort); - pvShort->put(0, 8, sv, 0); - serializationTest(pvShort); + typename PVT::shared_pointer pv = std::tr1::static_pointer_cast(getPVDataCreate()->createPVScalarArray(PVT::typeCode)); - ofile<<"\tPVIntArray\n"; - int32 intEmpty[] = { 0 }; - int32 iv[] = { 0, 1, 2, -1, INT_MAX_VALUE, INT_MAX_VALUE-1, - INT_MIN_VALUE+1, INT_MIN_VALUE }; - PVIntArrayPtr pvInt = - std::tr1::static_pointer_cast(factory->createPVScalarArray(epics::pvData::pvInt)); - pvInt->put(0, 0, intEmpty, 0); - serializationTest(pvInt); - pvInt->put(0, 8, iv, 0); - serializationTest(pvInt); - - ofile<<"\tPVLongArray\n"; - int64 longEmpty[] = { 0 }; - int64 lv[] = { 0, 1, 2, -1, LONG_MAX_VALUE, LONG_MAX_VALUE-1, - LONG_MIN_VALUE+1, LONG_MIN_VALUE }; - PVLongArrayPtr pvLong = - std::tr1::static_pointer_cast(factory->createPVScalarArray(epics::pvData::pvLong)); - pvLong->put(0, 0, longEmpty, 0); - serializationTest(pvLong); - pvLong->put(0, 8, lv, 0); - serializationTest(pvLong); - - ofile<<"\tPVUByteArray\n"; - uint8 ubyteEmpty[] = { 0 }; - uint8 ubyv[] = { 0, 1, 2, -1, BYTE_MAX_VALUE, BYTE_MAX_VALUE-1, - BYTE_MIN_VALUE+1, BYTE_MIN_VALUE, UBYTE_MAX_VALUE }; - PVUByteArrayPtr pvUByte = - std::tr1::static_pointer_cast(factory->createPVScalarArray(epics::pvData::pvUByte)); - pvUByte->put(0, 0, ubyteEmpty, 0); - serializationTest(pvUByte); - pvUByte->put(0, 9, ubyv, 0); - serializationTest(pvUByte); - - ofile<<"\tPVUShortArray\n"; - uint16 ushortEmpty[] = { 0 }; - uint16 usv[] = { 0, 1, 2, -1, SHORT_MAX_VALUE, SHORT_MAX_VALUE-1, - SHORT_MIN_VALUE+1, SHORT_MIN_VALUE, USHORT_MAX_VALUE }; - PVUShortArrayPtr pvUShort = - std::tr1::static_pointer_cast(factory->createPVScalarArray(epics::pvData::pvUShort)); - pvUShort->put(0, 0, ushortEmpty, 0); - serializationTest(pvUShort); - pvUShort->put(0, 8, usv, 0); - serializationTest(pvUShort); - - ofile<<"\tPVUIntArray\n"; - uint32 uintEmpty[] = { 0 }; - uint32 uiv[] = { 0, 1, 2, -1, INT_MAX_VALUE, INT_MAX_VALUE-1, - INT_MIN_VALUE+1, INT_MIN_VALUE, UINT_MAX_VALUE }; - PVUIntArrayPtr pvUInt = - std::tr1::static_pointer_cast(factory->createPVScalarArray(epics::pvData::pvUInt)); - pvUInt->put(0, 0, uintEmpty, 0); - serializationTest(pvUInt); - pvUInt->put(0, 9, uiv, 0); - serializationTest(pvUInt); - - ofile<<"\tPVULongArray\n"; - uint64 ulongEmpty[] = { 0 }; - uint64 ulv[] = { 0, 1, 2, -1, LONG_MAX_VALUE, LONG_MAX_VALUE-1, - LONG_MIN_VALUE+1, LONG_MIN_VALUE, ULONG_MAX_VALUE }; - PVULongArrayPtr pvULong = - std::tr1::static_pointer_cast(factory->createPVScalarArray(epics::pvData::pvULong)); - pvULong->put(0, 0, ulongEmpty, 0); - serializationTest(pvULong); - pvULong->put(0, 9, ulv, 0); - serializationTest(pvULong); - - ofile<<"\tPVFloatArray\n"; - float floatEmpty[] = { (float)0.0 }; - float fv[] = { (float)0.0, (float)1.1, (float)2.3, (float)-1.4, - FLOAT_MAX_VALUE, FLOAT_MAX_VALUE-(float)123456.789, FLOAT_MIN_VALUE - +(float)1.1, FLOAT_MIN_VALUE }; - PVFloatArrayPtr pvFloat = - std::tr1::static_pointer_cast(factory->createPVScalarArray(epics::pvData::pvFloat)); - pvFloat->put(0, 0, floatEmpty, 0); - serializationTest(pvFloat); - pvFloat->put(0, 8, fv, 0); - serializationTest(pvFloat); - - ofile<<"\tPVDoubleArray\n"; - double doubleEmpty[] = { (double)0.0 }; - double dv[] = { (double)0.0, (double)1.1, (double)2.3, (double)-1.4, - DOUBLE_MAX_VALUE, DOUBLE_MAX_VALUE-(double)123456.789, - DOUBLE_MIN_VALUE+(double)1.1, DOUBLE_MIN_VALUE }; - PVDoubleArrayPtr pvDouble = - std::tr1::static_pointer_cast(factory->createPVScalarArray(epics::pvData::pvDouble)); - pvDouble->put(0, 0, doubleEmpty, 0); - serializationTest(pvDouble); - pvDouble->put(0, 8, dv, 0); - serializationTest(pvDouble); - - ofile<<"\tPVStringArray\n"; - String stringEmpty[] = { "" }; - String - strv[] = - { - "", - "a", - "a b", - " ", - "test", - "smile", - "this is a little longer string... maybe a little but longer... this makes test better", - String(10000, 'b') }; - PVStringArrayPtr pvString = - std::tr1::static_pointer_cast(factory->createPVScalarArray(epics::pvData::pvString)); - pvString->put(0, 0, stringEmpty, 0); - serializationTest(pvString); - pvString->put(0, 8, strv, 0); - serializationTest(pvString); - - ofile<<"!!! PASSED\n\n"; + pv->replace(empty); + serializationTest(pv); + pv->replace(data); + serializationTest(pv); } -void testNonInitialized(std::ostream& ofile) { - ofile<<"Testing non-initialized...\n"; +static const boolean bdata[] = {0, 1, 0, 1, 1}; + +static const int8 i8data[] = { 0, 1, 2, -1, BYTE_MAX_VALUE, BYTE_MAX_VALUE-1, + BYTE_MIN_VALUE+1, BYTE_MIN_VALUE }; +static const uint8 u8data[] = { 0, 1, 2, -1, UBYTE_MAX_VALUE, UBYTE_MAX_VALUE-1 }; + +static const int16 i16data[] = { 0, 1, 2, -1, SHORT_MAX_VALUE, SHORT_MAX_VALUE-1, + SHORT_MIN_VALUE+1, SHORT_MIN_VALUE }; +static const uint16 u16data[] = { 0, 1, 2, -1, USHORT_MAX_VALUE, USHORT_MAX_VALUE-1 }; + +static const int32 i32data[] = { 0, 1, 2, -1, INT_MAX_VALUE, INT_MAX_VALUE-1, + INT_MIN_VALUE+1, INT_MIN_VALUE }; +static const uint32 u32data[] = { 0, 1, 2, -1, UINT_MAX_VALUE, UINT_MAX_VALUE-1 }; + +static const int64 i64data[] = { 0, 1, 2, -1, LONG_MAX_VALUE, LONG_MAX_VALUE-1, + LONG_MIN_VALUE+1, LONG_MIN_VALUE }; +static const uint64 u64data[] = { 0, 1, 2, -1, ULONG_MAX_VALUE, ULONG_MAX_VALUE-1 }; + +static const double ddata[] = { (double)0.0, (double)1.1, (double)2.3, (double)-1.4, + DOUBLE_MAX_VALUE, DOUBLE_MAX_VALUE-(double)123456.789, + DOUBLE_MIN_VALUE+(double)1.1, DOUBLE_MIN_VALUE }; + +static const float fdata[] = { (float)0.0, (float)1.1, (float)2.3, (float)-1.4, + FLOAT_MAX_VALUE, FLOAT_MAX_VALUE-(float)123456.789, + FLOAT_MIN_VALUE+(float)1.1, FLOAT_MIN_VALUE }; + +static const String sdata[] = { + "", + "a", + "a b", + " ", + "test", + "smile", + "this is a little longer string... maybe a little but longer... this makes test better", + String(10000, 'b') +}; + +void testArray() { + testDiag("Testing arrays..."); + + testArrayType(bdata, NELEMENTS(bdata)); + + testArrayType(i8data, NELEMENTS(i8data)); + testArrayType(u8data, NELEMENTS(u8data)); + testArrayType(i16data, NELEMENTS(i16data)); + testArrayType(u16data, NELEMENTS(u16data)); + testArrayType(i32data, NELEMENTS(i32data)); + testArrayType(u32data, NELEMENTS(u32data)); + testArrayType(i64data, NELEMENTS(i64data)); + testArrayType(u64data, NELEMENTS(u64data)); + + testArrayType(ddata, NELEMENTS(ddata)); + testArrayType(fdata, NELEMENTS(fdata)); + + testArrayType(sdata, NELEMENTS(sdata)); +} + +void testNonInitialized() { + testDiag("Testing non-initialized..."); PVDataCreatePtr factory = getPVDataCreate(); - assert(factory.get()!=NULL); + testOk1(factory.get()!=NULL); // be sure all is covered for (int i = pvBoolean; i < pvString; i++) @@ -558,17 +336,15 @@ void testNonInitialized(std::ostream& ofile) { // and a structure array PVStructureArrayPtr structureArray = factory->createPVStructureArray(getFieldCreate()->createStructureArray(structure->getStructure())); serializationTest(structureArray); - - ofile<<"!!! PASSED\n\n"; } -void testStructure(std::ostream& ofile) { - ofile<<"Testing structure...\n"; +void testStructure() { + testDiag("Testing structure..."); PVDataCreatePtr factory = getPVDataCreate(); - assert(factory.get()!=NULL); + testOk1(factory.get()!=NULL); - ofile<<"\tSimple structure serialization\n"; + testDiag("\tSimple structure serialization"); PVStructurePtr pvStructure = factory->createPVStructure(getStandardField()->timeStamp()); pvStructure->getLongField("secondsPastEpoch")->put(123); pvStructure->getIntField("nanoSeconds")->put(456); @@ -576,21 +352,19 @@ void testStructure(std::ostream& ofile) { serializationTest(pvStructure); - ofile<<"\tComplex structure serialization\n"; + testDiag("\tComplex structure serialization"); pvStructure = factory->createPVStructure( getStandardField()->structureArray( getStandardField()->timeStamp(), "alarm,control,display,timeStamp") ); // TODO fill with data serializationTest(pvStructure); - - ofile<<"!!! PASSED\n\n"; } -void testStructureId(std::ostream& ofile) { - ofile<<"Testing structureID...\n"; +void testStructureId() { + testDiag("Testing structureID..."); FieldCreatePtr fieldCreate = getFieldCreate(); @@ -607,15 +381,13 @@ void testStructureId(std::ostream& ofile) { StructureConstPtr structure2 = fieldCreate->createStructure("id2", fieldNames, fields); - assert(structureWithNoId!=structure1); - assert(structure1!=structure2); + testOk1(structureWithNoId!=structure1); + testOk1(structure1!=structure2); //serializationTest(structure1); PVStructurePtr pvStructure = getPVDataCreate()->createPVStructure(structure1); serializationTest(pvStructure); - - ofile<<"!!! PASSED\n\n"; } void serializatioTest(FieldConstPtr const & field) @@ -631,17 +403,15 @@ void serializatioTest(FieldConstPtr const & field) FieldConstPtr deserializedField = getFieldCreate()->deserialize(buffer, control); // must equal - bool isEqual = *field == *deserializedField; - assert(isEqual); - //assertEquals("field " + field.toString() + " serialization broken", field, deserializedField); + testOk1(*field == *deserializedField); } -void testIntrospectionSerialization(std::ostream& ofile) +void testIntrospectionSerialization() { - ofile<<"Testing introspection serialization...\n"; + testDiag("Testing introspection serialization..."); FieldCreatePtr factory = getFieldCreate(); - assert(factory.get()!=NULL); + testOk1(factory.get()!=NULL); // be sure all is covered for (int i = pvBoolean; i < pvString; i++) @@ -662,42 +432,34 @@ void testIntrospectionSerialization(std::ostream& ofile) // and a structure array StructureArrayConstPtr structureArray = factory->createStructureArray(structure); serializatioTest(structureArray); - - ofile<<"!!! PASSED\n\n"; } -void testStringCopy(std::ostream& ofile) { +void testStringCopy() { String s1 = "abc"; String s2 = s1; if (s1.c_str() != s2.c_str()) - ofile << "\n!!! implementation of epics::pvData::String assignment operator does not share content !!!\n\n"; + testDiag("implementation of epics::pvData::String assignment operator does not share content"); } -int main(int argc, char *argv[]) { - std::ofstream outfile; - std::ostream *out=NULL; - if(argc>1) { - outfile.open(argv[1]); - if(outfile.is_open()){ - out=&outfile; - }else{ - fprintf(stderr, "Failed to open test output file\n"); - } - } - if(!out) out=&std::cout; +} // end namespace + +MAIN(testSerialization) { + + testPlan(171); + flusher = new SerializableControlImpl(); control = new DeserializableControlImpl(); buffer = new ByteBuffer(1<<16); - testStringCopy(*out); + testStringCopy(); - testIntrospectionSerialization(*out); - testEquals(*out); - testNonInitialized(*out); + testIntrospectionSerialization(); + testEquals(); + testNonInitialized(); - testScalar(*out); - testArray(*out); - testStructure(*out); + testScalar(); + testArray(); + testStructure(); delete buffer; @@ -705,6 +467,6 @@ int main(int argc, char *argv[]) { delete flusher; epicsExitCallAtExits(); - return 0; + return testDone(); }