}

    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)

        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()

        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
    }

	n, err := r.src.Read(p)
	r.bytesRead += int64(n)
	if r.sha256 != nil {
		r.sha256.Write(p[:n])
	}
	if r.contentHasher != nil {
		r.contentHasher.Write(p[:n])
	}

	if err == io.EOF { // Verify content SHA256, if set.
		if r.expectedMin > 0 {
			if r.bytesRead < r.expectedMin {
				return 0, SizeTooSmall{Want: r.expectedMin, Got: r.bytesRead}
			}
		}
		if r.expectedMax > 0 {

            }
            throw e
          }

          if (bytesRead == -1L) {
            if (!cacheRequestClosed) {
              cacheRequestClosed = true
              cacheBody.close() // The cache response is complete!
            }
            return -1
          }

          sink.copyTo(cacheBody.buffer, sink.size - bytesRead, bytesRead)
          cacheBody.emitCompleteSegments()
          return bytesRead

	for {
		ev, err := r.ReadEvent()
		if err == io.EOF {
			validBytes = cr.bytesRead.Load()
			validEvents = len(t.events)
			break
		}
		if err != nil {
			t.err = err
			break
		}
		t.events = append(t.events, ev)
		s.Event(&t.events[len(t.events)-1])

		if ev.Kind() == trace.EventSync {
			validBytes = cr.bytesRead.Load()
			validEvents = len(t.events)
		}
	}

  private class CountingSource(source: Source) : ForwardingSource(source) {
    var bytesRead = 0L

    override fun read(
      sink: Buffer,
      byteCount: Long,
    ): Long {
      val result = delegate.read(sink, byteCount)
      if (result == -1L) return -1L
      bytesRead += result
      return result
    }
  }

	s2.Set("fizz buzz")
	b.ResetTimer()

	b.ReportAllocs()
	for i := 0; i < b.N; i++ {
		_ = m.String()
	}
}

func BenchmarkRealworldExpvarUsage(b *testing.B) {
	var (
		bytesSent Int
		bytesRead Int
	)

	// The benchmark creates GOMAXPROCS client/server pairs.
	// Each pair creates 4 goroutines: client reader/writer and server reader/writer.