assertEquals(0x0001, decodedHeader.getFlags());
        assertEquals(testSessionId, decodedHeader.getSessionId());
    }

    // Duplicate testFlags method removed - keeping the first one

    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 64, 1024, 4096, 65536 })
    @DisplayName("Should handle various message sizes")
    void testVariousMessageSizes(int messageSize) {

    //                                                                           Attribute
    //                                                                           =========
    // keeping parsed request parameters, normal texts or uploaded files
    // keys are requested parameter names (treated as field name here)
    protected Map<String, Object> elementsAll; // lazy-loaded, then after not null

        // Create multiple versions
        for (int i = 0; i < 5; i++) {
            keyManager.rotateSessionKey(sessionId);
        }

        // Clean up, keeping only 2 versions
        keyManager.cleanupArchivedKeys(2);

        // Verify only recent versions are kept
        assertTrue(keyManager.hasSessionKey(sessionId + ".v4"), "Version 4 should exist");

            try {
                boost = Float.parseFloat(value);
            } catch (final Exception e) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Invalid boost value, keeping current: value={}, error={}", value, e.getMessage());
                }
            }
        }
    }

    @Override
    public String getConfigId() {
        return ConfigType.WEB.getConfigId(getId());

            try {
                boost = Float.parseFloat(value);
            } catch (final Exception e) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Invalid boost value, keeping current: value={}, error={}", value, e.getMessage());
                }
            }
        }
    }

    @Override
    public String getConfigId() {
        return ConfigType.FILE.getConfigId(getId());

            sb.setLength(0); // Reset length
        }
        return sb;
    }

    private void returnStringBuilder(StringBuilder sb) {
        if (sb != null && sb.capacity() < 2048) { // Avoid keeping very large builders
            stringBuilderPool.offer(sb);
        }
    }

    private Map<String, Object> getContextMap() {
        HashMap<String, Object> map = mapPool.poll();
        if (map == null) {

        }

        /**
         * Deletes old documents from the search index.
         * This method removes documents that were indexed in previous
         * crawling sessions for the same data configuration, keeping
         * only the documents from the current session.
         *
         * <p>The deletion process:</p>
         * <ul>
         *   <li>Checks if old document deletion is enabled</li>

            try {
                boost = Float.parseFloat(value);
            } catch (final Exception e) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Invalid boost value, keeping current: value={}, error={}", value, e.getMessage());
                }
            }
        }
    }

    @Override
    public String getIndexingTarget(final String input) {
        // always return true