}
    }

    /**
     * Test boundary values for delay settings
     */
    @Test
    public void test_delayBoundaryValues() {
        FessIntervalController controller = new FessIntervalController();

        // Test with very large values
        controller.setDelayMillisAfterProcessing(Long.MAX_VALUE);

            @Override
            public int getLtrWindowSize() {
                return 50;
            }
        });

        Map<String, Object> params = new HashMap<>();
        params.put("param1", "value1");

        RescorerBuilder<?> result = ltrQueryRescorer.evaluate(params);
        assertNull(result);
    }

    @Test
    public void test_evaluate_withNullModelName() {
        // Test when model name is null

        final Map<String, String[]> multiFields = Collections.singletonMap("content", new String[] { "value1", "value2" });
        assertEquals("(content:\"value1\" OR content:\"value2\")", getQuery("", new String[0], multiFields, Collections.emptyMap(), false));

        final Map<String, String[]> nullFields = Collections.singletonMap("empty", null);

     *
     * @param values the array of JVM options to filter
     * @return the filtered array of JVM options applicable to the current Java version
     */
    public static String[] filterJvmOptions(final String[] values) {
        final int version = getJavaVersion();
        return Arrays.stream(values).map(s -> {
            final Matcher matcher = VERSION_PREFIX_PATTERN.matcher(s);

    }

    /**
     * Checks if a checkbox value represents an enabled state.
     * This method considers "on" and "true" (case-insensitive) as enabled values.
     *
     * @param value the checkbox value to check
     * @return true if the value represents an enabled checkbox, false otherwise
     */
    public static boolean isCheckboxEnabled(final String value) {
        if (value == null) {
            return false;
        }

    public void setEndTime_PercentileRanks(double[] values) {
        setEndTime_PercentileRanks(values, null);
    }

    public void setEndTime_PercentileRanks(double[] values, ConditionOptionCall<PercentileRanksAggregationBuilder> opLambda) {
        setEndTime_PercentileRanks("endTime", values, opLambda);
    }

        setCreatedTime_PercentileRanks(values, null);
    }

    public void setCreatedTime_PercentileRanks(double[] values, ConditionOptionCall<PercentileRanksAggregationBuilder> opLambda) {
        setCreatedTime_PercentileRanks("createdTime", values, opLambda);
    }

    public void setCreatedTime_PercentileRanks(String name, double[] values,

        infoMap = null;
    }

    /**
     * Adds a key-value pair to the information map.
     * Initializes the info map as a synchronized LinkedHashMap if it doesn't exist.
     *
     * @param key the parameter key to store
     * @param value the parameter value to store
     */
    public synchronized void putToInfoMap(final String key, final String value) {
        if (infoMap == null) {

        for (String cron : potentiallyValidCrons) {
            boolean result = validator.isValid(cron, context);
            // Don't assert true/false here, just test that method doesn't throw
            assertNotNull(Boolean.valueOf(result), "Validation should return a boolean result for: " + cron);
        }
    }

    // Test edge cases to understand the validation behavior
    @Test
    public void test_edgeCaseBehavior() {

                texts[i] = fragments[i].string();
            }
            final String value = StringUtils.join(texts, ELLIPSIS);
            if (StringUtil.isNotBlank(value) && !ComponentUtil.getFessConfig().endsWithFullstop(value)) {
                return value + ELLIPSIS;
            }
            return value;
        }
        return null;
    }

    /**