Type: "TCP",
			},
			inListener: &listener.Listener{
				FilterChains: []*listener.FilterChain{{
					Filters: []*listener.Filter{{
						Name: wellknown.TCPProxy,
					}},
				}},
			},
			expect: true,
		},
		{
			desc: "unknown-type",
			inFilter: &ListenerFilter{
				Type: "UNKNOWN",
			},
			inListener: &listener.Listener{
				FilterChains: []*listener.FilterChain{{

    RecordingListener listener = new RecordingListener();
    manager.addListener(listener, directExecutor());
    manager.startAsync().awaitHealthy();
    assertTrue(manager.isHealthy());
    assertTrue(listener.healthyCalled);
    assertFalse(listener.stoppedCalled);
    assertTrue(listener.failedServices.isEmpty());
    manager.stopAsync().awaitStopped();

                    InternalMavenSession.from(ee.getSession().getSession());
            Collection<Listener> listeners = session.getListeners();
            if (!listeners.isEmpty()) {
                Event event = new DefaultEvent(session, ee);
                for (Listener listener : listeners) {
                    listener.onEvent(event);
                }
            }
        }
    }

    @Override

    checkNotNull(unit);
    return get();
  }

  @Override
  public void addListener(Runnable runnable, Executor executor) {
    Listener listener = new Listener(runnable, executor);
    if (isDone()) {
      listener.execute();
    } else {
      listeners.add(listener);
    }
  }

  @CanIgnoreReturnValue
  protected boolean setException(Throwable throwable) {
    checkNotNull(throwable);

		// Support v2 or v3 in config dump. See ads.go:RequestedTypes for more info.
		l.ActiveState.Listener.TypeUrl = v3.ListenerType
		err := l.ActiveState.Listener.UnmarshalTo(listenerTyped)
		if err != nil {
			return
		}
		listeners = append(listeners, listenerTyped)
	}
	Print(writer, listeners)

  private static final ListenerCallQueue.Event<Listener> STARTING_EVENT =
      new ListenerCallQueue.Event<Listener>() {
        @Override
        public void call(Listener listener) {
          listener.starting();
        }

        @Override
        public String toString() {
          return "starting()";
        }
      };
  private static final ListenerCallQueue.Event<Listener> RUNNING_EVENT =

            ResolutionNode node,
            Artifact replacement,
            VersionRange newRange) {
        for (ResolutionListener listener : listeners) {
            switch (event) {
                case ResolutionListener.TEST_ARTIFACT:
                    listener.testArtifact(node.getArtifact());
                    break;
                case ResolutionListener.PROCESS_CHILDREN:

        ).setHeader("content-type", "text/event-stream")
        .build(),
    )
    val source = newEventSource()
    assertThat(source.request().url.encodedPath).isEqualTo("/")
    listener.assertOpen()
    listener.assertEvent(null, null, "hey")
    listener.assertClose()
  }

  @RetryingTest(5)
  fun cancelInEventShortCircuits() {
    server.enqueue(
      MockResponse.Builder()
        .body(
          """

    // Confirm the events occur when expected.
    listener.takeEvent(CallStart::class.java, 0L)
    listener.takeEvent(ConnectionAcquired::class.java, applicationInterceptorDelay)
    listener.takeEvent(RequestHeadersStart::class.java, networkInterceptorDelay)
    listener.takeEvent(RequestHeadersEnd::class.java, 0L)
    listener.takeEvent(RequestBodyStart::class.java, 0L)
    listener.takeEvent(RequestBodyEnd::class.java, requestBodyDelay)

    server.processNextFrame()
    client.listener.assertClosing(1000, "Hello!")
    server.listener.assertClosing(1000, "Hi!")
    client.webSocket!!.finishReader()
    server.webSocket!!.finishReader()
    client.listener.assertClosed(1000, "Hello!")
    server.listener.assertClosed(1000, "Hi!")
    taskFaker.runTasks()
    assertThat(client.closed).isTrue()