final String converted = URLEncoder.encode(target, Constants.UTF_8);
                    if (target.equals(converted)) {
                        encodedBuf.append(Base64.getUrlEncoder().encodeToString(target.getBytes(Constants.CHARSET_UTF_8)));
                    } else {
                        encodedBuf.append(converted);
                    }

                }
            } catch (final IOException e) {
                logger.warn("Failed to send {} to {}.", body, url, e);
            }
        }));
    }

    /**
     * Converts the discloser to a Slack message format.
     *
     * @param discloser the mail posting discloser
     * @return the formatted Slack message
     */

    }

    @Test
    public void test_convertCrawlingPath_s3_not_converted() {
        // S3 paths should be returned as-is, not converted
        String s3Path = "s3://my-bucket/path/to/object";
        assertEquals(s3Path, wizardAction.convertCrawlingPath(s3Path));

        // Verify it's not being converted to file: protocol
        assertFalse(wizardAction.convertCrawlingPath(s3Path).startsWith("file:"));
    }

    @Test

                .result());
    }

    /**
     * Creates a ListBody from a DictionaryFile for API responses.
     *
     * @param dictionaryFile the dictionary file to convert
     * @return the converted ListBody object
     */
    protected ListBody createListBody(final DictionaryFile<? extends DictionaryItem> dictionaryFile) {
        final ListBody body = new ListBody();
        body.id = dictionaryFile.getId();

        final OptionalEntity<SearchResponse> searchResponseOpt = sendRequest(query, params, userBean);
        return processResponse(searchResponseOpt);
    }

    /**
     * Processes the OpenSearch response and converts it to a SearchResult.
     *
     * @param searchResponseOpt the optional search response from OpenSearch
     * @return the processed search result
     */

        throw new InvalidQueryException(messages -> messages.addErrorsInvalidQueryUnknown(UserMessages.GLOBAL_PROPERTY_KEY),
                "Unknown q: " + query.getClass() + " => " + query);
    }

    /**
     * Converts a phrase query to a query builder.
     *
     * @param context the query context
     * @param phraseQuery the phrase query
     * @param boost the boost factor
     * @return the query builder
     */

        List<Object> resultList = (List<Object>) result;
        assertEquals(3, resultList.size());

        // First element should be converted to Map since it's an Entity
        assertTrue(resultList.get(0) instanceof Map);
        // All elements are converted by BeanUtil.copyBeanToNewMap when first element is Entity
        assertTrue(resultList.get(1) instanceof Map);
        assertTrue(resultList.get(2) instanceof Map);

    }

    /**
     * Retrieves related queries for a given search term.
     * The search is performed using the current virtual host context and
     * the query term is converted to lowercase for case-insensitive matching.
     *
     * @param query the search term to find related queries for
     * @return an array of related query strings, or empty array if none found
     */

import org.opensearch.common.unit.Fuzziness;
import org.opensearch.index.query.QueryBuilder;
import org.opensearch.index.query.QueryBuilders;

/**
 * Query command implementation for handling fuzzy search queries.
 * This class converts Lucene FuzzyQuery objects into OpenSearch fuzzy query builders,
 * supporting configurable fuzzy matching parameters like edit distance and expansions.
 *
 */
public class FuzzyQueryCommand extends QueryCommand {

    @Override
    public String toString() {
        return "StemmerOverrideItem [input=" + input + ", output=" + output + ", newInput=" + newInput + ", newOutput=" + newOutput + "]";
    }

    /**
     * Converts the item to a string representation for writing to a file.
     *
     * @return A string in the format "input=>output".
     */
    public String toLineString() {
        if (isUpdated()) {