assertEquals(3, settings.array().get(key).length);
        assertEquals(value1, settings.array().get(key)[0]);
        assertEquals(value2, settings.array().get(key)[1]);
        assertEquals(value3, settings.array().get(key)[2]);

        settings.array().delete(key, value2);
        assertEquals(2, settings.array().get(key).length);
        assertEquals(value1, settings.array().get(key)[0]);

    private SuggestUtil() {
    }

    /**
     * Creates a unique identifier for the given text by encoding it to a Base64 string.
     * If the encoded string exceeds the maximum allowed length, it truncates the string
     * to the specified maximum length.
     *
     * @param text the input text to be encoded
     * @return the encoded string, truncated if necessary
     */
    public static String createSuggestTextId(final String text) {

                throw new MaxLengthExceededException("Content length (" + contentLength + " bytes) exceeds the maximum allowed length ("
                        + maxContentLength + " bytes).");
            }
            if (contentLength == 0) {
                if (logger.isDebugEnabled()) {
                    logger.debug("The content length is 0.");
                }
                return new ExtractData(StringUtil.EMPTY);

            final int code = bytesReader.readVInt();
            final int count = code >>> 1;
            for (int i = 0; i < count; i++) {
                synonymMap.words.get(bytesReader.readVInt(), scratchBytes);
                if (scratchChars.chars.length < scratchBytes.length) {
                    scratchChars.chars = new char[scratchBytes.length];
                }

        if (defaultWords == null) {
            updateDefaultBadwords();
        }
        final String[] concat = new String[defaultWords.length + badWords.length];
        System.arraycopy(badWords, 0, concat, 0, badWords.length);
        System.arraycopy(defaultWords, 0, concat, badWords.length, defaultWords.length);
        return concat;
    }

    /**
     * Add a bad word.
     * @param badWord Bad word
     */

        }
        maxLengthMap.put(mimeType, maxLength);
    }

    /**
     * Gets the maximum content length for a specific MIME type.
     * If no specific length is set for the MIME type, returns the default maximum length.
     * @param mimeType The MIME type to get the maximum length for
     * @return The maximum content length in bytes
     */
    public long getMaxLength(final String mimeType) {
        if (StringUtil.isBlank(mimeType)) {

    }

    /**
     * Checks if the content length exceeds the maximum allowed length.
     * @param responseData The response data.
     */
    protected void checkMaxContentLength(final ResponseData responseData) {
        if (maxContentLength != null && responseData.getContentLength() > maxContentLength.longValue()) {
            throw new MaxLengthExceededException("The content length (" + responseData.getContentLength() + " byte) is over "

        final String[] roles = new String[roles1.length + roles2.length];

        if (roles1.length > 0) {
            System.arraycopy(roles1, 0, roles, 0, roles1.length);
        }
        if (roles2.length > 0) {
            System.arraycopy(roles2, 0, roles, roles1.length, roles2.length);
        }

        final List<SuggestItem> items = new ArrayList<>(fields.length);
        try {

            fail();
        } catch (final ChildUrlsException e) {
            String[] urls = e.getChildUrlList().stream().map(r -> r.getUrl()).sorted().toArray(String[]::new);
            assertEquals(3, urls.length);
            assertEquals(baseUrl + "dir1/", urls[0]);
            assertEquals(baseUrl + "dir3/", urls[1]);
            assertEquals(baseUrl + "file1.txt", urls[2]);
        }
        try {

        assertEquals(3, settings.badword().get(false).length);
        assertEquals(value1, settings.badword().get(false)[0]);
        assertEquals(value2, settings.badword().get(false)[1]);
        assertEquals(value3, settings.badword().get(false)[2]);

        settings.badword().delete(value2);
        assertEquals(2, settings.badword().get(false).length);
        assertEquals(value1, settings.badword().get(false)[0]);