*/
    public static final int SID_TYPE_INVALID = 7;

    /**
     * SID type for an unknown SID.
     */
    public static final int SID_TYPE_UNKNOWN = 8;

    /**
     * SID type for a non-use SID.
     */
    public static final int SID_TYPE_USE_NONE = 0;

    /**
     * SID type for a user.
     */
    public static final int SID_TYPE_USER = 1;

    /**

                    @Override
                    public int getStatus() {
                        // RED status should return non-zero status
                        return 2;
                    }
                };
                return response;
            }
        };

        SystemHelper systemHelper = new SystemHelper() {

                }
            });
            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());

labels.error_title=Erreur
labels.system_error_title=Erreur système
labels.contact_site_admin=Veuillez contacter l'administrateur de votre site.
labels.request_error_title=Format de requête non valide.
labels.bad_request=Votre requête à l'URL n'est pas valide.
labels.page_not_found_title=Page non trouvée.
labels.check_url=Veuillez vérifier l'URL.
labels.busy_title=Service temporairement indisponible

            val introStart = content.indexOf(FIXED_ISSUES_INTRO)
            val afterIntro = introStart + FIXED_ISSUES_INTRO.length
            // Find the end of the issues list: the first non-list line after the intro
            val listEnd = findEndOfListSection(content, afterIntro)
            content.substring(0, introStart) + newSection + "\n" + content.substring(listEnd)
        } else {

        queryContext.setQueryBuilder(initialQuery);

        queryContext.addQuery(boolQuery -> {
            // Don't add any clauses
        });

        // When no clauses are added to a non-MatchAllQuery, it still wraps in BoolQuery
        QueryBuilder result = queryContext.getQueryBuilder();
        assertTrue(result instanceof BoolQueryBuilder);
        BoolQueryBuilder boolResult = (BoolQueryBuilder) result;

        String[] result = JvmUtil.filterJvmOptions(new String[] { "8-:-Xmx1g", "9-:-Xmx2g" });
        assertEquals(1, result.length);
        assertEquals("-Xmx1g", result[0]);

        // Test with Java 9 (first non-1.x version)
        System.setProperty("java.version", "9.0.4");
        result = JvmUtil.filterJvmOptions(new String[] { "8-:-Xmx1g", "9-:-Xmx2g", "10-:-Xmx3g" });
        assertEquals(2, result.length);

                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(' ');
                        }

            final InputStreamThread it = jobProcess.getInputStreamThread();
            it.start();

            final Process currentProcess = jobProcess.getProcess();
            currentProcess.waitFor();
            it.join(5000);

            final int exitValue = currentProcess.exitValue();

            if (logger.isInfoEnabled()) {
                logger.info("Python: Exit Code={} - Process Output:\n{}", exitValue, it.getOutput());

    }

    private void assertArrays(final String[] expected, final String[] actual) {
        Arrays.sort(expected);
        Arrays.sort(actual);
        assertEquals(String.join(",", expected), String.join(",", actual));
    }

    @Test
    public void test_getEntraIdPermissionFields_withNewKey() {
        final Map<String, String> systemPropMap = new HashMap<>();
        FessProp.propMap.clear();