super(names, objects, componentImplementation);
        this.baseName = baseName;
        this.sourceFiles = sourceFiles;
        this.targetPlatform = targetPlatform;
        this.toolChain = toolChain;
        this.platformToolProvider = platformToolProvider;
        this.compileTaskProperty = objects.property(CppCompile.class);
        this.identity = identity;

        // TODO - reduce duplication with Swift binary

@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()

}'''),
            new JvmSourceFile("compile/test", "Person2.scala", '''
package compile.test;

class Person2 {
}
''')
    ]

    @Override
    void changeSources(List<TestFile> sourceFiles) {
        def personScalaFile = sourceFiles.find { it.name == "Person.scala" }
        personScalaFile.text = personScalaFile.text.replace("name", "lastName")
    }

    @Override
    void writeAdditionalSources(TestFile testFile) {

 */
@NonNullApi
@DisableCachingByDefault(because = "Super-class, not to be instantiated directly")
public abstract class SourceTask extends ConventionTask implements PatternFilterable {
    private ConfigurableFileCollection sourceFiles = getProject().getObjects().fileCollection();
    private final PatternFilterable patternSet;

    public SourceTask() {
        patternSet = getPatternSetFactory().create();
    }

    @Inject

    def setup() {
        spec.compileClasspath = [new File('Dep1.jar'), new File('Dep2.jar'), new File('Dep3.jar')]
        spec.groovyClasspath = spec.compileClasspath
        spec.sourceFiles = files('House.scala', 'Person1.java', 'package.html', 'Person2.groovy')
        spec.destinationDir = new File("destinationDir")
        spec.compileOptions = TestUtil.newInstance(CompileOptions.class, TestUtil.objectFactory())

    @SkipWhenEmpty
    @InputFiles
    @PathSensitive(PathSensitivity.NONE)
    public abstract ConfigurableFileCollection getSourceFiles();

    public void sources(FileCollection sourceFiles) {
        getSourceFiles().from(sourceFiles);
    }

    // ...
// end::custom-task-class[]

// tag::task-arg-method[]
    // ...
    public void sources(TaskProvider<?> inputTask) {
        getSourceFiles().from(inputTask);

            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

        filtersFile.addHeader(file("headerTwo"))

        then:
        assert sourceFile(0) == "sourceOne"
        assert sourceFile(1) == "sourceTwo"

        assert headerFile(0) == "headerOne"
        assert headerFile(1) == "headerTwo"
    }

    private String sourceFile(int index) {
        def source = itemGroup('Sources').ClCompile[index]

for each rawPackage:
	error uint32 - string offset // error is produced by fsys.ReadDir or fmt.Errorf
	dir uint32 - string offset (directory path relative to module root)
	len(sourceFiles) uint32
	sourceFiles [n]uint32 - offset to source file (relative to start of index file)
	for each sourceFile:
		error - string offset // error is either produced by fmt.Errorf,errors.New or is io.EOF

                    }
                }
            """
        }
        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 {