then:
        c.props.prop == "p"
        b.prop == "p"
    }

    void configureByMapTriesMethodForExtensibleObjects() {
        given:
        Bean bean = TestUtil.instantiatorFactory().decorateLenient().newInstance(Bean)

        when:
        ConfigureUtil.configureByMap(bean, method: "foo")

        then:
        bean.prop == "foo"
    }

    static class Bean {

        }
    }

    @Test
    public void doesNotIncludeToStringInGetPropertyErrorMessageWhenItIsNotImplemented() {
        DynamicObject bean = new ExtensibleDynamicObject(new Object(), Object.class, TestUtil.instantiatorFactory().decorateLenient());

        try {
            bean.getProperty("unknown");
            fail();
        } catch (MissingPropertyException e) {

    def propertyFactory = new DefaultPropertyFactory(Stub(PropertyHost))
    def patternSetFactory = TestFiles.patternSetFactory

    }

    @Override
    public DetachedResolver newDetachedResolver() {
        DependencyManagementServices dms = getServices().get(DependencyManagementServices.class);
        InstantiatorFactory instantiatorFactory = services.get(InstantiatorFactory.class);
        DefaultServiceRegistry lookup = new DefaultServiceRegistry(services);
        lookup.addProvider(new ServiceRegistrationProvider() {
            @Provides

            artifactIdentifierFileStore, externalResourceFileStore, pomParser, metadataParser, authenticationSchemeRegistry, ivyContextManager, moduleIdentifierFactory,
            TestUtil.instantiatorFactory(), Mock(FileResourceRepository), mavenMetadataFactory, ivyMetadataFactory, SnapshotTestUtil.isolatableFactory(), TestUtil.objectFactory(),
            CollectionCallbackActionDecorator.NOOP,

class DefaultScriptHandlerTest extends Specification {
    def repositoryHandler = Mock(RepositoryHandler)
    def dependencyHandler = Mock(DependencyHandler) {
        getArtifactTypes() >> new DefaultArtifactTypeContainer(TestUtil.instantiatorFactory().decorateLenient(), AttributeTestUtil.attributesFactory(), CollectionCallbackActionDecorator.NOOP)
    }
    def configurationContainer = Mock(RoleBasedConfigurationContainerInternal)

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

class AttributePrecedenceSchemaAttributeMatcherTest extends Specification {

    def schema = new DefaultAttributesSchema(TestUtil.instantiatorFactory(), new TestIsolatableFactory())
    def explanationBuilder = Stub(AttributeMatchingExplanationBuilder)

    def highest = Attribute.of("highest", String)
    def middle = Attribute.of("middle", String)

    @Before public void setUp() {
        testTask = TestUtil.create(temporaryFolder).task(TestTask.class);
        conventionAware = new ConventionAwareHelper(testTask, new DefaultConvention(TestUtil.instantiatorFactory().decorateLenient()));
    }

    @Test
    public void canMapPropertiesUsingClosure() {
        conventionAware.map("list1", TestUtil.toClosure("{ ['a'] }"));

import org.gradle.api.services.ServiceReference
import org.gradle.internal.Actions
import org.gradle.internal.Try
import org.gradle.internal.event.DefaultListenerManager
import org.gradle.internal.instantiation.InstantiatorFactory
import org.gradle.internal.resources.SharedResourceLeaseRegistry
import org.gradle.internal.service.Provides
import org.gradle.internal.service.ServiceRegistrationProvider
import org.gradle.internal.service.scopes.Scope

    )
}


internal
fun beanStateReaderLookupForTesting(): BeanStateReaderLookup =
    DefaultBeanStateReaderLookup(
        BeanConstructors(TestCrossBuildInMemoryCacheFactory()),
        TestUtil.instantiatorFactory()