fun tearDown() {
    taskQueue.shutdown()
    taskQueue.idleLatch().await(10, TimeUnit.SECONDS)
  }

  @Synchronized fun sentPingCount(): Int = sentPingCount

  @Synchronized fun receivedPingCount(): Int = receivedPingCount

  @Synchronized fun receivedPongCount(): Int = receivedPongCount

  @Throws(IOException::class)
  override fun onReadMessage(text: String) {

  }

  @Override
  public int size() {
    synchronized (lock) {
      return cachingHashMap.size();
    }
  }

  @Override
  public boolean isEmpty() {
    synchronized (lock) {
      return cachingHashMap.isEmpty();
    }
  }

  @Override
  public @Nullable V get(@Nullable Object key) {
    Timestamped<V> value;
    synchronized (lock) {
      checkNotNull(key);

   * into user code.
   *
   * @param enqueuedCall a call to enqueue in the synchronized block
   * @param finishedCall a call to finish in the synchronized block
   * @param finishedAsyncCall an async call to finish in the synchronized block
   */
  private fun promoteAndExecute(
    enqueuedCall: AsyncCall? = null,
    finishedCall: RealCall? = null,

  fun newClientBuilder(): OkHttpClient.Builder = newClient().newBuilder()

  @Synchronized private fun addEvent(event: String) {
    if (recordEvents) {
      logger?.info(event)

      synchronized(clientEventsList) {
        clientEventsList.add(event)
      }
    }
  }

  @Synchronized private fun initUncaughtException(throwable: Throwable) {
    if (uncaughtException == null) {

   * greater than the max size if a background deletion is pending.
   */
  @Synchronized
  @Throws(IOException::class)
  fun size(): Long {
    initialize()
    return size
  }

  @Synchronized
  @Throws(IOException::class)
  internal fun completeEdit(
    editor: Editor,
    success: Boolean,
  ) {
    val entry = editor.entry

     */
    public int getMessageCount() {
        synchronized (messagesLock) {
            return messages != null ? messages.size() : 0;
        }
    }

    /**
     * Clears all messages in this session and updates the last accessed timestamp.
     */
    public void clearMessages() {
        synchronized (messagesLock) {
            if (messages != null) {
                messages.clear();

                // we are in the transport thread, ie. on idle disconnecting
                // this is synchronous operation
                // This does not handle compound requests
                synchronized (this.inLock) {
                    final Long peekKey = peekKey();
                    if (peekKey == firstKey) {
                        doRecv(response);
                        response.received();

     * @param timeout the maximum time to wait for the response in milliseconds
     * @throws IOException if an I/O error occurs during communication
     */
    public synchronized void sendrecv(final Request request, final Response response, long timeout) throws IOException {
        makeKey(request);
        response.isReceived = false;
        try {
            response_map.put(request, response);

 */
class RecordingCallback : Callback {
  private val responses = mutableListOf<RecordedResponse>()

  @Synchronized
  override fun onFailure(
    call: Call,
    e: IOException,
  ) {
    responses.add(RecordedResponse(call.request(), null, null, null, e))
    (this as Object).notifyAll()
  }

  @Synchronized
  override fun onResponse(
    call: Call,
    response: Response,
  ) {

    enqueueHelper(event, label);
  }

  private void enqueueHelper(Event<L> event, Object label) {
    checkNotNull(event, "event");
    checkNotNull(label, "label");
    synchronized (listeners) {
      for (PerListenerQueue<L> queue : listeners) {
        queue.add(event, label);
      }
    }
  }

  /**