// error if the server message is invalid.  Calling Step after a conversation
// completes is also an error.
func (x *XDGSCRAMClient) Step(challenge string) (response string, err error) {
	response, err = x.ClientConversation.Step(challenge)
	return response, err
}

// Done returns true if the conversation is completed or has errored.
func (x *XDGSCRAMClient) Done() bool {
	return x.ClientConversation.Done()

            assertEquals(4, bytesRead, "Iteration " + i + " should read 4 bytes");
        }
    }

    @Test
    @DisplayName("Should verify complete response structure parsing")
    void testCompleteResponseParsing() throws SMBProtocolDecodingException {
        // Given - complete SMB2 TREE_DISCONNECT response
        byte[] completeResponse = new byte[] { 0x04, 0x00, // StructureSize = 4
                0x00, 0x00 // Reserved = 0

              errorMessage.set("Set call exited before future was complete.");
            }
          });
      executor.execute(
          () -> {
            future.setException(new IllegalArgumentException("failure"));
            if (!future.isDone()) {
              errorMessage.set("SetException call exited before future was complete.");
            }
          });
      executor.execute(
          () -> {

 */
public interface NtStatus {

    /* Don't bother to edit this. Everthing within the interface
     * block is automatically generated from the ntstatus package.
     */

    /** The operation completed successfully */
    int NT_STATUS_SUCCESS = 0x00000000;
    /** The requested operation was unsuccessful */
    int NT_STATUS_UNSUCCESSFUL = 0xC0000001;
    /** The requested operation is not implemented */

                        try {
                            startLatch.countDown();
                            holdLatch.await();
                            return "completed";
                        } catch (InterruptedException e) {
                            throw new RuntimeException(e);
                        }
                    });
                } catch (Exception e) {

The replication configuration in use on a bucket can be viewed using the `mc replicate export alias/bucket` command.

                        if (logger.isDebugEnabled()) {
                            logger.debug("SSE phase complete event sent. phase={}", phase);
                        }
                    } catch (final Exception e) {
                        if (logger.isDebugEnabled()) {
                            logger.debug("Failed to send phase complete event. phase={}, error={}", phase, e.getMessage());

	defer func() {
		if rinfo.ReplicationStatus == replication.Completed && tgt.ResetID != "" && dobj.OpType == replication.ExistingObjectReplicationType {
			rinfo.ResyncTimestamp = fmt.Sprintf("%s;%s", UTCNow().Format(http.TimeFormat), tgt.ResetID)
		}
	}()

	if dobj.VersionID == "" && rinfo.PrevReplicationStatus == replication.Completed && dobj.OpType != replication.ExistingObjectReplicationType {

     *
     * @param shareName the share name to monitor
     * @param serverAddress the server address
     * @param listener the notification listener
     * @return a future that completes with the registration
     */
    public CompletableFuture<WitnessRegistration> registerForNotifications(String shareName, InetAddress serverAddress,
            WitnessNotificationListener listener) {

            urlQueueService.delete(sessionId);
            dataService.delete(sessionId);
            urlFilter.clear();
            if (logger.isInfoEnabled()) {
                logger.info("Completed crawler cleanup: sessionId={}", sessionId);
            }
        } catch (final Exception e) {
            logger.warn("Failed to cleanup crawler data: sessionId={}", sessionId, e);
        }
    }

    /**