// Start all threads
        for (Thread thread : threads) {
            thread.start();
        }

        // Wait for all threads to complete
        for (Thread thread : threads) {
            thread.join(5000); // 5 second timeout
        }

        // Verify no errors occurred during concurrent execution
        assertFalse(hasError.get());
    }

        final Map<String, Object> params = new HashMap<>();
        final Map<String, String> nestedMap = new HashMap<>();
        nestedMap.put("name", "John");
        nestedMap.put("role", "Developer");
        params.put("user", nestedMap);

        assertEquals("John", groovyEngine.evaluate("return user.name", params));
        assertEquals("Developer", groovyEngine.evaluate("return user.role", params));
    }

    /**

                }
            });
            threads.add(thread);
            thread.start();
        }

        // Wait for all threads
        for (Thread thread : threads) {
            thread.join();
        }

        // Verify all documents were processed
        assertEquals(threadCount * docsPerThread, successCount.get());
        assertEquals(threadCount * docsPerThread, indexUpdateCallback.getDocumentSize());

        }

        request.getParameterMap().entrySet().stream().forEach(entry -> {
            if (entry.getValue().length > 1) {
                curlRequest.param(entry.getKey(), String.join(",", entry.getValue()));
            } else if (entry.getValue().length == 1) {
                curlRequest.param(entry.getKey(), entry.getValue()[0]);
            }
        });

                metaDataMap.put(key, values);

                // meta -> content
                if (fessConfig.isCrawlerMetadataContentIncluded(key)) {
                    final String joinedValue = StringUtils.join(values, ' ');
                    if (StringUtil.isNotBlank(joinedValue)) {
                        if (contentMetaBuf.length() > 0) {
                            contentMetaBuf.append(' ');
                        }

        ExecResult execResult = exec(command);
        if (execResult.returnCode() != 0) {
            throw new AssertionError(String.join(" ", command) + " failed with return code: " + execResult);
        }
        return execResult.stdout();
    }

        for (Thread thread : threads) {
            thread.start();
        }

        // Wait for all threads to complete
        for (Thread thread : threads) {
            try {
                thread.join();
            } catch (InterruptedException e) {
                fail("Thread interrupted");
            }
        }

        // Verify all stores were counted

            final InputStreamThread it = new InputStreamThread(currentProcess.getInputStream(), commandOutputEncoding, maxOutputLine);
            it.start();

            currentProcess.waitFor();
            it.join(5000);

            if (mt.isTeminated()) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Command execution timeout for user: username={}", username);
                }

            assertTrue("Should find custom thread in dump", customThreadFound.get() > 0);

        } finally {
            latch.countDown();
            customThread.join(1000); // Wait up to 1 second for thread to finish
        }
    }

    @Test
    public void test_writeThreadDump_fileContent() throws IOException {

        // Start all threads
        for (Thread thread : threads) {
            thread.start();
        }

        // Wait for all threads to complete
        for (Thread thread : threads) {
            thread.join();
        }

        // Check all providers were created successfully
        for (int i = 0; i < threadCount; i++) {
            assertNull(exceptions[i], "Thread " + i + " threw exception");