}{
		{
			name:      "partial push with headless endpoint update",
			proxy:     &model.Proxy{Type: model.SidecarProxy},
			request:   &model.PushRequest{Reason: model.NewReasonStats(model.HeadlessEndpointUpdate)},
			nameTable: emptyNameTable,
		},
		{
			name:      "full push",
			proxy:     &model.Proxy{Type: model.SidecarProxy},
			request:   &model.PushRequest{Full: true},
			nameTable: emptyNameTable,
		},
		{

// will only be effective if DNS capture is enabled in the proxy
func (configgen *ConfigGeneratorImpl) BuildNameTable(node *model.Proxy, push *model.PushContext) *dnsProto.NameTable {
	if node.Type != model.SidecarProxy {
		// DNS resolution is only for sidecars
		return nil
	}
	return dnsServer.BuildNameTable(dnsServer.Config{
		Node:                        node,
		Push:                        push,

		filter := b.applier.JwtFilter(true, b.proxy.Type != model.SidecarProxy)
		if filter != nil {
			return []*hcm.HttpFilter{filter}
		}
		return nil
	}
	res := []*hcm.HttpFilter{}
	if filter := b.applier.JwtFilter(false, false); filter != nil {
		res = append(res, filter)
	}
	forSidecar := b.proxy.Type == model.SidecarProxy
	if filter := b.applier.AuthNFilter(forSidecar); filter != nil {

	// For Gateways, we do not care about the following configs for example Sidecar.
	model.Router: sets.New(kind.Sidecar),
	// For Sidecar, we do not care about the following configs for example Gateway.
	model.SidecarProxy: sets.New(kind.Gateway, kind.KubernetesGateway),
}

// ConfigAffectsProxy checks if a pushEv will affect a specified proxy. That means whether the push will be performed
// towards the proxy.

		proxyVersion:    cb.proxyVersion,
		locality:        cb.locality,
		proxyClusterID:  cb.clusterID,
		proxySidecar:    cb.sidecarProxy(),
		proxyView:       cb.proxyView,
		hbone:           cb.sendHbone,
		http2:           port.Protocol.IsHTTP2(),
		downstreamAuto:  cb.sidecarProxy() && port.Protocol.IsUnsupported(),
		supportsIPv4:    cb.supportsIPv4,
		service:         service,
		destinationRule: dr,

	// HelloInstanceV0 is a mock IP address for v0 of HelloService
	HelloInstanceV0 = MakeIP(HelloService, 0)

	// HelloProxyV0 is a mock proxy v0 of HelloService
	HelloProxyV0 = model.Proxy{
		Type:         model.SidecarProxy,
		IPAddresses:  []string{HelloInstanceV0},
		ID:           "v0.default",
		DNSDomain:    "default.svc.cluster.local",
		IstioVersion: model.MaxIstioVersion,
		Metadata:     &model.NodeMetadata{},
	}

	push.InitContext(env, nil, nil)

	for _, c := range testCases {
		t.Run(c.name, func(t *testing.T) {
			gotConfigs := InsertedExtensionConfigurations(push.EnvoyFilters(&model.Proxy{Type: model.SidecarProxy, ConfigNamespace: "not-default"}),
				c.requestedNames)
			if len(gotConfigs) != len(c.wantExtensionConfig) {
				t.Fatalf("number of extension config got %v want %v", len(gotConfigs), len(c.wantExtensionConfig))
			}

	model.Router: sets.New(
		// for autopassthrough gateways, we build filterchains per-dr subset
		kind.WorkloadGroup,
		kind.WorkloadEntry,
		kind.Secret,
		kind.ProxyConfig,
		kind.DNSName,
	),
	model.SidecarProxy: sets.New(
		kind.Gateway,
		kind.WorkloadGroup,
		kind.WorkloadEntry,
		kind.Secret,
		kind.ProxyConfig,
		kind.DNSName,

		kind.KubernetesGateway,
	),
	model.Waypoint: sets.New(
		kind.Gateway,

					t.Fatalf("expected alpn list %v; got %v", util.ALPNInMeshWithMxc, got)
				}
			},
		},
	}

	proxy := &model.Proxy{
		Type:         model.SidecarProxy,
		Metadata:     &model.NodeMetadata{},
		IstioVersion: &model.IstioVersion{Major: 1, Minor: 5},
	}
	push := model.NewPushContext()
	for _, test := range tests {
		t.Run(test.name, func(t *testing.T) {