testLMapBitRangePlugin.cc

Go to the documentation of this file.

// SPDX-FileCopyrightText: Deutsches Elektronen-Synchrotron DESY, MSK, ChimeraTK Project <chimeratk-support@desy.de>
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#include "TransferGroup.h"
#define BOOST_TEST_DYN_LINK
#define BOOST_TEST_MODULE LMapBitRangePluginTest
#include <boost/test/unit_test.hpp>
using namespace boost::unit_test_framework;
 
#include "Device.h"
 
using namespace ChimeraTK;
 
BOOST_AUTO_TEST_SUITE(LMapBitRangeTestSuite)
 
/**********************************************************************************************************************/
 
BOOST_AUTO_TEST_CASE(testSimpleRead) {
  ChimeraTK::Device device;
  device.open("(logicalNameMap?map=bitRangeReadPlugin.xlmap)");
 
  auto accTarget = device.getScalarRegisterAccessor<int>("SimpleScalar");
 
  auto accRangedHi = device.getScalarRegisterAccessor<uint16_t>("HiByte");
  auto accRangedMid = device.getScalarRegisterAccessor<uint16_t>("MidByte");
  auto accRangedLo = device.getScalarRegisterAccessor<uint16_t>("LoByte");
 
  accTarget.setAndWrite(0x1f0f);
 
  accRangedLo.read();
  accRangedHi.read();
  accRangedMid.read();
 
  BOOST_TEST(accRangedLo == 0x0f);
  BOOST_TEST(accRangedHi == 0x1f);
  BOOST_TEST(accRangedMid == 0xf0);
 
  TransferGroup group;
  group.addAccessor(accRangedLo);
  group.addAccessor(accRangedHi);
 
  accTarget.setAndWrite(0);
  group.read();
  BOOST_TEST(accRangedLo == 0);
  BOOST_TEST(accRangedHi == 0);
 
  accTarget.setAndWrite(0x5a1f);
  group.read();
  BOOST_TEST(accRangedLo == 0x1f);
  BOOST_TEST(accRangedHi == 0x5a);
}
 
BOOST_AUTO_TEST_CASE(testSimpleWrite) {
  ChimeraTK::Device device;
  device.open("(logicalNameMap?map=bitRangeReadPlugin.xlmap)");
 
  auto accTarget = device.getScalarRegisterAccessor<int>("SimpleScalar");
 
  auto accRangedHi = device.getScalarRegisterAccessor<uint16_t>("HiByte");
  auto accRangedMid = device.getScalarRegisterAccessor<uint16_t>("MidByte");
  auto accRangedLo = device.getScalarRegisterAccessor<uint16_t>("LoByte");
 
  accTarget.setAndWrite(0x1f0f);
  accRangedHi = 0x76;
  accRangedHi.write();
 
  accRangedMid.read();
  BOOST_TEST(accRangedMid == 0x60);
  accTarget.read();
  BOOST_TEST(accTarget == 0x760f);
 
  // Use of overlapping ranges in transfer groups is undefined, so only use
  // the distinct accessors
  auto group = TransferGroup();
  group.addAccessor(accRangedLo);
  group.addAccessor(accRangedHi);
 
  accRangedHi = 0x75;
  accRangedLo = 0x80;
 
  group.write();
  accTarget.read();
 
  BOOST_TEST(accTarget == 0x7580);
 
  // Add overlapping accessor to group, check that the group cannot be written anymore
  group.addAccessor(accRangedMid);
  BOOST_CHECK_THROW(group.write(), ChimeraTK::logic_error);
}
 
/**********************************************************************************************************************/
 
BOOST_AUTO_TEST_CASE(testAccessorSanity) {
  ChimeraTK::Device device;
  device.open("(logicalNameMap?map=bitRangeReadPlugin.xlmap)");
 
  // Manual test for spec B.2.4
  // Accessor too small for the configured number of bits
  auto accTarget = device.getScalarRegisterAccessor<int>("SimpleScalar");
 
  auto accMiddle = device.getScalarRegisterAccessor<int8_t>("Middle");
  accTarget.setAndWrite(0x1ff0);
  accMiddle.read();
  BOOST_TEST(accMiddle == 127);
  BOOST_CHECK(accMiddle.dataValidity() == ChimeraTK::DataValidity::faulty);
 
  // The Number of bits requested from the target register is larger than the register
  auto accTooLarge = device.getScalarRegisterAccessor<int16_t>("TooLarge");
  accTooLarge.setAndWrite(0xff1);
  accTarget.read();
  BOOST_CHECK(accTarget == std::numeric_limits<int16_t>::max());
 
  // The number of bits requested is smaller than what is available in the user type and the value
  // written in the accessor is larger than maximum value in those bits
  accTarget.setAndWrite(0);
  accMiddle.read(); // To get the 0 into the shared buffer.
 
  auto accMiddle2 = device.getScalarRegisterAccessor<int16_t>("MidByte");
  accMiddle2.setAndWrite(0x100);
  accTarget.read();
  BOOST_TEST(accTarget == 0x0ff0);
  // FIXME: This is currently not implemented in the plugin, because it needs changes in the fixed point converter
  // see https://redmine.msktools.desy.de/issues/12912
  // BOOST_CHECK(accMiddle2.dataValidity() == ChimeraTK::DataValidity::faulty);
}
 
/**********************************************************************************************************************/
 
BOOST_AUTO_TEST_CASE(testMathPluginChaining) {
  ChimeraTK::Device device;
  // Regression test that you can chain the bit range plugin with the math plugin
  // The LoByteClamped register is the low-byte of SimpleScalar, but has a math plugin
  // chained that will clamp the written value
  device.open("(logicalNameMap?map=bitRangeReadPlugin.xlmap)");
 
  auto accTarget = device.getScalarRegisterAccessor<int>("SimpleScalar");
  accTarget.setAndWrite(0x1fff);
 
  // Write some value in range (range is 0-5).
  auto accClamped = device.getScalarRegisterAccessor<int8_t>("LoByteClamped");
  accClamped.setAndWrite(0x01);
  accTarget.read();
  // Check that the value is passed through correctly and that the upper byte is unchanged.
  BOOST_TEST(accTarget == 0x1f01);
  BOOST_CHECK(accTarget.dataValidity() == ChimeraTK::DataValidity::ok);
 
  // Write some value outside of the range clamped by the math plugin.
  accClamped.setAndWrite(55);
  accTarget.read();
 
  // Check that the value is passed through the math plugin (clamped to max) and that the upper byte is unchanged.
  BOOST_TEST(accTarget == 0x1f05);
  BOOST_CHECK(accTarget.dataValidity() == ChimeraTK::DataValidity::ok);
}
 
/**********************************************************************************************************************/
 
BOOST_AUTO_TEST_CASE(testBitExtraction) {
  ChimeraTK::Device device;
  device.open("(logicalNameMap?map=bitRangeReadPlugin.xlmap)");
 
  auto accTarget = device.getScalarRegisterAccessor<int>("SimpleScalar");
  accTarget.setAndWrite(0x5555);
 
  auto accRangedHi = device.getScalarRegisterAccessor<uint16_t>("HiByte");
 
  auto accBit0 = device.getScalarRegisterAccessor<ChimeraTK::Boolean>("Bit0");
  auto accBit1 = device.getScalarRegisterAccessor<ChimeraTK::Boolean>("Bit1");
  auto accBit2 = device.getScalarRegisterAccessor<ChimeraTK::Boolean>("Bit2");
  auto accBit3 = device.getScalarRegisterAccessor<ChimeraTK::Boolean>("Bit3");
 
  // See that the bits we get match the value we have
  accBit0.read();
  accBit1.read();
  accBit2.read();
  accBit3.read();
 
  BOOST_TEST(accBit0);
  BOOST_TEST(!accBit1);
  BOOST_TEST(accBit2);
  BOOST_TEST(!accBit3);
 
  // Write to the part that is not mapped to single bits
  // make sure the single bits are not modified
  accRangedHi.setAndWrite(0x11);
  accTarget.read();
 
  BOOST_TEST(accTarget == 0x1155);
 
  accBit0.read();
  accBit1.read();
  accBit2.read();
  accBit3.read();
 
  BOOST_TEST(accBit0);
  BOOST_TEST(!accBit1);
  BOOST_TEST(accBit2);
  BOOST_TEST(!accBit3);
 
  // Toggle single bits, make sure that this does not spread across the rest of the bits
  accBit1.setAndWrite(true);
  accBit3.setAndWrite(true);
 
  accTarget.read();
 
  BOOST_TEST(accTarget == 0x115F);
  accRangedHi.read();
  BOOST_TEST(accRangedHi == 0x11);
}
 
/**********************************************************************************************************************/
 
BOOST_AUTO_TEST_CASE(TestReadOnceRememberModifyWrite) {
  ChimeraTK::Device device("(logicalNameMap?map=bitRangeReadPlugin.xlmap)");
  device.open();
 
  auto accTarget = device.getScalarRegisterAccessor<int>("SimpleScalar");
  auto accLo = device.getScalarRegisterAccessor<uint16_t>("LoByte");
 
  // Set initial value on the device. SimpleScalar is int16 so values must stay within range.
  accTarget.setAndWrite(0x1234);
 
  // First write to LoByte: this is the "read once" step.
  // The decorator reads 0x1234 from the device into the shared buffer,
  // modifies the low byte (0xAB → 0x34→0xAB), and writes back 0x12AB.
  accLo = 0xAB;
  accLo.write();
  accTarget.read();
  BOOST_TEST(accTarget == 0x12AB);
 
  // Simulate another accessor modifying the underlying register directly.
  // This bypasses the shared buffer.
  accTarget.setAndWrite(0x3FFF); // still within int16
 
  // Second write to LoByte: this is the "remember" step.
  // The decorator does NOT re-read from the device. It uses the cached
  // shared-buffer value (still 0x12AB, not the current device value 0x3FFF).
  // So the write modifies 0x12AB → 0x1201, not 0x3FFF → 0x3F01.
  accLo = 0x01;
  accLo.write();
  accTarget.read();
  BOOST_TEST(accTarget == 0x1201);
 
  // Demonstrate shared buffer between two bit-range accessors.
  // Write to HiByte (first write): since shared buffer version is already >= versionOnOpen
  // (set by previous LoByte writes), it also uses the cached value 0x1201 without reading.
  accTarget.setAndWrite(0x7F23);
  auto accHi = device.getScalarRegisterAccessor<uint16_t>("HiByte");
  accHi = 0x3B;
  accHi.write();
  accTarget.read();
  BOOST_TEST(accTarget == 0x3B01);
 
  // Close and re-open the device.
  device.close();
  device.open();
 
  // Modify value on the device.
  accTarget.setAndWrite(0x7F00);
 
  // First write to LoByte after re-open: must re-read from device.
  accLo = 0x55;
  accLo.write();
  accTarget.read();
  BOOST_TEST(accTarget == 0x7F55);
}
 
/**********************************************************************************************************************/
 
BOOST_AUTO_TEST_CASE(testDataDescription) {
  ChimeraTK::Device device;
  device.open("(logicalNameMap?map=bitRangeReadPlugin.xlmap)");
 
  auto accTarget = device.getScalarRegisterAccessor<int>("SimpleScalar");
  accTarget.setAndWrite(0x5555);
 
  auto accLo = device.getScalarRegisterAccessor<uint8_t>("LoByte");
  auto accLoSigned = device.getScalarRegisterAccessor<int8_t>("LowerSigned");
 
  accLo.read();
  accLoSigned.read();
  BOOST_TEST(accLo == 85);
  BOOST_TEST(accLoSigned == 85);
 
  accTarget.setAndWrite(0x5580);
 
  accLo.read();
  accLoSigned.read();
 
  BOOST_TEST(int(accLo) == 128);
  BOOST_TEST(int(accLoSigned) == -128);
 
  accTarget.setAndWrite(0x5555);
  auto accFixed = device.getScalarRegisterAccessor<float>("LowerFixedPoint");
  accFixed.read();
  BOOST_TEST(accFixed == 5.3125);
}
 
/**********************************************************************************************************************/
 
BOOST_AUTO_TEST_SUITE_END()