before.assertRun();
    after.assertRun();
  }

  @SuppressWarnings("nullness") // test of a bogus call
  public void testNullListener() {
    assertThrows(NullPointerException.class, () -> future.addListener(null, directExecutor()));
  }

  @SuppressWarnings("nullness") // test of a bogus call
  public void testNullExecutor() {
    assertThrows(NullPointerException.class, () -> future.addListener(doNothing(), null));

    }

    @Test
    void encode_shouldCallEncNdrLongWithCorrectValue() throws NdrException {
        int testValue = 98765;
        NdrLong ndrLong = new NdrLong(testValue);

        // Call the encode method
        ndrLong.encode(mockNdrBuffer);

        // Verify that enc_ndr_long was called exactly once with the correct value
        verify(mockNdrBuffer, times(1)).enc_ndr_long(testValue);

        throws InterruptedException, ExecutionException, TimeoutException {
      recordedTasks = tasks;
      recordedTimeout = timeout;
      recordedTimeUnit = unit;
      try {
        return tasks.iterator().next().call();
      } catch (Exception e) {
        throw new ExecutionException(e);
      }
    }

    @Override
    public <T> List<Future<T>> invokeAll(

        mockPipeIn.lock = new Object();

        byte[] buffer = new byte[10];
        int bufferIndex = 0;
        int len = 10;

        // Call the method to be tested
        int result = response.readDataWireFormat(buffer, bufferIndex, len);

        // Verify the result
        assertEquals(len, result, "readDataWireFormat should return the length of data read.");

        long secondCall = response.getOffset();
        long thirdCall = response.getOffset();

        assertEquals(66L, firstCall, "First call should return 66");
        assertEquals(66L, secondCall, "Second call should return 66");
        assertEquals(66L, thirdCall, "Third call should return 66");
    }

const maxInt = int(^uint(0) >> 1)

// Bytes returns a slice of length b.Len() holding the unread portion of the buffer.
// The slice is valid for use only until the next buffer modification (that is,
// only until the next call to a method like [Buffer.Read], [Buffer.Write], [Buffer.Reset], or [Buffer.Truncate]).
// The slice aliases the buffer content at least until the next buffer modification,

     * detail message. The cause is not initialized, and may subsequently be
     * initialized by a call to {@link #initCause}.
     */
    public InterpolatorException() {}

    /**
     * Constructs a new InterpolatorException with the specified detail message.
     * The cause is not initialized, and may subsequently be initialized by
     * a call to {@link #initCause}.
     *

   * the {@link ByteSource} returned by {@link #asByteSource} is garbage collected. Prefer to {@link
   * #reset} the stream explicitly, rather than rely on garbage collection: If you call {@link
   * #reset} explicitly, you can call it more promptly, and you can appropriately handle any
   * exception that results.
   *
   * @param fileThreshold the number of bytes before the stream should switch to buffering to a file

        // Set structure size to 2
        SMBUtil.writeInt2(2, buffer, bufferIndex);

        // Call readBytesWireFormat multiple times
        for (int i = 0; i < 5; i++) {
            int result = response.readBytesWireFormat(buffer, bufferIndex);
            assertEquals(2, result, "Should consistently return 2 on call " + (i + 1));
        }
    }

    @Test
    @DisplayName("Test edge case with maximum buffer index")

	if err != nil {
		return nil, toStorageErr(err)
	}
	return respBody, nil
}

// Wrapper to restClient.Call to handle network errors, in case of network error the connection is disconnected
// and a healthcheck routine gets invoked that would reconnect.
func (client *storageRESTClient) call(ctx context.Context, rpcMethod string, values url.Values, body io.Reader, length int64) (io.ReadCloser, error) {
	if values == nil {