}

    def "creates isolated managed interface"() {
        def instantiator = instantiatorFactory().inject()
        def original = instantiator.newInstance(BeanInterface)
        original.prop1 = "a"

        given:
        _ * managedFactoryRegistry.lookup(_) >> instantiatorFactory().managedFactory

        expect:
        def isolated = isolatableFactory.isolate(original)

import org.gradle.api.model.ObjectFactory
import org.gradle.internal.component.external.model.ModuleComponentArtifactMetadata
import org.gradle.internal.instantiation.InstantiatorFactory
import org.gradle.internal.resource.ExternalResourceRepository
import org.gradle.internal.resource.local.LocallyAvailableResourceFinder
import org.gradle.util.TestUtil
import spock.lang.Specification

class TypedDomainObjectContainerWrapperTest extends Specification {

    DefaultPolymorphicDomainObjectContainer<Type> parent = new DefaultPolymorphicDomainObjectContainer<Type>(Type, TestUtil.instantiatorFactory().decorateLenient(), TestUtil.instantiatorFactory().decorateLenient(), CollectionCallbackActionDecorator.NOOP)

    def setup() {
        parent.add(type("typeOne"))
        parent.add(type("typeTwo"))
        parent.add(subtype("subTypeOne"))

import static org.junit.Assert.fail

class DefaultConventionTest {
    Convention convention

    TestPluginConvention1 convention1
    TestPluginConvention2 convention2

    Instantiator instantiator = TestUtil.instantiatorFactory().decorateLenient()

    @Before void setUp() {
        convention = new DefaultConvention(instantiator)
        convention1 = new TestPluginConvention1()
        convention2 = new TestPluginConvention2()

            ToUpperCase
        )), TestUtil.instantiatorFactory().decorateLenient(), shouldNotFail())
    }

    void withNonCacheableToUpperCaseRule() {
        rule = new InstantiatingAction<Details>(DefaultConfigurableRules.of(DefaultConfigurableRule.of(
            ToUpperCaseNotCached
        )), TestUtil.instantiatorFactory().decorateLenient(), shouldNotFail())
    }

        dsl.asDynamicObject

        then:
        thrown(IllegalStateException)
    }

    static class Thing {}

    def "works for dsl object"() {
        when:
        new DslObject(TestUtil.instantiatorFactory().decorateLenient().newInstance(Thing))

        then:
        notThrown(Exception)
    }

    def "can create a source set"() {
        given:
        def container = new DefaultSourceSetContainer(TestFiles.resolver(), TestFiles.taskDependencyFactory(), TestFiles.fileCollectionFactory(), TestUtil.instantiatorFactory().decorateLenient(), TestUtil.objectFactory(), CollectionCallbackActionDecorator.NOOP)

        when:
        SourceSet set = container.create("main")

        then:
        set instanceof DefaultSourceSet

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

import org.gradle.util.TestUtil
import spock.lang.Specification

class DefaultDomainObjectCollectionFactoryTest extends Specification {
    def factory = new DefaultDomainObjectCollectionFactory(TestUtil.instantiatorFactory(), TestUtil.services(), CollectionCallbackActionDecorator.NOOP, Stub(MutationGuard))

    def "creates container with decorated elements"() {
        given:

    def buildOperationRunner = new TestBuildOperationRunner()
    def buildOperationProgressEmitter = new NoOpBuildOperationProgressEventEmitter()
    def config = new DefaultBuildCacheConfiguration(TestUtil.instantiatorFactory().inject(), [
        new DefaultBuildCacheServiceRegistration(DirectoryBuildCache, TestDirectoryBuildCacheServiceFactory),