ClusterID:           "cluster1",
			DiscoveryController: memory.NewServiceDiscovery(),
		},
		{
			ProviderID:          "registry2",
			ClusterID:           "cluster2",
			DiscoveryController: memory.NewServiceDiscovery(),
		},
		{
			ProviderID:          provider.Kubernetes,
			ClusterID:           "cluster3",
			DiscoveryController: memory.NewServiceDiscovery(),
		},
	}
	ctrl := NewController(Options{})

		proxy := fuzz.Struct[*model.Proxy](fg)
		mesh := fuzz.Struct[*meshconfig.MeshConfig](fg)
		c := fuzz.Struct[*cluster.Cluster](fg)

		serviceDiscovery := memory.NewServiceDiscovery()
		env := newTestEnvironment(serviceDiscovery, mesh, buildEnvoyFilterConfigStore(patches))
		push := model.NewPushContext()
		push.InitContext(env, nil, nil)
		efw := push.EnvoyFilters(proxy)

		{
			name:                "only add extension config",
			requestedNames:      []string{"merge-extension-config"},
			wantExtensionConfig: []*core.TypedExtensionConfig{},
		},
	}

	serviceDiscovery := memory.NewServiceDiscovery()
	env := newTestEnvironment(serviceDiscovery, testMesh, buildEnvoyFilterConfigStore(configPatches))
	push := model.NewPushContext()
	push.InitContext(env, nil, nil)

	for _, c := range testCases {

	mutex sync.Mutex
}

var (
	_ model.Controller       = &ServiceDiscovery{}
	_ model.ServiceDiscovery = &ServiceDiscovery{}
)

// NewServiceDiscovery builds an in-memory ServiceDiscovery
func NewServiceDiscovery(services ...*model.Service) *ServiceDiscovery {
	svcs := map[host.Name]*model.Service{}
	for _, svc := range services {
		svcs[svc.Hostname] = svc
	}
	return &ServiceDiscovery{

			}
		})
	}
}

func buildEnvForClustersWithDistribute(distribute []*networking.LocalityLoadBalancerSetting_Distribute) *model.Environment {
	serviceDiscovery := memregistry.NewServiceDiscovery(&model.Service{
		Hostname:       "test.example.org",
		DefaultAddress: "1.1.1.1",
		Ports: model.PortList{
			&model.Port{
				Name:     "default",
				Port:     8080,
				Protocol: protocol.HTTP,

	}
	m, err := mesh.ApplyMeshConfigDefaults(configString)
	if err != nil {
		return 0
	}

	env := &model.Environment{}
	store := model.NewFakeStore()

	env.ConfigStore = store
	sd := memory.NewServiceDiscovery(services...)
	sd.WantGetProxyServiceTargets = slices.Map(serviceInstances, model.ServiceInstanceToTarget)
	env.ServiceDiscovery = sd

	env.Watcher = mesh.NewFixedWatcher(m)

		}
	})

	meshNetworks := mesh.NewFixedNetworksWatcher(nil)
	xdsUpdater := xdsfake.NewFakeXDS()
	env := &model.Environment{NetworksWatcher: meshNetworks, ServiceDiscovery: memory.NewServiceDiscovery()}
	if err := env.InitNetworksManager(xdsUpdater); err != nil {
		t.Fatal(err)
	}

	var gateways []model.NetworkGateway
	t.Run("initial resolution", func(t *testing.T) {

							},
						},
					},
					{
						Name: "route4.0",
					},
				},
			},
			{
				Name: "new-vhost",
			},
		},
	}

	serviceDiscovery := memory.NewServiceDiscovery()
	env := newTestEnvironment(serviceDiscovery, testMesh, buildEnvoyFilterConfigStore(configPatches))
	push := model.NewPushContext()
	push.InitContext(env, nil, nil)

			},
		},
		{
			Service: &model.Service{
				CreationTime: tnow,
				Hostname:     host.Name("test2.com"),
			},
		},
	}

	serviceDiscovery := memory.NewServiceDiscovery()
	serviceDiscovery.WantGetProxyServiceTargets = instances

	env := &model.Environment{
		ServiceDiscovery: serviceDiscovery,
	}

	proxy := &model.Proxy{}
	proxy.SetServiceTargets(env)

	clusterID := cluster.ID(fmt.Sprintf("cluster%d", networkNum))
	networkID := network.ID(fmt.Sprintf("network%d", networkNum))
	memRegistry := memory.NewServiceDiscovery()
	memRegistry.XdsUpdater = server.Discovery
	memRegistry.ClusterID = clusterID

	reg := serviceregistry.Simple{
		ClusterID:           clusterID,
		ProviderID:          provider.Mock,