Merge branch 'wip/ckampm/wip-fix-compatibility-da'

tests/executables_src/testPropagateDataFaultFlag.cc

@@ -557,6 +557,9 @@ struct Fixture_noTestableMode {
         ChimeraTK::BackendFactory::getInstance().createBackend(TestApplication3::ExceptionDummyCDD1))),
     device2DummyBackend(boost::dynamic_pointer_cast<ctk::ExceptionDummy>(
         ChimeraTK::BackendFactory::getInstance().createBackend(TestApplication3::ExceptionDummyCDD2))) {
+    auto device1Status =
+        test.getScalar<int32_t>(ctk::RegisterPath("/Devices") / TestApplication3::ExceptionDummyCDD1 / "status");
+
     device1DummyBackend->open();
     device2DummyBackend->open();
 
@@ -567,6 +570,7 @@ struct Fixture_noTestableMode {
     test.setScalarDefault("m1/o1", DEFAULT);
 
     test.runApplication();
+    CHECK_EQUAL_TIMEOUT((device1Status.readLatest(), device1Status), 0, 100000);
 
     // Making sure the default is written to the device before proceeding.
     auto m1o1 = device1DummyBackend->getRegisterAccessor<int>("m1/o1", 1, 0, false);
@@ -594,6 +598,9 @@ BOOST_AUTO_TEST_CASE(testDeviceReadFailure) {
   auto threadedFanoutInput = test.getScalar<int>("m1/o1");
   auto result = test.getScalar<int>("m1/Module1_result");
 
+  auto device2Status =
+      test.getScalar<int32_t>(ctk::RegisterPath("/Devices") / TestApplication3::ExceptionDummyCDD2 / "status");
+
   threadedFanoutInput = 10000;
   consumingFanoutSource = 1000;
   pollRegister = 1;
@@ -607,29 +614,40 @@ BOOST_AUTO_TEST_CASE(testDeviceReadFailure) {
 
   // -------------------------------------------------------------//
   // device module exception
+  threadedFanoutInput = 20000;
   pollRegister = 0;
 
   device2DummyBackend->throwExceptionRead = true;
 
   threadedFanoutInput.write();
-  // when the error detected the old value is written with faulty flag
+  // The new value from the fanout input should have been propagated,
+  // the new value of the poll input is not seen, because it gets skipped
   result.read();
-  BOOST_CHECK_EQUAL(result, 11001);
+  BOOST_CHECK_EQUAL(result, 21001);
   BOOST_CHECK(result.dataValidity() == ctk::DataValidity::faulty);
 
   // -------------------------------------------------------------//
+
+  threadedFanoutInput = 30000;
+  threadedFanoutInput.write();
+  // Further reads to the poll input are skipped
+  result.read();
+  BOOST_CHECK_EQUAL(result, 31001);
+  BOOST_CHECK(result.dataValidity() == ctk::DataValidity::faulty);
+
+  // -------------------------------------------------------------//
+
   // recovery from device module exception
   device2DummyBackend->throwExceptionRead = false;
-  // When the device recovers, the old value is written with ok flag
-  // It might be that the main loop does not write the value each time, so it has
-  // to be done once so the data does not stay invalid.
-  result.read();
-  BOOST_CHECK_EQUAL(result, 11001);
-  BOOST_CHECK(result.dataValidity() == ctk::DataValidity::ok);
+  CHECK_EQUAL_TIMEOUT((device2Status.readLatest(), device2Status), 0, 100000);
 
-  // finally the loop runs though and propagates the new value
+  threadedFanoutInput = 40000;
+  threadedFanoutInput.write();
   result.read();
-  BOOST_CHECK_EQUAL(result, 11000);
+  // Now we expect also the last value written to the pollRegister being
+  // propagated and the DataValidity should be ok again.
+  BOOST_CHECK_EQUAL(result, 41000);
+  BOOST_CHECK(result.dataValidity() == ctk::DataValidity::ok);
 }
 
 BOOST_AUTO_TEST_CASE(testReadDeviceWithTrigger) {
@@ -786,26 +804,16 @@ BOOST_AUTO_TEST_CASE(testDataFlowOnDeviceException) {
   // Now the device has to go into the error state
   CHECK_EQUAL_TIMEOUT((deviceStatus.readLatest(), deviceStatus), 1, 10000);
 
-  // The data is propagated once more to make sure the invaldi flag goes through (in this case it already was invalid, but
-  // cannot be nown by the code, see testDataValidPropagationOnException.
+  // The new value of the threadedFanoutInput should be propagated, the
+  // pollRegister is skipped, see testDataValidPropagationOnException.
   m1_result.read();
-  // FIXME: The correct behaviour according to the new spec is that the new value of threadedFanoutInput is already processed.
-  //BOOST_CHECK_EQUAL(m1_result, 1100);
-  BOOST_CHECK_EQUAL(m1_result, 1101);
+  BOOST_CHECK_EQUAL(m1_result, 1100);
   BOOST_CHECK(m1_result.dataValidity() == ctk::DataValidity::faulty);
   m2_result.read();
-  // FIXME: The correct behaviour according to the new spec is that the new value of threadedFanoutInput is already processed.
-  //BOOST_CHECK_EQUAL(m2_result, 1100);
-  BOOST_CHECK_EQUAL(m2_result, 1101);
+  // Same for m2
+  BOOST_CHECK_EQUAL(m2_result, 1100);
   BOOST_CHECK(m2_result.dataValidity() == ctk::DataValidity::faulty);
 
-  // Trigger the loop another time. Now the execution is blocked
-  threadedFanoutInput = 2;
-  threadedFanoutInput.write();
-
-  // The result of m1 must not be written out again. We can't test this at this safely here.
-  // Instead, we know that the next read after recovery will already contain the new data.
-
   // ---------------------------------------------------------------------//
   // device exception recovery
   device2DummyBackend->throwExceptionRead = false;
@@ -816,26 +824,14 @@ BOOST_AUTO_TEST_CASE(testDataFlowOnDeviceException) {
   // nothing else in the queue
   BOOST_CHECK(deviceStatus.readNonBlocking() == false);
 
-  /////////////////// FIXME: This is old behaviour and will go away with proper implementation of the spec//////////////////
-
-  // After recovering the old data has been written once, still with invalid because the fan input is still invalid
-  m1_result.read();
-  BOOST_CHECK_EQUAL(m1_result, 1101);
-  BOOST_CHECK(m1_result.dataValidity() == ctk::DataValidity::faulty);
-  m2_result.read();
-  BOOST_CHECK_EQUAL(m2_result, 1101);
-  BOOST_CHECK(m2_result.dataValidity() == ctk::DataValidity::faulty);
+  // ---------------------------------------------------------------------//
+  // Now both, threadedFanoutInput and pollRegister should propagate
+  pollRegister = 300;
+  threadedFanoutInput = 2;
+  threadedFanoutInput.write();
 
-  // Now the data for threadedFanoutInput = 0 is propagated. In the new spec this was already done above
   m1_result.read();
-  BOOST_CHECK_EQUAL(m1_result, 1200);
-  m2_result.read();
-  BOOST_CHECK_EQUAL(m2_result, 1200);
-
-  /////////////////// END OF FIXME: old behaviour ///////////////////////////////////////////////////
-
-  m1_result.read(); // we know there must be exaclty one value being written. Wait for it.
-  BOOST_CHECK_EQUAL(m1_result, 1202);
+  BOOST_CHECK_EQUAL(m1_result, 1302);
   // Data validity still faulty because the input from the fan is invalid
   BOOST_CHECK(m1_result.dataValidity() == ctk::DataValidity::faulty);
   // again, nothing else in the queue
@@ -843,7 +839,7 @@ BOOST_AUTO_TEST_CASE(testDataFlowOnDeviceException) {
 
   // same for m2
   m2_result.read();
-  BOOST_CHECK_EQUAL(m2_result, 1202);
+  BOOST_CHECK_EQUAL(m2_result, 1302);
   BOOST_CHECK(m2_result.dataValidity() == ctk::DataValidity::faulty);
   BOOST_CHECK(m2_result.readNonBlocking() == false);
 
@@ -854,12 +850,12 @@ BOOST_AUTO_TEST_CASE(testDataFlowOnDeviceException) {
   threadedFanoutInput.write();
 
   m1_result.read();
-  BOOST_CHECK_EQUAL(m1_result, 1203);
+  BOOST_CHECK_EQUAL(m1_result, 1303);
   BOOST_CHECK(m1_result.dataValidity() == ctk::DataValidity::ok);
   BOOST_CHECK(m1_result.readNonBlocking() == false);
 
   m2_result.read();
-  BOOST_CHECK_EQUAL(m2_result, 1203);
+  BOOST_CHECK_EQUAL(m2_result, 1303);
   BOOST_CHECK(m2_result.dataValidity() == ctk::DataValidity::ok);
   BOOST_CHECK(m1_result.readNonBlocking() == false);
 }
@@ -936,45 +932,80 @@ BOOST_AUTO_TEST_CASE(testDataValidPropagationOnException) {
   device2DummyBackend->throwExceptionRead = true;
   pushInput.write();
 
-  // Output should be rewritten exactly once and the data valditity should be propagated
   CHECK_EQUAL_TIMEOUT((deviceStatus.readLatest(), deviceStatus), 1, 10000);
   result.read();
   BOOST_CHECK(result.readLatest() == false);
-  // FIXME: This is olde behaviour:
-  BOOST_CHECK_EQUAL(result, 11);
-  // According to the new spec the new value for the push input should have been propagated already:
-  //BOOST_CHECK_EQUAL(result, 21);
+  // The new data from the pushInput and the DataValidity::faulty should have been propagated to the outout,
+  // the pollRegister should be skipped (Exceptionhandling spec B.2.2.3), so we don't expect the latest assigned value of 2
+  BOOST_CHECK_EQUAL(result, 21);
   BOOST_CHECK(result.dataValidity() == ctk::DataValidity::faulty);
 
-  // triggering once more does not produce any output until the device has recovered
+  // Writeing the pushInput should still trigger module execution and
+  // update the result value. Result validity should still be faulty because
+  // the device still has the exception
   pushInput = 30;
   pushInput.setDataValidity(ctk::DataValidity::ok);
   pushInput.write();
-  // just a short sleep, waiting for nothing. We will test below that there was nothing when the device recovers
-  sleep(1);
-  BOOST_CHECK(result.readLatest() == false);
+  result.read();
+  BOOST_CHECK_EQUAL(result, 31);
+  BOOST_CHECK(result.dataValidity() == ctk::DataValidity::faulty);
 
+  // let the device recover
+  device2DummyBackend->throwExceptionRead = false;
+  CHECK_EQUAL_TIMEOUT((deviceStatus.readLatest(), deviceStatus), 0, 10000);
+
+  // Everything should be back to normal, also the value of the pollRegister
+  // should be reflected in the output
+  pushInput = 40;
   pollRegister = 3;
-  device2DummyBackend->throwExceptionRead = false; // let the device recover
+  pushInput.write();
+  result.read();
+  BOOST_CHECK_EQUAL(result, 43);
+  BOOST_CHECK(result.dataValidity() == ctk::DataValidity::ok);
+  // nothing more in the queue
+  BOOST_CHECK(result.readLatest() == false);
 
-  // the 2 from the poll register is never seen...
+  // Check if we get faulty output from the exception alone,
+  // keep pushInput ok
+  pollRegister = 4;
+  pushInput = 50;
+  device2DummyBackend->throwExceptionRead = true;
 
-  // /////////////////////////// FIXME: old behaviour. This will go away with the new spec
-  // The original data is written again, still with faulty as the push input was faulty as well
+  pushInput.write();
   result.read();
-  BOOST_CHECK_EQUAL(result, 11);
+  BOOST_CHECK(result.readLatest() == false);
+  // The new data from the pushInput, the device exception should yield DataValidity::faulty at the outout,
+  BOOST_CHECK_EQUAL(result, 53);
   BOOST_CHECK(result.dataValidity() == ctk::DataValidity::faulty);
-  // The 20 at the push input is propagated (together with its faulty flag). It already sees the new value from the poll type
-  // It's good that this goes away. This combination was never at the souces at the same time.
+
+  // Also set pushInputValidity to faulty
+  pushInput = 60;
+  pushInput.setDataValidity(ctk::DataValidity::faulty);
+  pushInput.write();
   result.read();
-  BOOST_CHECK_EQUAL(result, 23);
+  BOOST_CHECK_EQUAL(result, 63);
   BOOST_CHECK(result.dataValidity() == ctk::DataValidity::faulty);
 
-  // /////////////////////////// END OF FIXME: old behaviour
+  // let the device recover
+  device2DummyBackend->throwExceptionRead = false;
+  CHECK_EQUAL_TIMEOUT((deviceStatus.readLatest(), deviceStatus), 0, 10000);
+
+  // The new pollRegister value should now be reflected in the result,
+  // but it's still faulty from the pushInput
+  pushInput = 70;
+  pollRegister = 5;
+  pushInput.write();
+  result.read();
+  BOOST_CHECK_EQUAL(result, 75);
+  BOOST_CHECK(result.dataValidity() == ctk::DataValidity::faulty);
 
-  // The new, good value arrives
+  // MAke pushInput ok, everything should be back to normal
+  pushInput = 80;
+  pushInput.setDataValidity(ctk::DataValidity::ok);
+  pollRegister = 6;
+  pushInput.write();
   result.read();
-  BOOST_CHECK_EQUAL(result, 33);
+  BOOST_CHECK_EQUAL(result, 86);
   BOOST_CHECK(result.dataValidity() == ctk::DataValidity::ok);
   // nothing more in the queue
   BOOST_CHECK(result.readLatest() == false);