server.close(1000, null)
    serverListener.assertClosed(1000, "goodbye")
  }

  @Test
  fun webSocketsDontTriggerEventListener() {
    val listener = RecordingEventListener()
    client =
      client.newBuilder()
        .eventListenerFactory(clientTestRule.wrap(listener))
        .build()
    webServer.enqueue(
      MockResponse.Builder()
        .webSocketUpgrade(serverListener)
        .build(),
    )

  // operation in the constructor.
  //
  // 1. In the listener that performs the callback. In this case it is fine since inputFuture is
  //    assigned prior to calling addListener, and addListener happens-before any invocation of the
  //    listener. Notably, this means that 'volatile' is unnecessary to make 'inputFuture' visible
  //    to the listener.
  //

            }
            buf.append('\n');
        });
        return buf.toString();
    }

    public void addUpdateConfigListener(final String name, final Supplier<String> listener) {
        updateConfigListenerMap.put(name, listener);
    }

    public boolean isChangedClusterState(final int status) {
        return previousClusterState.getAndSet(status) != status;
    }

        ModelBuildingListener listener = getModelBuildingListener(request);

        if (listener != null) {
            AtomicReference<Model> m = new AtomicReference<>(model);

            ModelBuildingEvent event = new DefaultModelBuildingEvent(model, m::set, request, problems);

            catapult.accept(listener, event);

            return m.get();
        }

   * [requestBodyOpen], [responseBodyOpen], and [expectMoreExchanges].
   *
   * This will release the connection if it is still held.
   *
   * It will also notify the listener that the call completed; either successfully or
   * unsuccessfully.
   *
   * If the call was canceled or timed out, this will wrap [e] in an exception that provides that

    peer.play()

    // Play it back.
    val connection =
      Http2Connection.Builder(true, TaskRunner.INSTANCE)
        .socket(peer.openSocket())
        .pushObserver(Http2ConnectionTest.IGNORE)
        .listener(realConnection)
        .build()
    connection.start(sendConnectionPreface = false)

    // verify the peer received the ACK
    val ackFrame = peer.takeFrame()

			wantException:    false,
		},
		{ // supplying valid pod name retrieves Envoy config (fails because we don't check in Envoy config unit tests)
			execClientConfig: loggingConfig,
			args:             strings.Split("listener httpbin-794b576b6c-qx6pf", " "),
			expectedString:   `config dump has no configuration type`,
			wantException:    true,
		},

import org.eclipse.aether.repository.RepositoryPolicy;
import org.eclipse.aether.resolution.ResolutionErrorPolicy;
import org.eclipse.aether.util.graph.version.*;
import org.eclipse.aether.util.listener.ChainedRepositoryListener;
import org.eclipse.aether.util.repository.AuthenticationBuilder;
import org.eclipse.aether.util.repository.ChainedLocalRepositoryManager;

  repeated string hosts = 1;

  // secretName is the name of the secret used to terminate TLS traffic on
  // port 443. Field is left optional to allow TLS routing based on SNI
  // hostname alone. If the SNI host in a listener conflicts with the "Host"
  // header field used by an IngressRule, the SNI host is used for termination
  // and value of the Host header is used for routing.
  // +optional
  optional string secretName = 2;

			},
			ObjectMeta: metav1.ObjectMeta{
				Name:      waypointName,
				Namespace: ns,
			},
			Spec: gateway.GatewaySpec{
				GatewayClassName: constants.WaypointGatewayClassName,
				Listeners: []gateway.Listener{{
					Name:     "mesh",
					Port:     15008,
					Protocol: gateway.ProtocolType(protocol.HBONE),
				}},
			},
		}