<!-- For tests only. Must be in compile scope such that the Teamcity generate goal is able to compile the tests -->
        <dependency>
            <groupId>io.mockk</groupId>
            <artifactId>mockk</artifactId>
            <version>${mockk.version}</version>
        </dependency>
        <dependency>
            <groupId>net.bytebuddy</groupId>
            <artifactId>byte-buddy</artifactId>

        registry.close()

        then:
        1 * service.stop()
    }

    def closeClosesServicesInDependencyOrder() {
        def service1 = Mock(TestCloseService)
        def service2 = Mock(TestStopService)
        def service3 = Mock(CloseableService)
        def registry = new DefaultServiceRegistry()

        given:
        registry.addProvider(new ServiceRegistrationProvider() {

    def buildListener = Mock(BuildListener)
    def buildModelLifecycleListener = Mock(BuildModelLifecycleListener)
    def workExecutor = Mock(BuildWorkExecutor)
    def workPreparer = Mock(BuildWorkPreparer)

    def settingsMock = Mock(SettingsInternal.class)
    def gradleMock = Mock(GradleInternal.class)

    def buildModelController = Mock(BuildModelController)

        def processedMetadata = Mock(ComponentMetadata) {
            getStatus() >> 'from rule'
            getStatusScheme() >> ['from', 'rule']
        }
        given:
        resolveState.id >> id
        resolveState.componentMetadataProcessorFactory >> Mock(ComponentMetadataProcessorFactory) {
            createComponentMetadataProcessor(_) >> Mock(ComponentMetadataProcessor) {

class LoggingBridgingBuildActionExecuterTest extends Specification {
    final BuildActionExecutor<ConnectionOperationParameters, BuildRequestContext> target = Mock()
    final LoggingManagerInternal loggingManager = Mock()
    final BuildAction action = Mock()
    final ClientBuildRequestContext buildRequestContext = Mock()
    final ConnectionOperationParameters parameters = Stub()
    final ProviderOperationParameters providerParameters = Stub()

class ConsumerPomArtifactTransformerTest {

    @Test
    void transform() throws Exception {
        RepositorySystemSession systemSessionMock = Mockito.mock(RepositorySystemSession.class);
        SessionData sessionDataMock = Mockito.mock(SessionData.class);
        when(systemSessionMock.getData()).thenReturn(sessionDataMock);
        when(sessionDataMock.get(any())).thenReturn(new NoTransformerContext());

import org.gradle.test.fixtures.concurrent.ConcurrentSpec

class StdInStreamTest extends ConcurrentSpec {
    def "read byte requests input from client and blocks until it is available"() {
        def dispatch = Mock(OutputEventListener)
        def stream = new StdInStream(dispatch)
        def text = "some text"
        def bytes = text.bytes

        when:
        async {
            start {

    def "generates end of stdin event when connection stopped"() {
        StdinHandler handler = Mock()

        when:
        daemonConnection.onStdin(handler)
        daemonConnection.stop()

        then:
        1 * handler.onEndOfInput()
        0 * handler._
    }

    def "buffers stdin events"() {
        StdinHandler handler = Mock()
        def input1 = new ForwardInput("hello".bytes)

class SuiteTestClassProcessorTest extends Specification {
    private final TestResultProcessor resultProcessor = Mock()
    private final TestClassProcessor targetProcessor = Mock()
    private final TestDescriptorInternal suiteDescriptor = Mock()
    private final TestClassRunInfo testClass = Mock()
    private final Clock timeProvider = Mock()

import spock.lang.Specification
import org.gradle.internal.classpath.ClassPath

class DefaultClassPathRegistryTest extends Specification {
    final ClassPathProvider provider1 = Mock()
    final ClassPathProvider provider2 = Mock()
    final DefaultClassPathRegistry registry = new DefaultClassPathRegistry(provider1, provider2)

    def "fails for unknown classpath"() {
        given:
        provider1.findClassPath(_) >> null