peer.acceptFrame() // PING
    peer.sendFrame().ping(true, 99, 0) // This pong is silently ignored.
    peer.sendFrame().ping(false, 4, 0)
    peer.acceptFrame() // PING
    peer.play()

    // Play it back.
    connect(peer)

    // Verify the peer received what was expected.
    val ping2 = peer.takeFrame()
    assertThat(ping2.payload1).isEqualTo(2)
    val ping4 = peer.takeFrame()

                }
            }
            resultBuf.append("Status of ").append(ping.getClusterName()).append(" is changed to ").append(ping.getClusterStatus())
                    .append('.');
        } else if (status == 0) {
            resultBuf.append(ping.getClusterName()).append(" is alive.");
        } else {
            resultBuf.append(ping.getClusterName()).append(" is not available.");
        }

    client.processNextFrame() // Pong.

    // After 1000ms the client will attempt a ping 2, but we don't process it. That'll cause the
    // client to fail at 1500ms when it's time to send ping 3 because pong 2 hasn't been received.
    taskFaker.advanceUntil(ns(1000L))
    taskFaker.advanceUntil(ns(1500L))
    client.listener.assertFailure(
      SocketTimeoutException::class.java,

    assertThat(nextEvent()).isEqualTo(Message(payload))
  }

  fun assertPing(payload: ByteString) {
    assertThat(nextEvent()).isEqualTo(Ping(payload))
  }

  fun assertPong(payload: ByteString) {
    assertThat(nextEvent()).isEqualTo(Pong(payload))
  }

  fun assertClosing(
    code: Int,
    reason: String,
  ) {
    assertThat(nextEvent()).isEqualTo(Closing(code, reason))
  }

   *
   * To differentiate the two cases we ping the server when a stream times out. If the overall
   * connection is fine the ping will receive a pong; otherwise it won't.
   *
   * The deadline to respond to this ping attempts to limit the cost of being wrong. If it is too
   * long, streams created while we await the pong will reuse broken connections and inevitably

            return FormatType.FAVORITE;
        }
        if (FormatType.FAVORITES.name().equals(type)) {
            return FormatType.FAVORITES;
        }
        if (FormatType.PING.name().equals(type)) {
            return FormatType.PING;
        }
        if (FormatType.SCROLL.name().equals(type)) {
            return FormatType.SCROLL;
        }
        if (FormatType.SUGGEST.name().equals(type)) {

  const val TYPE_RST_STREAM = 0x3
  const val TYPE_SETTINGS = 0x4
  const val TYPE_PUSH_PROMISE = 0x5
  const val TYPE_PING = 0x6
  const val TYPE_GOAWAY = 0x7
  const val TYPE_WINDOW_UPDATE = 0x8
  const val TYPE_CONTINUATION = 0x9

  const val FLAG_NONE = 0x0
  const val FLAG_ACK = 0x1 // Used for settings and ping.
  const val FLAG_END_STREAM = 0x1 // Used for headers and data.

		return false, err
	}
	return target.isActive()
}

func (target *RedisTarget) isActive() (bool, error) {
	conn := target.pool.Get()
	defer conn.Close()

	_, pingErr := conn.Do("PING")
	if pingErr != nil {
		if xnet.IsConnRefusedErr(pingErr) {
			return false, store.ErrNotConnected
		}
		return false, pingErr
	}
	return true, nil
}

  /** Send a ping with the supplied [payload]. */
  @Throws(IOException::class)
  fun writePing(payload: ByteString) {
    writeControlFrame(OPCODE_CONTROL_PING, payload)
  }

  /** Send a pong with the supplied [payload]. */
  @Throws(IOException::class)
  fun writePong(payload: ByteString) {
    writeControlFrame(OPCODE_CONTROL_PONG, payload)
  }

  /**

	if err == nil {
		return stmt.QueryRowContext(ctx, args...)
	}
	return &sql.Row{}
}

func (db *PreparedStmtDB) Ping() error {
	conn, err := db.GetDBConn()
	if err != nil {
		return err
	}
	return conn.Ping()
}

type PreparedStmtTX struct {
	Tx
	PreparedStmtDB *PreparedStmtDB
}

func (db *PreparedStmtTX) GetDBConn() (*sql.DB, error) {