buildType.componentSources.componentA.@creator[0] == 'Rules#addSources(BuildType) > create(componentA)'

        buildType.testSources.@type[0] == "org.gradle.model.ModelSet<CustomSourceSet>"
        buildType.testSources.@creator[0] == 'Rules#buildType(BuildType)'
        buildType.testSources."0".@type[0] == 'CustomSourceSet'
        buildType.testSources."0".@creator[0] == 'Rules#addSources(BuildType) > create()'
    }

        binary.builtBy(Stub(Task))

        and:
        binary.staticLibraryFile = outputFile

        and:
        final headerDir = tmpDir.createDir("headerDir")
        addSources(binary, headerDir)

        expect:
        binary.headerDirs.files == [headerDir] as Set
        binary.headerDirs.toString() == "Headers for static library 'main:staticLibrary'"

        }

        class Rules extends RuleSource {
            @Model
            void buildType(BuildType buildType) { }

            @Mutate
            void addSources(BuildType buildType){
                buildType.componentSources.create("componentA")
                buildType.testSources.create({})
            }
        }

        apply plugin: Rules
        """

            // to the sources won't cause any issues.
            unit.addSources(new File[]{new File("ForceStubGeneration.java")});
        }
        unit.addSources(getSortedSourceFiles(spec));

        unit.setCompilerFactory(new JavaCompilerFactory() {
            @Override

type SourcesReadyFn func(sourcesSeen sets.Set[string]) bool

// SourcesReady tracks the set of configured sources seen by the kubelet.
type SourcesReady interface {
	// AddSource adds the specified source to the set of sources managed.
	AddSource(source string)
	// AllReady returns true if the currently configured sources have all been seen.
	AllReady() bool
}

// NewSourcesReady returns a SourcesReady with the specified function.

        itemGroup('Headers').children().isEmpty()
    }

    def "adds sources and header files"() {
        when:
        filtersFile.loadDefaults()

        and:
        filtersFile.addSource(file("sourceOne"))
        filtersFile.addSource(file("sourceTwo"))

        filtersFile.addHeader(file("headerOne"))
        filtersFile.addHeader(file("headerTwo"))

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

                            sourceFile.bufferedReader().readText().replace("@org.jetbrains.annotations.Nullable", "")
                        addSource(StringReader(filteredSourceCode))
                    } else {
                        addSource(sourceFile)
                    }
                }
        }

    override fun close() =
        loader.close()
}


/**

		if a.Key == slog.SourceKey {
			source := a.Value.Any().(*slog.Source)
			source.File = filepath.Base(source.File)
		}
		return a
	}
	logger := slog.New(slog.NewTextHandler(os.Stdout, &slog.HandlerOptions{AddSource: true, ReplaceAttr: replace}))
	Infof(logger, "message, %s", "formatted")

	// Output:
	// level=INFO source=example_wrap_test.go:43 msg="message, formatted"

	analyzer := analyzers.AllCombined()
	all := kuberesource.ConvertInputsToSchemas(analyzer.Metadata().Inputs)

	ia := local.NewIstiodAnalyzer(analyzer, "", resource.Namespace(namespace), func(name config.GroupVersionKind) {})
	ia.AddSource(rwConfigStore)

	// Filter out configs watched by rwConfigStore so we don't watch multiple times
	store := crdclient.NewForSchemas(kubeClient,
		crdclient.Option{
			Revision:     revision,
			DomainSuffix: domainSuffix,

        super(xmlTransformer)
        this.fileLocationResolver = fileLocationResolver
    }

    protected String getDefaultResourceName() {
        'default.vcxproj.filters'
    }

    def addSource(File sourceFile) {
        sources.appendNode("ClCompile", [Include: toPath(sourceFile)]).appendNode('Filter', 'Source Files')
    }

    def addHeader(File headerFile) {