ci: improve CI stability with parallel builds, Valgrind, and coverage

tests/functionaltests/functionaltests.c

@@ -69,6 +69,12 @@ main(int argc, char* argv[])
         }
     }
 
+    char group_env[16];
+    snprintf(group_env, sizeof(group_env), "%d", group);
+    setenv("PROF_TEST_GROUP", group_env, 1);
+    
+    fprintf(stderr, "[PROF_TEST] Starting functional tests, group=%d\n", group);
+
     /* ============================================================
      * GROUP 1: Connect, Ping, Rooms, Software
      * Basic XMPP session establishment and server queries

tests/functionaltests/proftest.c

@@ -136,8 +136,14 @@ _create_logs_dir(void)
 void
 _cleanup_dirs(void)
 {
+    const char *group_env = getenv("PROF_TEST_GROUP");
+    int group = group_env ? atoi(group_env) : 0;
+    int dir_id = (group >= 1 && group <= 4) ? group : stub_port;
+    
+    fprintf(stderr, "[PROF_TEST] Cleaning up directories for group %d (dir_id %d)\n", group, dir_id);
+    
     char cmd[512];
-    snprintf(cmd, sizeof(cmd), "rm -rf ./tests/functionaltests/files/%d", stub_port);
+    snprintf(cmd, sizeof(cmd), "rm -rf ./test-files/%d", dir_id);
     int res = system(cmd);
     if (res == -1) {
         assert_true(FALSE);
@@ -221,30 +227,73 @@ prof_start(void)
     /* Set non-blocking mode for reading */
     int flags = fcntl(fd, F_GETFL, 0);
     fcntl(fd, F_SETFL, flags | O_NONBLOCK);
+    
+    /* Brief wait for process to initialize */
+    usleep(50000);  /* 50ms */
 }
 
 int
 init_prof_test(void **state)
 {
+    /* Get test group from environment for static resource allocation */
+    const char *group_env = getenv("PROF_TEST_GROUP");
+    int group = group_env ? atoi(group_env) : 0;
+    
+    /* Get build index for port offset (for parallel CI builds) */
+    const char *build_env = getenv("PROF_BUILD_INDEX");
+    int build_idx = build_env ? atoi(build_env) : 0;
+    
+    /* Calculate port base: each build uses a different range of 4 ports
+     * Build 0/1: 5230-5233, Build 2: 5234-5237, Build 3: 5238-5241, Build 4: 5242-5245 */
+    int port_base = 5230 + ((build_idx > 0 ? build_idx - 1 : 0) * 4);
+    
+    /* Static resource allocation to avoid conflicts in parallel execution.
+     * Group 1-4: use static port assignment.
+     * Group 0 (all groups): use dynamic allocation as fallback. */
     gboolean started = FALSE;
-    for (int p = 5230; p < 5250; ++p) {
-        int ret = stbbr_start(STBBR_LOGDEBUG, p, 0);
-        if (ret == 0) {
-            stub_port = p;
+    
+    if (group >= 1 && group <= 4) {
+        /* Static allocation: each group gets a dedicated port */
+        stub_port = port_base + group - 1;
+        fprintf(stderr, "[PROF_TEST] Build %d, Group %d: trying port %d\n", build_idx, group, stub_port);
+        
+        if (stbbr_start(STBBR_LOGDEBUG, stub_port, 0) == 0) {
             started = TRUE;
-            break;
+            fprintf(stderr, "[PROF_TEST] Started stabber on port %d\n", stub_port);
+        } else {
+            fprintf(stderr, "[PROF_TEST] Failed to start stabber on port %d\n", stub_port);
         }
     }
+    
+    /* Fallback to dynamic allocation if static failed or group=0 */
     if (!started) {
-        assert_true(FALSE); // could not start stabber on any port in range
+        fprintf(stderr, "[PROF_TEST] Using dynamic port allocation\n");
+        for (int p = port_base; p < port_base + 20; ++p) {
+            if (stbbr_start(STBBR_LOGDEBUG, p, 0) == 0) {
+                stub_port = p;
+                started = TRUE;
+                fprintf(stderr, "[PROF_TEST] Started stabber on port %d\n", stub_port);
+                break;
+            }
+        }
+    }
+    
+    if (!started) {
+        fprintf(stderr, "[PROF_TEST] ERROR: could not start stabber on any port\n");
+        assert_true(FALSE);
         return -1;
     }
 
-    // Generate unique XDG paths based on stub_port for parallel execution
+    // Generate unique XDG paths based on group for parallel execution
+    // Use ./test-files/ in current (build) directory for out-of-tree builds compatibility
+    int dir_id = (group >= 1 && group <= 4) ? group : stub_port;
     snprintf(xdg_config_home, sizeof(xdg_config_home),
-             "./tests/functionaltests/files/%d/xdg_config_home", stub_port);
+             "./test-files/%d/xdg_config_home", dir_id);
     snprintf(xdg_data_home, sizeof(xdg_data_home),
-             "./tests/functionaltests/files/%d/xdg_data_home", stub_port);
+             "./test-files/%d/xdg_data_home", dir_id);
+    
+    fprintf(stderr, "[PROF_TEST] Group %d using directories: config=%s, data=%s\n", 
+            group, xdg_config_home, xdg_data_home);
 
     // Give stabber server thread time to start listening
     usleep(100000); // 100ms
@@ -398,9 +447,19 @@ prof_output_regex(const char *pattern)
             return 1;
         }
         
-        usleep(50000);  /* 50ms */
+        usleep(50000);
     }
     
+    /* Timeout reached - log diagnostic info */
+    fprintf(stderr, "Timeout waiting for regex '%s' after %d seconds. Last output:\n", pattern, expect_timeout);
+    size_t len = strlen(output_buffer);
+    if (len > 500) {
+        fprintf(stderr, "...%s", output_buffer + len - 500);
+    } else {
+        fprintf(stderr, "%s", output_buffer);
+    }
+    fprintf(stderr, "\n");
+    
     regfree(&regex);
     return 0;
 }