unit test for concurrent execution done

Author: miccol

tests/gtest_reactive_tree.cpp

@@ -64,13 +64,14 @@ struct ComplexReactiveTree : testing::Test
 TEST_F(ComplexReactiveTree, ConditionsFalse)
 {
 
+    auto t0 = std::chrono::high_resolution_clock::now();
+
+
     condition_1.setBoolean(false);
     condition_2.setBoolean(false);
 
     BT::NodeStatus state = root.executeTick();
 
-    state = root.executeTick();
-
     ASSERT_EQ(NodeStatus::RUNNING, state);
     ASSERT_EQ(NodeStatus::RUNNING, fal_1.status());
     ASSERT_EQ(NodeStatus::FAILURE, condition_1.status());
@@ -97,29 +98,19 @@ TEST_F(ComplexReactiveTree, ConditionsFalse)
 
     std::this_thread::sleep_for(milliseconds(300));
     condition_1.setBoolean(false);
-
+    std::cout << "Ticking..." << std::endl;
     state = root.executeTick();
+    std::cout << "...done" << std::endl;
+
 
-    ASSERT_EQ(NodeStatus::RUNNING, state);
-    ASSERT_EQ(NodeStatus::RUNNING, fal_1.status());
-    ASSERT_EQ(NodeStatus::FAILURE, condition_1.status());
-    ASSERT_EQ(NodeStatus::RUNNING, action_1.status());
-    ASSERT_EQ(NodeStatus::IDLE, fal_2.status());
-    ASSERT_EQ(NodeStatus::IDLE, condition_2.status());
-    ASSERT_EQ(NodeStatus::IDLE, action_2.status());
 
-//    std::this_thread::sleep_for(milliseconds(300));
+    std::this_thread::sleep_for(milliseconds(300));
 
-//    condition_1.setBoolean(false);
+    std::cout << action_1.startTimePoint().time_since_epoch().count() << std::endl;
+    std::cout << action_2.stopTimePoint().time_since_epoch().count() << std::endl;
 
-//    state = root.executeTick();
+    ASSERT_TRUE(action_1.startTimePoint().time_since_epoch().count() >
+                action_2.stopTimePoint().time_since_epoch().count()  );
 
-//    ASSERT_EQ(NodeStatus::RUNNING, state);
-//    ASSERT_EQ(NodeStatus::RUNNING, fal_1.status());
-//    ASSERT_EQ(NodeStatus::FAILURE, condition_1.status());
-//    ASSERT_EQ(NodeStatus::RUNNING, action_1.status());
-//    ASSERT_EQ(NodeStatus::IDLE, fal_2.status());
-//    ASSERT_EQ(NodeStatus::IDLE, condition_2.status());
-//    ASSERT_EQ(NodeStatus::IDLE, action_2.status());
 
 }

tests/include/action_test_node.h

@@ -58,12 +58,39 @@ class AsyncActionTest : public AsyncActionNode
         tick_count_ = 0;
     }
 
-  private:
+    void setStartTimePoint(std::chrono::high_resolution_clock::time_point now)
+    {
+       std::cout << this->name() << " Setting Start Time: " << now.time_since_epoch().count() << std::endl;
+
+        start_time_ = now;
+    }
+
+    std::chrono::high_resolution_clock::time_point startTimePoint() const
+    {
+        return start_time_;
+    }
+
+
+    void setStopTimePoint(std::chrono::high_resolution_clock::time_point now)
+    {
+        std::cout << this->name() << " Setting Stop Time: " << now.time_since_epoch().count()  << std::endl;
+
+        stop_time_ = now;
+    }
+
+    std::chrono::high_resolution_clock::time_point stopTimePoint() const
+    {
+        return stop_time_;
+    }
+
+
+private:
     // using atomic because these variables might be accessed from different threads
     BT::Duration time_;
     std::atomic_bool boolean_value_;
     std::atomic<int> tick_count_;
     std::atomic_bool stop_loop_;
+    std::chrono::high_resolution_clock::time_point start_time_, stop_time_;
 };
 }
 

tests/src/action_test_node.cpp

@@ -13,6 +13,12 @@
 
 #include "action_test_node.h"
 #include <string>
+#include <ctime>
+#include <chrono>
+#include <time.h>
+#include <ratio>
+#include <iomanip>
+using namespace std::chrono;
 
 BT::AsyncActionTest::AsyncActionTest(const std::string& name, BT::Duration deadline_ms) :
     AsyncActionNode(name, {})
@@ -30,17 +36,26 @@ BT::AsyncActionTest::~AsyncActionTest()
 
 BT::NodeStatus BT::AsyncActionTest::tick()
 {
+    setStartTimePoint(high_resolution_clock::now());
     setStatus(NodeStatus::RUNNING);
     using std::chrono::high_resolution_clock;
     tick_count_++;
     stop_loop_ = false;
     auto initial_time = high_resolution_clock::now();
 
+
     while (!stop_loop_ && high_resolution_clock::now() < initial_time + time_)
     {
-        std::this_thread::sleep_for(std::chrono::milliseconds(1));
+//        high_resolution_clock::time_point t2 = high_resolution_clock::now();
+
+//        std::cout << this->name() << " Running. Time: " << std::chrono::system_clock::to_time_t(t2)  << std::endl;
+
+
+        std::this_thread::sleep_for(std::chrono::milliseconds(100));
     }
 
+    setStopTimePoint(high_resolution_clock::now());
+
     if (!stop_loop_)
     {
         return boolean_value_ ? NodeStatus::SUCCESS : NodeStatus::FAILURE;
@@ -51,6 +66,8 @@ BT::NodeStatus BT::AsyncActionTest::tick()
     }
 }
 
+
+
 void BT::AsyncActionTest::halt()
 {
     stop_loop_ = true;