AvPair decoded = decodedPairs.get(i);

            assertEquals(original.getType(), decoded.getType(), "Type should match at index " + i);
            assertTrue(Arrays.equals(original.getRaw(), decoded.getRaw()), "Raw data should match at index " + i);
        }
    }

    /**
     * Test decode with AvSingleHost type
     */
    @Test

                        doc.put(scoreField, Float.valueOf(rrfScore));
                        documentsByIdMap.put(id, doc);
                    }
                    // Track documents from main searcher (index 0) within window size
                    if (searcherIndex == 0 && docRank < windowSize / 2) {
                        mainSearcherIdSet.add(id);
                    }
                }
            }
        }

      Invokable<Object, ?> unsafe = (Invokable<Object, ?>) invokable;
      unsafe.invoke(instance, params);
      Assert.fail(
          "No exception thrown for parameter at index "
              + paramIndex
              + " from "
              + invokable
              + Arrays.toString(params)
              + " for "
              + testedClass);

        }

        if (sb.length() > 0) {
            list.add(sb.toString());
        }

        return list;
    }

    private String unescape(final String s) {
        if (s.indexOf('\\') >= 0) {
            final StringBuilder sb = new StringBuilder();
            for (int i = 0; i < s.length(); i++) {
                final char ch = s.charAt(i);
                if (ch == '\\' && i < s.length() - 1) {

            return StringUtil.EMPTY; // empty
        }

        if (url.startsWith("file:////")) {
            final String value = decodeUrlAsName(url.substring(9), true);
            final int pos = value.indexOf('/');
            if (pos > 0) {
                return value.substring(0, pos);
            }
            if (pos == -1) {
                return value;
            }
            return "localhost";

import org.codelibs.fess.opensearch.config.exentity.ThumbnailQueue;
import org.codelibs.fess.util.ComponentUtil;
import org.codelibs.fess.util.DocumentUtil;
import org.codelibs.fess.util.ResourceUtil;
import org.opensearch.index.query.QueryBuilders;

import com.google.common.collect.Lists;

import jakarta.annotation.PostConstruct;
import jakarta.annotation.PreDestroy;

/**
 * Manager class for handling thumbnail generation and management.

import org.dbflute.optional.OptionalEntity;
import org.dbflute.util.DfTypeUtil;
import org.opensearch.action.bulk.BulkRequestBuilder;
import org.opensearch.action.delete.DeleteRequestBuilder;
import org.opensearch.action.index.IndexRequestBuilder;

/**
 * @author ESFlute (using FreeGen)
 */
public abstract class BsWebConfigBhv extends EsAbstractBehavior<WebConfig, WebConfigCB> {

        }

        @Override
        public void add(int index, V element) {
            asList().add(index, element);
        }

        @Override
        public V remove(int index) {
            return asList().remove(index);
        }

        @Override
        public V get(int index) {
            return asList().get(index);
        }

        @Override

        }
    }

    /**
     * Processes and normalizes a document title.
     * Applies text normalization using configured space characters and returns
     * a clean title suitable for indexing.
     *
     * @param responseData the response data from crawling (not currently used)
     * @param title the raw title text to process
     * @param dataMap additional data map (not currently used)

     *
     * @param form the search form containing search criteria
     * @return HTML response for the path mapping list page
     */
    @Execute
    @Secured({ ROLE, ROLE + VIEW })
    public HtmlResponse index(final SearchForm form) {
        return asListHtml();
    }

    /**
     * Displays the path mapping list with pagination support.
     *
     * @param pageNumber the optional page number for pagination