}

    /**
     * Calculate average send latency in microseconds
     *
     * @return average send latency
     */
    public double getAverageSendLatencyMicros() {
        long sends = rdmaSends.get();
        if (sends == 0) {
            return 0.0;
        }
        return totalSendTime.get() / (double) sends / 1000.0; // Convert to microseconds
    }

    /**

            }
        }
    }

    /**
     * Monitors active registrations and sends heartbeats.
     */
    private void monitorRegistrations() {
        for (WitnessRegistration registration : registrations.values()) {
            if (registration.getState() == WitnessRegistrationState.REGISTERED) {
                // Send periodic heartbeat
                sendHeartbeat(registration);
            }
        }

    frame.writeByte(Http2.TYPE_HEADERS)
    frame.writeByte(FLAG_END_HEADERS or FLAG_END_STREAM)
    frame.writeInt(expectedStreamId and 0x7fffffff)
    frame.writeAll(headerBytes)

    // Check writer sends the same bytes.
    assertThat(sendHeaderFrames(true, sentHeaders)).isEqualTo(frame)
    reader.nextFrame(
      requireSettings = false,
      object : BaseTestHandler() {
        override fun headers(

            } catch (final IOException ioe) {
                state = 0;
                throw ioe;
            }
        }
    }

    /**
     * Sends a DCERPC message and receives the response
     * @param msg the message to send
     * @throws DcerpcException if the RPC operation fails
     * @throws IOException if an I/O error occurs
     */

     * @throws IOException if an I/O error occurs
     */
    protected abstract Request peekKey() throws IOException;

    /**
     * Sends a request to the remote endpoint.
     *
     * @param request the request to send
     * @throws IOException if an I/O error occurs
     */
    protected abstract void doSend(Request request) throws IOException;

    /**

        h.release();
        verify(tree, never()).send(isA(Smb2CloseRequest.class), any());
        verify(tree, never()).send(any(CommonServerMessageBlockRequest.class), any(SmbComBlankResponse.class), any(RequestParam[].class));

        // Second release: should close now via SMB2 path
        h.release();
        verify(tree, times(1)).send(isA(Smb2CloseRequest.class), eq(RequestParam.NO_RETRY));

    /**
     * Apply inbound settings and send an acknowledgement to the peer that provided them.
     *
     * We need to apply the settings and ack them atomically. This is because some HTTP/2
     * implementations (nghttp2) forbid peers from taking advantage of settings before they have
     * acknowledged! In particular, we shouldn't send frames that assume a new `initialWindowSize`
     * until we send the frame that acknowledges this new size.

            if (aggregations != null) {
                builder.facetResponse(new FacetResponse(aggregations));
            }

        });
        return builder.build();
    }

    /**
     * Sends a search request to OpenSearch with the specified parameters.
     *
     * @param query the search query string
     * @param params the search request parameters

    @Override
    public String toString() {
        return this.binding.toString();
    }

    /**
     * Sends a DCERPC fragment to the remote endpoint
     * @param buf the buffer containing the fragment data
     * @param off the offset into the buffer
     * @param length the length of data to send
     * @throws IOException if an I/O error occurs during transmission
     */

import okio.Buffer
import okio.ForwardingTimeout
import okio.Sink
import okio.Source
import okio.Timeout

/**
 * A socket connection that can be used to send HTTP/1.1 messages. This class strictly enforces the
 * following lifecycle:
 *
 *  1. [Send request headers][writeRequest].
 *  2. Open a sink to write the request body. Either [known][newKnownLengthSink] or
 *     [chunked][newChunkedSink].