@DisplayName("Should return correct size with multiple chunks")
        @ValueSource(ints = { 1, 2, 3, 5, 10, 100 })
        void testSizeWithMultipleChunks(int chunkCount) {
            // Given
            byte[] sourceKey = new byte[SOURCE_KEY_SIZE];
            SrvCopychunk[] chunks = new SrvCopychunk[chunkCount];
            for (int i = 0; i < chunkCount; i++) {
                chunks[i] = new SrvCopychunk(i * 100, i * 200, i * 300);

                            wsize = byteLimit;
                        }

                        int chunks = (int) (wsize / maxChunkSize);
                        int lastChunkSize;
                        if (chunks + 1 > maxChunks) {
                            chunks = maxChunks;
                            lastChunkSize = maxChunkSize;
                        } else {

    private final SrvCopychunk[] chunks;

    /**
     * Constructs a server copy chunk operation request
     * @param sourceKey the resume key identifying the source file
     * @param chunks the array of copy chunk descriptors
     */
    public SrvCopychunkCopy(final byte[] sourceKey, final SrvCopychunk... chunks) {
        this.sourceKey = sourceKey;
        this.chunks = chunks;
    }

    /**
     * {@inheritDoc}

        void testDecodeVariousChunksWritten(int chunks) throws SMBProtocolDecodingException {
            byte[] buffer = createValidCopyChunkResponse(chunks, 0, 0);

            int bytesDecoded = response.decode(buffer, 0, buffer.length);

            assertEquals(12, bytesDecoded);
            assertEquals(chunks, response.getChunksWritten());
        }

        @ParameterizedTest

 * nullness annotations in particular will outweigh the costs. (And it's worth noting that we have
 * released multiple ListenableFuture.class files that are not byte-for-byte compatible even from
 * the beginning, thanks to using different `-source -target` values for compiling our `-jre` and
 * `-android` "flavors.")
 *
 * (We could consider releasing a listenablefuture:1.0.1 someday. But we would want to look into how

<!--  Thanks for sending a pull request!  Here are some tips for you:

1. If this is your first time, please read our contributor guidelines: https://git.k8s.io/community/contributors/guide/first-contribution.md#your-first-contribution and developer guide https://git.k8s.io/community/contributors/devel/development.md#development-guide

   * size.
   *
   * @param chunkSize the number of bytes available per {@link #process(ByteBuffer)} invocation;
   *     must be at least 4
   */
  protected AbstractStreamingHasher(int chunkSize) {
    this(chunkSize, chunkSize);
  }

  /**
   * Constructor for use by subclasses. This hasher instance will process chunks of the specified

      // Start with "%--" and fill in the blanks
      char[] dest = new char[3];
      dest[0] = '%';
      dest[2] = upperHexDigits[cp & 0xF];
      dest[1] = upperHexDigits[cp >>> 4];
      return dest;
    } else if (cp <= 0x7ff) {
      // Two byte UTF-8 characters [cp >= 0x80 && cp <= 0x7ff]
      // Start with "%--%--" and fill in the blanks
      char[] dest = new char[6];
      dest[0] = '%';

    char[] buf = new char[expected.length()];
    assertEquals(expected.length() == 0 ? -1 : expected.length(), reader.read(buf));
    assertEquals(expected, new String(buf));
    assertFullyRead(reader);

    // read in chunks to fixed array
    reader = new CharSequenceReader(charSequence);
    buf = new char[5];
    StringBuilder builder = new StringBuilder();
    int read;
    while ((read = reader.read(buf, 0, buf.length)) != -1) {

     * @return the chunkBytesWritten
     */
    public int getChunkBytesWritten() {
        return this.chunkBytesWritten;
    }

    /**
     * Gets the number of chunks successfully written
     * @return the chunksWritten
     */
    public int getChunksWritten() {
        return this.chunksWritten;
    }

    /**