Fix Windows test failure and add hex utility coverage

- Fix file_upload tests to use subdirectory instead of /tmp for
  cross-platform compatibility
- Extract hex validation functions (is_valid_hex, hex_char_to_val)
  from webserver.cpp to string_utilities for testability
- Add unit tests for hex utility functions to improve coverage

Author: etr

src/httpserver/string_utilities.hpp

@@ -42,6 +42,20 @@ const std::string to_upper_copy(const std::string& str);
 const std::string to_lower_copy(const std::string& str);
 const std::vector<std::string> string_split(const std::string& s, char sep = ' ', bool collapse = true);
 
+/**
+ * Validate that a string contains only valid hexadecimal characters (0-9, a-f, A-F)
+ * @param s The string to validate
+ * @return true if string contains only valid hex characters, false otherwise
+ */
+bool is_valid_hex(const std::string& s);
+
+/**
+ * Convert a hex character to its numeric value (0-15)
+ * @param c The hex character to convert
+ * @return numeric value (0-15), or 0 for invalid characters
+ */
+unsigned char hex_char_to_val(char c);
+
 }  // namespace string_utilities
 
 }  // namespace httpserver

src/string_utilities.cpp

@@ -55,5 +55,22 @@ const std::vector<std::string> string_split(const std::string& s, char sep, bool
     return result;
 }
 
+bool is_valid_hex(const std::string& s) {
+    for (char c : s) {
+        if (!((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') ||
+              (c >= 'A' && c <= 'F'))) {
+            return false;
+        }
+    }
+    return true;
+}
+
+unsigned char hex_char_to_val(char c) {
+    if (c >= '0' && c <= '9') return static_cast<unsigned char>(c - '0');
+    if (c >= 'a' && c <= 'f') return static_cast<unsigned char>(c - 'a' + 10);
+    if (c >= 'A' && c <= 'F') return static_cast<unsigned char>(c - 'A' + 10);
+    return 0;
+}
+
 }  // namespace string_utilities
 }  // namespace httpserver

src/webserver.cpp

@@ -58,6 +58,7 @@
 #include "httpserver/http_resource.hpp"
 #include "httpserver/http_response.hpp"
 #include "httpserver/http_utils.hpp"
+#include "httpserver/string_utilities.hpp"
 #include "httpserver/string_response.hpp"
 
 struct MHD_Connection;
@@ -429,25 +430,6 @@ void webserver::disallow_ip(const string& ip) {
 }
 
 #ifdef HAVE_GNUTLS
-// Validate that a string contains only valid hexadecimal characters
-static bool is_valid_hex(const std::string& s) {
-    for (char c : s) {
-        if (!((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') ||
-              (c >= 'A' && c <= 'F'))) {
-            return false;
-        }
-    }
-    return true;
-}
-
-// Convert a hex character to its numeric value
-static unsigned char hex_char_to_val(char c) {
-    if (c >= '0' && c <= '9') return static_cast<unsigned char>(c - '0');
-    if (c >= 'a' && c <= 'f') return static_cast<unsigned char>(c - 'a' + 10);
-    if (c >= 'A' && c <= 'F') return static_cast<unsigned char>(c - 'A' + 10);
-    return 0;
-}
-
 // MHD_PskServerCredentialsCallback signature:
 // The 'cls' parameter is our webserver pointer (passed via MHD_OPTION)
 // Returns 0 on success, -1 on error
@@ -476,7 +458,8 @@ int webserver::psk_cred_handler_func(void* cls,
 
     // Validate hex string before allocating memory
     size_t psk_len = psk_hex.size() / 2;
-    if (psk_len == 0 || (psk_hex.size() % 2 != 0) || !is_valid_hex(psk_hex)) {
+    if (psk_len == 0 || (psk_hex.size() % 2 != 0) ||
+        !string_utilities::is_valid_hex(psk_hex)) {
         return -1;
     }
 
@@ -489,8 +472,8 @@ int webserver::psk_cred_handler_func(void* cls,
     // Convert hex string to binary
     for (size_t i = 0; i < psk_len; i++) {
         psk_data[i] = static_cast<unsigned char>(
-            (hex_char_to_val(psk_hex[i * 2]) << 4) |
-             hex_char_to_val(psk_hex[i * 2 + 1]));
+            (string_utilities::hex_char_to_val(psk_hex[i * 2]) << 4) |
+             string_utilities::hex_char_to_val(psk_hex[i * 2 + 1]));
     }
 
     *psk = psk_data;

test/integ/file_upload.cpp

@@ -889,7 +889,9 @@ LT_END_AUTO_TEST(file_cleanup_no_callback_deletes)
 
 // Test file upload keeping original filename (without random generation)
 LT_BEGIN_AUTO_TEST(file_upload_suite, file_upload_original_filename)
-    string upload_directory = "/tmp";  // Use temp directory to avoid conflicts
+    // Use a subdirectory to avoid overwriting the test input file
+    string upload_directory = "upload_test_dir";
+    mkdir(upload_directory.c_str(), 0755);
 
     auto ws = std::make_unique<webserver>(create_webserver(PORT)
                        .file_upload_target(httpserver::FILE_UPLOAD_DISK_ONLY)
@@ -915,15 +917,16 @@ LT_BEGIN_AUTO_TEST(file_upload_suite, file_upload_original_filename)
 
     ws->stop();
 
-    // Clean up the file
+    // Clean up the file and directory
     unlink(expected_path.c_str());
+    rmdir(upload_directory.c_str());
 LT_END_AUTO_TEST(file_upload_original_filename)
 
 // Test file upload with explicit content-type header
 // This exercises the content_type != nullptr branch in webserver.cpp post_iterator
 LT_BEGIN_AUTO_TEST(file_upload_suite, file_upload_with_content_type)
     int port = PORT + 1;
-    string upload_directory = "/tmp";
+    string upload_directory = ".";
 
     auto ws = std::make_unique<webserver>(create_webserver(port)
                        .file_upload_target(httpserver::FILE_UPLOAD_DISK_ONLY)

test/unit/string_utilities_test.cpp

@@ -173,6 +173,38 @@ LT_BEGIN_AUTO_TEST(string_utilities_suite, split_string_single_element)
     LT_CHECK_EQ(actual[0], "hello");
 LT_END_AUTO_TEST(split_string_single_element)
 
+// Test is_valid_hex with valid strings
+LT_BEGIN_AUTO_TEST(string_utilities_suite, is_valid_hex_valid)
+    LT_CHECK_EQ(httpserver::string_utilities::is_valid_hex("0123456789"), true);
+    LT_CHECK_EQ(httpserver::string_utilities::is_valid_hex("abcdef"), true);
+    LT_CHECK_EQ(httpserver::string_utilities::is_valid_hex("ABCDEF"), true);
+    LT_CHECK_EQ(httpserver::string_utilities::is_valid_hex("0123456789abcdefABCDEF"), true);
+LT_END_AUTO_TEST(is_valid_hex_valid)
+
+// Test is_valid_hex with invalid strings
+LT_BEGIN_AUTO_TEST(string_utilities_suite, is_valid_hex_invalid)
+    LT_CHECK_EQ(httpserver::string_utilities::is_valid_hex("ZZZZ"), false);
+    LT_CHECK_EQ(httpserver::string_utilities::is_valid_hex("hello"), false);
+    LT_CHECK_EQ(httpserver::string_utilities::is_valid_hex("12g4"), false);
+    LT_CHECK_EQ(httpserver::string_utilities::is_valid_hex("12 34"), false);
+LT_END_AUTO_TEST(is_valid_hex_invalid)
+
+// Test is_valid_hex with empty string
+LT_BEGIN_AUTO_TEST(string_utilities_suite, is_valid_hex_empty)
+    LT_CHECK_EQ(httpserver::string_utilities::is_valid_hex(""), true);
+LT_END_AUTO_TEST(is_valid_hex_empty)
+
+// Test hex_char_to_val with digits
+LT_BEGIN_AUTO_TEST(string_utilities_suite, hex_char_to_val_digits)
+    LT_CHECK_EQ(httpserver::string_utilities::hex_char_to_val('0'), 0);
+    LT_CHECK_EQ(httpserver::string_utilities::hex_char_to_val('9'), 9);
+    LT_CHECK_EQ(httpserver::string_utilities::hex_char_to_val('a'), 10);
+    LT_CHECK_EQ(httpserver::string_utilities::hex_char_to_val('f'), 15);
+    LT_CHECK_EQ(httpserver::string_utilities::hex_char_to_val('A'), 10);
+    LT_CHECK_EQ(httpserver::string_utilities::hex_char_to_val('F'), 15);
+    LT_CHECK_EQ(httpserver::string_utilities::hex_char_to_val('z'), 0);
+LT_END_AUTO_TEST(hex_char_to_val_digits)
+
 LT_BEGIN_AUTO_TEST_ENV()
     AUTORUN_TESTS()
 LT_END_AUTO_TEST_ENV()