ci: improve CI stability with parallel builds and Valgrind

Major changes:
Run 4 build configurations in parallel with Valgrind on Linux
Add test failure detection verification (meta-test)
Port allocation per build to prevent conflicts in parallel runs
Add --coverage-only flag for dedicated coverage builds
Code quality:

Add TEST_GROUPS constant, CMOCKA patterns, helper functions
Organize ci-build.sh into sections

tests/functionaltests/proftest.c

@@ -17,6 +17,9 @@
 
 #include "proftest.h"
 
+/* Number of parallel test groups for CI builds */
+#define TEST_GROUPS 4
+
 char *config_orig;
 char *data_orig;
 
@@ -136,8 +139,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 <= TEST_GROUPS) ? group : stub_port;
+    
+    printf("[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 +230,74 @@ 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 TEST_GROUPS ports.
+     * Build 0 (local/default): 5230-5233, Full: 5230-5233, Minimal: 5234-5237, etc.
+     * Build 0 and Full share the same range because build 0 is for local runs or sequential run (no parallel builds),
+     * while Full/Minimal/NoEncrypt/Default are used in CI where they run in parallel. */
+    int port_base = 5230 + ((build_idx > 0 ? build_idx - 1 : 0) * TEST_GROUPS);
+    
+    /* 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 <= TEST_GROUPS) {
+        /* Static allocation: each group gets a dedicated port */
+        stub_port = port_base + group - 1;
+        printf("[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;
+            printf("[PROF_TEST] Started stabber on port %d\n", stub_port);
+        } else {
+            printf("[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
+        printf("[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;
+                printf("[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");
         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 <= TEST_GROUPS) ? 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);
+    
+    printf("[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
@@ -401,6 +454,16 @@ prof_output_regex(const char *pattern)
         usleep(50000);  /* 50ms */
     }
     
+    /* 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;
 }