}

    List<SourceFile> getConfSources() {
        return sourceFiles("conf", "shared") + sourceFiles("conf")
    }

    List<SourceFile> getTestSources() {
        return sourceFiles("test")
    }

    List<SourceFile> getOtherSources() {
        return [ sourceFile("", "README", "shared") ]
    }


    protected SourceFile sourceFile(String path, String name, String baseDir = getName()) {

performanceTest.registerTestProject("withVerboseTestNG", JvmProjectGeneratorTask) {
    projects = 1
    sourceFiles = 10
    subProjectTemplates << 'with-verbose-testng'
    daemonMemory = '256m'
}
performanceTest.registerTestProject("withVerboseJUnit", JvmProjectGeneratorTask) {
    projects = 1
    sourceFiles = 10
    subProjectTemplates << 'with-verbose-junit'
    daemonMemory = '256m'
}

#include <stdio.h>

<% sourceFiles.times {
  if (projectName == 'root') {
%>
#include "lib${it + 1}.h"
<% } else { %>
#include "${projectName}lib${it + 1}.h"
<%
  }
} %>

<% if (useMacroIncludes) { %>
#define STDIO <stdio.h>
#include STDIO
<% }%>

int main () {
  long sum = 1;
  <% sourceFiles.times {
    def functionName = "lib${it + 1}"
    if (projectName != 'root') {

        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:

            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

#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 {
  %>

@KaAnalysisApiInternals
class KaCompiledFileForOutputFile(private val outputFile: OutputFile) : KaCompiledFile {
    override val path: String
        get() = outputFile.relativePath

    override val sourceFiles: List<File>
        get() = outputFile.sourceFiles

    override val content: ByteArray
        get() = outputFile.asByteArray()

            reflectasm: 'com.googlecode:reflectasm:1.01',
        ]

        config.subProjects = this.subProjects
        config.projectDepth = this.projectDepth
        config.sourceFiles = this.sourceFiles
        config.minLinesOfCodePerSourceFile = 100
        config.compositeBuild = this.compositeBuild

        config.daemonMemory = this.daemonMemory
        config.compilerMemory = this.compilerMemory

                    }
                }
            """
        }
        sourceFiles = subprojects.collectMany { projectDir ->
            (1..NUMBER_OF_SOURCES_PER_SUBPROJECT).collect {
                def sourceFile = rootProject.file("${projectDir}/src/main/java/my/domain/Dummy${it}.java")
                modifySourceFile(sourceFile, 0)
                return sourceFile
            }
        }

        executer.beforeExecute {

                private final ConfigurableFileCollection sourceFiles = getProject().files();

                @InputFiles
                public ConfigurableFileCollection getSourceFiles() {
                    System.out.println("get files from field");
                    return sourceFiles;
                }

                public void setSourceFiles(Object files) {