// At most one of (body,webSocketListener,streamHandler) is non-null.
  val body: MockResponseBody?
  val webSocketListener: WebSocketListener?
  val streamHandler: StreamHandler?

  val inTunnel: Boolean
  val informationalResponses: List<MockResponse>

  val throttleBytesPerPeriod: Long
  val throttlePeriodNanos: Long

  val socketPolicy: SocketPolicy

  val bodyDelayNanos: Long
  val headersDelayNanos: Long

   * This method returns false in that case, and in any other case where this web socket is closing,
   * closed, or canceled.
   *
   * This method returns immediately.
   */
  fun send(text: String): Boolean

  /**
   * Attempts to enqueue `bytes` to be sent as a the data of a binary (type `0x2`) message.
   *
   * This method returns true if the message was enqueued. Messages that would overflow the outgoing

    }


    private void assertNotified ( SmbWatchHandle w, int action, String name, List<FileNotifyInformation> infos )
            throws InterruptedException, ExecutionException, TimeoutException {
        boolean found = checkInResult(action, name, infos);
        if ( !found ) {
            // retry, the first watch may have already come back before the triggered change was active
            try {
                setupWatch(w);

package jcifs.smb1.util.transport;

public abstract class Response {
    public long expiration;
    public boolean isReceived;

    }

    @Override
    public boolean put(@ParametricNullness K key, @ParametricNullness V value) {
      throw new UnsupportedOperationException();
    }

    @Override
    public boolean putAll(@ParametricNullness K key, Iterable<? extends V> values) {
      throw new UnsupportedOperationException();
    }

    @Override
    public boolean putAll(Multimap<? extends K, ? extends V> multimap) {

 */
public class FessUserLocaleProcessProvider implements UserLocaleProcessProvider {
    private static final Logger logger = LogManager.getLogger(FessUserLocaleProcessProvider.class);

    @Override
    public boolean isAcceptCookieLocale() {
        return false;
    }

    @Override
    public OptionalThing<Locale> findBusinessLocale(final ActionRuntime runtimeMeta, final RequestManager requestManager) {

  }

  override fun getLastAccessedTime(): Long {
    return delegate!!.lastAccessedTime
  }

  override fun invalidate() {
    delegate!!.invalidate()
  }

  override fun isValid(): Boolean {
    return delegate!!.isValid
  }

  override fun putValue(
    s: String,
    o: Any,
  ) {
    delegate!!.putValue(s, o)
  }

  override fun getValue(s: String): Any {

    return delegate.supportedCipherSuites
  }

  @Throws(IOException::class)
  override fun createSocket(
    socket: Socket,
    host: String,
    port: Int,
    autoClose: Boolean,
  ): SSLSocket {
    val sslSocket = delegate.createSocket(socket, host, port, autoClose) as SSLSocket
    return configureSocket(sslSocket)
  }

  @Throws(IOException::class)

  public static <E> QueueTestSuiteBuilder<E> using(TestQueueGenerator<E> generator) {
    return new QueueTestSuiteBuilder<E>().usingGenerator(generator);
  }

  private boolean runCollectionTests = true;

  /**
   * Specify whether to skip the general collection tests. Call this method when testing a
   * collection that's both a queue and a list, to avoid running the common collection tests twice.

 */
public interface ParameterizedClassDesc {

    /**
     * このインスタンスが表現するクラスがパラメタ化されていれば<code>true</code>を返します。
     *
     * @return このインスタンスが表現するクラスがパラメタ化されていれば<code>true</code>
     */
    boolean isParameterizedClass();

    /**
     * 原型となるクラスを返します。
     *
     * @param <T>
     *            原型となるクラスの型
     * @return 原型となるクラス
     * @see ParameterizedType#getRawType()
     */