}

    def toOtherSourceSet(SourceFile sourceFile) {
        return new SourceFile("other", sourceFile.name, sourceFile.content)
    }

    def renameSourceFile(SourceFile sourceFile, String name) {
        return new SourceFile(sourceFile.path, name, sourceFile.content)
    }

    def addFunction(SourceFile sourceFile) {
        return new SourceFile(sourceFile.path, sourceFile.name, sourceFile.content + """

    }

    def added(TestFile sourceFile) {
        virtualFileSystem.invalidateAll()
        modifiedFiles << sourceFile
        graph[sourceFile] = []
    }

    def sourceAdded(TestFile sourceFile, List<File> deps = []) {
        virtualFileSystem.invalidateAll()
        sourceFiles << sourceFile
        modifiedFiles << sourceFile
        graph[sourceFile] = deps
    }

            project(':b') {
                dependencies {
                    implementation project(':a')
                }
            }
        """
        def sourceFile = file("a/src/main/${language.name}/ToolImpl.${language.name}")
        sourceFile << """
            public class ToolImpl {
                private String thing() { return null; }
                private ToolImpl t = this;
            }
        """

        val versionsToIncubating = mutableMapOf<Version, MutableSet<IncubatingDescription>>()
        JavaParser().parse(sourceFile).getResult().get().run {
            solver.inject(this)
            findAllIncubating()
                .map { node -> toVersionIncubating(sourceFile, node) }
                .forEach { (version, incubating) ->

    private final String description;
    private final File sourceFile;
    private final URI sourceUri;
    private final RelativeFilePathResolver resolver;

    UriTextResource(String description, @Nonnull File sourceFile, RelativeFilePathResolver resolver) {
        this.description = description;
        this.sourceFile = FileUtils.normalize(sourceFile);
        this.sourceUri = sourceFile.toURI();
        this.resolver = resolver;
    }

        resolve() == [header]
    }

    def resolve() {
        def directives = parser.parseSource(sourceFile)
        directives = serialize(directives, serializer)
        def macros = new CollectingMacroLookup()
        macros.append(sourceFile, directives)
        def result = resolver.resolveInclude(sourceFile, directives.all.first(), macros)
        assert result.complete
        result.files.file as List
    }

        assert includes == []
        true
    }

    def noImports() {
        assert imports == []
        true
    }

    def useDirective(String directive) {
        sourceFile.text = sourceFile.text.replace("include", directive)
    }

    Expression expression(String value) {
        return RegexBackedCSourceParser.parseExpression(value)
    }

    Expression token(String value) {

        when:
        final newFile = file("src/main/${app.sourceType}/changed.${app.sourceExtension}")
        newFile << sourceFile.text
        sourceFile.delete()

        and:
        run "mainExecutable"

        then:
        outputs.recompiledFile newFile
        objectFileFor(sourceFile).assertDoesNotExist()
    }

    @ToBeFixedForConfigurationCache

		p.error = errors.New(errstr)
	}
	p.dir = r.string()
	p.sourceFiles = make([]*sourceFile, r.int())
	for i := range p.sourceFiles {
		p.sourceFiles[i] = &sourceFile{
			d:   m.d,
			pos: r.int(),
		}
	}
	p.modroot = m.modroot
	return p
}

// sourceFile represents the information of a given source file in the module index.
type sourceFile struct {
	d               *decoder // encoding of this source file

    private final static String TEST_INTERFACE_NAME = 'org.gradle.api.ApiTest'
    private final static String TEST_INTERFACE_SIMPLE_NAME = 'ApiTest'

    @TempDir
    File tmp
    File sourceFile

    BinaryCompatibilityRepository repository

    def jApiClassifier = Stub(JApiClass) // represents interfaces, enums and annotations
    def jApiMethod = Stub(JApiMethod)