m:        mesh.DefaultMeshConfig(),
			host:     "s.kube-system.svc.cluster.local",
			expected: true,
		},
		{
			name:     "api server local is local",
			m:        mesh.DefaultMeshConfig(),
			host:     "kubernetes.default.svc.cluster.local",
			expected: true,
		},
		{
			name:     "discovery server is local",
			m:        mesh.DefaultMeshConfig(),

	"istio.io/istio/pkg/config/validation/agent"
	"istio.io/istio/pkg/test/util/assert"
	"istio.io/istio/pkg/util/protomarshal"
)

func TestApplyProxyConfig(t *testing.T) {
	config := mesh.DefaultMeshConfig()
	defaultDiscovery := config.DefaultConfig.DiscoveryAddress

	t.Run("apply single", func(t *testing.T) {
		mc, err := mesh.ApplyProxyConfig("discoveryAddress: foo", config)
		if err != nil {
			t.Fatal(err)
		}

}

func TestMultiWatcherShouldNotifyHandlers(t *testing.T) {
	watcherShouldNotifyHandlers(t, true)
}

func watcherShouldNotifyHandlers(t *testing.T, multi bool) {
	path := newTempFile(t)

	m := mesh.DefaultMeshConfig()
	writeMessage(t, path, m)

	w := newWatcher(t, path, multi)
	assert.Equal(t, w.Mesh(), m)

	doneCh := make(chan struct{}, 1)

	var newM *meshconfig.MeshConfig
	w.AddMeshHandler(func() {

	client.RunAndWait(stop)

	var mu sync.Mutex
	newM := mesh.DefaultMeshConfig()
	w.AddMeshHandler(func() {
		mu.Lock()
		defer mu.Unlock()
		newM = w.Mesh()
	})

	steps := []struct {
		added   *v1.ConfigMap
		updated *v1.ConfigMap
		deleted *v1.ConfigMap

		expect *meshconfig.MeshConfig
	}{
		{expect: mesh.DefaultMeshConfig()},
		{added: cm, expect: m},

func NewConfigMapWatcher(client kube.Client, namespace, name, key string, multiWatch bool, stop <-chan struct{}) *mesh.MultiWatcher {
	w := mesh.NewMultiWatcher(mesh.DefaultMeshConfig())
	c := configmapwatcher.NewController(client, namespace, name, func(cm *v1.ConfigMap) {
		meshNetworks, err := ReadNetworksConfigMap(cm, "meshNetworks")
		if err != nil {

)

func TestTelemetryMetricsExhaustiveness(t *testing.T) {
	AssertProvidersHandled(telemetryFilterHandled)
}

func TestMergeMetrics(t *testing.T) {
	withoutMetricsProviders := mesh.DefaultMeshConfig()
	withMetricsProviders := mesh.DefaultMeshConfig()
	withMetricsProviders.DefaultProviders = &meshconfig.MeshConfig_DefaultProviders{
		Metrics: []string{"prometheus"},
	}

	enablePrometheus := &tpb.Metrics{

	g := NewWithT(t)

	sa := NewSourceAnalyzer(blankCombinedAnalyzer, "", "", nil)

	src := model.NewFakeStore()
	sa.AddSource(dfCache{ConfigStore: src})
	assert.Equal(t, sa.meshCfg, mesh.DefaultMeshConfig()) // Base default meshcfg
	g.Expect(sa.meshNetworks.Networks).To(HaveLen(0))
	g.Expect(sa.stores).To(HaveLen(1))
}

func TestAddRunningKubeSource(t *testing.T) {
	g := NewWithT(t)

// By default, it is empty.
func DefaultMeshNetworks() *meshconfig.MeshNetworks {
	return ptr.Of(EmptyMeshNetworks())
}

// DefaultMeshConfig returns the default mesh config.
// This is merged with values from the mesh config map.
func DefaultMeshConfig() *meshconfig.MeshConfig {
	proxyConfig := DefaultProxyConfig()

	// Defaults matching the standard install
	// order matches the generated mesh config.

				Status: v1.NodeStatus{},
			})
			nodes := kclient.New[*v1.Node](fc)
			fc.RunAndWait(test.NewStop(t))
			cc := &Controller{
				nodes:       nodes,
				meshWatcher: mesh.NewFixedWatcher(mesh.DefaultMeshConfig()),
				networkManager: &networkManager{
					clusterID: c.ctl.cluster,
					network:   c.ctl.network,
				},
				opts: Options{ClusterID: c.ctl.cluster},
			}
			eb := cc.NewEndpointBuilder(&pod)

			}
			ordered := []config.Config{}
			for _, v := range cfgs {
				ordered = append(ordered, *v)
			}
			for _, obj := range input {
				ingress := obj.(*knetworking.Ingress)
				m := mesh.DefaultMeshConfig()
				gws := ConvertIngressV1alpha3(*ingress, m, "mydomain")
				ordered = append(ordered, gws)
			}

			sort.Slice(ordered, func(i, j int) bool {
				return ordered[i].Name < ordered[j].Name
			})