def providesALoggingManagerFactory() {
        given:
        def registry = LoggingServiceRegistry.newCommandLineProcessLogging()

        expect:
        def factory = registry.getFactory(LoggingManagerInternal.class)
        factory instanceof DefaultLoggingManagerFactory
    }

    def providesAStyledTextOutputFactory() {
        given:
        def registry = LoggingServiceRegistry.newCommandLineProcessLogging()

        expect:

        })

        expect:
        10.times {
            start {
                assert registry.get(String) == "12"
                assert registry.get(Long) == 123
            }
        }
    }

    def "multiple threads can locate factories"() {
        def registry = new DefaultServiceRegistry()
        registry.addProvider(new ServiceRegistrationProvider() {
            @Provides

        registry.addProvider(provider)

        expect:
        registry.get(Integer).is(registry.get(Integer))
        registry.get(Number).is(registry.get(Number))

        and:
        registry.get(String).is(registry.get(String))
    }

    def usesProviderDecoratorMethodToDecorateParentServiceInstance() {
        def parent = Mock(ParentServices)
        def registry = new DefaultServiceRegistry(registry(parent))

datsun

// day : 2014-01-30 Charleston Road Registry Inc.
day

// dclk : 2014-11-20 Charleston Road Registry Inc.
dclk

// dds : 2015-05-07 Registry Services, LLC
dds

// deal : 2015-06-25 Amazon Registry Services, Inc.
deal

// dealer : 2014-12-22 Intercap Registry Inc.
dealer

// deals : 2014-05-22 Binky Moon, LLC
deals

        registry.registerOutputs(file('build/outputs'))
        registry.registerOutputs(file('build/outputs/other'))
        registry.registerOutputs(file('outputs'))
        registry.resolveOutputs()

        expect:
        registry.isOutputOwnedByBuild(file('build/outputs'))
        registry.isOutputOwnedByBuild(file('build/outputs/some-dir/other-dir'))
        registry.isOutputOwnedByBuild(file('build/outputs/other'))

        given:
        def registry = new DefaultSerializerRegistry()
        registry.register(Long, longSerializer)
        registry.register(Integer, intSerializer)
        registry.useJavaSerialization(StringBuilder)

        expect:
        registry.canSerialize(Long)
        registry.canSerialize(Number)
        registry.canSerialize(Object)
        !registry.canSerialize(BigDecimal)

        def defaultToolChain3 = availableToolChain("test3")

        when:
        registry.registerDefaultToolChain("test1", TestNativeToolChain)
        registry.registerDefaultToolChain("test2", TestNativeToolChain)
        registry.registerDefaultToolChain("test3", TestNativeToolChain)
        registry.addDefaultToolChains()

        then:
        registry.asList() == [defaultToolChain1, defaultToolChain2, defaultToolChain3]
    }

        def buzzFactory = factory(Buzz)
        registry.withFactories(barFactory, fooFactory)

        expect:
        registry.lookup(buzzFactory.id) == null
    }

    def "can lookup factory in parent registry"() {
        def fooFactory = factory(Foo)
        def barFactory = factory(Bar)
        def parent = new DefaultManagedFactoryRegistry().withFactories(fooFactory)

import org.gradle.launcher.daemon.protocol.Success
import org.gradle.launcher.daemon.registry.DaemonInfo
import org.gradle.launcher.daemon.registry.DaemonRegistry
import org.gradle.launcher.daemon.registry.DaemonStopEvent
import spock.lang.Specification

class ReportDaemonStatusClientTest extends Specification {
    DaemonRegistry registry = Mock(DaemonRegistry)
    DaemonConnector connector = Mock(DaemonConnector)

    private final DaemonRegistry registry
    private final DaemonContext context

    DaemonRegistryStateProbe(DaemonRegistry registry, DaemonContext context) {
        this.context = context
        this.registry = registry
    }

    void resetToken() {
        def daemonInfo = registry.all.find { it.context.pid == context.pid }
        registry.remove(daemonInfo.address)