def classLoader = new GroovyClassLoader(getClass().classLoader)
    def pluginRegistry = new DefaultPluginRegistry(pluginInspector, scope(classLoader))
    def target = Mock(PluginTarget)
    def instantiator = TestUtil.instantiatorFactory().inject()

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

import javax.inject.Inject

class DefaultIvyArtifactRepositoryTest extends Specification {
    final instantiator = TestUtil.instantiatorFactory().decorateLenient()
    final FileResolver fileResolver = Mock()
    final RepositoryTransportFactory transportFactory = Mock()
    final LocallyAvailableResourceFinder locallyAvailableResourceFinder = Mock()

        services.each { name, value ->
            registry.add(value.class, value)
        }
        def instantiator = new ImplicitInputsCapturingInstantiator(registry, TestUtil.instantiatorFactory()) {
            @Override
            def <IN, OUT, SERVICE> ImplicitInputsProvidingService<IN, OUT, SERVICE> findInputCapturingServiceByName(String name) {
                services[name]
            }
        }

    def setup() {
        substitutions = DefaultDependencySubstitutions.forResolutionStrategy(componentIdentifierFactory, moduleNotationParser, TestUtil.instantiatorFactory().decorateScheme().instantiator(), TestUtil.objectFactory(), AttributeTestUtil.attributesFactory(), Stub(NotationParser))
    }

    def "provides no op resolve rule when no rules or forced modules configured"() {

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

class AbstractNamedDomainObjectContainerTest extends Specification {
    Instantiator instantiator = TestUtil.instantiatorFactory().decorateLenient()
    CollectionCallbackActionDecorator collectionCallbackActionDecorator = CollectionCallbackActionDecorator.NOOP

import org.gradle.util.internal.ConfigureUtil
import org.gradle.util.TestUtil

class DefaultNamedDomainObjectSetSpec extends AbstractNamedDomainObjectCollectionSpec<Bean> {
    private final Instantiator instantiator = TestUtil.instantiatorFactory().decorateLenient()
    private final Namer<Bean> namer = new Namer<Bean>() {
        String determineName(Bean bean) {
            return bean.name
        }
    };

import spock.lang.Specification

class DefaultArtifactTypeRegistryTest extends Specification {
    def attributesFactory = AttributeTestUtil.attributesFactory()
    def registry = new DefaultArtifactTypeRegistry(TestUtil.instantiatorFactory().decorateLenient(), attributesFactory, CollectionCallbackActionDecorator.NOOP, Stub(VariantTransformRegistry))

    def "creates as required and reuses"() {
        expect:
        def container = registry.create()

@UsesNativeServices
class NativeSpecVisualStudioTargetBinaryTest extends Specification {
    final flavor = new DefaultFlavor("flavor1")
    def flavors = new DefaultFlavorContainer(TestUtil.instantiatorFactory().decorateLenient(), CollectionCallbackActionDecorator.NOOP)
    def exe = Mock(NativeExecutableSpec) {
        getFlavors() >> flavors
    }
    def lib = Mock(NativeLibrarySpec) {
        getFlavors() >> flavors

    interface BeanInterface {
        String getProp1()

        void setProp1(String value)
    }

    def "creates snapshot for managed interface"() {
        def instantiator = TestUtil.instantiatorFactory().inject()
        def value = instantiator.newInstance(BeanInterface)
        value.prop1 = "a"
        def value1 = instantiator.newInstance(BeanInterface)
        value1.prop1 = "a"

    }
    private UserCodeApplicationContext userCodeApplicationContext = Mock()
    private CalculatedValueContainerFactory calculatedValueContainerFactory = Mock()
    private Instantiator instantiator = TestUtil.instantiatorFactory().decorateLenient()
    private ImmutableAttributesFactory immutableAttributesFactory = AttributeTestUtil.attributesFactory()
    private DomainObjectContext domainObjectContext = new RootScriptDomainObjectContext()