272 lines
9.0 KiB
C++
272 lines
9.0 KiB
C++
#include <stdexcept>
|
|
|
|
#include <pv/pvUnitTest.h>
|
|
#include <testMain.h>
|
|
|
|
#include <dbStaticLib.h>
|
|
#include <epicsTypes.h>
|
|
#include <pv/valueBuilder.h>
|
|
#include <pv/pvData.h>
|
|
|
|
|
|
#include "pvif.h"
|
|
|
|
namespace pvd = epics::pvData;
|
|
|
|
namespace {
|
|
template<pvd::ScalarType ENUM, typename DBF, typename E>
|
|
void testPVD2DBR_scalar(unsigned dbf, typename pvd::meta::arg_type<typename pvd::ScalarTypeTraits<ENUM>::type>::type V, E expect)
|
|
{
|
|
testDiag("testPVD2DBR_scalar(%s, %s)", pvd::ScalarTypeFunc::name(ENUM), dbGetFieldTypeString(dbf));
|
|
|
|
pvd::PVStructure::shared_pointer top(pvd::ValueBuilder()
|
|
.add<ENUM>("value", V)
|
|
.buildPVStructure());
|
|
|
|
DBF buf;
|
|
|
|
copyPVD2DBF(top->getSubFieldT("value"), &buf, dbf, NULL);
|
|
|
|
testEqual(buf, expect);
|
|
}
|
|
|
|
void testPVD2DBR_enum()
|
|
{
|
|
testDiag("testPVD2DBR_enum()");
|
|
|
|
pvd::shared_vector<std::string> choices(3);
|
|
choices[0] = "zero";
|
|
choices[1] = "one";
|
|
choices[2] = "two";
|
|
|
|
pvd::PVStructure::shared_pointer top(pvd::ValueBuilder()
|
|
.addNested("value")
|
|
.add<pvd::pvInt>("index", 1)
|
|
.add("choices", pvd::static_shared_vector_cast<const void>(pvd::freeze(choices)))
|
|
.endNested()
|
|
.buildPVStructure());
|
|
|
|
{
|
|
epicsEnum16 ival;
|
|
|
|
copyPVD2DBF(top->getSubFieldT("value"), &ival, DBF_ENUM, NULL);
|
|
testEqual(ival, 1);
|
|
|
|
ival = 0;
|
|
|
|
testOk1(!!top->getSubField("value"));
|
|
copyPVD2DBF(top->getSubFieldT("value"), &ival, DBF_USHORT, NULL);
|
|
testEqual(ival, 1);
|
|
}
|
|
|
|
{
|
|
epicsUInt32 ival;
|
|
|
|
copyPVD2DBF(top->getSubFieldT("value"), &ival, DBF_LONG, NULL);
|
|
testEqual(ival, 1u);
|
|
}
|
|
|
|
char sval[MAX_STRING_SIZE];
|
|
|
|
copyPVD2DBF(top->getSubFieldT("value"), sval, DBF_STRING, NULL);
|
|
testEqual(std::string(sval) , "one");
|
|
}
|
|
|
|
void testPVD2DBR_array()
|
|
{
|
|
testDiag("testPVD2DBR_array()");
|
|
|
|
pvd::shared_vector<const pvd::uint32> arr;
|
|
{
|
|
pvd::shared_vector<pvd::uint32> iarr(3);
|
|
iarr[0] = 1; iarr[1] = 2; iarr[2] = 3;
|
|
arr = pvd::freeze(iarr);
|
|
}
|
|
|
|
pvd::PVStructure::shared_pointer top(pvd::ValueBuilder()
|
|
.add("value", pvd::static_shared_vector_cast<const void>(arr))
|
|
.buildPVStructure());
|
|
|
|
{
|
|
epicsUInt16 sarr[5];
|
|
|
|
{
|
|
long nreq = 5;
|
|
copyPVD2DBF(top->getSubFieldT("value"), sarr, DBF_SHORT, &nreq);
|
|
testEqual(nreq, 3);
|
|
}
|
|
|
|
testEqual(sarr[0], arr[0]);
|
|
testEqual(sarr[1], arr[1]);
|
|
testEqual(sarr[2], arr[2]);
|
|
}
|
|
|
|
{
|
|
char sarr[MAX_STRING_SIZE*5];
|
|
|
|
{
|
|
long nreq = 5;
|
|
copyPVD2DBF(top->getSubFieldT("value"), sarr, DBF_STRING, &nreq);
|
|
testEqual(nreq, 3);
|
|
}
|
|
|
|
testEqual(sarr[0*MAX_STRING_SIZE+0], '1');
|
|
testEqual(int(sarr[0*MAX_STRING_SIZE+1]), int('\0'));
|
|
testEqual(sarr[1*MAX_STRING_SIZE+0], '2');
|
|
testEqual(int(sarr[1*MAX_STRING_SIZE+1]), int('\0'));
|
|
testEqual(sarr[2*MAX_STRING_SIZE+0], '3');
|
|
testEqual(int(sarr[2*MAX_STRING_SIZE+1]), int('\0'));
|
|
}
|
|
}
|
|
|
|
template<typename input_t, typename output_t>
|
|
void testDBR2PVD_scalar(const input_t& input,
|
|
const output_t& expect)
|
|
{
|
|
pvd::ScalarType in = (pvd::ScalarType)pvd::ScalarTypeID<input_t>::value;
|
|
pvd::ScalarType out = (pvd::ScalarType)pvd::ScalarTypeID<output_t>::value;
|
|
testDiag("testDBR2PVD_scalar(%s, %s)", pvd::ScalarTypeFunc::name(in), pvd::ScalarTypeFunc::name(out));
|
|
|
|
pvd::PVStructure::shared_pointer top(pvd::getPVDataCreate()->createPVStructure(pvd::getFieldCreate()->createFieldBuilder()
|
|
->add("value", out) // initially zero or ""
|
|
->createStructure()));
|
|
pvd::PVStringArray::const_svector choices;
|
|
pvd::BitSet changed;
|
|
|
|
pvd::shared_vector<input_t> buf(1);
|
|
buf[0] = input;
|
|
|
|
copyDBF2PVD(pvd::static_shared_vector_cast<const void>(pvd::freeze(buf)),
|
|
top->getSubFieldT("value"), changed, choices);
|
|
|
|
output_t actual = top->getSubFieldT<pvd::PVScalar>("value")->getAs<output_t>();
|
|
testEqual(actual, expect);
|
|
testOk1(changed.get(top->getSubFieldT("value")->getFieldOffset()));
|
|
}
|
|
|
|
template<typename input_t>
|
|
void testDBR2PVD_enum(const input_t& input, pvd::int32 expect)
|
|
{
|
|
testDiag("testDBR2PVD_enum()");
|
|
|
|
pvd::shared_vector<const std::string> choices;
|
|
{
|
|
pvd::shared_vector<std::string> temp(3);
|
|
temp[0] = "zero";
|
|
temp[1] = "one";
|
|
temp[2] = "two";
|
|
choices = pvd::freeze(temp);
|
|
}
|
|
|
|
pvd::PVStructure::shared_pointer top(pvd::ValueBuilder()
|
|
.addNested("value")
|
|
.add<pvd::pvInt>("index", 0)
|
|
.add("choices", pvd::static_shared_vector_cast<const void>(choices))
|
|
.endNested()
|
|
.buildPVStructure());
|
|
|
|
pvd::BitSet changed;
|
|
|
|
pvd::shared_vector<input_t> buf(1);
|
|
buf[0] = input;
|
|
|
|
copyDBF2PVD(pvd::static_shared_vector_cast<const void>(pvd::freeze(buf)),
|
|
top->getSubFieldT("value"), changed, choices);
|
|
|
|
pvd::int32 actual = top->getSubFieldT<pvd::PVScalar>("value.index")->getAs<pvd::int32>();
|
|
testShow()<<top;
|
|
testShow()<<changed;
|
|
testEqual(actual, expect);
|
|
testOk1(changed.get(top->getSubFieldT("value.index")->getFieldOffset()));
|
|
}
|
|
|
|
void testDBR2PVD_array()
|
|
{
|
|
testDiag("testDBR2PVD_array()");
|
|
|
|
pvd::PVStructure::shared_pointer top(pvd::getPVDataCreate()->createPVStructure(pvd::getFieldCreate()->createFieldBuilder()
|
|
->addArray("value", pvd::pvInt) // initially zero or ""
|
|
->createStructure()));
|
|
pvd::PVStringArray::const_svector choices;
|
|
pvd::BitSet changed;
|
|
|
|
{
|
|
pvd::shared_vector<pvd::uint32> buf(3);
|
|
buf[0] = 1; buf[1] = 2; buf[2] = 3;
|
|
copyDBF2PVD(pvd::static_shared_vector_cast<const void>(pvd::freeze(buf)),
|
|
top->getSubFieldT("value"), changed, choices);
|
|
|
|
pvd::PVIntArray::const_svector arr(top->getSubFieldT<pvd::PVIntArray>("value")->view());
|
|
testEqual(arr.size(), 3u);
|
|
testEqual(arr[0], 1);
|
|
testEqual(arr[1], 2);
|
|
testEqual(arr[2], 3);
|
|
testOk1(changed.get(top->getSubFieldT("value")->getFieldOffset()));
|
|
}
|
|
|
|
changed.clear();
|
|
|
|
{
|
|
pvd::shared_vector<std::string> buf(4);
|
|
buf[0] = "4";
|
|
buf[1] = "5";
|
|
buf[2] = "6";
|
|
buf[3] = "7";
|
|
|
|
copyDBF2PVD(pvd::static_shared_vector_cast<const void>(pvd::freeze(buf)),
|
|
top->getSubFieldT("value"), changed, choices);
|
|
|
|
pvd::PVIntArray::const_svector arr(top->getSubFieldT<pvd::PVIntArray>("value")->view());
|
|
testEqual(arr.size(), 4u);
|
|
testEqual(arr[0], 4);
|
|
testEqual(arr[1], 5);
|
|
testEqual(arr[2], 6);
|
|
testEqual(arr[3], 7);
|
|
testOk1(changed.get(top->getSubFieldT("value")->getFieldOffset()));
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
MAIN(testdbf_copy)
|
|
{
|
|
testPlan(53);
|
|
try{
|
|
testPVD2DBR_scalar<pvd::pvDouble, double>(DBF_DOUBLE, 42.2, 42.2);
|
|
testPVD2DBR_scalar<pvd::pvDouble, pvd::uint16>(DBF_USHORT, 42.2, 42u);
|
|
|
|
testPVD2DBR_scalar<pvd::pvInt, pvd::int32>(DBF_LONG, 42, 42);
|
|
testPVD2DBR_scalar<pvd::pvInt, char[MAX_STRING_SIZE]>(DBF_STRING, 42, std::string("42"));
|
|
|
|
testPVD2DBR_scalar<pvd::pvLong, pvd::int64>(DBF_INT64, 42, 42);
|
|
testPVD2DBR_scalar<pvd::pvLong, char[MAX_STRING_SIZE]>(DBF_STRING, 42, std::string("42"));
|
|
|
|
testPVD2DBR_scalar<pvd::pvUShort, pvd::uint16>(DBF_USHORT, 41u, 41);
|
|
testPVD2DBR_scalar<pvd::pvByte, pvd::int8>(DBF_CHAR, 41, 41);
|
|
|
|
testPVD2DBR_scalar<pvd::pvString, char[MAX_STRING_SIZE]>(DBF_STRING, "hello", std::string("hello"));
|
|
testPVD2DBR_scalar<pvd::pvString, pvd::int32>(DBF_LONG, "-100", -100);
|
|
|
|
//testPVD2DBR_scalar<pvd::pvBoolean, pvd::int8>(DBF_CHAR, true, 1);
|
|
|
|
testPVD2DBR_enum();
|
|
|
|
testPVD2DBR_array();
|
|
|
|
testDBR2PVD_scalar<double, double>(42.2, 42.2);
|
|
testDBR2PVD_scalar<pvd::uint16, double>(42u, 42.0);
|
|
testDBR2PVD_scalar<pvd::int32, pvd::int32>(-41, -41);
|
|
testDBR2PVD_scalar<std::string, pvd::int32>("-41", -41);
|
|
testDBR2PVD_scalar<std::string, std::string>("hello", "hello");
|
|
testDBR2PVD_scalar<pvd::int32, std::string>(-42, "-42");
|
|
|
|
testDBR2PVD_enum<pvd::uint32>(2, 2);
|
|
testDBR2PVD_enum<std::string>("two", 2);
|
|
|
|
testDBR2PVD_array();
|
|
}catch(std::exception& e){
|
|
testFail("Unexpected exception: %s", e.what());
|
|
}
|
|
return testDone();
|
|
}
|