testDataConsistencyAC.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
 
#define BOOST_TEST_MODULE testDataConsistencyAC
 
#include "Application.h"
#include "ApplicationModule.h"
#include "ArrayAccessor.h"
#include "ScalarAccessor.h"
#include "TestFacility.h"
#include "VoidAccessor.h"
 
#include <ChimeraTK/DataConsistencyGroup.h>
#include <ChimeraTK/DataConsistencyGroupHistorizedMatcher.h>
 
#include <boost/test/included/unit_test.hpp>
 
namespace Tests::testDataConsistencyAC {
 
  using namespace boost::unit_test_framework;
 
  using MatchingMode = ChimeraTK::DataConsistencyGroup::MatchingMode;
 
  /********************************************************************************************************************/
 
  struct ModuleA : ChimeraTK::ApplicationModule {
    explicit ModuleA(ChimeraTK::ModuleGroup* owner) : ChimeraTK::ApplicationModule(owner, "modA", "") {}
 
    ChimeraTK::VoidInput in1{this, "in1", ""};
    ChimeraTK::ScalarPushInput<unsigned> in2{this, "in2", "", ""};
    ChimeraTK::ArrayPushInput<unsigned> in3{this, "in3", "", 2, ""};
 
    ChimeraTK::ScalarOutput<unsigned> out1{this, "out1", "", ""};
    ChimeraTK::ScalarOutput<unsigned> out2{this, "out2", "", ""};
 
    void mainLoop() override {
      auto rag = readAnyGroup();
 
      ChimeraTK::DataConsistencyGroup dGroup{matchingMode};
      dGroup.add(in1);
      dGroup.add(in2);
      dGroup.add(in3);
 
      auto diagnostic = [&](ChimeraTK::TransferElementAbstractor& a) {
        return dynamic_cast<const ChimeraTK::DataConsistencyGroupDetail::HistorizedMatcher&>(dGroup.getMatcher())
            .getTargetElements()
            .at(a.getId())
            .lastMatchingIndex;
      };
 
      ChimeraTK::TransferElementID updatedId;
      while(true) {
        // note, in general it will be a good idea to consider initial values as consistent set; however, here
        // we do not process them
        if(dGroup.update(updatedId)) {
          std::cout << "ModuleA consistent, updated " << dGroup.getElements().at(updatedId).getName();
          if(matchingMode == MatchingMode::historized) {
            std::cout << ", histIndex(in1,in2,in3)=" << diagnostic(in1) << "," << diagnostic(in2) << ","
                      << diagnostic(in3);
          }
          std::cout << std::endl;
 
          out2 = in2 + 0;
          writeAllDestructively();
        }
        updatedId = rag.readAny();
      }
    }
    MatchingMode matchingMode;
  };
 
  struct TestFixture {
    struct Server : ChimeraTK::Application {
      Server() : Application("testSuite") {}
      ~Server() override { shutdown(); }
 
      ModuleA modA{this};
    } testApp;
    ChimeraTK::TestFacility testFacility{testApp};
  };
 
  /********************************************************************************************************************/
 
  /*
   * we test that MatchingMode::historized also works with ApplicationCore.
   * Explicit testing, in addition to DeviceAccess tests, makes sence because of MetaDataPropagatingRegisterDecorator.
   */
  BOOST_FIXTURE_TEST_CASE(testHistorizedMatching, TestFixture) {
    std::cout << "testHistorizedMatching" << std::endl;
 
    testApp.modA.matchingMode = MatchingMode::historized;
 
    auto in1 = testFacility.getVoid("/modA/in1");
    auto in2 = testFacility.getScalar<unsigned>("/modA/in2");
    auto in3 = testFacility.getArray<unsigned>("/modA/in3");
    auto out1 = testFacility.getScalar<unsigned>("/modA/out1");
    auto out2 = testFacility.getScalar<unsigned>("/modA/out2");
 
    testFacility.runApplication();
 
    ChimeraTK::VersionNumber vn;
    in1.write(vn);
    in2 = 10;
    in2.write(vn);
 
    // provided data not complete yet -> outputs should not be available
    testFacility.stepApplication();
    BOOST_TEST(out1.readLatest() == false);
 
    // complete provided data and check that output is available
    in3.write(vn);
    testFacility.stepApplication();
    BOOST_TEST(out1.readLatest() == true);
    out2.readLatest();
    BOOST_TEST(out2 == 10);
 
    // test that historizing actually helps:
    // let VersionNumber provided to in2 overtake the other inputs.
    ChimeraTK::VersionNumber vn2;
    in2 = 11;
    in2.write(vn2);
    ChimeraTK::VersionNumber vn3;
    in2 = 12;
    in2.setDataValidity(ChimeraTK::DataValidity::faulty);
    in2.write(vn3);
    in1.write(vn2);
    in3.write(vn2);
    testFacility.stepApplication();
    BOOST_TEST(out2.readLatest() == true);
    BOOST_TEST(out2 == 11);
 
    // Test version numbers as seen by consuming modules
    BOOST_TEST(out2.getVersionNumber() == vn2);
    // test whether versionNumber seen "from the inside" is correct
    BOOST_TEST(testApp.modA.out2.getVersionNumber() == vn2);
 
    // Test data validity as seen by consuming modules
    BOOST_TEST(out2.dataValidity() == ChimeraTK::DataValidity::ok);
    // "from the inside", we should also see correct VersionNumber
    BOOST_TEST(testApp.modA.out2.dataValidity() == ChimeraTK::DataValidity::ok);
 
    // check that clearing invalid does not cause crash
    in2.setDataValidity(ChimeraTK::DataValidity::faulty);
    in2.write();
    testFacility.stepApplication();
  }
 
  /********************************************************************************************************************/
 
  BOOST_FIXTURE_TEST_CASE(testExactMatching, TestFixture) {
    std::cout << "testExactMatching" << std::endl;
    testApp.modA.matchingMode = MatchingMode::exact;
 
    auto in1 = testFacility.getVoid("/modA/in1");
    auto in2 = testFacility.getScalar<unsigned>("/modA/in2");
    auto in3 = testFacility.getArray<unsigned>("/modA/in3");
    auto out1 = testFacility.getScalar<unsigned>("/modA/out1");
    auto out2 = testFacility.getScalar<unsigned>("/modA/out2");
 
    testFacility.runApplication();
 
    // with VersionNumber provided to in2 overtaking the other inputs, data should get lost.
    ChimeraTK::VersionNumber vn10;
    in2 = 20;
    in2.write(vn10);
    ChimeraTK::VersionNumber vn11;
    in2 = 21;
    in2.write(vn11);
    in1.write(vn10);
    in3.write(vn10);
    testFacility.stepApplication();
    BOOST_TEST(out2.readLatest() == false);
 
    // when other inputs catch up, we should see an update
    in1.write(vn11);
    in3.write(vn11);
    testFacility.stepApplication();
    BOOST_TEST(out2.readLatest() == true);
  }
 
  /********************************************************************************************************************/
 
  struct ModuleIVProvider : ChimeraTK::ApplicationModule {
    explicit ModuleIVProvider(ChimeraTK::ModuleGroup* owner) : ChimeraTK::ApplicationModule(owner, "modA", "") {}
 
    ChimeraTK::ScalarPushInput<unsigned> trigger{this, "/trigger", "", ""};
    ChimeraTK::ArrayOutput<unsigned> data{this, "/data", "", 10, ""};
 
    void mainLoop() override {
      // on initial value of trigger, do not provide data
      while(true) {
        trigger.read();
        data[0] = trigger;
        data[1] = 1;
        data.writeDestructively();
      }
    }
  };
 
  struct ModuleIVConsumer : ChimeraTK::ApplicationModule {
    explicit ModuleIVConsumer(ChimeraTK::ModuleGroup* owner) : ChimeraTK::ApplicationModule(owner, "modB", "") {}
 
    ChimeraTK::ScalarPushInput<unsigned> trigger{this, "/trigger", "", ""};
    ChimeraTK::ArrayPushInput<unsigned> data{this, "/data", "", 10, ""};
    ChimeraTK::ScalarOutput<ChimeraTK::Boolean> ok{this, "/ok", "", ""};
 
    void mainLoop() override {
      // on module startup, we should have inconsitent initial values
      std::cout << "ModuleIVConsumer initial vns: data.vn=" << data.getVersionNumber()
                << " trigger.vn=" << trigger.getVersionNumber() << std::endl;
      auto rag = readAnyGroup();
      ChimeraTK::DataConsistencyGroup dGroup(
          {data, trigger}, ChimeraTK::DataConsistencyGroup::MatchingMode::historized);
      assert(data[1] == 1);
      assert(!dGroup.isConsistent());
 
      ChimeraTK::TransferElementID updatedId;
      while(true) {
        updatedId = rag.readAny();
        for(auto& li : this->getAccessorListRecursive()) {
          auto& a = li.getAppAccessorNoType();
          if(a.getId() == updatedId) {
            std::cout << " updated=" << a.getName() << " vn=" << a.getVersionNumber()
                      << " cur.vn=" << getCurrentVersionNumber() << std::endl;
          }
        }
        std::cout << "data[0,1] = " << data[0] << " " << data[1] << std::endl;
        dGroup.update(updatedId);
        ok = dGroup.isConsistent() && data[1] == 1;
        writeAllDestructively();
      }
    }
  };
 
  struct TestFixtureIV {
    struct Server : ChimeraTK::Application {
      Server() : Application("testSuite") {}
      ~Server() override { shutdown(); }
 
      ModuleIVProvider modA{this};
      ModuleIVConsumer modB{this};
    } testApp;
    // cannot use TestableMode here since it waits on all modules entering main loop
    ChimeraTK::TestFacility testFacility{testApp, false};
  };
 
  BOOST_FIXTURE_TEST_CASE(testHistorizedInitialVals, TestFixtureIV) {
    std::cout << "testHistorizedInitialVals" << std::endl;
    // this is a regression test for a bug with MatchingMode::histored and initial values
    //
    // Let(A, B) be set of vars that should be consistent.
    // If initial Value A matches with value B coming in later, initial value of A might be lost.
    // This could happen because initial value was already swapped into MetaDataRegisterDecorator.
    auto trigger = testFacility.getScalar<unsigned>("/trigger");
 
    testFacility.runApplication();
 
    trigger.write();
    auto isOk = testFacility.getScalar<ChimeraTK::Boolean>("/ok");
    isOk.read();
    BOOST_TEST(isOk == true);
  }
 
  /********************************************************************************************************************/
 
} // namespace Tests::testDataConsistencyAC