{"index":{"_index":"fess_config.scheduled_job","_id":"ping_es"}}

      .isCloseTo(1500.0, 250.0)

    // The client pinged the server 3 times, and it has ponged back 3 times.
    assertThat(webSocket.sentPingCount()).isEqualTo(3)
    assertThat(server.receivedPingCount()).isEqualTo(3)
    assertThat(webSocket.receivedPongCount()).isEqualTo(3)

    // The server has never pinged the client.
    assertThat(server.receivedPongCount()).isEqualTo(0)

      {
        "lang_en": {
          "match": "*_en-ie",
          "mapping": {
            "type": "text",
            "analyzer": "irish_analyzer"
          }
        }
      },
      {
        "lang_es": {
          "match": "*_es",
          "mapping": {
            "type": "text",
            "analyzer": "spanish_analyzer"
          }
        }
      },
      {
        "lang_et": {

      {
        "lang_en": {
          "match": "*_en-ie",
          "mapping": {
            "type": "text",
            "analyzer": "irish_analyzer"
          }
        }
      },
      {
        "lang_es": {
          "match": "*_es",
          "mapping": {
            "type": "text",
            "analyzer": "spanish_analyzer"
          }
        }
      },
      {
        "lang_et": {

  /** True if this web socket failed and the listener has been notified. */
  private var failed = false

  /** Total number of pings sent by this web socket. */
  private var sentPingCount = 0

  /** Total number of pings received by this web socket. */
  private var receivedPingCount = 0

  /** Total number of pongs received by this web socket. */
  private var receivedPongCount = 0

      {
        "lang_en": {
          "match": "*_en-ie",
          "mapping": {
            "type": "text",
            "analyzer": "irish_analyzer"
          }
        }
      },
      {
        "lang_es": {
          "match": "*_es",
          "mapping": {
            "type": "text",
            "analyzer": "spanish_analyzer"
          }
        }
      },
      {
        "lang_et": {

    pings, but it did not track whether the reply pongs were received. With this
    update OkHttp requires that every ping receive a response: if it does not
    the connection will be closed and the listener's `onFailure()` method will
    be called.

    Web sockets have always been had pings, but pings on HTTP/2 connections is
    new in this release. Pings are used for connections that are busy carrying

     *
     * The default value of 0 disables client-initiated pings.
     */
    fun pingInterval(
      interval: Long,
      unit: TimeUnit,
    ) = apply {
      pingInterval = checkDuration("interval", interval, unit)
    }

    /**
     * Sets the interval between HTTP/2 and web socket pings initiated by this client. Use this to

  private val settingsListenerQueue = taskRunner.newQueue()

  /** User code to run in response to push promise events. */
  private val pushObserver: PushObserver = builder.pushObserver

  // Total number of pings send and received of the corresponding types. All guarded by this.
  private var intervalPingsSent = 0L
  private var intervalPongsReceived = 0L
  private var degradedPingsSent = 0L
  private var degradedPongsReceived = 0L

    client.processNextFrame()
    taskFaker.runTasks()
    server.webSocket!!.pong("pong 3".encodeUtf8())
    client.processNextFrame()

    // After 500ms the client automatically pings and the server pongs back.
    taskFaker.advanceUntil(ns(500L))
    server.processNextFrame() // Ping.
    client.processNextFrame() // Pong.