classPathScriptRunner.data >> PluginRequests.EMPTY
        def configuration = Mock(Configuration)
        configurations.getByName(ScriptHandler.CLASSPATH_CONFIGURATION) >> configuration
        configuration.getFiles() >> Collections.emptySet()
        baseScope.getExportClassLoader() >> baseChildClassLoader
        classpathHasher.hash(_ as ClassPath) >> TestHashCodes.hashCodeFrom(123)
    }

        return mainFeature.getSourceSet().getRuntimeClasspath();
    }

    private FileCollection jarsOnlyRuntimeClasspath(JvmFeatureInternal mainFeature) {
        return mainFeature.getJarTask().get().getOutputs().getFiles().plus(mainFeature.getRuntimeClasspathConfiguration());
    }

    private CopySpec configureDistribution(Project project, JvmFeatureInternal mainFeature, Distribution mainDistribution, JavaApplication pluginExtension) {

        Set<Path> testSourceFolders = pathsOf(existing(getTestSources().getFiles()));
        Set<Path> resourceFolders = pathsOf(existing(getResourceDirs()));
        Set<Path> testResourceFolders = pathsOf(existing(getTestResources().getFiles()));
        Set<Path> excludeFolders = pathsOf(getExcludeDirs());

        SwiftCompileSpec spec = new DefaultSwiftCompileSpec();
        spec.setModuleName(moduleName.getOrNull());
        spec.setModuleFile(moduleFile.get().getAsFile());
        for (File file : modules.getFiles()) {
            if (file.isFile()) {
                spec.include(file.getParentFile());
            } else {
                spec.include(file);
            }
        }

                boolean isComplete() {
                    return !unresolved.contains(sourceFile)
                }

                @Override
                Collection<SourceIncludesResolver.IncludeFile> getFiles() {
                    return [
                        new SourceIncludesResolver.IncludeFile() {
                            @Override
                            boolean isQuotedInclude() {

                forEachArtifactOf(component, dependency::add);
            }
            return dependency;
        }

        @Override
        @Nonnull
        public Set<File> getFiles() {
            SoftwareComponentInternal component = component();
            return component == null ? ImmutableSet.of() : filesOf(component);
        }

                transform.getInputArtifactDependenciesDirectorySensitivity(),
                transform.getInputArtifactDependenciesLineEndingNormalization(),
                () -> dependencies.getFiles()
                    .orElse(FileCollectionFactory.empty())));
    }

    protected void emitIdentifyTransformExecutionProgressDetails(TransformWorkspaceIdentity transformWorkspaceIdentity) {

                variant.getFiles(), variant.getCapabilities(), variantToDependencies.get(variant.getName()), variant.isExternalVariant()));
        }

                    ${directorySensitivity == DirectorySensitivity.IGNORE_DIRECTORIES ? "@${IgnoreEmptyDirectories.class.simpleName}" : ''}
                    ConfigurableFileCollection getFiles()
                }

                @InputArtifact
                ${directorySensitivity == DirectorySensitivity.IGNORE_DIRECTORIES ? "@${IgnoreEmptyDirectories.class.simpleName}" : ''}

                    collectDependencies(library.getImplementationDependencies(), dependencies, target);
                    Set<File> headerDirs = library.getPublicHeaderDirs().getFiles();
                    if (!headerDirs.isEmpty()) {
                        // TODO - deal with more than one directory
                        target.setPublicHeaderDir(headerDirs.iterator().next());
                    }