func (t *testData) DryRun() bool                            { return false }
func (t *testData) Cfg() *kubeadmapi.UpgradeConfiguration   { return nil }
func (t *testData) InitCfg() *kubeadmapi.InitConfiguration  { return nil }
func (t *testData) IsControlPlaneNode() bool                { return false }
func (t *testData) Client() clientset.Interface             { return nil }

		fuzzUpgradeConfiguration,
	}
}

func fuzzInitConfiguration(obj *kubeadm.InitConfiguration, c fuzz.Continue) {
	c.FuzzNoCustom(obj)

	// Pinning values for fields that get defaults if fuzz value is empty string or nil (thus making the round trip test fail)

	// Avoid round tripping the ClusterConfiguration embedded in the InitConfiguration, since it is
	// only present in the internal version and not in public versions

)

func addDefaultingFuncs(scheme *runtime.Scheme) error {
	return RegisterDefaults(scheme)
}

// SetDefaults_InitConfiguration assigns default values for the InitConfiguration
func SetDefaults_InitConfiguration(obj *InitConfiguration) {
	SetDefaults_BootstrapTokens(obj)
	SetDefaults_APIEndpoint(&obj.LocalAPIEndpoint)
	SetDefaults_NodeRegistration(&obj.NodeRegistration)
	if obj.Timeouts == nil {

	var tests = []struct {
		name     string
		s        *kubeadmapi.InitConfiguration
		expected bool
	}{
		{"invalid missing InitConfiguration",
			&kubeadmapi.InitConfiguration{}, false},
		{"invalid missing token with IPv4 service subnet",
			&kubeadmapi.InitConfiguration{
				LocalAPIEndpoint: kubeadmapi.APIEndpoint{
					AdvertiseAddress: "1.2.3.4",
					BindPort:         6443,

		# upload the configuration of your cluster
		kubeadm init phase upload-config --config=myConfig.yaml
		`)

	uploadKubeletConfigLongDesc = cmdutil.LongDesc(`
		Upload the kubelet configuration extracted from the kubeadm InitConfiguration object
		to a kubelet-config ConfigMap in the cluster
		`)

	uploadKubeletConfigExample = cmdutil.Examples(`
		# Upload the kubelet configuration from the kubeadm Config file to a ConfigMap in the cluster.

		}
	}

	return nil
}

// GetPathManagerForUpgrade returns a path manager properly configured for the given InitConfiguration.
func GetPathManagerForUpgrade(kubernetesDir, patchesDir string, internalcfg *kubeadmapi.InitConfiguration, etcdUpgrade bool) (StaticPodPathManager, error) {
	isExternalEtcd := internalcfg.Etcd.External != nil

// The "nodeData" type from "cmd/upgrade/node.go" must satisfy this interface.
type Data interface {
	EtcdUpgrade() bool
	RenewCerts() bool
	DryRun() bool
	Cfg() *kubeadmapi.UpgradeConfiguration
	InitCfg() *kubeadmapi.InitConfiguration
	IsControlPlaneNode() bool
	Client() clientset.Interface
	IgnorePreflightErrors() sets.Set[string]
	PatchesDir() string
	KubeConfigPath() string
	OutputWriter() io.Writer

}

// genCSRConfig is the configuration required by the gencsr command
type genCSRConfig struct {
	kubeadmConfigPath string
	certDir           string
	kubeConfigDir     string
	kubeadmConfig     *kubeadmapi.InitConfiguration
}

func newGenCSRConfig() *genCSRConfig {
	return &genCSRConfig{
		kubeConfigDir: kubeadmconstants.KubernetesDir,
	}
}

func (o *genCSRConfig) addFlagSet(flagSet *pflag.FlagSet) {

func (t *testInitData) SetCertificateKey(key string)                         {}
func (t *testInitData) SkipCertificateKeyPrint() bool                        { return false }
func (t *testInitData) Cfg() *kubeadmapi.InitConfiguration                   { return nil }
func (t *testInitData) DryRun() bool                                         { return false }
func (t *testInitData) SkipTokenPrint() bool                                 { return false }

// Note that the mark-control-plane phase is left out, not needed, and no token is created as that doesn't belong to the upgrade
func PerformPostUpgradeTasks(client clientset.Interface, cfg *kubeadmapi.InitConfiguration, patchesDir string, dryRun bool, out io.Writer) error {
	var errs []error

	// Upload currently used configuration to the cluster