given:
        def compiler = getCompiler()
        def testDir = tmpDirProvider.testDirectory
        def sourceFile = testDir.file("source.ext")

        when:
        def args = compiler.getSourceArgs(sourceFile)

        then:
        args == [sourceFile.absoluteFile.toString()]
    }

    def "output file directory honors output extension '#extension' and directory"() {
        given:

                           projectDeps: depInfo.dependencies[projectNumber - 1].collect {
                               "project${it}"
                           },
                           sourceFiles: testProject.sourceFiles,
                           projectName: testProject.name,
                           useMacroIncludes: false
        ] + args
        generateWithTemplate(projectDir, 'build.gradle', 'build.gradle', projectArgs)

        given:
        def app = new MixedLanguageHelloWorldApp(AbstractInstalledToolChainIntegrationSpec.toolChain)
        def asmSources = app.sourceFiles.findAll({it.path == 'asm'})
        def mainSources = app.headerFiles + app.sourceFiles.findAll({it.path != 'asm'})
        mainSources.removeAll {it.path == 'asm'}
        mainSources*.writeToDir(file("src/main"))
        asmSources*.writeToDir(file("src/input"))

            dependencyTree.calculateClassDependencies(0, 0, config.sourceFiles - 1)
        } else {
            for (int subProjectNumber = 0; subProjectNumber < config.subProjects; subProjectNumber++) {
                def sourceFileRangeStart = subProjectNumber * config.sourceFiles
                def sourceFileRangeEnd = sourceFileRangeStart + config.sourceFiles - 1

import org.example.*

plugins {
    base
}

val processTemplates by tasks.registering(ProcessTemplates::class) {
    templateEngine = TemplateEngineType.FREEMARKER
    sourceFiles.from(fileTree("src/templates"))
    templateData.name = "test"
    templateData.variables = mapOf("year" to "2012")
    outputDir = file(layout.buildDirectory.dir("genOutput"))
}

interface Injected {
    @get:Inject val fs: FileSystemOperations
}

    @ToBeFixedForConfigurationCache
    def "can have sourcefiles with same base name in same directory"() {
        setup:
        def testApp = new DuplicateMixedSameBaseNamesTestApp(AbstractInstalledToolChainIntegrationSpec.toolChain)


        testApp.getSourceFiles().each { SourceFile sourceFile ->
            file("src/main/all/${sourceFile.name}") << sourceFile.content
        }

#include "${functionName}.h"

// Include functions from dependencies
<% projectDeps.each { p ->
  sourceFiles.times { %>
#include "${p}lib${it + 1}.h"
<%
  }
} %>

<% functionCount.times { %>
long CPP_${functionName}_${it + 1} () {
  long sum = 1;
  // Call functions defined in dependent projects.
  <% projectDeps.each { p ->
    sourceFiles.times {
      def functionName = "${p}lib${it + 1}"
      functionCount.times {
  %>

  }

  subgraph thirdLine {
    {rank=same sourceFiles compileVariantCpp outputDirectory}
    includeRoot -> compileVariantCpp
    sourceFiles -> compileVariantCpp
    compileVariantCpp -> outputDirectory

    sourceFiles[style="rounded,filled", fillcolor="#bfffbf", label="Source files"]
    compileVariantCpp[label=<compile<i>Variant</i>Cpp>]

    }

    @Override
    public List<File> getSourceFiles() {
        return sourceFiles;
    }

    @Override
    public void source(Iterable<File> sources) {
        addAll(sourceFiles, sources);
    }

    @Override
    public void setSourceFiles(Collection<File> sources) {
        sourceFiles.clear();
        sourceFiles.addAll(sources);
    }

    @Override
    public List<File> getRemovedSourceFiles() {

		if err == errNonSource {
			// not a source or object file. completely ignore in the index
			continue
		} else if err != nil {
			p.sourceFiles = append(p.sourceFiles, &rawFile{name: name, error: err.Error()})
			continue
		} else if info == nil {
			p.sourceFiles = append(p.sourceFiles, &rawFile{name: name, ignoreFile: true})
			continue
		}
		rf := &rawFile{
			name:                 name,