allJvmArgs = allJvmArgs.filter { !it.startsWith("--add-opens") }
    }
    if (name.matches("test.*UnitTest".toRegex()) && javaLauncher.get().metadata.languageVersion.asInt() < 17) {
      // Work around robolectric requirements and limitations
      // https://github.com/robolectric/robolectric/issues/10419

    @Execute
    public JsonResponse<ApiResult> docs(final SearchBody body) {
        validateApi(body, messages -> {});

        if (StringUtil.isBlank(body.q)) {
            // query matches on all documents.
            body.q = Constants.MATCHES_ALL_QUERY;
        }

        final SearchRenderData renderData = new SearchRenderData();
        body.initialize();
        try {

    //                                                                        Small Helper
    //                                                                        ============
    /**
     * Verifies that the CRUD mode matches the expected mode.
     *
     * @param crudMode the actual CRUD mode
     * @param expectedMode the expected CRUD mode
     */
    protected void verifyCrudMode(final int crudMode, final int expectedMode) {

        parser.parse(new InputSource(is));
        Node node = parser.getDocument().getFirstChild().getLastChild().getFirstChild();
        return tag.matches(node);
    }

    public void test_normalizeQueryLanguages() {
        FessProp.propMap.clear();
        FessConfig fessConfig = new FessConfig.SimpleImpl() {
            @Override

        // Act & Assert
        // Due to implementation, iteration uses this.b.length and ignores extra bytes in argument
        assertTrue(shorter.equals(longer), "Shorter equals longer when prefix matches (implementation behavior)");

        // In the opposite direction, an out-of-bounds occurs internally and is caught as false
        assertFalse(longer.equals(shorter), "Longer does not equal shorter (implementation behavior)");

        assertTrue(log.contains(", heap "));
        assertTrue(log.contains(", max "));
        assertTrue(log.endsWith("}"));

        // Verify format contains expected memory units
        assertTrue(log.matches(".*used [0-9.]+[a-zA-Z]+, heap [0-9.]+[a-zA-Z]+, max [0-9.]+[a-zA-Z]+.*"));
    }

    public void test_byteCountToDisplaySize_edgeCases() {

import java.util.Collections;
import java.util.Set;
import org.jspecify.annotations.Nullable;

/**
 * CompactLinkedHashSet is an implementation of a Set, which a predictable iteration order that
 * matches the insertion order. All optional operations (adding and removing) are supported. All
 * elements, including {@code null}, are permitted.
 *

    //                                                                              ======
    /**
     * Handles the prologue phase of action execution.
     * <p>
     * This method catches UserRoleLoginException and redirects to the
     * appropriate action class.
     * </p>
     *
     * @param runtime the action runtime context

    //                                                                        Small Helper
    //                                                                        ============
    /**
     * Verify that the CRUD mode matches the expected mode.
     *
     * @param crudMode the actual CRUD mode
     * @param expectedMode the expected CRUD mode
     * @param dictId the dictionary ID for error redirection
     */

            return false;
        }
        for (final Map.Entry<String, String> entry : conditionMap.entrySet()) {
            if (docMap.get(entry.getKey()) instanceof final String value && value.matches(entry.getValue())) {
                if (logger.isDebugEnabled()) {
                    logger.debug("[{}] match {}:{}", entry.getKey(), name, value);
                }
                return true;
            }