}

    protected int prepareRead() {
        int bytesUnread = (currentReadChunk != null) ? currentReadChunk.bytesUnread() : 0;
        if (bytesUnread == 0) {
            if (!chunks.isEmpty()) {
                currentReadChunk = chunks.removeFirst();
                bytesUnread = currentReadChunk.bytesUnread();
                totalBytesUnreadInList -= bytesUnread;
            } else if (currentReadChunk != currentWriteChunk) {

          val bytesToRead = minOf(byteCount, upstreamPos - sourcePos)
          buffer.copyTo(sink, sourcePos - bufferPos, bytesToRead)
          sourcePos += bytesToRead
          return bytesToRead
        }

      // Read from the file.
      if (source == SOURCE_FILE) {
        val bytesToRead = minOf(byteCount, upstreamPos - sourcePos)

          long bytesRead = super.read(sink, byteCount);
          // read() returns the number of bytes read, or -1 if this source is exhausted.
          totalBytesRead += bytesRead != -1 ? bytesRead : 0;
          progressListener.update(totalBytesRead, responseBody.contentLength(), bytesRead == -1);
          return bytesRead;
        }
      };
    }
  }

public class ExternalResourceReadResult<T> {

    private final long bytesRead;
    private final T result;

    private ExternalResourceReadResult(long bytesRead, T result) {
        this.bytesRead = bytesRead;
        this.result = result;
    }

    public static ExternalResourceReadResult<Void> of(long bytesRead) {
        return new ExternalResourceReadResult<Void>(bytesRead, null);
    }

        downloadOps[0].result.bytesRead == 0
        downloadOps[1].details.location == m.rootMetaData.uri.toString()
        downloadOps[1].result.bytesRead == 0
        downloadOps[2].details.location == m.pom.uri.toString()
        downloadOps[2].result.bytesRead == m.pom.file.length()
        downloadOps[3].details.location == m.artifact.uri.toString()
        downloadOps[3].result.bytesRead == m.artifact.file.length()

type countUpReader struct {
	reader    io.Reader
	bytesRead int64
}

// Max bzip2 concurrency across calls. 50% of GOMAXPROCS.
var bz2Limiter = pbzip2.CreateConcurrencyPool((runtime.GOMAXPROCS(0) + 1) / 2)

func (r *countUpReader) Read(p []byte) (n int, err error) {
	n, err = r.reader.Read(p)
	atomic.AddInt64(&r.bytesRead, int64(n))
	return n, err
}

func (r *countUpReader) BytesRead() int64 {
	if r == nil {
		return 0
	}

        private final long bytesRead;

        private ReadOperationResult(long bytesRead) {
            this.bytesRead = bytesRead;
        }

        @Override
        public long getBytesRead() {
            return bytesRead;
        }

        @Override
        public String toString() {
            return "ExternalResourceReadBuildOperationType.Result{bytesRead=" + bytesRead + '}';
        }

    }
    var mutablePos = pos
    var mutableByteCount = byteCount

    while (mutableByteCount > 0L) {
      val bytesRead = fileChannel.transferTo(mutablePos, mutableByteCount, sink)
      mutablePos += bytesRead
      mutableByteCount -= bytesRead
    }
  }

        def result = resource.writeToIfPresent(file)

        then:
        result.bytesRead == 5
        file.text == "12345"
        0 * _

        when:
        expectResourceRead(name, "hi")
        result = resource.writeTo(file)

        then:
        result.bytesRead == 2
        file.text == "hi"
        0 * _
    }

    def "can apply Action to the content of the resource"() {

            }
        })
        result.bytesRead == 4

        def result2 = resource.withContent(new Action<InputStream>() {
            @Override
            void execute(InputStream inputStream) {
                assert inputStream.read() == '1'
                assert inputStream.read() == '2'
            }
        })
        result2.bytesRead == 2
    }