kubeconfig, err := clientcmd.LoadFromFile(kubeconfigPath)
	if err != nil {
		return errors.Wrapf(err, "could not load %q", kubeconfigPath)
	}

	// Perform basic validation. The errors here can only happen if the kubelet.conf was corrupted.
	if len(kubeconfig.CurrentContext) == 0 {
		return errors.Errorf("the file %q does not have current context set", kubeconfigPath)
	}

		return nil, err
	}

	kubeconfigPath := cfg.Meta.String(kubeconfigMetaKey)
	kubeconfigPath, err = file.NormalizePath(kubeconfigPath)
	if err != nil {
		return nil, err
	}

	var client istioKube.CLIClient
	if len(cfg.HTTPProxy) > 0 {
		proxyURL, err := url.Parse(cfg.HTTPProxy)
		if err != nil {
			return nil, err
		}
		client, err = buildClientWithProxy(kubeconfigPath, proxyURL)
		if err != nil {

// should stop immediately.
func isClientConfigStillValid(kubeconfigPath string) (bool, error) {
	_, err := os.Stat(kubeconfigPath)
	if os.IsNotExist(err) {
		return false, nil
	}
	if err != nil {
		return false, fmt.Errorf("error reading existing bootstrap kubeconfig %s: %v", kubeconfigPath, err)
	}
	bootstrapClientConfig, err := loadRESTClientConfig(kubeconfigPath)
	if err != nil {

			want: []string{options.CfgPath,
				options.KubeconfigPath,
				options.KubernetesVersion,
				options.ImageRepository,
				options.DryRun,
				options.APIServerAdvertiseAddress,
				options.ControlPlaneEndpoint,
				options.APIServerBindPort,
				options.NetworkingPodSubnet,
			},
		}, {
			name: "coredns",
			want: []string{options.CfgPath,
				options.KubeconfigPath,
				options.KubernetesVersion,

	}))
	defer server.Close()

	kubeconfigPath := filepath.Join(tmpDir, "config.kubeconfig")
	if err := os.WriteFile(kubeconfigPath, []byte(fmt.Sprintf(fakeKubeconfig, server.URL)), os.FileMode(0600)); err != nil {
		t.Fatal(err)
	}

	for morph := range knownMorphs {
		morph := morph
		t.Run(morph, func(t *testing.T) {
			s := &hollowNodeConfig{
				KubeconfigPath: kubeconfigPath,
				Morph:          morph,
			}

	if _, err := os.Stat(filepath); os.IsNotExist(err) {
		isControlPlaneNode = false
	}
	if len(nodeOptions.kubeConfigPath) == 0 {
		// Update the kubeconfig path depending on whether this is a control plane node or not.
		nodeOptions.kubeConfigPath = constants.GetKubeletKubeConfigPath()
		if isControlPlaneNode {
			nodeOptions.kubeConfigPath = constants.GetAdminKubeConfigPath()
		}
	}

	externalCfg := &v1beta4.UpgradeConfiguration{}

	timeout := cfg.Timeouts.Discovery.Duration
	switch {
	case cfg.Discovery.File != nil:
		kubeConfigPath := cfg.Discovery.File.KubeConfigPath
		if isHTTPSURL(kubeConfigPath) {
			return https.RetrieveValidatedConfigInfo(kubeConfigPath, timeout)
		}
		return file.RetrieveValidatedConfigInfo(kubeConfigPath, timeout)
	case cfg.Discovery.BootstrapToken != nil:
		return token.RetrieveValidatedConfigInfo(&cfg.Discovery, timeout)

	kubeadmconstants "k8s.io/kubernetes/cmd/kubeadm/app/constants"
)

// applyPlanFlags holds the values for the common flags in `kubeadm upgrade apply` and `kubeadm upgrade plan`
type applyPlanFlags struct {
	kubeConfigPath            string
	cfgPath                   string
	featureGatesString        string
	allowExperimentalUpgrades bool
	allowRCUpgrades           bool
	printConfig               bool
	ignorePreflightErrors     []string

	if err != nil {
		t.Fatal(err)
	}
	defer os.Remove(testUpgradeDiffManifest)

	kubeConfigPath, err := createTestRunDiffFile([]byte(testConfigToken))
	if err != nil {
		t.Fatal(err)
	}
	//nolint:errcheck
	defer os.Remove(kubeConfigPath)

	flags := &diffFlags{
		cfgPath: "",
		out:     io.Discard,
	}

	testCases := []struct {
		name            string

	if err != nil {
		return err
	}
	client, err := kubeconfigutil.ClientSetFromFile(flags.kubeConfigPath)
	if err != nil {
		return errors.Wrapf(err, "couldn't create a Kubernetes client from file %q", flags.kubeConfigPath)
	}
	initCfg, err := fetchInitConfigurationFromCluster(client, &output.TextPrinter{}, "upgrade/diff", false, true)
	if err != nil {
		return err
	}