*       one with {@link CharSequence#charAt(int)}.
   *   <li>use {@link Appendable#append(CharSequence)} in {@link #copyTo(Appendable)} and {@link
   *       #copyTo(CharSink)}. We know this is correct since strings are immutable and so the length
   *       can't change, and it is faster because many writers and appendables are optimized for

        public void setAllJvmArgs(Iterable<?> arguments) {
            throw new UnsupportedOperationException();
        }

        @Override
        public JavaForkOptions copyTo(JavaForkOptions options) {
            return delegate.copyTo(options);
        }

        @Override
        public boolean isCompatibleWith(JavaForkOptions options) {
            return delegate.isCompatibleWith(options);
        }

    StringBuilder builder = new StringBuilder();

    assertEquals(expected.length(), source.copyTo(builder));

    assertExpectedString(builder.toString());
  }

  public void testCopyTo_charSink() throws IOException {
    TestCharSink sink = new TestCharSink();

    assertEquals(expected.length(), source.copyTo(sink));

    assertExpectedString(sink.getString());
  }

        when:
        succeeds("installDebug")

        then:
        def install = installation(installDir)
        install.assertInstalled()
        install.exec()

        when:
        installDir.copyTo(relocatedInstallDir)

        then:
        def relocatedInstall = installation(relocatedInstallDir)
        relocatedInstall.assertInstalled()
        relocatedInstall.exec()

        when:

    def canCopyToTargetOptions() {
        given:
        def target = Mock(ProcessForkOptions)

        when:
        options.executable('executable')
        options.environment('key', 12)
        options.copyTo(target)

        then:
        1 * target.setWorkingDir(baseDir)
        1 * target.setExecutable('executable')
        1 * target.setEnvironment({ !it.empty })
    }

            File target = fileResolver.resolve(details.getRelativePath().getPathString());
            renameIfCaseChanged(target);
            boolean copied = details.copyTo(target);
            if (copied) {
                didWork = true;
            }
        }

        private void renameIfCaseChanged(File target) {
            if (target.exists()) {

        homeDir == gradleHomeDir
        gradleHomeDir.assertIsDir()
        gradleHomeDir.file("bin/gradle").assertIsFile()

        and:
        1 * download.download(configuration.distribution, _) >> { templateZipFile.copyTo(it[1]) }
        0 * download._

        when:
        homeDir = install.createDist(configuration)

        then:
        homeDir == gradleHomeDir

        and:
        0 * download._
    }

        final FileCopyDetailsInternal details = Mock(FileCopyDetailsInternal)
        _ * details.relativePath >> relativePath
        1 * details.copyTo(targetFile)
        0 * details._
        return details
    }

    @Override
    public ExternalModuleDependency copy() {
        DefaultExternalModuleDependency copiedModuleDependency = new DefaultExternalModuleDependency(getGroup(), getName(), getVersion(), getTargetConfiguration());
        copyTo(copiedModuleDependency);
        return copiedModuleDependency;
    }

    @Override
    public boolean contentEquals(Dependency dependency) {
        if (this == dependency) {
            return true;
        }

    ByteArrayOutputStream out = new ByteArrayOutputStream();
    source.copyTo(out);
    assertExpectedBytes(out.toByteArray());
  }

  public void testCopyTo_byteSink() throws IOException {
    final ByteArrayOutputStream out = new ByteArrayOutputStream();
    // HERESY! but it's ok just for this I guess
    source.copyTo(
        new ByteSink() {
          @Override