})
	return m
}

func (m *Multicluster) ForCluster(clusterID cluster.ID) (credentials.Controller, error) {
	cc := m.component.ForCluster(clusterID)
	if cc == nil {
		return nil, fmt.Errorf("cluster %v is not configured", clusterID)
	}
	agg := &AggregateController{}
	agg.controllers = []*CredentialsController{}
	agg.authController = *cc
	if clusterID != m.configCluster {

	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,

		out[LabelTopologyRegion] = region
	}
	if len(zone) > 0 {
		out[LabelTopologyZone] = zone
	}
	if len(subzone) > 0 {
		out[label.TopologySubzone.Name] = subzone
	}
	if len(clusterID) > 0 {
		out[label.TopologyCluster.Name] = clusterID.String()
	}
	if len(k8sNode) > 0 {
		out[LabelHostname] = k8sNode
	}
	if len(networkID) > 0 {
		out[label.TopologyNetwork.Name] = networkID.String()
	}
	return out
}

	}

	if !cloud.HasClusterID() {
		if config.ComponentConfig.KubeCloudShared.AllowUntaggedCloud {
			klog.Warning("detected a cluster without a ClusterID.  A ClusterID will be required in the future.  Please tag your cluster to avoid any future issues")
		} else {
			klog.Fatalf("no ClusterID found.  A ClusterID is required for the cloud provider to function properly.  This check can be bypassed by setting the allow-untagged-cloud option")
		}
	}

	return sa, nil
}

type fakeClientImpl struct {
	kube.CLIClient
	clusterID cluster.ID
}

func (f *fakeClientImpl) ClusterID() cluster.ID {
	return f.clusterID
}

func addStore(sa *local.IstiodAnalyzer, clusterName string, yamls []string) error {
	client := &fakeClientImpl{
		CLIClient: kube.NewFakeClient(),
		clusterID: cluster.ID(clusterName),
	}
	// Gather test files

}

// Simple Instance implementation, where fields are set individually.
type Simple struct {
	ProviderID provider.ID
	ClusterID  cluster.ID

	DiscoveryController
}

func (r Simple) Provider() provider.ID {
	return r.ProviderID
}

func (r Simple) Cluster() cluster.ID {
	return r.ClusterID

	})

	return nil
}

// initKubeRegistry creates all the k8s service controllers under this pilot
func (s *Server) initKubeRegistry(args *PilotArgs) (err error) {
	args.RegistryOptions.KubeOptions.ClusterID = s.clusterID
	args.RegistryOptions.KubeOptions.Revision = args.Revision
	args.RegistryOptions.KubeOptions.Metrics = s.environment
	args.RegistryOptions.KubeOptions.XDSUpdater = s.XDSServer

					s := xds.NewFakeDiscoveryServer(t, fakeOpts)
					for clusterID := range want {
						p := s.SetupProxy(&model.Proxy{Metadata: &model.NodeMetadata{ClusterID: clusterID}})
						eps := xdstest.ExtractLoadAssignments(s.Endpoints(p))[tt.serviceCluster]
						if want := want[clusterID]; !slices.EqualUnordered(eps, want) {
							t.Errorf("got %v but want %v for %s", eps, want, clusterID)
						}
					}
				})
			}
		})
	}

			}
			cds, lds, eds, rds, ecds := getSyncStatus(&clientConfig)
			cp := multixds.CpInfo(dr)
			fullStatus = append(fullStatus, &xdsWriterStatus{
				proxyID:               clientConfig.GetNode().GetId(),
				clusterID:             meta.ClusterID.String(),
				istiodID:              cp.ID,
				istiodVersion:         meta.IstioVersion,
				clusterStatus:         cds,
				listenerStatus:        lds,
				routeStatus:           rds,

			expectedException: true,
			expectedOutput:    "Error: expecting a WorkloadGroup artifact file or the name and namespace of an existing WorkloadGroup\n",
		},
		{
			description:       "Invalid command args - missing valid input spec",
			args:              strings.Split("entry configure -n bar -o temp --clusterID cid", " "),
			expectedException: true,