return lineNumber;
    }

    public int getColumnNumber() {
        return columnNumber;
    }

    public InputSource getSource() {
        return source;
    }

    @Override
    public InputLocation getLocation(Object key) {
        return locations != null ? locations.get(key) : null;
    }

    public Map<Object, InputLocation> getLocations() {
        return locations;
    }

 * ```
 */
class MockWebServerRule : ExternalResource() {
  val server: MockWebServer = MockWebServer()

  override fun before() {
    try {
      server.start()
    } catch (e: IOException) {
      throw RuntimeException(e)
    }
  }

  override fun after() {
    server.close()
  }

  fun receivingConnectionWindowChanged(windowCounter: WindowCounter)

  /** Noop implementation */
  object None : FlowControlListener {
    override fun receivingStreamWindowChanged(
      streamId: Int,
      windowCounter: WindowCounter,
      bufferSize: Long,
    ) {
    }

    override fun receivingConnectionWindowChanged(windowCounter: WindowCounter) {
    }
  }

  fun assertResponseCookies(vararg cookies: String?) {
    assertThat(takeResponseCookies().map(Cookie::toString)).containsExactly(*cookies)
  }

  override fun saveFromResponse(
    url: HttpUrl,
    cookies: List<Cookie>,
  ) {
    responseCookies.add(cookies)
  }

  override fun loadForRequest(url: HttpUrl): List<Cookie> = if (requestCookies.isEmpty()) emptyList() else requestCookies.removeFirst()

 */
package org.codelibs.fess.mylasta.mail;

import org.codelibs.fess.unit.UnitFessTestCase;

public class EsStatusPostcardTest 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

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;