UNIT_TEST: Fix clang build failure when using std::search

Author: esindril

unit_tests/common/WebNotifyTests.cc

@@ -24,6 +24,8 @@
 #include "Namespace.hh"
 #include "common/WebNotify.hh"
 #include "gtest/gtest.h"
+#include <algorithm>
+#include <execution>
 #include <iostream>
 #include <string>
 #include <vector>
@@ -36,107 +38,124 @@
 #include <sys/socket.h>
 #include <netinet/in.h>
 
-class SimpleTCPServer {
+class SimpleTCPServer
+{
 public:
-  explicit SimpleTCPServer(int port) : port_(port), ready_(false), running_(false) { Start(); }
-  
-  ~SimpleTCPServer() {
+  explicit SimpleTCPServer(int port) : port_(port), ready_(false),
+    running_(false)
+  {
+    Start();
+  }
+
+  ~SimpleTCPServer()
+  {
     Shutdown();
+
     if (server_thread_.joinable()) {
       server_thread_.join();  // Avoid std::terminate()
     }
   }
-  
-  void Start() {
-    if (running_) return;  // Don't start twice
-    
+
+  void Start()
+  {
+    if (running_) {
+      return;  // Don't start twice
+    }
+
     running_ = true;
     server_thread_ = std::thread(&SimpleTCPServer::RunServer, this);
   }
 
-  std::vector<char> GetMessage() {
+  std::vector<char> GetMessage()
+  {
     std::unique_lock<std::mutex> lock(msg_mutex_);
     cv_.wait(lock, [&ready = ready_] { return ready.load(); });
     return message_;
   }
-  
+
 private:
-  void RunServer() {
+  void RunServer()
+  {
     int server_fd, client_fd;
     struct sockaddr_in address {};
     socklen_t addrlen = sizeof(address);
     const int buffer_size = 4096;
     char buffer[buffer_size];
-    
     server_fd = socket(AF_INET, SOCK_STREAM, 0);
+
     if (server_fd < 0) {
       perror("Socket failed");
       return;
     }
-    
+
     server_fd_ = server_fd;  // Save for shutdown
-    
     int opt = 1;
     setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
-    
     address.sin_family = AF_INET;
     address.sin_addr.s_addr = INADDR_ANY;
     address.sin_port = htons(port_);
-    
+
     if (bind(server_fd, (struct sockaddr*)&address, sizeof(address)) < 0) {
       perror("Bind failed");
       close(server_fd);
       return;
     }
-    
+
     if (listen(server_fd, 1) < 0) {
       perror("Listen failed");
       close(server_fd);
       return;
     }
-    
+
     std::cout << "Server listening on port " << port_ << "\n";
-    
     client_fd = accept(server_fd, (struct sockaddr*)&address, &addrlen);
+
     if (client_fd < 0) {
-      if (running_) perror("Accept failed");
+      if (running_) {
+        perror("Accept failed");
+      }
+
       close(server_fd);
       return;
     }
-    
+
     std::vector<char> local_msg;
     ssize_t bytes_read;
+
     while ((bytes_read = read(client_fd, buffer, buffer_size)) > 0) {
       local_msg.insert(local_msg.end(), buffer, buffer + bytes_read);
       break;
     }
-    
+
     {
       std::lock_guard<std::mutex> lock(msg_mutex_);
       message_ = std::move(local_msg);
       ready_ = true;
     }
-    
+
     close(client_fd);
     close(server_fd);
     running_ = false;
     cv_.notify_all();
   }
-  
-  void Shutdown() {
+
+  void Shutdown()
+  {
     if (running_) {
       running_ = false;
+
       if (server_fd_ != -1) {
-	shutdown(server_fd_, SHUT_RDWR);
-	close(server_fd_);
-	server_fd_ = -1;
+        shutdown(server_fd_, SHUT_RDWR);
+        close(server_fd_);
+        server_fd_ = -1;
       }
+
       if (server_thread_.joinable()) {
-	server_thread_.join();
+        server_thread_.join();
       }
     }
   }
-  
+
   int port_;
   std::thread server_thread_;
   std::vector<char> message_;
@@ -147,106 +166,122 @@ class SimpleTCPServer {
   int server_fd_ = -1;
 };
 
-std::string to_visible_string(const std::vector<char>& in) {
-    std::string out;
-    char buf[5];
-    for (unsigned char c : in)
-        out += (c == '\n') ? "\\n" :
-               (c == '\r') ? "\\r" :
-               (c == '\t') ? "\\t" :
-               (c == '\\') ? "\\\\" :
-               (c == '\"') ? "\\\"" :
-               std::isprint(c) ? std::string(1, c) :
-               (std::snprintf(buf, sizeof(buf), "\\x%02x", c), buf);
-    return out;
+std::string to_visible_string(const std::vector<char>& in)
+{
+  std::string out;
+  char buf[5];
+
+  for (unsigned char c : in)
+    out += (c == '\n') ? "\\n" :
+           (c == '\r') ? "\\r" :
+           (c == '\t') ? "\\t" :
+           (c == '\\') ? "\\\\" :
+           (c == '\"') ? "\\\"" :
+           std::isprint(c) ? std::string(1, c) :
+           (std::snprintf(buf, sizeof(buf), "\\x%02x", c), buf);
+
+  return out;
 }
 
 
 EOSCOMMONNAMESPACE_BEGIN
 
-TEST(WebNotifyTimeoutTests, HttpPostNotification_TimesOut) {
-    WebNotify notifier;
-    std::string url = "http://10.255.255.1:12345"; // Non-routable IP (used for timeout testing)
-    std::string message = "{\"event\":\"timeout_test\"}";
-
-    EXPECT_FALSE(notifier.sendHttpPostNotification(url, message, 250));
+TEST(WebNotifyTimeoutTests, HttpPostNotification_TimesOut)
+{
+  WebNotify notifier;
+  std::string url =
+    "http://10.255.255.1:12345"; // Non-routable IP (used for timeout testing)
+  std::string message = "{\"event\":\"timeout_test\"}";
+  EXPECT_FALSE(notifier.sendHttpPostNotification(url, message, 250));
 }
 
 
-TEST(WebNotifyTimeoutTests, HttpPostNotification_OK) {
-    WebNotify notifier;
-    std::string url = "http://localhost:12345"; 
-    std::string message = "{\"event\":\"ok_test\"}";
-    SimpleTCPServer server(12345);
-    EXPECT_FALSE(notifier.sendHttpPostNotification(url, message, 250));
-    auto response_message = server.GetMessage();  // Blocks until message is received
-    std::cerr << to_visible_string(response_message) << std::endl;
-    EXPECT_EQ("POST / HTTP/1.1\r\nHost: localhost:12345\r\nAccept: */*\r\nContent-Type: application/json\r\nContent-Length: 19\r\n\r\n{\"event\":\"ok_test\"}",std::string(response_message.begin(), response_message.end()));
+TEST(WebNotifyTimeoutTests, HttpPostNotification_OK)
+{
+  WebNotify notifier;
+  std::string url = "http://localhost:12345";
+  std::string message = "{\"event\":\"ok_test\"}";
+  SimpleTCPServer server(12345);
+  EXPECT_FALSE(notifier.sendHttpPostNotification(url, message, 250));
+  auto response_message =
+    server.GetMessage();  // Blocks until message is received
+  std::cerr << to_visible_string(response_message) << std::endl;
+  EXPECT_EQ("POST / HTTP/1.1\r\nHost: localhost:12345\r\nAccept: */*\r\nContent-Type: application/json\r\nContent-Length: 19\r\n\r\n{\"event\":\"ok_test\"}",
+            std::string(response_message.begin(), response_message.end()));
 }
 
-TEST(WebNotifyTimeoutTests, GrpcNotification_TimesOut) {
-    WebNotify notifier;
-    std::string target = "10.255.255.1:50051"; // Unreachable IP
-    std::string message = "gRPC timeout check";
-    EXPECT_FALSE(notifier.sendGrpcNotification(target, message, 250));
+TEST(WebNotifyTimeoutTests, GrpcNotification_TimesOut)
+{
+  WebNotify notifier;
+  std::string target = "10.255.255.1:50051"; // Unreachable IP
+  std::string message = "gRPC timeout check";
+  EXPECT_FALSE(notifier.sendGrpcNotification(target, message, 250));
 }
 
-TEST(WebNotifyTimeoutTests, GrpcNotification_Ok) {
-    WebNotify notifier;
-    std::string target = "localhost:12345";
-    std::string message = "gRPC timeout check";
-    SimpleTCPServer server(12345);
-    EXPECT_FALSE(notifier.sendGrpcNotification(target, message, 250));
+TEST(WebNotifyTimeoutTests, GrpcNotification_Ok)
+{
+  WebNotify notifier;
+  std::string target = "localhost:12345";
+  std::string message = "gRPC timeout check";
+  SimpleTCPServer server(12345);
+  EXPECT_FALSE(notifier.sendGrpcNotification(target, message, 250));
 }
 
-TEST(WebNotifyTimeoutTests, QClientNotification_TimesOut) {
-    WebNotify notifier;
-    std::string target = "10.255.255.1"; // Unreachable IP
-    int port = 50051;
-    std::string message = "QCLient timeout check";
-    std::string channel = "Notification";
-    EXPECT_FALSE(notifier.sendQClientNotification(target, port, channel, message, 250));
+TEST(WebNotifyTimeoutTests, QClientNotification_TimesOut)
+{
+  WebNotify notifier;
+  std::string target = "10.255.255.1"; // Unreachable IP
+  int port = 50051;
+  std::string message = "QCLient timeout check";
+  std::string channel = "Notification";
+  EXPECT_FALSE(notifier.sendQClientNotification(target, port, channel, message,
+               250));
 }
 
-TEST(WebNotifyTimeoutTests, QClientNotification_Ok) {
-    WebNotify notifier;
-    std::string target = "localhost";
-    int port = 12345;
-    std::string message = "QClient timeout check";
-    std::string channel = "Notification";
-    SimpleTCPServer server(12345);
-    EXPECT_FALSE(notifier.sendQClientNotification(target, port, channel, message, 250));
-    auto response_message = server.GetMessage();  // Blocks until message is received
-    std::cerr << to_visible_string(response_message) << std::endl;
-    EXPECT_EQ("*2\r\n$4\r\nPING\r\n$33\r\nqclient-connection-initialization\r\n", std::string(response_message.begin(), response_message.end()));
+TEST(WebNotifyTimeoutTests, QClientNotification_Ok)
+{
+  WebNotify notifier;
+  std::string target = "localhost";
+  int port = 12345;
+  std::string message = "QClient timeout check";
+  std::string channel = "Notification";
+  SimpleTCPServer server(12345);
+  EXPECT_FALSE(notifier.sendQClientNotification(target, port, channel, message,
+               250));
+  auto response_message =
+    server.GetMessage();  // Blocks until message is received
+  std::cerr << to_visible_string(response_message) << std::endl;
+  EXPECT_EQ("*2\r\n$4\r\nPING\r\n$33\r\nqclient-connection-initialization\r\n",
+            std::string(response_message.begin(), response_message.end()));
 }
 
-TEST(WebNotifyTimeoutTests, ActiveMQNotification_TimesOut) {
-    WebNotify notifier;
-    std::string brokerURI = "tcp://10.255.255.1:61616"; // Unreachable
-    std::string queue = "timeout_test";
-    std::string message = "ActiveMQ timeout check";
-
-    EXPECT_FALSE(notifier.sendActiveMQNotification(brokerURI, queue, message, 250));
+TEST(WebNotifyTimeoutTests, ActiveMQNotification_TimesOut)
+{
+  WebNotify notifier;
+  std::string brokerURI = "tcp://10.255.255.1:61616"; // Unreachable
+  std::string queue = "timeout_test";
+  std::string message = "ActiveMQ timeout check";
+  EXPECT_FALSE(notifier.sendActiveMQNotification(brokerURI, queue, message, 250));
 }
 
-TEST(WebNotifyTimeoutTests, ActiveMQNotification_Ok) {
-    WebNotify notifier;
-    std::string brokerURI = "tcp://localhost:12345";
-    std::string queue = "timeout_test";
-    std::string message = "ActiveMQ timeout check";
-    SimpleTCPServer server(12345);  // Non-blocking
-    EXPECT_FALSE(notifier.sendActiveMQNotification(brokerURI, queue, message, 250));
-    auto response_message = server.GetMessage();  // Blocks until message is received
-    auto containsActiveMQ = [](const std::vector<char>& response) {
-			      const std::string target = "ActiveMQ";
-			      return std::search(
-						 response.begin(), response.end(),
-						 target.begin(), target.end()
-						 ) != response.end();
-			    };
-    
-    EXPECT_TRUE(containsActiveMQ(response_message));
+TEST(WebNotifyTimeoutTests, ActiveMQNotification_Ok)
+{
+  WebNotify notifier;
+  std::string brokerURI = "tcp://localhost:12345";
+  std::string queue = "timeout_test";
+  std::string message = "ActiveMQ timeout check";
+  SimpleTCPServer server(12345);  // Non-blocking
+  EXPECT_FALSE(notifier.sendActiveMQNotification(brokerURI, queue, message, 250));
+  auto response_message =
+    server.GetMessage();  // Blocks until message is received
+  auto containsActiveMQ = [](const std::vector<char>& response) {
+    const std::string target = "ActiveMQ";
+    return std::search(std::execution::seq,
+                       response.begin(), response.end(),
+                       target.begin(), target.end()
+                      ) != response.end();
+  };
+  EXPECT_TRUE(containsActiveMQ(response_message));
 }