import org.gradle.internal.nativeintegration.filesystem.FileSystem;
import org.gradle.internal.resource.local.LocalFileStandInExternalResource;

public class DefaultResourceResolver implements ResourceResolver {
    private final FileResolver fileResolver;
    private final FileSystem fileSystem;

    public DefaultResourceResolver(FileResolver fileResolver, FileSystem fileSystem) {
        this.fileResolver = fileResolver;

            private final FileSystem fileSystem;
            private final TemporaryFileProvider tempFileProvider;
            private final TaskDependencyFactory taskDependencyFactory;
            private final ApiTextResourceAdapter.Factory textResourceAdapterFactory;

        CrossBuildFileHashCache fileStore,
        FileSystem fileSystem,
        FileTimeStampInspector fileTimeStampInspector,
        FileHasherStatistics.Collector statisticsCollector
    ) {
        md5 = createCache(stringInterner, fileStore, fileSystem, fileTimeStampInspector, "md5", Hashing.md5(), statisticsCollector);

import org.gradle.internal.nativeintegration.filesystem.FileSystem
import org.gradle.internal.reflect.Instantiator
import spock.lang.Specification

class CopyFileVisitorImplTest extends Specification {
    CopySpecResolver specResolver = Mock()
    CopyActionProcessingStreamAction action = Mock()
    Instantiator instantiator = Mock()
    ObjectFactory objectFactory = Mock()
    FileSystem fileSystem = Mock()
    FileTree source = Mock()

	"strings"

	utilfs "k8s.io/kubernetes/pkg/util/filesystem"
)

const (
	// Name prefix for the temporary files.
	tmpPrefix = "."
)

// FileStore is an implementation of the Store interface which stores data in files.
type FileStore struct {
	// Absolute path to the base directory for storing data files.
	directoryPath string

	// filesystem to use.
	filesystem utilfs.Filesystem
}

    private final Instantiator instantiator;
    private final ObjectFactory objectFactory;
    private final FileSystem fileSystem;
    private final boolean reproducibleFileOrder;

    public CopyFileVisitorImpl(CopySpecResolver spec, CopyActionProcessingStreamAction action, Instantiator instantiator, ObjectFactory objectFactory, FileSystem fileSystem,
                               boolean reproducibleFileOrder) {
        this.copySpecResolver = spec;

        resource.withContentIfPresent({} as ExternalResource.ContentAndMetadataAction) == null
    }

    def "can fail on missing file when using ContentAndMetadataAction"() {
        def file = tmpDir.file("missing")
        def resource = new LocalFileStandInExternalResource(file, TestFiles.fileSystem())

        when:

	// than imagefs can store both image layers and writeable layers.
	SignalImageFsAvailable Signal = "imagefs.available"
	// SignalImageFsInodesFree is amount of inodes available on filesystem that container runtime uses for storing images layers.
	// If the container filesystem and image filesystem are not separate,
	// than imagefs can store both image layers and writeable layers.

import java.util.concurrent.atomic.AtomicBoolean;
import java.util.stream.Stream;

public class ReproducibleDirectoryWalker implements DirectoryWalker {
    private final FileSystem fileSystem;

    public ReproducibleDirectoryWalker(FileSystem fileSystem) {
        this.fileSystem = fileSystem;
    }

    @Override

import org.gradle.api.tasks.WorkResult;
import org.gradle.api.tasks.util.PatternSet;
import org.gradle.internal.Factory;
import org.gradle.internal.file.Deleter;
import org.gradle.internal.nativeintegration.filesystem.FileSystem;
import org.gradle.internal.reflect.Instantiator;

import java.io.File;

public class FileCopier {
    private final Deleter deleter;
    private final DirectoryFileTreeFactory directoryFileTreeFactory;