if err := decoder.Decode(&size); err != nil {
			break
		}

		select {
		case channel <- size:
		case <-ctx.Done():
			// To avoid leaking this routine, exit if the http request finishes. This path
			// would generally be hit if starting the process fails and nothing is started to
			// ingest these resize events.
			return
		}
	}
}

type Request interface {
	// Finish determines whether to execute or reject the request and
	// invokes `execute` if the decision is to execute the request.
	// The returned `idle bool` value indicates whether the QueueSet
	// was idle when the value was calculated, but might no longer be
	// accurate by the time the client examines that value.
	Finish(execute func()) (idle bool)
}

// last virtual finish time of the queue is the virtual finish time of
// the last request in the queue. While the queue is empty and has a
// request executing: the last virtual finish time is the queue’s
// virtual start time. When a request is dequeued for service the
// queue’s virtual start time is advanced by G. When a request
// finishes being served, and the actual service time was S, the

	e.end()
}

// write writes an event into the trace.
func (e traceEventWriter) write(ev traceEv, args ...traceArg) traceEventWriter {
	e.w = e.w.event(ev, args...)
	return e
}

// end finishes writing to the trace. The traceEventWriter must not be used after this call.
func (e traceEventWriter) end() {
	e.w.end()
}

// traceEventWrite is the part of traceEvent that actually writes the event.

 * limitations under the License.
 */

package org.gradle.launcher.daemon.protocol;

/**
 * Sent from the daemon client to the daemon to indicate it has finished with the connection. This is the last
 * message sent from the client to the daemon.
 */
public class Finished extends Message {

	}
}

// 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[]
        }
    }
}

			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')