args     string
		expected bool
	}{
		{"shell not expected", "", false},
		{"unsupported shell type", "foo", false},
	}

	for _, rt := range tests {
		t.Run(rt.name, func(t *testing.T) {
			_, _, _, actual := RunCmd(kubeadmPath, "completion", rt.args)
			if (actual == nil) != rt.expected {
				t.Errorf(
					"failed CmdCompletion running 'kubeadm completion %s' with an error: %v\n\texpected: %t\n\t  actual: %t",
					rt.args,

	// a singleton in the InitData methods (thus avoiding to initialize data
	// more than one time)
	runData RunData

	// runCmd is part of the internal state of the runner and it is used to track the
	// command that will trigger the runner (only if the runner is BindToCommand).
	runCmd *cobra.Command

	// cmdAdditionalFlags holds additional, shared flags that could be added to the subcommands generated

	kubeadmArgs := []string{"init", "--dry-run", "--ignore-preflight-errors=all"}
	kubeadmArgs = append(kubeadmArgs, args...)
	return RunCmd(kubeadmPath, kubeadmArgs...)
}

func getKubeadmVersion() *version.Version {
	kubeadmPath := getKubeadmPath()
	kubeadmArgs := []string{"version", "-o=short"}
	out, _, _, err := RunCmd(kubeadmPath, kubeadmArgs...)
	if err != nil {
		panic(fmt.Sprintf("could not run 'kubeadm version -o=short': %v", err))
	}

			args:     "--kubernetes-version=stable-1",
			expected: false,
		},
	}

	kubeadmPath := getKubeadmPath()
	for _, rt := range tests {
		t.Run(rt.name, func(t *testing.T) {
			_, stderr, _, err := RunCmd(kubeadmPath, "config", "images", "list", "--v=1", rt.args)
			if err != nil {
				t.Fatalf("failed to run 'kubeadm config images list --v=1 %s', err: %v", rt.args, err)
			}

				subTest.Run(child.runInternal)
			}
		}
	}
	tst.runEnd = time.Now()
}

func (tst *test) timeRange() timeRange {
	return timeRange{
		start: tst.runStart,
		end:   tst.cleanupEnd,
	}
}

func (tst *test) doCheck() error {
	// Make sure the component was closed after the test's run method exited.
	if tst.componentCloseStart.Before(tst.runEnd) {

	dir, err := os.MkdirTemp(c.workDir, name)
	if err != nil {
		scopes.Framework.Errorf("Error creating temp dir: runID='%s', prefix='%s', workDir='%v', err='%v'",
			c.settings.RunID, name, c.workDir, err)
	} else {
		scopes.Framework.Debugf("Created a temp dir: runID='%s', name='%s'", c.settings.RunID, dir)
	}
	return dir, err
}

// CreateTmpDirectory creates a new temporary directory with the given prefix.

)

func init() {
	base.AddBuildFlagsNX(&CmdFmt.Flag)
	base.AddChdirFlag(&CmdFmt.Flag)
	base.AddModFlag(&CmdFmt.Flag)
	base.AddModCommonFlags(&CmdFmt.Flag)
}

var CmdFmt = &base.Command{
	Run:       runFmt,
	UsageLine: "go fmt [-n] [-x] [packages]",
	Short:     "gofmt (reformat) package sources",
	Long: `
Fmt runs the command 'gofmt -l -w' on the packages named

    final AtomicInteger numCalls = new AtomicInteger();

    Runnable runMe =
        new Runnable() {
          @Override
          public void run() {
            numCalls.incrementAndGet();
            throw new RuntimeException("FAKE EXCEPTION!");
          }
        };

    e.execute(runMe);
    e.execute(runMe);
    fakePool.runAll();

    assertEquals(2, numCalls.get());
  }

    final AtomicInteger numCalls = new AtomicInteger();

    Runnable runMe =
        new Runnable() {
          @Override
          public void run() {
            numCalls.incrementAndGet();
            throw new RuntimeException("FAKE EXCEPTION!");
          }
        };

    e.execute(runMe);
    e.execute(runMe);
    fakePool.runAll();

    assertEquals(2, numCalls.get());
  }

		return results, fmt.Errorf("error running pods: %v", failedPods)
	}
	klog.InfoS("Pods started", "numPods", len(pods))
	return results, err
}

// runPod runs a single pod and waits until all containers are running.
func (kl *Kubelet) runPod(ctx context.Context, pod *v1.Pod, retryDelay time.Duration) error {
	var isTerminal bool
	delay := retryDelay
	retry := 0
	for !isTerminal {