if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
          val parameters = sslSocket.sslParameters
          val sni = parameters.serverNames
          Log.d("CustomSSLSocketFactory", "old SNI: $sni")
          parameters.serverNames = mutableListOf<SNIServerName>(SNIHostName("cloudflare-dns.com"))
          sslSocket.sslParameters = parameters
        }

        return sslSocket
      }
    }

		match = &listener.FilterChainMatch{}
	}
	// filterChaince also has SuffixLen, SourceType, SourcePrefixRanges which are not rendered.

	descrs := []string{}
	if len(match.ServerNames) > 0 {
		descrs = append(descrs, fmt.Sprintf("SNI: %s", strings.Join(match.ServerNames, ",")))
	}
	if len(match.TransportProtocol) > 0 {
		descrs = append(descrs, fmt.Sprintf("Trans: %s", match.TransportProtocol))
	}

							PortValue: 80,
						},
					},
				},
			},
			FilterChains: []*listener.FilterChain{
				{
					FilterChainMatch: &listener.FilterChainMatch{
						ServerNames: []string{"match.com", "*.foo.com"},
					},
					Filters: []*listener.Filter{
						{
							Name: wellknown.HTTPConnectionManager,
							ConfigType: &listener.Filter_TypedConfig{

			continue
		}
		if m.TransportProtocol == xdsfilters.TLSTransportProtocol {
			t.Errorf("transport protocol set, but missing tls inspector: %v", Dump(t, l))
		}
		if m.TransportProtocol == "" && len(m.ServerNames) > 0 {
			t.Errorf("server names set, but missing tls inspector: %v", Dump(t, l))
		}
		// This is a bit suspect; I suspect this could be done with just http inspector without tls inspector,

		if match.Name != fc.Name {
			return false
		}
	}
	if match.Sni != "" {
		if fc.FilterChainMatch == nil || len(fc.FilterChainMatch.ServerNames) == 0 {
			return false
		}
		sniMatched := false
		for _, sni := range fc.FilterChainMatch.ServerNames {
			if sni == match.Sni {
				sniMatched = true
				break
			}
		}
		if !sniMatched {
			return false
		}
	}

			}
		}
		f, err := ranger.Contains(net.ParseIP(input.Address))
		if err != nil {
			sim.t.Fatalf("cidr containers %v failed: %v", input.Address, err)
		}
		return f
	})
	chains = filter("ServerNames", chains, func(fc *listener.FilterChainMatch) bool {
		return fc.GetServerNames() == nil
	}, func(fc *listener.FilterChainMatch) bool {
		sni := host.Name(input.Sni)
		for _, s := range fc.GetServerNames() {

		if fc.FilterChainMatch == nil {
			t.Fatalf("expected filter chain match for chain %s to be set, found nil", fc.Name)
		}
		if len(fc.FilterChainMatch.ServerNames) == 0 {
			t.Fatalf("expected SNI to be set, found %v", fc.FilterChainMatch.ServerNames)
		}
	}
	log.Printf("Listeners: %v", listeners)
}

func TestOutboundListenerConfigWithSidecarHTTPProxy(t *testing.T) {
	sidecarConfig := &config.Config{

				break
			}
		}
		if !fullWildcardFound {
			chain.sniHosts = append([]string{}, chain.sniHosts...)
			sort.Stable(sort.StringSlice(chain.sniHosts))
			match.ServerNames = chain.sniHosts
		}
	}
	if len(chain.destinationCIDRs) > 0 {
		chain.destinationCIDRs = append([]string{}, chain.destinationCIDRs...)
		sort.Stable(sort.StringSlice(chain.destinationCIDRs))