def executionContext = Mock(TaskExecutionContext)

    def executer = new EventFiringTaskExecuter(buildOperationRunner, taskExecutionListener, taskListener, delegate)

    def "notifies task listeners"() {
        when:
        executer.execute(task, state, executionContext)

        then:
        _ * task.getIdentityPath() >> Path.path(":a")

        1 * task.getTaskIdentity() >> taskIdentity

	// UseRemoteAddress sets useRemoteAddress to true for sidecar outbound listeners so that it picks up the localhost
	// address of the sender, which is an internal address, so that trusted headers are not sanitized.
	UseRemoteAddress = env.Register(
		"PILOT_SIDECAR_USE_REMOTE_ADDRESS",
		false,
		"UseRemoteAddress sets useRemoteAddress to true for sidecar outbound listeners.",
	).Get()

	EnableEDSForHeadless = env.Register(

 * but we need to allow, external (i.e. non ListenerManager), listeners per build.
 * <p>
 * Furthermore, the actual lifecycle is not something that we currently model with the service registries.
 * The notification listener is effectively of cross build tree scope, which doesn't exist.
 * This is because GradleBuild uses a discrete tree (which is intended to change later).

        }

        then: "task progress events must be forwarded to the attached listeners"
        !events.tasks.empty
        events.operations == events.tasks
    }

    def "receive current task progress event even if one of multiple task listeners throws an exception"() {
        given:
        goodCode()

        when: "launching a build"

@ServiceScope(Scope.Global.class)
public interface OperationResultPostProcessorFactory {
    /**
     * Creates the post processors relevant for the given subscriptions. The processors are also registered as listeners.
     */
    List<OperationResultPostProcessor> createProcessors(BuildEventSubscriptions subscriptions, BuildEventConsumer consumer);

	"istio.io/istio/pkg/util/sets"
)

type ListenersTest struct {
	// Match listener by name
	Name string
	// Match listener by port
	Port uint32

	// Listener assertions
	Listener ListenerTest
}

// ListenerTest provides a struct for defining expectations for a listener
type ListenerTest struct {
	// Assert the listener contains these filter chains (in order, if TotalMatch)
	FilterChains []FilterChainTest

@Suppress("UnstableApiUsage")
@KaAnalysisNonPublicApi
object PluginStructureProvider {
    /**
     * This fake plugin is required to provide it as a required parameter.
     * Effectively, it is only used to group project listeners.
     */
    private val fakePluginDescriptor = DefaultPluginDescriptor("analysis-api-standalone-base-loader")

    private object ReadContext : ReadModuleContext {
        override val interner get() = NoOpXmlInterner

        graphNotifyOps.size() == 2
        graphNotifyOps[0].displayName == 'Notify task graph whenReady listeners (:buildSrc)'
        graphNotifyOps[0].details.buildPath == ':buildSrc'
        graphNotifyOps[0].parentId == treeTaskGraphOps[0].id
        graphNotifyOps[1].displayName == "Notify task graph whenReady listeners"
        graphNotifyOps[1].details.buildPath == ":"
        graphNotifyOps[1].parentId == treeTaskGraphOps[1].id

     * @see org.gradle.api.invocation.GradleLifecycle#afterProject(IsolatedAction)
     */
    void afterProject(IsolatedAction<? super Project> action);

    /**
     * Returns an isolated listener for the registered actions, if any. The listener makes it impossible for
     * the actions to carry any shared mutable state across projects and can be safely executed in parallel.
     */
    @Nullable

						gatewayNameOverride:                "default",
					},
				},
				Spec: k8s.GatewaySpec{
					GatewayClassName: k8s.ObjectName(features.GatewayAPIDefaultGatewayClass),
					Listeners: []k8s.Listener{{
						Name:     "http",
						Port:     k8s.PortNumber(80),
						Protocol: k8s.HTTPProtocolType,
					}},
				},
			},
			objects:                  defaultObjects,