return getRelativePath().getLastName();
    }

    @Override
    public String getPath() {
        return getRelativePath().getPathString();
    }

    @Override
    public void copyTo(OutputStream output) {
        try {
            InputStream inputStream = open();
            try {
                IOUtils.copyLarge(inputStream, output);
            } finally {
                inputStream.close();

    assertFalse(out.closed());
    source.copyTo(out);
    assertFalse(out.closed());
  }

  public void testClosesOnErrors_copyingToByteSinkThatThrows() {
    for (TestOption option : EnumSet.of(OPEN_THROWS, WRITE_THROWS, CLOSE_THROWS)) {
      TestByteSource okSource = new TestByteSource(bytes);
      assertThrows(IOException.class, () -> okSource.copyTo(new TestByteSink(option)));

		max_b = nil
	}

	// copy the values
	copyTo := 0
	for bx := b; ; bx = bx.Succs[0].b {
		if bx != max_b {
			copy(t[copyTo:], bx.Values)
		} else if copyTo != totalBeforeMax { // trust but verify.
			panic(fmt.Errorf("totalBeforeMax (%d) != copyTo (%d), max_b=%v, b=%v, c=%v", totalBeforeMax, copyTo, max_b, b, c))
		}
		if bx == c {
			break
		}
		copyTo += len(bx.Values)
	}
	c.Values = t

        this.capabilitiesMutator = capabilitiesMutator;
        this.classifier = classifier;
        this.artifactType = artifactType;
    }

    @Override
    public void copyTo(AbstractExternalModuleDependency target) {
        super.copyTo(target);
        if (target instanceof DefaultMinimalDependencyVariant) {
            DefaultMinimalDependencyVariant depVariant = (DefaultMinimalDependencyVariant) target;

    }

    @Override
    public InputStream open() {
        throw new UnsupportedOperationException();
    }

    @Override
    public void copyTo(OutputStream output) {
        throw new UnsupportedOperationException();
    }

    @Override
    public boolean copyTo(File target) {
        throw new UnsupportedOperationException();
    }

    @Override
    public String getName() {
        return file.getName();

      TestByteSource failSource = new TestByteSource(new byte[10], option);
      TestByteSink okSink = new TestByteSink();
      assertThrows(IOException.class, () -> failSource.copyTo(okSink));
      // ensure stream was closed IF it was opened (depends on implementation whether or not it's
      // opened at all if source.newInputStream() throws).
      assertTrue(

      TestByteSource failSource = new TestByteSource(new byte[10], option);
      TestByteSink okSink = new TestByteSink();
      assertThrows(IOException.class, () -> failSource.copyTo(okSink));
      // ensure stream was closed IF it was opened (depends on implementation whether or not it's
      // opened at all if source.newInputStream() throws).
      assertTrue(

        expect:
        createOpts().allJvmArgs.contains("-Dfile.encoding=${defaultCharset}".toString());
    }

    def "copyTo respects defaultFileEncoding"() {
        JavaForkOptions target = Mock(JavaForkOptions)
        when:
        parse("-Dfile.encoding=UTF-8 -Dfoo.encoding=blah -Dfile.encoding=UTF-16").copyTo(target)
        then:
        1 * target.systemProperties({

            if (file == null) {
                file = createFileInstance(fileName);
                if (!file.exists()) {
                    fileGenerationListener.execute(file);
                    copyTo(file);
                } else {
                    updateFileOnlyWhenGeneratedContentChanges();
                }
                // round to nearest second

        getDelegate().environment(name, value);
        return this;
    }

    @Override
    default ProcessForkOptions copyTo(ProcessForkOptions options) {
        getDelegate().copyTo(options);
        return this;
    }

    BaseExecSpec getDelegate();