}
	}
	l := &listener.Listener{
		Name:              MainInternalName,
		ListenerSpecifier: &listener.Listener_InternalListener{InternalListener: &listener.Listener_InternalListenerConfig{}},
		ListenerFilters: []*listener.ListenerFilter{
			xdsfilters.OriginalDestination,
			// TODO: This may affect the data path due to the server-first protocols triggering a time-out. Need exception filter.
			xdsfilters.HTTPInspector,
		},

					configdump.ClusterFilter{
						FQDN:      host.Name(fqdn),
						Port:      port,
						Subset:    subset,
						Direction: model.TrafficDirection(direction),
					},
					configdump.ListenerFilter{
						Address: address,
						Port:    uint32(port),
						Type:    listenerType,
						Verbose: verboseProxyConfig,
					},
					configdump.RouteFilter{
						Name:    routeName,

	filterChains := make([]*listener.FilterChain, 0, len(opts.filterChainOpts))
	var listenerFilters []*listener.ListenerFilter

	// Strip PROXY header first for non-QUIC traffic if requested.
	if opts.needPROXYProtocol {
		listenerFilters = append(listenerFilters, xdsfilters.ProxyProtocol)
	}

	// add a TLS inspector if we need to detect ServerName or ALPN

}

// Return the first HTTP Connection Manager config for the inbound port
func getInboundHTTPConnectionManager(cd *configdump.Wrapper, port int32) (*hcm.HttpConnectionManager, error) {
	filter := istio_envoy_configdump.ListenerFilter{
		Port: uint32(port),
	}
	listeners, err := cd.GetListenerConfigDump()
	if err != nil {
		return nil, err
	}

	for _, l := range listeners.DynamicListeners {
		if l.ActiveState == nil {

		} else {
			if !isHTTPFilterChain(l.FilterChains[0]) {
				t.Fatalf("expected http filter chain, found %s", l.FilterChains[1].Filters[0].Name)
			}
			if len(l.ListenerFilters) > 0 {
				t.Fatalf("expected %d listener filter, found %d", 0, len(l.ListenerFilters))
			}
		}
	}
}

func TestGetActualWildcardAndLocalHost(t *testing.T) {
	tests := []struct {
		name     string
		proxy    *model.Proxy

                      }
                    }
                  }
                }
              }
            }
          ]
        }
      ],
      "listener_filters": null
    },
    "127.0.0.1_2000": {
      "name": "127.0.0.1_2000",
      "address": {
        "Address": {
          "SocketAddress": {
            "address": "127.0.0.1",
            "PortSpecifier": {

	}
}

func VerifyListener(t test.Failer, l *listener.Listener, lt ListenerTest) {
	t.Helper()
	haveFilters := []string{}
	for _, lf := range l.ListenerFilters {
		haveFilters = append(haveFilters, lf.Name)
	}

	// Check ListenerFilters

	if lt.Filters != nil {
		if lt.TotalMatch {
			assert.Equal(t, lt.Filters, haveFilters, l.Name+": listener filters should be equal")
		} else {

                      }
                    }
                  }
                }
              }
            }
          ]
        }
      ],
      "listener_filters": null
    },
    "127.0.0.1_15002": {
      "name": "127.0.0.1_15002",
      "address": {
        "Address": {
          "SocketAddress": {
            "address": "127.0.0.1",

apiVersion: release-notes/v2
kind: feature
area: traffic-management
issue:
  - 41445
releaseNotes:
  - |

				clusterName:       "inbound|8888||",
				port: model.ServiceInstancePort{
					ServicePort: &model.Port{},
				},
			}

			listenerFilters := NewListenerBuilder(cg.SetupProxy(nil), cg.PushContext()).buildInboundNetworkFilters(fcc)
			tcp := &tcp.TcpProxy{}
			listenerFilters[len(listenerFilters)-1].GetTypedConfig().UnmarshalTo(tcp)
			if tcp.StatPrefix != tt.expectedStatPrefix {