}

    /**
     * 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
    }

    /**

                }
                return t.send(request, response, params);
            } catch (final DfsReferral dre) {
                if (dre.getData().unwrap(DfsReferralDataInternal.class).isResolveHashes()) {
                    throw dre;
                }
                request.reset();
                log.trace("send0", dre);
            }
        }

     * @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));

    @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
     */

            }

            return response;

        } catch (Exception e) {
            throw new IOException("Witness unregister RPC failed", e);
        }
    }

    /**
     * Sends a witness heartbeat.
     *
     * @param request the heartbeat request
     * @return the heartbeat response
     * @throws IOException if the RPC call fails
     */

            } 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
     */

            }
        }
    }

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

        lenient().when(fh.isValid()).thenReturn(true);
        lenient().when(fh.getTree()).thenReturn(tree);

        // Mock both sends and return response
        when(tree.send(any(TransWaitNamedPipe.class), any(TransWaitNamedPipeResponse.class))).thenAnswer(inv -> inv.getArgument(1));
        when(tree.send(any(TransCallNamedPipe.class), any(TransCallNamedPipeResponse.class))).thenAnswer(inv -> inv.getArgument(1));

    @Test
    @DisplayName("setLength(): SMB2 path sends Smb2SetInfoRequest")
    void setLength_smb2_sendsSetInfo() throws Exception {
        SmbRandomAccessFile raf = newInstance("rw", true, false, false);
        SmbFileHandleImpl fh = (SmbFileHandleImpl) getField(raf, "handle");
        SmbTreeHandleImpl tree = fh.getTree();
        // do not actually perform network call