* The response sequence number should match the request sequence number.
     *
     * @return true if the response is valid
     */
    public boolean isValidResponse() {
        return isSuccess() && responseSequenceNumber == sequenceNumber;
    }

    @Override
    protected void encodeWitnessParameters(NdrBuffer buf) throws NdrException {
        // Encode input parameters for WitnessHeartbeat

    public ArtifactResolutionResult setUnresolvedArtifacts(final List<Artifact> unresolvedArtifacts) {
        this.missingArtifacts = unresolvedArtifacts;

        return this;
    }

    public boolean isSuccess() {
        return !(hasMissingArtifacts() || hasExceptions());
    }

    // ------------------------------------------------------------------------
    // Exceptions

        return data;
    }

    /**
     * Check if negotiation was successful
     *
     * @return true if successful
     */
    public boolean isSuccess() {
        return status == STATUS_SUCCESS;
    }

    // Getters and setters

    /**
     * Get the minimum SMB Direct protocol version
     *
     * @return minimum protocol version
     */

        lenient().when(registerResponse.isSuccess()).thenReturn(true);
        lenient().when(registerResponse.getRegistrationId()).thenReturn("test-reg-123");

        // Setup successful unregistration
        WitnessUnregisterResponse unregisterResponse = mock(WitnessUnregisterResponse.class);
        lenient().when(unregisterResponse.isSuccess()).thenReturn(true);

            // Create response from RPC message results
            WitnessRegisterResponse response = new WitnessRegisterResponse();
            response.setReturnCode(message.getReturnCode());

            if (message.isSuccess()) {
                // Generate registration ID from context handle
                byte[] contextHandle = message.getContextHandle();

      try {
        val plan = routePlanner.plan()

        if (!plan.isReady) {
          val tcpConnectResult = plan.connectTcp()
          val connectResult =
            when {
              tcpConnectResult.isSuccess -> plan.connectTlsEtc()
              else -> tcpConnectResult
            }

          val (_, nextPlan, failure) = connectResult

          if (failure != null) throw failure
          if (nextPlan != null) {

        if (connectResult == null) {
          connectResult = awaitTcpConnect(awaitTimeoutNanos, TimeUnit.NANOSECONDS) ?: continue
        }

        if (connectResult.isSuccess) {
          // We have a connected TCP connection. Cancel and defer the racing connects that all lost.
          cancelInFlightConnects()

                request.setFlags(registration.getFlags());

                WitnessRegisterResponse response = rpcClient.register(request);

                if (response != null && response.isSuccess()) {
                    registration.setState(WitnessRegistrationState.REGISTERED);
                    registration.setContextHandle(response.getContextHandle());

            return info;
        }
        return null;
    }
    
    public void completeReconnect(String path, boolean success) {
        HandleInfo info = handles.get(path);
        if (info != null) {
            if (success) {
                info.updateAccessTime();
                info.reconnecting = false;
            } else {
                // Remove failed handle

    
    public void recordOperation(String channelId, long bytes, long latency, boolean success) {
        ChannelStatistics stats = channelStats.computeIfAbsent(channelId, 
            k -> new ChannelStatistics());
            
        stats.operations.incrementAndGet();
        stats.latencyTotal.addAndGet(latency);
        
        if (success) {
            stats.bytesReceived.addAndGet(bytes);
        } else {