ScriptSource source1 = forFile(new File(testDir, "build.gradle"));
        ScriptSource source2 = forFile(new File(testDir, "subdir/build.gradle"));
        assertThat(source1.getClassName(), not(equalTo(source2.getClassName())));

        ScriptSource source3 = forFile(new File(testDir, "build.gradle"));
        assertThat(source1.getClassName(), equalTo(source3.getClassName()));
    }

    @Test

    KotlinScriptTypeMatch.forFile(candidate)?.scriptType


enum class KotlinScriptType {
    INIT, SETTINGS, PROJECT
}


data class KotlinScriptTypeMatch private constructor(
    val scriptType: KotlinScriptType,
    val match: Match
) {

    companion object {

        internal
        fun forFile(file: File): KotlinScriptTypeMatch? =
            forName(file.name)

        // If the script file is known, determine its type
        val scriptType = scriptFile?.let {
            KotlinScriptTypeMatch.forFile(it)?.scriptType
        }

        // We also add the "buildSrc" sources onto the source path.
        val projectBuildSrcRoots = when (scriptType) {
            KotlinScriptType.INIT, KotlinScriptType.SETTINGS -> emptyList()

        }
    }

    @Override
    protected VisualStudioFiltersFile create() {
        return new VisualStudioFiltersFile(getXmlTransformer(), RelativeFileNameTransformer.forFile(getProject().getRootDir(), visualStudioProject.getFiltersFile().getLocation()));
    }

    public ResolvedArtifact toPublicView() {
        return publicView;
    }

    @Override
    public ResolvableArtifact transformedTo(File file) {
        IvyArtifactName artifactName = DefaultIvyArtifactName.forFile(file, artifact.getClassifier());

        String originalFileName;
        if (artifactId instanceof TransformedComponentFileArtifactIdentifier) {

        val file = readNonNull<File>()
        val artifactId = ComponentFileArtifactIdentifier(ownerId, file.name)
        val artifact = PreResolvedResolvableArtifact(null, DefaultIvyArtifactName.forFile(file, null), artifactId, file, TaskDependencyContainer.EMPTY, calculatedValueContainerFactory)
        val steps = readNonNull<List<TransformStepSpec>>().map { BoundTransformStep(it.transformStep, it.recreateDependencies()) }

    private RelativeFileNameTransformer(File rootDir, File currentDir) {
        this.rootDir = rootDir;
        this.currentDir = currentDir;
    }

    public static Transformer<String, File> forFile(File rootDir, File relativeFile) {
        return new RelativeFileNameTransformer(rootDir, relativeFile.getParentFile());
    }

    public static Transformer<String, File> forDirectory(File rootDir, File currentDirectory) {

    public boolean isResolveSynchronously() {
        return true;
    }

    @Override
    public ResolvableArtifact transformedTo(File file) {
        IvyArtifactName artifactName = DefaultIvyArtifactName.forFile(file, artifact.getClassifier());

        String originalFileName;
        if (artifactId instanceof TransformedComponentFileArtifactIdentifier) {

        return new DefaultIvyArtifactName(name, publishArtifact.getType(), publishArtifact.getExtension(), classifier);
    }

    public static DefaultIvyArtifactName forFile(File file, @Nullable String classifier) {
        String fileName = file.getName();
        return forFileName(fileName, classifier);
    }

                }

                return "\"gradle\"" + args;
            }
        });
    }

    @Internal
    public Transformer<String, File> getTransformer() {
        return RelativeFileNameTransformer.forFile(getProject().getRootDir(), visualStudioProject.getProjectFile().getLocation());
    }

    public void setVisualStudioProject(VisualStudioProject vsProject) {