if len(s.controlPlaneTopology) != len(clusterConfigs) {
			return nil, fmt.Errorf("istio.test.kube.controlPlaneTopology has %d entries but there are %d clusters", len(controlPlaneTopology), len(clusterConfigs))
		}
		for src, dst := range s.controlPlaneTopology {
			clusterConfigs[src].PrimaryClusterName = clusterConfigs[dst].Name
		}
	}
	if s.configTopology != nil {
		if len(s.configTopology) != len(clusterConfigs) {

	// hold networkTopology from command line to parse later
	networkTopology string
	// hold configTopology from command line to parse later
	configTopology string
	// file defining all types of topology
	clusterConfigs configsVal
)

// NewSettingsFromCommandLine returns Settings obtained from command-line flags.
// config.Parse must be called before calling this function.
func NewSettingsFromCommandLine() (*Settings, error) {

`)
		}
	}()
	scopes.Framework.Infof("Test Framework Kubernetes environment Settings:\n%s", s)
	e := &Environment{
		ctx: ctx,
		s:   s,
	}
	e.id = ctx.TrackResource(e)

	configs, err := s.clusterConfigs()
	if err != nil {
		return nil, err
	}
	clusters, err := buildClusters(configs)
	if err != nil {
		return nil, err
	}
	e.clusters = clusters

	return e, nil
}

}

func makeSecret(namespace string, secret string, clusterConfigs ...clusterCredential) *v1.Secret {
	s := &v1.Secret{
		ObjectMeta: metav1.ObjectMeta{
			Name:      secret,
			Namespace: namespace,
			Labels: map[string]string{
				MultiClusterSecretLabel: "true",
			},
		},
		Data: map[string][]byte{},
	}

	for _, config := range clusterConfigs {
		s.Data[config.clusterID] = config.kubeconfig
	}
	return s

	}

	// load the default cluster config
	_, clusterConfig := kubeconfigutil.GetClusterFromKubeConfig(config)
	if clusterConfig == nil {
		return "", errors.New("failed to get default cluster config")
	}

	// load CA certificates from the kubeconfig (either from PEM data or by file path)
	var caCerts []*x509.Certificate
	if clusterConfig.CertificateAuthorityData != nil {

}

type clusterConfig struct {
	configBase
	config kubeadmapiv1.ClusterConfiguration
}

func (cc *clusterConfig) DeepCopy() kubeadmapi.ComponentConfig {
	result := &clusterConfig{}
	cc.configBase.DeepCopyInto(&result.configBase)
	cc.config.DeepCopyInto(&result.config)
	return result
}

func (cc *clusterConfig) Marshal() ([]byte, error) {

	storagetesting.RunTestWatchInitializationSignal(ctx, t, store)
}

func TestProgressNotify(t *testing.T) {
	clusterConfig := testserver.NewTestConfig(t)
	clusterConfig.ExperimentalWatchProgressNotifyInterval = time.Second
	ctx, store, _ := testSetup(t, withClientConfig(clusterConfig))

	storagetesting.RunOptionalTestProgressNotify(ctx, t, store)
}

// TestWatchDispatchBookmarkEvents makes sure that

	}

	for _, m := range migrations {
		t.Run(m.title, func(t *testing.T) {
			start := mustParseEtcdVersionPair(m.startVersion)
			end := mustParseEtcdVersionPair(m.endVersion)

			testCfgs := clusterConfig(t, m.title, m.memberCount, m.protocol, m.clientListenUrls)

			servers := []*EtcdMigrateServer{}
			for _, cfg := range testCfgs {
				client, err := NewEtcdMigrateClient(cfg)
				if err != nil {

						ClusterType: &envoy_cluster.Cluster_CustomClusterType{
							Name: "envoy.clusters.dynamic_forward_proxy",
							TypedConfig: protoconv.MessageToAny(&envoy_clusters_dynamic_forward_proxy.ClusterConfig{
								ClusterImplementationSpecifier: &envoy_clusters_dynamic_forward_proxy.ClusterConfig_DnsCacheConfig{
									DnsCacheConfig: dynamicForwardProxyCacheConfig,
								},
							}),
						},
					},
				},