def id1 = new NamespaceId('namespace', 'info1')
        def id2 = new NamespaceId('namespace', 'info2')
        def extraAttrs = [:]
        extraAttrs[id1] = "info1 value"
        extraAttrs[id2] = "info2 value"
        metadata.extraAttributes = extraAttrs
        metadata.branch = "someBranch"

        def capturedDescriptor = null

}


class CompositeFunctionExtractor(internal val extractors: Iterable<FunctionExtractor>) : FunctionExtractor {
    override fun memberFunctions(kClass: KClass<*>, preIndex: DataSchemaBuilder.PreIndex): Iterable<SchemaMemberFunction> =
        extractors.flatMapTo(mutableSetOf()) { it.memberFunctions(kClass, preIndex) }

        }
    }
}


class CompositePropertyExtractor(internal val extractors: Iterable<PropertyExtractor>) : PropertyExtractor {
    override fun extractProperties(kClass: KClass<*>, propertyNamePredicate: (String) -> Boolean): Iterable<CollectedPropertyInformation> = buildList {

import org.gradle.model.internal.inspect.*

class ScopedRuleTest extends ProjectRegistrySpec {
    def extractors = [new DependencyAddingModelRuleExtractor()] + MethodModelRuleExtractors.coreExtractors(schemaStore)
    ModelRegistry registry = new ModelRegistryHelper(new ModelRuleExtractor(extractors, proxyFactory, schemaStore, structBindingsStore))

    static class RuleSourceUsingRuleWithDependencies extends RuleSource {

 *
 * Given that, introduces the following features in the schema:
 * * Type discovery ensuring that the types of the extensions get discovered and included in the schema (but just those types, not recursing)
 * * Function extractors which introduce configuring functions for the extensions
 *
 * If object conversion is enabled ([ifConversionSupported]):

        assertEquals("z", nonReadablePropertyError.property.name)
    }

    @Test
    fun `if multiple property extractors have properties with the same name, first wins`() {
        val expectedName = "test"
        val schema = schemaFromTypes(
            MyReceiver::class,
            listOf(MyReceiver::class),

    ModelRuleExtractor createModelRuleInspector(List<MethodModelRuleExtractor> extractors, ModelSchemaStore modelSchemaStore, StructBindingsStore structBindingsStore, ManagedProxyFactory managedProxyFactory) {
        List<MethodModelRuleExtractor> coreExtractors = MethodModelRuleExtractors.coreExtractors(modelSchemaStore);
        return new ModelRuleExtractor(Iterables.concat(coreExtractors, extractors), managedProxyFactory, modelSchemaStore, structBindingsStore);
    }

    @Rule
    TemporaryFolder temporaryDirectory = new TemporaryFolder()

    def setup() {
        temporaryDirectory.create()
    }

    def "api class extractors affect the configuration hash"() {
        def apiClassExtractor1 = Mock(ApiClassExtractor)
        def apiClassExtractor2 = Mock(ApiClassExtractor)

        def handle = executer.withTasks("extract").start()
        // Wait for all extracters to be ready
        waiting.waitForAllPendingCalls()

        def firstExtracter = server.expectAndBlock("extract")
        // release the extracters so they start trying to extract concurrently
        waiting.releaseAll()
        // wait for the first extracter to start extracting

t t=(()=>i.purge?.extract?i.purge.extract:i.content?.extract?i.content.extract:i.purge?.extract?.DEFAULT?i.purge.extract.DEFAULT:i.content?.extract?.DEFAULT?i.content.extract.DEFAULT:i.purge?.options?.extractors?i.purge.options.extractors:i.content?.options?.extractors?i.content.options.extractors:{})(),r={},n=(()=>{if(i.purge?.options?.defaultExtractor)return i.purge.options.defaultExtractor;if(i.content?.options?.defaultExtractor)return i.content.options.defaultExtractor})();if(n!==void 0&&(r.DEFAULT=n),typeof...