TaskDetails task2 = taskDetails(':other')
        TaskDetails task3 = taskDetails(':sub:task')
        _ * task1.findTask(_) >> Mock(Task)
        _ * task2.findTask(_) >> Mock(Task)
        _ * task3.findTask(_) >> Mock(Task)

        TaskReportModel project1 = Mock()
        TaskReportModel project2 = Mock()
        _ * project1.groups >> (['group'] as LinkedHashSet)
        _ * project1.getTasksForGroup('group') >> ([task1, task2] as Set)

   "apiVersion":"v1",
   "metadata":{
     "name":"mock",
     "labels":{
       "app":"mock"
     }
   },
   "spec":{
     "ports": [{
       "protocol": "TCP",
       "port": 99,
       "targetPort": 9949
     }],
     "selector":{
       "app":"mock"
     }
   }
}
{
   "kind":"ReplicationController",
   "apiVersion":"v1",
   "metadata":{
     "name":"mock",
     "labels":{
       "app":"mock"
     }

apiVersion: v1
kind: Service
metadata:
  name: mock
  labels:
    app: mock
    status: replaced
spec:
  ports:
  - port: 99
    protocol: TCP
    targetPort: 9949
  selector:
    app: mock
---
apiVersion: v1
kind: ReplicationController
metadata:
  name: mock
spec:
  replicas: 1
  selector:
    app: mock
  template:
    metadata:
      labels:
        app: mock
        status: replaced
    spec:

        adapter.onEvent(Mock(InternalProgressEvent))

        then:
        0 * listener.statusChanged(_)
    }

    def "only TaskProgressEventX instances of known type are processed"() {
        given:
        def listener = Mock(ProgressListener)
        def adapter = createAdapter(listener)

        when:
        def unknownEvent = Mock(InternalProgressEvent)
        adapter.onEvent(unknownEvent)

        then:

    def "should include uri when file not found"() {
        def gcsStorageClient = Mock(Storage)
        URI uri = new URI("https://somehost/file.txt")
        GcsClient gcsClient = new GcsClient(gcsStorageClient)

        gcsStorageClient.objects(*_) >> Mock(Storage.Objects) {
            get(*_) >> Mock(Storage.Objects.Get) {
                execute() >> { throw Mock(GoogleJsonResponseException) {
                    getStatusCode() >> 404

        val clientModule = mock<org.gradle.api.artifacts.ClientModule> {
            on { isTransitive = any() }.thenAnswer { it.mock }
        }

        val commonsCliDependency = mock<ExternalModuleDependency>(name = "commonsCliDependency")

        val antModule = mock<org.gradle.api.artifacts.ClientModule>(name = "antModule")
        val antLauncherDependency = mock<ExternalModuleDependency>(name = "antLauncherDependency")

import org.junit.Test


class TaskContainerExtensionsTest {

    @Test
    fun `can create tasks with injected constructor arguments`() {

        val task = mock<DefaultTask>()
        val tasks = mock<TaskContainer> {
            on { create("my", DefaultTask::class.java, "foo", "bar") } doReturn task
        }

        tasks.create<DefaultTask>("my", "foo", "bar")

        1 * action3.get() >> "three"
        0 * _
    }

    def "queues supplied actions to run in parallel"() {
        given:
        def action1 = Mock(Supplier)
        def action2 = Mock(Supplier)
        def action3 = Mock(Supplier)
        def queue = Mock(BuildOperationQueue)

        when:
        def result = runner.run([action1, action2, action3])

        then:
        result == ["one", "two", "three"]

        given:
        def ancestryTracker = Mock(BuildOperationAncestryTracker)
        def testExecutionRequest = Mock(TestExecutionRequestAction)
        TestExecutionResultEvaluator evaluator = new TestExecutionResultEvaluator(ancestryTracker, testExecutionRequest)
        1 * testExecutionRequest.getTaskSpecs() >> []

        def testDescriptorInternal = Mock(TestDescriptorInternal)

    def consumerProvidedVariantFinder = Mock(ConsumerProvidedVariantFinder)
    def transformedVariantFactory = Mock(TransformedVariantFactory)
    def dependenciesResolverFactory = Mock(TransformUpstreamDependenciesResolverFactory)
    def attributeMatcher = Mock(AttributeMatcher)
    def attributesSchema = Mock(AttributesSchemaInternal) {
        withProducer(_) >> attributeMatcher