resources.findResource("permissions.tar").copyTo(archiveFile);

        final Map<String, Integer> expected = new HashMap<>();
        expected.put("file", 0644);
        expected.put("folder", 0755);

        assertVisitsPermissions(tree, expected);
    }

    @Test
    public void readsTarFileWithNullPermissions() {
        resources.findResource("nullpermissions.tar").copyTo(archiveFile);

        this.fileCollectionFactory = fileCollectionFactory;
        this.classpath = fileCollectionFactory.configurableFiles("classpath");
    }

    public void copyTo(JavaExecSpec targetSpec) {
        // JavaExecSpec
        targetSpec.setArgs(getArgs());
        targetSpec.getArgumentProviders().addAll(getArgumentProviders());
        targetSpec.getMainClass().set(getMainClass());

    }

    @Override
    default ListProperty<String> getJvmArguments() {
        return getDelegate().getJvmArguments();
    }

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

    @Override
    JavaExecSpec getDelegate();

    public void writeTo(OutputStream output) throws IOException {
        Closer closer = Closer.create();
        closer.register(output);
        try {
            stored = true;
            Files.asByteSource(file).copyTo(output);
        } catch (Exception e) {
            throw closer.rethrow(e);
        } finally {
            closer.close();
        }
    }

    public boolean isStored() {
        return stored;
    }

@SuppressWarnings("deprecation")
public abstract class AbstractDependency implements org.gradle.api.internal.artifacts.ResolvableDependency, Dependency {
    private String reason;

    protected void copyTo(AbstractDependency target) {
        target.reason = reason;
    }

    @Override
    @Deprecated
    public void resolve(org.gradle.api.internal.artifacts.CachingDependencyResolveContext context) {
    }

}

internal class BufferMockResponseBody(
  val buffer: Buffer,
) : MockResponseBody {
  override val contentLength = buffer.size

  override fun writeTo(sink: BufferedSink) {
    buffer.copyTo(sink.buffer)
    sink.emitCompleteSegments()
  }

        mock.getRelativePath() >> RelativePath.parse(false, path)
        mock.getLastModified() >> 1000L
        mock.isDirectory() >> false
        mock.getPermissions() >> new DefaultFilePermissions(1)
        mock.copyTo(_ as OutputStream) >> { OutputStream out ->
            out << "contents of $path"
        }
        mock
    }

    private FileCopyDetailsInternal dir(final String path) {

import org.gradle.api.model.ObjectFactory;
import org.gradle.internal.typeconversion.NotationParser;

public interface MinimalExternalModuleDependencyInternal extends MinimalExternalModuleDependency {
    void copyTo(AbstractExternalModuleDependency target);

    ImmutableAttributesFactory getAttributesFactory();

    NotationParser<Object, Capability> getCapabilityNotationParser();

    ObjectFactory getObjectFactory();

 * signatures.
 */
fun Buffer.isProbablyUtf8(): Boolean {
  try {
    val prefix = Buffer()
    val byteCount = size.coerceAtMost(64)
    copyTo(prefix, 0, byteCount)
    for (i in 0 until 16) {
      if (prefix.exhausted()) {
        break
      }
      val codePoint = prefix.readUtf8CodePoint()

        details.getLastModified() >> 1000L
        details.getSize() >> content.getBytes().length
        details.isDirectory() >> false
        details.getPermissions() >> new DefaultFilePermissions(1)
        details.copyTo(_ as OutputStream) >> {OutputStream out -> IOUtils.write(content, out)}

        return details
    }

    private FileCopyDetailsInternal dir(final String path) {