}

# Setup default values
CLUSTERNAME="cluster1"
K8SRELEASE=""
IPSPACE=255
IPFAMILY="ipv4"
MODE="sidecar"
NUMNODES=""
PODSUBNET=""
SERVICESUBNET=""
IPV6GW=false

# Handling parameters
while [[ $# -gt 0 ]]; do
  optkey="$1"
  case $optkey in
    -n|--cluster-name)
      CLUSTERNAME="$2"; shift 2;;
    -r|--k8s-release)

    private final int status;

    private final String clusterName;

    private final String clusterStatus;

    private String message = StringUtil.EMPTY;

    public PingResponse(final ClusterHealthResponse response) {
        status = response.getStatus() == ClusterHealthStatus.RED ? 1 : 0;
        clusterName = response.getClusterName();
        clusterStatus = response.getStatus().toString();

		eb = endpoints.NewCDSEndpointBuilder(
			proxy,
			cb.req.Push,
			clusterName,
			model.TrafficDirectionOutbound, "", service.Hostname, port.Port,
			service, dr,
		)
	}
	return clusterCache{
		clusterName:     clusterName,
		proxyVersion:    cb.proxyVersion,
		locality:        cb.locality,
		proxyClusterID:  cb.clusterID,

	// with a well known value of clusterName (in this case `foo`)
	currentFooClusterConfig = fmt.Sprintf(`
		apiVersion: %s
		kind: ClusterConfiguration
		clusterName: foo
	`, kubeadmapiv1.SchemeGroupVersion)

	// oldFooClusterConfig is a minimal unsupported ClusterConfiguration
	// with a well known value of clusterName (in this case `foo`)
	oldFooClusterConfig = fmt.Sprintf(`

		APIVersion:  "v1",
		Preferences: api.Preferences{},
		Clusters: map[string]*api.Cluster{
			clusterName: newCluster(&c.restConfig),
		},
		AuthInfos: map[string]*api.AuthInfo{
			authInfoName: newAuthInfo(&c.restConfig),
		},
		Contexts: map[string]*api.Context{
			contextName: {
				Cluster:  clusterName,
				AuthInfo: authInfoName,
			},
		},
		CurrentContext: contextName,
	}

	return cfg, nil
}

					TransportApiVersion:       core.ApiVersion_V3,
					GrpcServices: []*core.GrpcService{
						{
							TargetSpecifier: &core.GrpcService_EnvoyGrpc_{
								EnvoyGrpc: &core.GrpcService_EnvoyGrpc{ClusterName: SDSClusterName},
							},
						},
					},
				},
			},
			ResourceApiVersion:  core.ApiVersion_V3,
			InitialFetchTimeout: durationpb.New(time.Second * 0),
		},
	}

}

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
	src := file.NewKubeSource(collections.All)
	for i, yamlFile := range yamls {
		data, err := os.ReadFile(yamlFile)

func buildInsecureBootstrapKubeConfig(endpoint, clustername string) *clientcmdapi.Config {
	controlPlaneEndpoint := fmt.Sprintf("https://%s", endpoint)
	bootstrapConfig := kubeconfigutil.CreateBasic(controlPlaneEndpoint, clustername, BootstrapUser, []byte{})
	bootstrapConfig.Clusters[clustername].InsecureSkipTLSVerify = true
	return bootstrapConfig
}

	}
	for clusterName, manifests := range i.manifests {
		clusterDir := path.Join(manifestsDir, clusterName)
		if err := os.Mkdir(manifestsDir, 0o700); err != nil {
			scopes.Framework.Errorf("Unable to create directory for dumping %s install manifests: %v", clusterName, err)
		}
		for i, manifest := range manifests {

	// and their corresponding line numbers as values
	FieldMap() map[string]int
	Comparator() string

	// ClusterName returns the cluster name where the resource is located
	ClusterName() cluster.ID
}

// Reference provides more information about an Origin. This is also source-implementation dependent.
type Reference interface {
	String() string