if err != nil {
		return err
	}

	eventData, eErr := target.store.Get(key)
	if eErr != nil {
		// The last event key in a successful batch will be sent in the channel atmost once by the replayEvents()
		// Such events will not exist and wouldve been already been sent successfully.
		if os.IsNotExist(eErr) {
			return nil
		}
		return eErr
	}

	if err := target.send(eventData); err != nil {
		return err

            for (int i = 0; i < buffer.length; i++) {
                buffer[i] = (byte) (Math.random() * 256);
            }

            // When & Then
            // Should either read successfully if random data happens to be 4,
            // or throw SMBProtocolDecodingException
            try {
                int result = response.readBytesWireFormat(buffer, 0);

 * try block in order to catch any exception that may be thrown (including from the call to {@code
 * close()}).
 *
 * <p>This pattern ensures the following:
 *
 * <ul>
 *   <li>Each {@code Closeable} resource that is successfully registered will be closed later.
 *   <li>If a {@code Throwable} is thrown in the try block, no exceptions that occur when attempting
 *       to close resources will be thrown from the finally block. The throwable from the try block

   *
   * @param service the {@code ExecutorService} to shut down
   * @param timeout the maximum time to wait for the {@code ExecutorService} to terminate
   * @return {@code true} if the {@code ExecutorService} was terminated successfully, {@code false}
   *     if the call timed out or was interrupted
   * @since 28.0 (but only since 33.4.0 in the Android flavor)
   */
  @CanIgnoreReturnValue
  @J2ktIncompatible

        }
    }

    @Nested
    @DisplayName("Bind Operation Tests")
    class BindOperationTests {

        @Test
        @DisplayName("Should execute bind operation successfully")
        void testBindSuccess() throws DcerpcException, IOException {
            // Given: Spy to intercept sendrecv calls
            TestDcerpcHandle spyHandle = spy(new TestDcerpcHandle(mockContext, mockBinding));

## Test MinIO Connectivity

### Test using MinIO Console

MinIO Server comes with an embedded web based object browser.
Point your web browser to <http://127.0.0.1:9000> to ensure your server has started successfully.

> [!NOTE]
> MinIO runs console on random port by default, if you wish to choose a specific port use `--console-address` to pick a specific interface and port.

### Test using MinIO Client `mc`

            byte[] smallBuffer = new byte[10];
            int[] ciphers = { 1, 2 };

            EncryptionNegotiateContext context = new EncryptionNegotiateContext(mockConfig, ciphers);

            // Should encode successfully at the beginning
            int encoded = context.encode(smallBuffer, 0);
            assertEquals(6, encoded);

            // Should handle encoding at the end of buffer correctly

        void testIsNotSigned() {
            response.setFlagsForTest(0);

            assertFalse(response.isSigned());
        }

        @Test
        @DisplayName("Should verify signature successfully")
        void testVerifySignatureSuccess() {
            byte[] buffer = new byte[100];
            response.setDigest(mockDigest);
            when(mockDigest.verify(buffer, 0, 100, 0, response)).thenReturn(false);

        SocketInputStream sis = new SocketInputStream(in);

        // Read in chunks
        byte[] buffer = new byte[10];

        // The read will either:
        // 1. Successfully read all 5 bytes
        // 2. Throw IOException if it tries to read past the message
        try {
            int read = sis.read(buffer, 0, 10);

            // Should read all 5 available bytes

      super(NOT_RUN);
      this.delegate = delegate;
      this.sequencer = sequencer;
    }

    @Override
    public void execute(Runnable task) {
      // If this operation was successfully cancelled already, calling the runnable will be a noop.
      // This also avoids a race where if outputFuture is cancelled, it will call taskFuture.cancel,