Refactor tests to use common TestableTcpServer

Author: urfeex

tests/test_external_control_program.cpp

@@ -32,10 +32,8 @@
 
 #include "test_utils.h"
 #include "ur_client_library/example_robot_wrapper.h"
-#include "ur_client_library/log.h"
 
 using namespace urcl;
-
 const std::string SCRIPT_FILE = "../resources/external_control.urscript";
 const std::string OUTPUT_RECIPE = "resources/rtde_output_recipe.txt";
 const std::string INPUT_RECIPE = "resources/rtde_input_recipe.txt";
@@ -46,16 +44,6 @@ std::unique_ptr<ExampleRobotWrapper> g_my_robot;
 
 class ExternalControlProgramTest : public ::testing::Test
 {
-public:
-  // callback functions
-  void connectionCallback(const socket_t filedescriptor)
-  {
-    std::lock_guard<std::mutex> lk(connect_mutex_);
-    client_fd_ = filedescriptor;
-    connect_cv_.notify_one();
-    connection_callback_ = true;
-  }
-
 protected:
   static void SetUpTestSuite()
   {
@@ -75,9 +63,7 @@ class ExternalControlProgramTest : public ::testing::Test
       ASSERT_TRUE(g_my_robot->resendRobotProgram());
       ASSERT_TRUE(g_my_robot->waitForProgramRunning(500));
     }
-    server_.reset(new comm::TCPServer(60005));
-    server_->setConnectCallback(
-        std::bind(&ExternalControlProgramTest::connectionCallback, this, std::placeholders::_1));
+    server_.reset(new TestableTcpServer(60005));
     server_->start();
   }
 
@@ -105,42 +91,20 @@ class ExternalControlProgramTest : public ::testing::Test
     prog += "\nsocket_open(\"{{SERVER_IP_REPLACE}}\", 60005, \"test_socket\")\n";
     prog += "\nsleep(0.6)\n";
     prog += "\ntextmsg(\"sleeping done.\")\n";
-    std::ofstream out_file;
-    out_file.open(modified_script_path);
-    out_file << prog;
-    out_file.close();
+    ofs << prog;
+    ofs.close();
 
     return modified_script_path;
   }
 
-  bool waitForConnectionCallback(int milliseconds = 100)
-  {
-    std::unique_lock<std::mutex> lk(connect_mutex_);
-    if (connect_cv_.wait_for(lk, std::chrono::milliseconds(milliseconds),
-                             [this]() { return connection_callback_ == true; }))
-    {
-      connection_callback_ = false;
-      return true;
-    }
-    else
-    {
-      return false;
-    }
-  }
-  std::unique_ptr<comm::TCPServer> server_;
-
-private:
-  std::condition_variable connect_cv_;
-  std::mutex connect_mutex_;
-  socket_t client_fd_ = INVALID_SOCKET;
-  bool connection_callback_ = false;
+  std::unique_ptr<TestableTcpServer> server_;
 };
 
 TEST_F(ExternalControlProgramTest, program_halts_on_timeout)
 {
   vector6d_t zeros = { 0, 0, 0, 0, 0, 0 };
   g_my_robot->getUrDriver()->writeJointCommand(zeros, comm::ControlMode::MODE_IDLE, RobotReceiveTimeout::millisec(200));
-  EXPECT_FALSE(waitForConnectionCallback(1000));
+  EXPECT_FALSE(server_->waitForConnectionCallback(1000));
 }
 
 TEST_F(ExternalControlProgramTest, stop_control_does_not_halt_program)
@@ -150,7 +114,7 @@ TEST_F(ExternalControlProgramTest, stop_control_does_not_halt_program)
 
   // Make sure that we can stop the robot control, when robot receive timeout has been set off
   g_my_robot->getUrDriver()->stopControl();
-  EXPECT_TRUE(waitForConnectionCallback(1000));
+  EXPECT_TRUE(server_->waitForConnectionCallback(1000));
 }
 
 int main(int argc, char* argv[])

tests/test_pipeline.cpp

@@ -31,6 +31,8 @@
 #include <gtest/gtest.h>
 #include <condition_variable>
 
+#include "test_utils.h"
+
 #include <ur_client_library/comm/pipeline.h>
 #include <ur_client_library/comm/tcp_server.h>
 #include <ur_client_library/comm/stream.h>
@@ -45,8 +47,7 @@ class PipelineTest : public ::testing::Test
 protected:
   void SetUp()
   {
-    server_.reset(new comm::TCPServer(60002));
-    server_->setConnectCallback(std::bind(&PipelineTest::connectionCallback, this, std::placeholders::_1));
+    server_.reset(new TestableTcpServer(60002));
     server_->start();
 
     // Setup pipeline
@@ -68,28 +69,7 @@ class PipelineTest : public ::testing::Test
     server_.reset();
   }
 
-  void connectionCallback(const socket_t filedescriptor)
-  {
-    std::lock_guard<std::mutex> lk(connect_mutex_);
-    client_fd_ = filedescriptor;
-    connect_cv_.notify_one();
-    connection_callback_ = true;
-  }
-
-  bool waitForConnectionCallback(int milliseconds = 100)
-  {
-    std::unique_lock<std::mutex> lk(connect_mutex_);
-    if (connect_cv_.wait_for(lk, std::chrono::milliseconds(milliseconds)) == std::cv_status::no_timeout ||
-        connection_callback_ == true)
-    {
-      connection_callback_ = false;
-      return true;
-    }
-    return false;
-  }
-
-  std::unique_ptr<comm::TCPServer> server_;
-  socket_t client_fd_;
+  std::unique_ptr<TestableTcpServer> server_;
 
   std::unique_ptr<comm::URStream<rtde_interface::RTDEPackage>> stream_;
   std::unique_ptr<rtde_interface::RTDEParser> parser_;
@@ -138,8 +118,6 @@ class PipelineTest : public ::testing::Test
 private:
   std::condition_variable connect_cv_;
   std::mutex connect_mutex_;
-
-  bool connection_callback_ = false;
 };
 
 TEST_F(PipelineTest, get_product_from_stopped_pipeline)
@@ -151,13 +129,13 @@ TEST_F(PipelineTest, get_product_from_stopped_pipeline)
 
 TEST_F(PipelineTest, get_product_from_running_pipeline)
 {
-  waitForConnectionCallback();
+  server_->waitForConnectionCallback();
   pipeline_->run();
 
   // RTDE package with timestamp
   uint8_t data_package[] = { 0x00, 0x0c, 0x55, 0x01, 0x40, 0xbb, 0xbf, 0xdb, 0xa5, 0xe3, 0x53, 0xf7 };
   size_t written;
-  server_->write(client_fd_, data_package, sizeof(data_package), written);
+  server_->write(data_package, sizeof(data_package), written);
 
   std::unique_ptr<rtde_interface::RTDEPackage> urpackage;
   std::chrono::milliseconds timeout{ 500 };
@@ -178,13 +156,13 @@ TEST_F(PipelineTest, get_product_from_running_pipeline)
 
 TEST_F(PipelineTest, stop_pipeline)
 {
-  waitForConnectionCallback();
+  server_->waitForConnectionCallback();
   pipeline_->run();
 
   // RTDE package with timestamp
   uint8_t data_package[] = { 0x00, 0x0c, 0x55, 0x01, 0x40, 0xbb, 0xbf, 0xdb, 0xa5, 0xe3, 0x53, 0xf7 };
   size_t written;
-  server_->write(client_fd_, data_package, sizeof(data_package), written);
+  server_->write(data_package, sizeof(data_package), written);
 
   std::unique_ptr<rtde_interface::RTDEPackage> urpackage;
   std::chrono::milliseconds timeout{ 500 };
@@ -206,13 +184,13 @@ TEST_F(PipelineTest, consumer_pipeline)
   pipeline_.reset(
       new comm::Pipeline<rtde_interface::RTDEPackage>(*producer_.get(), &consumer, "RTDE_PIPELINE", notifier_));
   pipeline_->init();
-  waitForConnectionCallback();
+  server_->waitForConnectionCallback();
   pipeline_->run();
 
   // RTDE package with timestamp
   uint8_t data_package[] = { 0x00, 0x0c, 0x55, 0x01, 0x40, 0xbb, 0xbf, 0xdb, 0xa5, 0xe3, 0x53, 0xf7 };
   size_t written;
-  server_->write(client_fd_, data_package, sizeof(data_package), written);
+  server_->write(data_package, sizeof(data_package), written);
 
   // Wait for data to be consumed
   int max_retries = 3;
@@ -223,7 +201,7 @@ TEST_F(PipelineTest, consumer_pipeline)
     {
       break;
     }
-    server_->write(client_fd_, data_package, sizeof(data_package), written);
+    server_->write(data_package, sizeof(data_package), written);
     count++;
   }
   EXPECT_LT(count, max_retries);

tests/test_producer.cpp

@@ -31,6 +31,7 @@
 #include <gtest/gtest.h>
 #include <chrono>
 #include <condition_variable>
+#include "test_utils.h"
 
 #include <ur_client_library/comm/producer.h>
 #include <ur_client_library/comm/stream.h>
@@ -44,8 +45,7 @@ class ProducerTest : public ::testing::Test
 protected:
   void SetUp()
   {
-    server_.reset(new comm::TCPServer(60002));
-    server_->setConnectCallback(std::bind(&ProducerTest::connectionCallback, this, std::placeholders::_1));
+    server_.reset(new TestableTcpServer(60002));
     server_->start();
   }
 
@@ -55,34 +55,7 @@ class ProducerTest : public ::testing::Test
     server_.reset();
   }
 
-  void connectionCallback(const socket_t filedescriptor)
-  {
-    std::lock_guard<std::mutex> lk(connect_mutex_);
-    client_fd_ = filedescriptor;
-    connect_cv_.notify_one();
-    connection_callback_ = true;
-  }
-
-  bool waitForConnectionCallback(int milliseconds = 100)
-  {
-    std::unique_lock<std::mutex> lk(connect_mutex_);
-    if (connect_cv_.wait_for(lk, std::chrono::milliseconds(milliseconds)) == std::cv_status::no_timeout ||
-        connection_callback_ == true)
-    {
-      connection_callback_ = false;
-      return true;
-    }
-    return false;
-  }
-
-  std::unique_ptr<comm::TCPServer> server_;
-  socket_t client_fd_;
-
-private:
-  std::condition_variable connect_cv_;
-  std::mutex connect_mutex_;
-
-  bool connection_callback_ = false;
+  std::unique_ptr<TestableTcpServer> server_;
 };
 
 TEST_F(ProducerTest, get_data_package)
@@ -94,13 +67,13 @@ TEST_F(ProducerTest, get_data_package)
   comm::URProducer<rtde_interface::RTDEPackage> producer(stream, parser);
 
   producer.setupProducer();
-  waitForConnectionCallback();
+  server_->waitForConnectionCallback();
   producer.startProducer();
 
   // RTDE package with timestamp
   uint8_t data_package[] = { 0x00, 0x0c, 0x55, 0x01, 0x40, 0xbb, 0xbf, 0xdb, 0xa5, 0xe3, 0x53, 0xf7 };
   size_t written;
-  server_->write(client_fd_, data_package, sizeof(data_package), written);
+  server_->write(data_package, sizeof(data_package), written);
 
   std::vector<std::unique_ptr<rtde_interface::RTDEPackage>> products;
   EXPECT_EQ(producer.tryGet(products), true);