From 0ab4f937a7fba1c35f066700a8991a513861bb74 Mon Sep 17 00:00:00 2001 From: Michael Davidsaver Date: Tue, 8 Jan 2019 08:23:13 -0800 Subject: [PATCH] test 64-bit integer field access --- testApp/testpvif.cpp | 98 ++++++++++++++++++++++++++++++++++++++++++- testApp/testpvif64.db | 8 ++++ 2 files changed, 105 insertions(+), 1 deletion(-) create mode 100644 testApp/testpvif64.db diff --git a/testApp/testpvif.cpp b/testApp/testpvif.cpp index 33d185f..a8361df 100644 --- a/testApp/testpvif.cpp +++ b/testApp/testpvif.cpp @@ -7,6 +7,14 @@ #include #include #include +#include + +#ifdef EPICS_VERSION_INT +# if EPICS_VERSION_INT>=VERSION_INT(3,16,1,0) +# define USE_INT64 +# include +# endif +#endif #include "helper.h" #include "pvif.h" @@ -28,11 +36,17 @@ void testScalar() testdbReadDatabase("p2pTestIoc.dbd", NULL, NULL); p2pTestIoc_registerRecordDeviceDriver(pdbbase); testdbReadDatabase("testpvif.db", NULL, NULL); +#ifdef USE_INT64 + testdbReadDatabase("testpvif64.db", NULL, NULL); +#endif longinRecord *prec_li = (longinRecord*)testdbRecordPtr("test:li"); stringinRecord *prec_si = (stringinRecord*)testdbRecordPtr("test:si"); aiRecord *prec_ai = (aiRecord*)testdbRecordPtr("test:ai"); mbbiRecord *prec_mbbi = (mbbiRecord*)testdbRecordPtr("test:mbbi"); +#ifdef USE_INT64 + int64inRecord *prec_i64 = (int64inRecord*)testdbRecordPtr("test:i64"); +#endif IOC.init(); @@ -44,6 +58,9 @@ void testScalar() DBCH chan_ai("test:ai"); DBCH chan_ai_rval("test:ai.RVAL"); DBCH chan_mbbi("test:mbbi"); +#ifdef USE_INT64 + DBCH chan_i64("test:i64"); +#endif testEqual(dbChannelFieldType(chan_li), DBR_LONG); testEqual(dbChannelFieldType(chan_si), DBR_STRING); testEqual(dbChannelFieldType(chan_ai), DBR_DOUBLE); @@ -53,10 +70,16 @@ void testScalar() testEqual(dbChannelFinalFieldType(chan_ai), DBR_DOUBLE); testEqual(dbChannelFinalFieldType(chan_ai_rval), DBR_LONG); testEqual(dbChannelFinalFieldType(chan_mbbi), DBR_ENUM); +#ifdef USE_INT64 + testEqual(dbChannelFinalFieldType(chan_i64), DBR_INT64); +#endif ScalarBuilder builder; pvd::FieldConstPtr dtype_li(builder.dtype(chan_li)); +#ifdef USE_INT64 + pvd::FieldConstPtr dtype_i64(builder.dtype(chan_i64)); +#endif pvd::FieldConstPtr dtype_si(builder.dtype(chan_si)); pvd::FieldConstPtr dtype_ai(builder.dtype(chan_ai)); pvd::FieldConstPtr dtype_ai_rval(builder.dtype(chan_ai_rval)); @@ -64,6 +87,9 @@ void testScalar() pvd::StructureConstPtr dtype_root(pvd::getFieldCreate()->createFieldBuilder() ->add("li", dtype_li) +#ifdef USE_INT64 + ->add("i64", dtype_i64) +#endif ->add("si", dtype_si) ->add("ai", dtype_ai) ->add("ai_rval", dtype_ai_rval) @@ -73,6 +99,9 @@ void testScalar() pvd::PVStructurePtr root(pvd::getPVDataCreate()->createPVStructure(dtype_root)); p2p::auto_ptr pvif_li(builder.attach(chan_li, root, FieldName("li"))); +#ifdef USE_INT64 + p2p::auto_ptr pvif_i64(builder.attach(chan_i64, root, FieldName("i64"))); +#endif p2p::auto_ptr pvif_si(builder.attach(chan_si, root, FieldName("si"))); p2p::auto_ptr pvif_ai(builder.attach(chan_ai, root, FieldName("ai"))); p2p::auto_ptr pvif_ai_rval(builder.attach(chan_ai_rval, root, FieldName("ai_rval"))); @@ -109,6 +138,39 @@ void testScalar() #undef OFF mask.clear(); +#ifdef USE_INT64 + + dbScanLock((dbCommon*)prec_i64); + prec_i64->time.secPastEpoch = 0x12345678; + prec_i64->time.nsec = 12345678; + pvif_i64->put(mask, DBE_VALUE|DBE_ALARM|DBE_PROPERTY, NULL); + dbScanUnlock((dbCommon*)prec_i64); + +#define OFF(NAME) (epicsUInt32)root->getSubFieldT(NAME)->getFieldOffset() + testEqual(mask, pvd::BitSet() + .set(OFF("i64.value")) + .set(OFF("i64.alarm.severity")) + .set(OFF("i64.alarm.status")) + .set(OFF("i64.alarm.message")) + .set(OFF("i64.timeStamp.secondsPastEpoch")) + .set(OFF("i64.timeStamp.nanoseconds")) + .set(OFF("i64.display.limitHigh")) + .set(OFF("i64.display.limitLow")) + .set(OFF("i64.display.description")) + .set(OFF("i64.display.units")) + .set(OFF("i64.display.format")) + .set(OFF("i64.control.limitHigh")) + .set(OFF("i64.control.limitLow")) + .set(OFF("i64.valueAlarm.highWarningLimit")) + .set(OFF("i64.valueAlarm.lowWarningLimit")) + .set(OFF("i64.valueAlarm.highAlarmLimit")) + .set(OFF("i64.valueAlarm.lowAlarmLimit"))) + <<" i64 changes\n"<stream().show(mask); +#undef OFF + mask.clear(); + +#endif + dbScanLock((dbCommon*)prec_si); prec_si->time.secPastEpoch = 0x12345678; prec_si->time.nsec = 12345678; @@ -211,6 +273,19 @@ void testScalar() testFieldEqual(root, "li.display.limitLow", 10.0); testFieldEqual(root, "li.display.units", "arb"); +#ifdef USE_INT64 + testFieldEqual(root, "i64.value", 0x7fffffffffffffffLL); + testFieldEqual(root, "i64.alarm.severity", 1); + testFieldEqual(root, "i64.alarm.status", 1); + testFieldEqual(root, "i64.timeStamp.secondsPastEpoch", 0x12345678+POSIX_TIME_AT_EPICS_EPOCH); + testFieldEqual(root, "i64.timeStamp.nanoseconds", 12345678); + testFieldEqual(root, "i64.display.limitHigh", 100.0); + testFieldEqual(root, "i64.display.limitLow", 10.0); + testTodoBegin("Bug in int64inRecord get_units()"); + testFieldEqual(root, "i64.display.units", "arb"); + testTodoEnd(); +#endif + testFieldEqual(root, "si.value", "hello"); testFieldEqual(root, "si.alarm.severity", 0); testFieldEqual(root, "si.timeStamp.secondsPastEpoch", 0x12345678+POSIX_TIME_AT_EPICS_EPOCH); @@ -250,6 +325,9 @@ void testScalar() } root->getSubFieldT("li.value")->put(102043); +#ifdef USE_INT64 + root->getSubFieldT("i64.value")->put(-0x8000000000000000LL); +#endif root->getSubFieldT("si.value")->put("world"); root->getSubFieldT("ai.value")->put(44.4); root->getSubFieldT("ai_rval.value")->put(2143); @@ -262,6 +340,15 @@ void testScalar() testEqual(prec_li->val, 102043); dbScanUnlock((dbCommon*)prec_li); +#ifdef USE_INT64 + dbScanLock((dbCommon*)prec_i64); + mask.clear(); + mask.set(root->getSubFieldT("i64.value")->getFieldOffset()); + pvif_i64->get(mask); + testEqual(prec_i64->val, epicsInt64(-0x8000000000000000LL)); + dbScanUnlock((dbCommon*)prec_i64); +#endif + dbScanLock((dbCommon*)prec_si); mask.clear(); mask.set(root->getSubFieldT("si.value")->getFieldOffset()); @@ -414,7 +501,16 @@ void testPlain() MAIN(testpvif) { - testPlan(71); + testPlan(71 +#ifdef USE_INT64 + +11 +#endif + ); +#ifdef USE_INT64 + testDiag("Testing of 64-bit field access"); +#else + testDiag("64-bit field access not supported"); +#endif testScalar(); testPlain(); return testDone(); diff --git a/testApp/testpvif64.db b/testApp/testpvif64.db new file mode 100644 index 0000000..a633058 --- /dev/null +++ b/testApp/testpvif64.db @@ -0,0 +1,8 @@ +record(int64in, "test:i64") { + field(VAL, "0x7fffffffffffffff") + field(SEVR, "1") + field(STAT, "1") + field(EGU, "arb") + field(HOPR, "100") + field(LOPR, "10") +}