def registry = new DefaultServiceRegistry().with {
            add(DocumentationRegistry.class, new DocumentationRegistry())
        }
        return ResolutionFailureDescriberRegistry.standardRegistry(TestUtil.instantiatorFactory().inject(registry))
    }

    private CompatibilityRule<Object> compatibilityRules
    private DisambiguationRule<Object> disambiguationRules

    def setup() {
        AttributesSchema schema = new DefaultAttributesSchema(TestUtil.instantiatorFactory(), SnapshotTestUtil.isolatableFactory())
        JavaEcosystemSupport.configureSchema(schema, TestUtil.objectFactory())
        compatibilityRules = schema.compatibilityRules(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE)

        def lister = new InstantiatingAction<ComponentMetadataListerDetails>(DefaultConfigurableRules.of(Stub(ConfigurableRule)), TestUtil.instantiatorFactory().inject(), Stub(InstantiatingAction.ExceptionHandler))

    def container = createContainer()

    private DefaultPolymorphicDomainObjectContainer<Person> createContainer() {
        new DefaultPolymorphicDomainObjectContainer<Person>(Person, TestUtil.instantiatorFactory().decorateLenient(), TestUtil.instantiatorFactory().decorateLenient(), callbackActionDecorator)
    }

    boolean supportsBuildOperations = true

    @Override
    final PolymorphicDomainObjectContainer<Person> getContainer() {

 *
 * <p>A service of this type is available in all scopes. However, the recommended way to receive an {@code Instantiator} is via a {@link org.gradle.internal.instantiation.InstantiatorFactory}.</p>
 */
@UsedByScanPlugin("test-retry")
public interface Instantiator {

    /**
     * Create a new instance of T, using {@code parameters} as the construction parameters.
     *

    def projectFinder = Mock(ProjectFinder)
    def capabilityNotationParser = new CapabilityNotationParserFactory(false).create()
    def depFactory = new DefaultProjectDependencyFactory(
        TestUtil.instantiatorFactory().decorateLenient(), true, capabilityNotationParser, TestUtil.objectFactory(),
        AttributeTestUtil.attributesFactory(), TestFiles.taskDependencyFactory()
    )
    def factory = new ProjectDependencyFactory(depFactory)

            getGroup() >> "org.example"
            getVersion() >> "0.0.1"
        }
        def dependencyFactory = new DefaultProjectDependencyFactory(
                TestUtil.instantiatorFactory().decorateLenient(),
                true,
                new CapabilityNotationParserFactory(false).create(),
                TestUtil.objectFactory(),
                AttributeTestUtil.attributesFactory(),

            temporaryFileProvider,
            textResourceAdapterFactory(temporaryFileProvider)
        );

        return new DefaultFileOperations(
            fileResolver,
            TestUtil.instantiatorFactory().inject(),
            directoryFileTreeFactory(),
            fileHasher(),
            resourceHandlerFactory,
            fileCollectionFactory(basedDir),
            objectFactory(),

                void setValue(String value);
            }
        """

        buildFile << """
            import org.gradle.internal.instantiation.InstantiatorFactory

            ext.testObject = getServices().get(InstantiatorFactory.class).inject().newInstance(SomeExtension)
            ext.testObject.value = "bar"

            ${parameterWorkAction('SomeExtension', 'println parameters.testParam.value', true) }

        ServiceLookup services = new DefaultServiceRegistry().add(ObjectFactory, TestUtil.objectFactory())
        spec.groovyCompileOptions = new MinimalGroovyCompileOptions(TestUtil.instantiatorFactory().decorateLenient(services).newInstance(GroovyCompileOptions.class))
    }

    def "silently excludes source files not ending in .java or .groovy by default"() {
        when:
        compiler.execute(spec)