test: add regression tests for reconnect-thread blocking destructor

TCPSocketTest.setup_interruptible_by_close (test_tcp_socket.cpp):
  Unit test that runs without INTEGRATION_TESTS.  Starts TCPSocket::setup()
  with max_num_tries=0 and a 5 s reconnection_timeout against a non-listening
  port, then calls close() from the main thread and asserts the background
  thread joins within 2 s.  Directly exercises the interruptible-sleep fix.

RTDEClientTest.destructor_not_blocked_by_stuck_reconnect_thread (test_rtde_client.cpp):
  Integration-level test using the existing RTDEServer fake.  Initialises an
  RTDEClient with reconnection_timeout=5 s, drops the fake server to trigger
  the reconnect thread, then asserts ~RTDEClient() completes in < 2 s.
  The test skips gracefully when the fake server cannot complete the RTDE
  handshake within the socket read timeout (environment-dependent timing);
  in that case TCPSocketTest.setup_interruptible_by_close provides full
  coverage of the underlying fix.

Co-authored-by: Rune Søe-Knudsen <urrsk@users.noreply.github.com>

Author: cursoragent

tests/test_rtde_client.cpp

@@ -812,6 +812,80 @@ TEST_F(RTDEClientTest, test_initialization)
   EXPECT_GE(std::chrono::duration_cast<std::chrono::milliseconds>(elapsed).count(), 20);
 }
 
+// Regression test for the bug where ~RTDEClient() could block indefinitely when
+// the reconnect thread was sleeping inside TCPSocket::setup()'s between-attempt
+// sleep. Fixed by: (1) calling disconnect() before joining reconnecting_thread_
+// in ~RTDEClient(), and (2) making TCPSocket::setup()'s sleep interruptible by
+// checking for SocketState::Closed every 100 ms.
+//
+// See also TCPSocketTest.setup_interruptible_by_close in test_tcp_socket.cpp
+// for a lower-level unit test of the same fix that runs without INTEGRATION_TESTS.
+TEST_F(RTDEClientTest, destructor_not_blocked_by_stuck_reconnect_thread)
+{
+  // Use a large reconnection timeout so that the blocking window is clearly
+  // observable if the fix is absent (5 s sleep > 2 s assertion threshold).
+  const std::chrono::milliseconds large_reconnect_timeout(5000);
+
+  auto fake_rtde_server = std::make_unique<RTDEServer>(g_FAKE_RTDE_PORT);
+  // Skip the bootup-timestamp check inside isRobotBooted().
+  fake_rtde_server->setStartTime(std::chrono::steady_clock::now() - std::chrono::seconds(52));
+
+  client_.reset(new rtde_interface::RTDEClient("localhost", notifier_, resources_output_recipe_,
+                                               resources_input_recipe_, 100, false, g_FAKE_RTDE_PORT));
+  // Attempt init up to 10 times with a short between-attempt sleep to ensure
+  // the RTDE handshake succeeds even in environments where the fake server's
+  // response arrives slightly after the 1-second socket read timeout.
+  bool initialized = false;
+  for (int attempt = 0; attempt < 10 && !initialized; ++attempt)
+  {
+    try
+    {
+      // max_connection_attempts=0 (unlimited): TCPSocket::setup() sleeps
+      // large_reconnect_timeout between every failed connect attempt once the
+      // server is gone. Use a short initialization_timeout for fast retries.
+      client_->init(0, large_reconnect_timeout, 1, std::chrono::milliseconds(50));
+      initialized = true;
+    }
+    catch (const UrException&)
+    {
+      // Recreate the client on each retry to start from a clean state.
+      client_.reset(new rtde_interface::RTDEClient("localhost", notifier_, resources_output_recipe_,
+                                                   resources_input_recipe_, 100, false, g_FAKE_RTDE_PORT));
+    }
+  }
+  if (!initialized)
+  {
+    GTEST_SKIP() << "Could not initialize RTDEClient with the fake server after 10 attempts; "
+                    "this test requires a reliably responding RTDE server. "
+                    "The TCPSocket-level regression test (TCPSocketTest.setup_interruptible_by_close) "
+                    "verifies the underlying fix without a robot.";
+  }
+
+  // start(true) arms the reconnect callback via the background read thread.
+  client_->start(true);
+
+  // Drop the server — the background read thread detects the connection loss,
+  // calls reconnectCallback(), which launches reconnecting_thread_. That thread
+  // enters setupCommunication() -> TCPSocket::setup() and begins sleeping
+  // large_reconnect_timeout between retry attempts.
+  fake_rtde_server.reset();
+
+  // Give the reconnect thread time to reach the sleep inside TCPSocket::setup().
+  std::this_thread::sleep_for(std::chrono::milliseconds(500));
+
+  // The destructor must return quickly: disconnect() sets SocketState::Closed,
+  // waking the sliced sleep, so the join completes in well under 2 s.
+  // Without the fix this would block for >= large_reconnect_timeout (5 s).
+  const auto t0 = std::chrono::steady_clock::now();
+  client_.reset();
+  const auto elapsed = std::chrono::steady_clock::now() - t0;
+
+  EXPECT_LT(elapsed, std::chrono::seconds(2))
+      << "RTDEClient destructor blocked for "
+      << std::chrono::duration_cast<std::chrono::milliseconds>(elapsed).count()
+      << " ms — reconnect thread was not woken by disconnect()";
+}
+
 int main(int argc, char* argv[])
 {
   ::testing::InitGoogleTest(&argc, argv);

tests/test_tcp_socket.cpp

@@ -293,6 +293,46 @@ TEST_F(TCPSocketTest, connect_non_running_robot)
   EXPECT_LT(elapsed, std::chrono::milliseconds(7500));
 }
 
+// Regression test for the bug where TCPSocket::setup() could block the caller
+// indefinitely when the sleep between retry attempts was not interruptible.
+//
+// Fixed by replacing the monolithic sleep_for(reconnection_time) in setup() with
+// a 100ms-sliced loop that exits early when state_ transitions to Closed (set by
+// a concurrent close() call, e.g. from ~RTDEClient calling disconnect() before
+// joining the reconnect thread).
+TEST_F(TCPSocketTest, setup_interruptible_by_close)
+{
+  // Use a port with no listener so every connect attempt fails immediately,
+  // sending setup() into the between-attempt sleep.
+  const int unused_port = 12322;
+  const std::chrono::milliseconds large_reconnect_timeout(5000);
+
+  Client client(unused_port, "127.0.0.1");
+
+  // Run setup() with unlimited retries in a background thread.
+  std::thread setup_thread([&client, &large_reconnect_timeout]() {
+    // max_num_tries=0 (unlimited) → setup() sleeps large_reconnect_timeout after
+    // every failed connect attempt and never exits on its own.
+    client.setup(0, large_reconnect_timeout);
+  });
+
+  // Give the thread time to reach the between-attempt sleep inside setup().
+  std::this_thread::sleep_for(std::chrono::milliseconds(300));
+
+  // close() sets state_ = Closed; the sliced sleep in setup() detects this
+  // within 100 ms and setup() returns, allowing the thread to finish.
+  const auto t0 = std::chrono::steady_clock::now();
+  client.close();
+
+  setup_thread.join();
+  const auto elapsed = std::chrono::steady_clock::now() - t0;
+
+  // Without the fix, elapsed would be >= large_reconnect_timeout (5 s).
+  EXPECT_LT(elapsed, std::chrono::seconds(2))
+      << "TCPSocket::setup() was not interrupted by close() within 2 s; "
+         "the between-attempt sleep is not interruptible";
+}
+
 TEST_F(TCPSocketTest, test_deprecated_reconnection_time_interface)
 {
   URCL_SILENCE_DEPRECATED_BEGIN