assertEquals(STRING.length(), source.copyTo(sink));
    assertTrue(source.wasStreamOpened() && source.wasStreamClosed());
    assertTrue(sink.wasStreamOpened() && sink.wasStreamClosed());

    assertEquals(STRING, sink.getString());
  }

  public void testRead_toString() throws IOException {
    assertEquals(STRING, source.read());
    assertTrue(source.wasStreamOpened() && source.wasStreamClosed());
  }

        this.configuration = null;
    }

    public MojoExecution(MojoDescriptor mojoDescriptor, String executionId, Source source) {
        this.mojoDescriptor = mojoDescriptor;
        this.executionId = executionId;
        this.configuration = null;
        this.source = source;
    }

    public MojoExecution(MojoDescriptor mojoDescriptor, String executionId) {
        this.mojoDescriptor = mojoDescriptor;

            result.setCreatedTime(DfTypeUtil.toLong(source.get("createdTime")));
            result.setDepth(DfTypeUtil.toInteger(source.get("depth")));
            result.setDescription(DfTypeUtil.toString(source.get("description")));
            result.setExcludedDocPaths(DfTypeUtil.toString(source.get("excludedDocPaths")));
            result.setExcludedPaths(DfTypeUtil.toString(source.get("excludedPaths")));

            result.setLanguages(DfTypeUtil.toString(source.get("languages")));
            result.setQueryId(DfTypeUtil.toString(source.get("queryId")));
            result.setQueryOffset(DfTypeUtil.toInteger(source.get("queryOffset")));
            result.setQueryPageSize(DfTypeUtil.toInteger(source.get("queryPageSize")));
            result.setQueryTime(DfTypeUtil.toLong(source.get("queryTime")));

    }

    public void setSource(String source) {
        this.source = source;
        this.sourceModel = null;
    }

    public void setSource(Model source) {
        this.sourceModel = source;
        this.source = null;

        if (rootModel == null) {
            rootModel = source;
        }
    }

    private String getSource() {
        if (source == null && sourceModel != null) {

    String string = source.read();
    assertExpectedString(string);
  }

  public void testReadFirstLine() throws IOException {
    if (expectedLines.isEmpty()) {
      assertNull(source.readFirstLine());
    } else {
      assertEquals(expectedLines.get(0), source.readFirstLine());
    }
  }

  public void testReadLines_toList() throws IOException {
    assertExpectedLines(source.readLines());
  }

 */
internal class DerReader(source: Source) {
  private val countingSource: CountingSource = CountingSource(source)
  private val source: BufferedSource = countingSource.buffer()

  /** Total bytes read thus far. */
  private val byteCount: Long
    get() = countingSource.bytesRead - source.buffer.size

        private final Source source;

        SourceWrapper(Source source) {
            this.source = source;
        }

        @Override
        public InputStream getInputStream() throws IOException {
            return source.openStream();
        }

        @Override
        public String getLocation() {
            return source.getLocation();
        }

        @Override

    upstream: String?,
    metadata: ByteString?,
  ) {
    val source = file.source().buffer()
    assertThat(source.readByteString(prefix.size.toLong())).isEqualTo(prefix)
    assertThat(source.readLong()).isEqualTo(upstreamSize)
    assertThat(source.readLong()).isEqualTo(metadataSize.toLong())
    if (upstream != null) {
      assertThat(source.readUtf8(upstreamSize)).isEqualTo(upstream)
    }
    if (metadata != null) {

      for (CharSource source : sources) {
        if (!source.isEmpty()) {
          return false;
        }
      }
      return true;
    }

    @Override
    public Optional<Long> lengthIfKnown() {
      long result = 0L;
      for (CharSource source : sources) {
        Optional<Long> lengthIfKnown = source.lengthIfKnown();
        if (!lengthIfKnown.isPresent()) {