cfg := data.InitCfg()
		dryRun := data.DryRun()

		// Write the configuration for the kubelet down to disk and print the generated manifests instead if dry-running.
		// If not dry-running, the kubelet config file will be backed up to /etc/kubernetes/tmp/ dir, so that it could be
		// recovered if there is anything goes wrong.
		err := upgrade.WriteKubeletConfigFiles(cfg, data.PatchesDir(), dryRun, data.OutputWriter())
		if err != nil {

		return &metav1.DeleteOptions{DryRun: options.DryRun}, nil
	}
	if len(eviction.DeleteOptions.DryRun) == 0 {
		eviction.DeleteOptions.DryRun = options.DryRun
		return eviction.DeleteOptions, nil
	}
	if len(options.DryRun) == 0 {
		return eviction.DeleteOptions, nil
	}

	if !reflect.DeepEqual(options.DryRun, eviction.DeleteOptions.DryRun) {

	}

	return &initData{
		cfg:                     cfg,
		certificatesDir:         cfg.CertificatesDir,
		skipTokenPrint:          initOptions.skipTokenPrint,
		dryRun:                  cmdutil.ValueFromFlagsOrConfig(cmd.Flags(), options.DryRun, cfg.DryRun, initOptions.dryRun).(bool),
		dryRunDir:               dryRunDir,
		kubeconfigDir:           initOptions.kubeconfigDir,
		kubeconfigPath:          initOptions.kubeconfigPath,

		cfg := data.InitCfg()
		client := data.Client()
		dryRun := data.DryRun()
		etcdUpgrade := data.EtcdUpgrade()
		renewCerts := data.RenewCerts()
		patchesDir := data.PatchesDir()

		// Upgrade the control plane and etcd if installed on this node
		fmt.Printf("[upgrade] Upgrading your Static Pod-hosted control plane instance to version %q...\n", cfg.KubernetesVersion)
		if dryRun {
			return upgrade.DryRunStaticPodUpgrade(patchesDir, cfg)

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

		t.Errorf("The first join condition is over written instead of combining")
	}
}

func TestToSQL(t *testing.T) {
	// By default DB.DryRun should false
	if DB.DryRun {
		t.Fatal("Failed expect DB.DryRun to be false")
	}

	if DB.Dialector.Name() == "sqlserver" {
		t.Skip("Skip SQL Server for this test, because it too difference with other dialects.")
	}

	dryRunDir := ""
	if opt.dryRun || cfg.DryRun {
		if dryRunDir, err = kubeadmconstants.CreateTempDirForKubeadm("", "kubeadm-join-dryrun"); err != nil {
			return nil, errors.Wrap(err, "couldn't create a temporary directory on dryrun")
		}
	}

	return &joinData{
		cfg:                   cfg,
		dryRun:                cmdutil.ValueFromFlagsOrConfig(cmd.Flags(), options.DryRun, cfg.DryRun, opt.dryRun).(bool),

func GetKubeletDir(dryRun bool) (string, error) {
	if dryRun {
		return kubeadmconstants.CreateTempDirForKubeadm("", "kubeadm-upgrade-dryrun")
	}
	return kubeadmconstants.KubeletRunDirectory, nil

        this.filter = filter;
        this.objects = objects;
        this.testTaskTemporaryDir = testTaskTemporaryDir;
        this.htmlReport = htmlReport;
        this.options = options;
        this.detector = new TestNGDetector(new ClassFileExtractionManager(testTaskTemporaryDir));
        this.dryRun = dryRun;

        conventionMapOutputDirectory(options, htmlReport);

		return err
	}

	return nil
}

// newControlPlaneWaiter returns a new waiter that is used to wait on the control plane to boot up.
func newControlPlaneWaiter(dryRun bool, timeout time.Duration, client clientset.Interface, out io.Writer) (apiclient.Waiter, error) {
	if dryRun {
		return dryrunutil.NewWaiter(), nil
	}
	return apiclient.NewKubeWaiter(client, timeout, out), nil