* governing permissions and limitations under the License.
 */
package org.codelibs.fess.entity;

import java.util.List;
import java.util.Map;

import org.codelibs.fess.util.FacetResponse;

public class SearchRenderData {

    protected List<Map<String, Object>> documentItems;

    protected FacetResponse facetResponse;

    protected String appendHighlightParams;

@Named
@Singleton
@Deprecated(since = "4.0.0")
public class DefaultProfileSelector implements ProfileSelector {

    private final List<ProfileActivator> activators;

    public DefaultProfileSelector() {
        this.activators = new ArrayList<>();
    }

    @Inject
    public DefaultProfileSelector(List<ProfileActivator> activators) {
        this.activators = new ArrayList<>(activators);
    }

  /** Regression test for b/4124577 */
  public void testRegression_dataCorruption() {
    int size = 8;
    List<Integer> expected = createOrderedList(size);
    MinMaxPriorityQueue<Integer> q = MinMaxPriorityQueue.create(expected);
    List<Integer> contents = Lists.newArrayList(expected);
    List<Integer> elements = Lists.newArrayListWithCapacity(size);
    while (!q.isEmpty()) {
      assertThat(q).containsExactlyElementsIn(contents);

        }

        @Override
        public Optional<Lifecycle> lookup(String id) {
            return Optional.empty();
        }

        @Override
        public List<String> computePhases(Lifecycle lifecycle) {
            return List.of();
        }
    };

    private static final PackagingRegistry emptyPackagingRegistry = new PackagingRegistry() {
        @Override

    }
  }

  override fun toString(): String = format("Parsing: <%s> against <%s>", input!!, base!!)

  companion object {
    fun load(source: BufferedSource): List<WebPlatformUrlTestData> {
      val list = mutableListOf<WebPlatformUrlTestData>()
      while (true) {
        val line = source.readUtf8Line() ?: break
        if (line.isEmpty() || line.startsWith("#")) continue

        var i = 0

                    }
                    if (bufferSize > 0) {
                        list.add(line);
                    }
                    if (outputCallback != null) {
                        outputCallback.accept(line);
                    }
                    if (list.size() > bufferSize) {
                        list.remove(0);
                    }
                }
            } catch (final Exception e) {

    }

    public static List<String> getAsList(final Object value) {
        if (value == null) {
            return new ArrayList<>();
        }

        if (value instanceof String) {
            final List<String> list = new ArrayList<>();
            list.add(value.toString());
            return list;
        }
        if (value instanceof List) {
            return (List<String>) value;

class FakeDns : Dns {
  private val hostAddresses: MutableMap<String, List<InetAddress>> = mutableMapOf()
  private val requestedHosts: MutableList<String> = mutableListOf()
  private var nextAddress = 0xff000064L // 255.0.0.100 in IPv4; ::ff00:64 in IPv6.

  /** Sets the results for `hostname`.  */
  operator fun set(
    hostname: String,
    addresses: List<InetAddress>,
  ): FakeDns {
    hostAddresses[hostname] = addresses

         * chain.addConverter(new KatakanaToAlphabetConverter()); chain.init();
         *
         * List<String> list = chain.convert("検索"); assertTrue(list.contains("ケンサク"));
         * assertTrue(list.contains("kennsaku"));
         */
    }

            Artifact artifact, ArtifactRepository localRepository, List<ArtifactRepository> remoteRepositories) {
        throw new UnsupportedOperationException("Cannot retrieve metadata in this test case");
    }

    public List<ArtifactVersion> retrieveAvailableVersions(
            Artifact artifact, ArtifactRepository localRepository, List<ArtifactRepository> remoteRepositories) {