t.Error("Invalid forceReset")
				}
			},
		},
		{
			name: "dryRun configured in the config file only",
			flags: map[string]string{
				options.CfgPath: configFilePath,
			},
			validate: func(t *testing.T, data *resetData) {
				if data.dryRun != true {
					t.Error("Invalid dryRun")
				}
			},
		},
		{
			name: "--cert-dir flag is not allowed to mix with config",

	// TODO: think of a better place to move this call - e.g. a hidden phase.
	if data.DryRun() {
		if err := dryrunutil.PrintFilesIfDryRunning(true /* needPrintManifest */, data.ManifestDir(), data.OutputWriter()); err != nil {
			return errors.Wrap(err, "error printing files on dryrun")
		}
	}

	// Both Wait* calls below use a /healthz endpoint, thus a client without permissions works fine

}

func writeFiles(dir string, files map[string]string, dryRun bool) {
	defer logRuntime(time.Now(), "Done writing files for dir %v", dir)
	for fname, text := range files {
		writeFile(filepath.Join(dir, fname), text, dryRun)
	}
}

func writeFile(path, text string, dryRun bool) {
	if dryRun {
		return
	}
	if strings.TrimSpace(text) == "" {

func RenderToDir(manifests name.ManifestMap, outputDir string, dryRun bool, l clog.Logger) error {
	l.LogAndPrintf("Component dependencies tree: \n%s", helmreconciler.InstallTreeString())
	l.LogAndPrintf("Rendering manifests to output dir %s", outputDir)
	return renderRecursive(manifests, helmreconciler.InstallTree, outputDir, dryRun, l)
}

}

func (al *Allocators) txnAllocClusterIPs(service *api.Service, dryRun bool) (transaction, error) {
	// clusterIPs that were allocated may need to be released in case of
	// failure at a higher level.
	allocated, err := al.allocClusterIPs(service, dryRun)
	if err != nil {
		return nil, err
	}

	txn := callbackTransaction{
		revert: func() {
			if dryRun {
				return
			}

type applyOptions struct {
	// Path to the kubeconfig file.
	Kubeconfig string
	// ComponentName of the kubeconfig context to use.
	Context string
	// DryRun performs all steps except actually applying the manifests or creating output dirs/files.
	DryRun bool
	// Maximum amount of time to wait for resources to be ready after install when Wait=true.
	WaitTimeout time.Duration
}

		Run:     runKubeletStart,
		InheritFlags: []string{
			options.CfgPath,
			options.ImageRepository,
			options.NodeCRISocket,
			options.NodeName,
			options.Patches,
			options.DryRun,
		},
	}
}

// runKubeletStart executes kubelet start logic.
func runKubeletStart(c workflow.RunData) error {
	data, ok := c.(InitData)
	if !ok {

)

type RootArgs struct {
	// DryRun performs all steps except actually applying the manifests or creating output dirs/files.
	DryRun bool
}

func addFlags(cmd *cobra.Command, rootArgs *RootArgs) {
	cmd.PersistentFlags().BoolVarP(&rootArgs.DryRun, "dry-run", "",
		false, "Console/log output only, make no changes.")
}

	if _, err := isPrivileged.Check(); err != nil {
		return
	}
	testCases := []struct {
		name       string
		dryrun     bool
		patchesDir string
		errPattern string
		cfg        *kubeadmapi.InitConfiguration
	}{
		// Be careful that if the dryrun is set to false and the test is run on a live cluster, the kubelet config file might be overwritten.

			options.Patches,
			options.DryRun,
		}
	case "download-certs":
		flags = []string{
			options.CfgPath,
			options.ControlPlane,
			options.FileDiscovery,
			options.TokenDiscovery,
			options.TokenDiscoveryCAHash,
			options.TokenDiscoverySkipCAHash,
			options.TLSBootstrapToken,
			options.TokenStr,
			options.CertificateKey,
			options.DryRun,
		}
	case "certs":
		flags = []string{