package org.codelibs.fess.opensearch.client;

import org.codelibs.fess.unit.UnitFessTestCase;

public class SearchEngineClientTest extends UnitFessTestCase {

    @Override
    public void setUp() throws Exception {
        super.setUp();
    }

    @Override
    public void tearDown() throws Exception {
        super.tearDown();
    }

    // Basic test to verify test framework is working

  public ImmutableMultimapAsMapImplementsMapTest() {
    super(false, false, false);
  }

  @Override
  protected Map<String, Collection<Integer>> makeEmptyMap() {
    return ImmutableMultimap.<String, Integer>of().asMap();
  }

  @Override
  protected Map<String, Collection<Integer>> makePopulatedMap() {
    Multimap<String, Integer> delegate = HashMultimap.create();
    populate(delegate);

  public MultimapsTransformValuesAsMapTest() {
    super(true, true, true);
  }

  @Override
  protected Map<String, Collection<Integer>> makeEmptyMap() {
    return Multimaps.transformValues(
            ArrayListMultimap.<String, Integer>create(), Functions.<Integer>identity())
        .asMap();
  }

  @Override
  protected Map<String, Collection<Integer>> makePopulatedMap() {

            Deque.class,
            new Function<Deque, Deque<?>>() {
              @Override
              public Deque<?> apply(Deque delegate) {
                return wrap((Deque<?>) delegate);
              }
            });
  }

  private static <T> Deque<T> wrap(Deque<T> delegate) {
    return new ForwardingDeque<T>() {
      @Override
      protected Deque<T> delegate() {
        return delegate;
      }
    };
  }

            new Function<ListIterator, ListIterator<?>>() {
              @Override
              public ListIterator<?> apply(ListIterator delegate) {
                return wrap((ListIterator<?>) delegate);
              }
            });
  }

  private static <T> ListIterator<T> wrap(ListIterator<T> delegate) {
    return new ForwardingListIterator<T>() {
      @Override
      protected ListIterator<T> delegate() {
        return delegate;

    private String indexName = null;

    @Override
    protected String asEsIndex() {
        if (indexName == null) {
            final String name = ComponentUtil.getFessConfig().getIndexLogIndex();
            indexName = super.asEsIndex().replaceFirst(Pattern.quote("fess_log"), name);
        }
        return indexName;
    }

    @Override
    protected LocalDateTime toLocalDateTime(final Object value) {

        .Builder()
        .webSocketUpgrade(serverListener)
        .build(),
    )
    val e = RuntimeException()
    clientListener.setNextEventDelegate(
      object : WebSocketListener() {
        override fun onOpen(
          webSocket: WebSocket,
          response: Response,
        ): Unit = throw e
      },
    )
    newWebSocket()
    serverListener.assertOpen()

      object : ResponseBody() {
        override fun contentType() = original.contentType()

        override fun contentLength() = original.contentLength()

        override fun source() = uppercase(original.source()).buffer()
      }

    private fun uppercase(original: Source): Source {
      return object : ForwardingSource(original) {
        override fun read(
          sink: Buffer,

    return new Joiner(this) {
      @Override
      CharSequence toString(@Nullable Object part) {
        return (part == null) ? nullText : Joiner.this.toString(part);
      }

      @Override
      public Joiner useForNull(String nullText) {
        throw new UnsupportedOperationException("already specified useForNull");
      }

      @Override
      public Joiner skipNulls() {

                @Override
                public String getDomain() {
                    return null;
                }

                @Override
                public String getLink() {
                    return null;
                }

                @Override
                public String getServer() {
                    return null;
                }

                @Override