when:
        container.withType(plugin.class).clear()

        then:
        thrown UnsupportedOperationException
    }

    def scope(ClassLoader classLoader) {
        return Stub(ClassLoaderScope) {
            getLocalClassLoader() >> classLoader
        }
    }

    final VisualStudioVersionLocator systemPathLocator = Mock(VisualStudioVersionLocator)
    final VisualStudioMetaDataProvider versionDeterminer = Mock(VisualStudioMetaDataProvider)
    final SystemInfo systemInfo =  Stub(SystemInfo)
    final VisualStudioLocator visualStudioLocator = new DefaultVisualStudioLocator(commandLineLocator, windowsRegistryLocator, systemPathLocator, versionDeterminer, systemInfo)

    }

    def "provides no op resolve rule when no rules or forced modules configured"() {
        given:
        def details = Mock(DependencySubstitutionInternal)

        when:

    DomainObjectContext context = Mock()
    DependencySubstitutionRules dependencySubstitutionRules = Mock()
    FileResourceListener listener = Mock()
    PropertyFactory propertyFactory = new DefaultPropertyFactory(Stub(PropertyHost))
    FilePropertyFactory filePropertyFactory = TestFiles.filePropertyFactory()

    @Subject
    DefaultDependencyLockingProvider provider

    def setup() {

        dependencies.forEach { node.addDependencySuccessor(it) }
    }

    def stubConverter(Class<? extends Node> supportedNodeType, NodeType nodeType) {
        Stub(ToPlannedNodeConverter) {
            getSupportedNodeType() >> supportedNodeType
            getConvertedNodeType() >> nodeType
        }
    }

        expect:
        toList(collection) == ["a"]
    }

    def restoresUserCodeApplicationWhenFilterSpecIsEvaluated() {
        def spec = Mock(Spec)
        def source = Stub(UserCodeSource)
        def collection = null

        given:
        userCodeApplicationContext.apply(source) {
            collection = container.matching(spec)
        }

    def "creates stateful listener registered after another listener added"() {
        def created = Mock(Runnable)
        def listener = Mock(TestListener)

        when:
        listenerManager.addListener(Stub(TestListener))
        services.addProvider(new ServiceRegistrationProvider() {
            @Provides
            TestListener createListener() {
                created.run()
                return listener

import spock.lang.Specification

class IsolatableSerializerRegistryTest extends Specification {
    def managedFactoryRegistry = TestUtil.managedFactoryRegistry()
    def classLoaderHasher = Stub(ClassLoaderHierarchyHasher) {
        getClassLoaderHash(_) >> TestHashCodes.hashCodeFrom(123)
    }
    IsolatableFactory isolatableFactory = new DefaultIsolatableFactory(classLoaderHasher, managedFactoryRegistry)

    DefaultExecutionPlan executionPlan
    DefaultFinalizedExecutionPlan finalizedPlan

    def accessHierarchies = new ExecutionNodeAccessHierarchies(CASE_SENSITIVE, Stub(Stat))
    def taskNodeFactory = new TaskNodeFactory(thisBuild, Stub(BuildTreeWorkGraphController), nodeValidator, new TestBuildOperationRunner(), accessHierarchies)
    def dependencyResolver = new TaskDependencyResolver([new TaskNodeDependencyResolver(taskNodeFactory)])

    def classpathWalker = new ClasspathWalker(TestFiles.fileSystem())
    def gradleCoreInstrumentingRegistry = Stub(GradleCoreInstrumentationTypeRegistry) {
        getInstrumentedTypesHash() >> Optional.empty()
        getUpgradedPropertiesHash() >> Optional.empty()
    }

    def "instrumentation for #factory preserves classes"() {