}
}

// finish completes a RoundTrip by sending the request body, consuming the response body,
// and closing the response body.
func (rt *transportDialTesterRoundTrip) finish() {
	rt.t.Helper()

	if rt.finished {
		return
	}
	rt.finished = true

	<-rt.done

	if rt.err != nil {
		return
	}
	rt.reqBody.Close()

    @Override
    public void onFinish(FinishEvent finishEvent) {
        if (finishEvent instanceof TaskFinishEvent) { // <2>
            // Handle task finish event...
// end::build-service[]
            System.out.println(
                "Task finished = " + ((TaskFinishEvent) finishEvent).getDescriptor().getTaskPath());
// tag::build-service[]
        }
    }
}

	}

	// two set of requests
	//  - n1: this set will finish using this waitgroup before Wait is invoked
	//  - n2: this set will be in flight after Wait is invoked
	n1, n2 := 100, 101

	// so we know when all requests in n1 are done using the waitgroup
	n1DoneWG := sync.WaitGroup{}

	// so we know when all requests in n2 have called Add,
	// but not finished with the waitgroup yet.

			Help:           "The number of Jobs managed by an external controller",
			StabilityLevel: metrics.ALPHA,
		},
		[]string{"controller_name"},
	)

	// JobPodsFinished records the number of finished Pods that the job controller
	// finished tracking.
	// It only applies to Jobs that were created while the feature gate
	// JobTrackingWithFinalizers was enabled.
	// Possible label values:
	//   completion_mode: Indexed, NonIndexed

            broadcaster.progress(Stub(OperationIdentifier), operationProgressEvent())
            broadcaster.finished(descriptor, finishEvent)
            signalBuildFinished()
        }

        then:
        1 * listener.finished(descriptor, finishEvent)
        0 * listener._
    }

    def "does nothing when listener is already subscribed"() {

        containsEvent(FINISHED, DefaultTestMethodDescriptor, 'TestSuite > LightTest > org.company.SystemOutTest > testOut')
        containsEvent(FINISHED, DefaultTestClassDescriptor, 'TestSuite > LightTest > org.company.SystemOutTest')
        containsEvent(FINISHED, DefaultTestSuiteDescriptor, 'TestSuite > LightTest')

                aGradle.buildFinished {
                    println "Gradle Plugin received build finished!"
                }
            }
        }
        """
        then:
        def executed = succeeds('tasks')
        executed.output.contains("Gradle Plugin received build finished!")
    }

    @ToBeFixedForConfigurationCache(because = "Gradle.buildFinished")

            start("2", id2),
            start("3", id2),
            finished("3", id1),
            finished("2", id1),
            finished("1", id1),
            finished("3", id2),
            finished("2", id2),
            finished("1", id2),
        ]
    }

    def "does not forward progress notifications outside of start and finish"() {
        given:
        manager.addListener(recordingListener("1"))

            gradle.buildFinished {
                println "root build finished"
                assert System.getProperty("buildsrc") == "done"
            }
        """

        when:
        run()

        then:
        output.indexOf("running tasks") < output.indexOf("buildSrc finished")
        output.indexOf("buildSrc finished") < output.indexOf("root build finished")
    }

        0 * tracker1._
        0 * tracker2._
        0 * tracker3._

        when:
        generator.finished(operation, finishEvent)

        then:
        1 * tracker1.finished(operation, finishEvent)
        1 * tracker2.finished(operation, finishEvent)
        1 * tracker3.finished(operation, finishEvent)

        then:
        1 * tracker1.discardState(operation)