desc       string
		inFilter   *ListenerFilter
		inListener *listener.Listener
		expect     bool
	}{
		{
			desc: "filter-fields-empty",
			inFilter: &ListenerFilter{
				Address: "",
				Port:    0,
				Type:    "",
			},
			inListener: &listener.Listener{},
			expect:     true,
		},
		{
			desc: "addrs-dont-match",
			inFilter: &ListenerFilter{
				Address: "0.0.0.0",
			},

				continue
			}
			lis.ListenerFilters, applied = insertBeforeFunc(
				lis.ListenerFilters,
				func(e *listener.ListenerFilter) (bool, *listener.ListenerFilter) {
					if listenerFilterMatch(e, lp) {
						return true, proto.Clone(lp.Value).(*listener.ListenerFilter)
					}
					return false, nil
				},
			)

const (
	Error   Result = "error"
	Applied Result = "applied"
)

type PatchType string

const (
	Cluster        PatchType = "cluster"
	Listener       PatchType = "listener"
	ListenerFilter PatchType = "listenerfilter"
	FilterChain    PatchType = "filterchain"
	NetworkFilter  PatchType = "networkfilter"
	// nolint
	HttpFilter  PatchType = "httpfilter"
	Route       PatchType = "route"
	VirtualHost PatchType = "vhost"

				},
			}),
		},
	}
	TLSInspector = &listener.ListenerFilter{
		Name: wellknown.TLSInspector,
		ConfigType: &listener.ListenerFilter_TypedConfig{
			TypedConfig: protoconv.MessageToAny(&tlsinspector.TlsInspector{}),
		},
	}
	HTTPInspector = &listener.ListenerFilter{
		Name: wellknown.HTTPInspector,
		ConfigType: &listener.ListenerFilter_TypedConfig{

			DefaultFilterChain: &listener.FilterChain{
				Filters: []*listener.Filter{
					{Name: "default-network-filter"},
					{Name: "default-network-filter-removed"},
				},
			},
			ListenerFilters: []*listener.ListenerFilter{
				{
					Name: "filter-to-be-removed",
				},
				{
					Name: "filter-before-replace",
				},
			},
		},
		{
			Name: "another-listener",
		},
		{

	}
	lb.authzBuilder = oldBuilder
	accessLogBuilder.setListenerAccessLog(lb.push, lb.node, l, istionetworking.ListenerClassSidecarInbound)
	l.ListenerFilters = append(l.ListenerFilters, xdsfilters.OriginalDestination)
	// TODO: Exclude inspectors from some inbound ports.
	l.ListenerFilters = append(l.ListenerFilters, populateListenerFilters(lb.node, l, true)...)
	return []*listener.Listener{terminate, l}
}

	IPMatcher = "type.googleapis.com/xds.type.matcher.v3.IPMatcher"
)

// ListenerFilter is used to pass filter information into listener based config writer print functions
type ListenerFilter struct {
	Address string
	Port    uint32
	Type    string
	Verbose bool
}

// Verify returns true if the passed listener matches the filter fields
func (l *ListenerFilter) Verify(listener *listener.Listener) bool {

	case networking.EnvoyFilter_EXTENSION_CONFIG:
		obj = &core.TypedExtensionConfig{}
	case networking.EnvoyFilter_BOOTSTRAP:
		obj = &bootstrap.Bootstrap{}
	case networking.EnvoyFilter_LISTENER_FILTER:
		obj = &listener.ListenerFilter{}
	default:
		return nil, fmt.Errorf("Envoy filter: unknown object type for applyTo %s", applyTo.String()) // nolint: stylecheck
	}

	if err := StructToMessage(value, obj, strict); err != nil {

	for _, l := range rc {
		res[l.Name] = l
	}
	return res
}

func ExtractListenerFilters(l *listener.Listener) map[string]*listener.ListenerFilter {
	res := map[string]*listener.ListenerFilter{}
	for _, lf := range l.ListenerFilters {
		res[lf.Name] = lf
	}
	return res
}

func ExtractFilterChain(name string, l *listener.Listener) *listener.FilterChain {

		return err
	}

	secretWriter := sdscompare.NewSDSWriter(c.Stdout, sdscompare.TABULAR)
	return secretWriter.PrintSecretItems(secretItems)
}

func (c *ConfigWriter) PrintFullSummary(cf ClusterFilter, lf ListenerFilter, rf RouteFilter, epf EndpointFilter) error {
	if err := c.PrintBootstrapSummary(); err != nil {
		return err
	}
	_, _ = c.Stdout.Write([]byte("\n"))
	if err := c.PrintClusterSummary(cf); err != nil {