file {
        beforeMerged {
          assert it.facets.contains(new Facet('facet.one', '1.0'))
          it.facets.add(new Facet('facet.two', '2.0'))
        }
        whenMerged {
          assert it.facets.contains(new Facet('facet.one', '1.0'))
          assert it.facets.contains(new Facet('facet.two', '2.0'))
          it.facets.add(new Facet('facet.three', '3.0'))
        }

    }
    def loadMetadata = Mock(BuildCacheLoadResult)
    def deleter = Mock(Deleter)
    def fileSystemAccess = Mock(FileSystemAccess)
    def outputChangeListener = Mock(OutputChangeListener)

    def step = new BuildCacheStep<TestCachingContext>(buildCacheController, deleter, fileSystemAccess, outputChangeListener, delegate)
    def delegateResult = Mock(AfterExecutionResult)

    def "loads from cache"() {

class ClassLoadersCachingIntegrationTest extends PersistentBuildProcessIntegrationTest {

    def getIsCachedCheck() {
        """
            class StaticState {
                static set = new java.util.concurrent.atomic.AtomicBoolean()
            }
            println project.path + " cached: " + StaticState.set.getAndSet(true)
        """
    }

    def addIsCachedCheck(String project = null) {

import static org.gradle.api.tasks.compile.JavaAnnotationProcessingIntegrationTest.CompileMode.IN_PROCESS

class JavaAnnotationProcessingIntegrationTest extends AbstractIntegrationSpec {

    def fixture = new HelperProcessorFixture()
    def operations = new CompileJavaBuildOperationsFixture(executer, testDirectoryProvider)

    def annotationProjectDir = file("annotation")
    def processorProjectDir = file("processor")

    def setup() {

    DependencySubstitutionsInternal substitutions;
    NotationParser moduleNotationParser = NotationParserBuilder.builder(Object, ComponentSelector).converter(new ModuleSelectorStringNotationConverter(new DefaultImmutableModuleIdentifierFactory())).toComposite()

    def setup() {

        MavenPom pom = new MavenPom(file("build/repo/com/acme/root/1.3/root-1.3.pom"))
        pom.scope("runtime") {
            assertOptionalDependencies(
                    "org.apache.commons:commons-lang3:3.9"
            )
        }

        and: "appears as a variant in Gradle Module metadata"

         */

        def xmlReport = new JUnitXmlTestExecutionResult(testDirectory)
        def classResult = xmlReport.testClass("FooTest")

        assertTestClassExecutionResultOutput(classResult)

        def htmlReport = new HtmlTestExecutionResult(testDirectory)
        def classReport = htmlReport.testClass("FooTest")

        given:
        def parent = Mock(ClassLoader, useObjenesis: false)
        def spec = new FilteringClassLoader.Spec([ 'allow.ClassName' ], [ 'allowPackage' ], [ 'allowPackagePrefix' ], [ 'allowPackageResource' ], [ 'allowResource' ], [ 'disallow.ClassName' ], [ 'disallowPackage' ])
        def filteringClassLoader = new FilteringClassLoader(parent, spec)
        def visitor = Mock(ClassLoaderVisitor)

        when:

                    implementation project(':greeter')
                }
            }
            project(':greeter') {
                apply plugin: 'cpp-library'
            }
"""
        def app = new CppAppWithLibrary()
        app.greeter.writeToProject(file('greeter'))
        app.main.writeToProject(file('app'))

        when:
        succeeds("xcode")

        then:

class TomlCatalogFileParserTest extends Specification implements VersionCatalogErrorMessages {

    def supplier = Stub(Supplier)
    def problems = new DefaultProblems(
        Stub(ProblemEmitter)
    )

    def createVersionCatalogBuilder() {
        new DefaultVersionCatalogBuilder(
            "libs",
            Interners.newStrongInterner(),
            Interners.newStrongInterner(),