feat: tolerant of errors during unconfigured AM-695/error-on-init

Author: Aaron Roller

CMakeLists.txt

@@ -222,6 +222,7 @@ if (CATKIN_ENABLE_TESTING)
                  error_status 
                  error_status_without_stats 
                  error_terminal_before_config
+                 error_tolerant_before_config
                  hz_config
                  manual_to_disarming 
                  param

include/super_lib/am_life_cycle_mediator.h

@@ -193,8 +193,12 @@ class AMLifeCycleMediator
 
     bool redundantShutdown(const AMLifeCycleMediator::LifeCycleInfo& info);
 
+    /** @brief return true if already in error state */
     bool redundantError(const AMLifeCycleMediator::LifeCycleInfo& info);
 
+    /** @brief return true if in UNCONFIGURED or CONFIGURING */
+    bool unconfigured(const AMLifeCycleMediator::LifeCycleInfo& info);
+
     bool illegalDestroy(const AMLifeCycleMediator::LifeCycleInfo& info);
 
   private:

rostest/error_tolerant_before_config/error_tolerant_before_config_rostest.cpp

@@ -0,0 +1,34 @@
+#include <am_rostest_lib/am_rostest.h>
+
+/** Shows an error that happens upon construction will be reported as an ERROR during configuration. 
+ */
+class LifeCycleErrorTest : public RostestBase, public am::AMLifeCycle
+{
+protected:
+
+  LifeCycleErrorTest() : 
+    RostestBase() 
+  {
+      errorTolerant("tolerant error during construction", "HW8S");
+  }
+
+
+  void onConfigure()
+  {
+    //do nothing...stay in configure
+  }
+};
+
+TEST_F(LifeCycleErrorTest, testStatus_Error)
+{
+  waitUntil(LifeCycleState::INACTIVE,"NAKW");
+  waitUntil(LifeCycleStatus::OK,"NQNE");
+}
+
+int main(int argc, char** argv)
+{
+  ::testing::InitGoogleTest(&argc, argv);
+  ros::init(argc, argv, ros::this_node::getName());
+
+  return RUN_ALL_TESTS();
+}

rostest/error_tolerant_before_config/error_tolerant_before_config_rostest.test

@@ -0,0 +1,6 @@
+<launch>
+  <!-- include test file and pass in this test node name -->
+  <include file="$(find am_super)/rostest/am_super_rostest.test">
+    <arg name="test_name" value="error_tolerant_before_config"/>
+  </include>
+</launch>

src/super_lib/am_life_cycle_mediator.cpp

@@ -205,6 +205,19 @@ bool AMLifeCycleMediator::shutdown(const AMLifeCycleMediator::LifeCycleInfo& inf
     info.state == LifeCycleState::ACTIVE;
 }
 
+bool AMLifeCycleMediator::unconfigured(const AMLifeCycleMediator::LifeCycleInfo& info)
+{
+  switch (info.state)
+  {
+  case LifeCycleState::UNCONFIGURED:
+  case LifeCycleState::CONFIGURING:
+    return true;
+  default:
+    return false;
+  }
+}
+
+
 bool AMLifeCycleMediator::redundantShutdown(const AMLifeCycleMediator::LifeCycleInfo& info)
 {
   return info.state == LifeCycleState::SHUTTING_DOWN || 

test/am_life_cycle_mediator_unit_tests.cpp

@@ -65,6 +65,14 @@ class AMLifeCycleMediatorTest : public ::testing::Test
     info.state = state;
     EXPECT_EQ(life_cycle_mediator_.illegalDestroy(info), expected);
   }
+
+  bool EXPECT_EQ_UNCONFIGURED(const LifeCycleState& state, bool expected)
+  {
+    AMLifeCycleMediator::LifeCycleInfo info;
+    info.state = state;
+    EXPECT_EQ(life_cycle_mediator_.unconfigured(info), expected);
+  }
+
 };
 
 TEST_F(AMLifeCycleMediatorTest, statusError_LCStatusError)
@@ -299,6 +307,23 @@ TEST_F(AMLifeCycleMediatorTest, redundantError)
   EXPECT_EQ_REDUNDANT_ERROR(LifeCycleState::SHUTTING_DOWN, false);
 }
 
+
+TEST_F(AMLifeCycleMediatorTest, unconfigured)
+{
+  EXPECT_EQ_UNCONFIGURED(LifeCycleState::CONFIGURING, true);
+  EXPECT_EQ_UNCONFIGURED(LifeCycleState::UNCONFIGURED, true);
+
+  EXPECT_EQ_UNCONFIGURED(LifeCycleState::FINALIZED, false);
+  EXPECT_EQ_UNCONFIGURED(LifeCycleState::ERROR_PROCESSING, false);
+  EXPECT_EQ_UNCONFIGURED(LifeCycleState::ACTIVATING, false);
+  EXPECT_EQ_UNCONFIGURED(LifeCycleState::ACTIVE, false);
+  EXPECT_EQ_UNCONFIGURED(LifeCycleState::CLEANING_UP, false);
+  EXPECT_EQ_UNCONFIGURED(LifeCycleState::DEACTIVATING, false);
+  EXPECT_EQ_UNCONFIGURED(LifeCycleState::INACTIVE, false);
+  EXPECT_EQ_UNCONFIGURED(LifeCycleState::INVALID, false);
+  EXPECT_EQ_UNCONFIGURED(LifeCycleState::SHUTTING_DOWN, false);
+}
+
 TEST_F(AMLifeCycleMediatorTest, illegalDestroy)
 {
   EXPECT_EQ_ILLEGAL_DESTROY(LifeCycleState::FINALIZED, false);