@Override
                Void create() {
                    runPmd(ant, parameters)
                    return null
                }
            })
        } else {
            runPmd(ant, parameters)
        }
    }

    private static runPmd(AntBuilderDelegate ant, PmdActionParameters parameters) {

	}

	// Build a package in a mode not handled by the make script.
	runCmd(t, gorootSrc, env, goCmdPath, "build", "-race", "archive/tar")

	// Rebuild the toolchain with GOEXPERIMENT.
	env = append(env, "GOEXPERIMENT=fieldtrack")
	runCmd(t, gorootSrc, env, makeScriptPath)

	// Verify compiler version string.
	gotVersion = bytes.TrimSpace(runCmd(t, gorootSrc, env, goCmdPath, "tool", "compile", "-V=full"))

		cmdStr += " -o yaml"
	}
	out, err := p.Runner.RunCmd(cmdStr, "", p.KubeConfig, p.KubeContext, p.DryRun)
	return map[string]string{
		"secrets": out,
	}, err
}

// GetCRs returns CR contents for all CRDs in the cluster.
func GetCRs(p *Params) (map[string]string, error) {
	crds, err := getCRDList(p)
	if err != nil {
		return nil, err
	}

			names = append(names, name)
		}
	}
	sort.Strings(names)
	return names
}

type runCmd func(...string) ([]byte, error)

func compileFile(runcmd runCmd, longname string, flags []string) (out []byte, err error) {
	cmd := []string{goTool, "tool", "compile", "-e", "-p=p", "-importcfg=" + stdlibImportcfgFile()}
	cmd = append(cmd, flags...)

	cmd.Stdout = &bout
	cmd.Stderr = &berr
	err := cmd.Run()
	stdout, stderr := bout.String(), berr.String()
	return stdout, stderr, cmd.ProcessState.ExitCode(), err
}

// RunCmd is a utility function for kubeadm testing that executes a specified command
func RunCmd(command string, args ...string) (string, string, int, error) {
	stdout, stderr, retcode, err := runCmdNoWrap(command, args...)
	if err != nil {

	}
	return addrs
}

func TestInterfaceAddrsWithNetsh(t *testing.T) {
	checkNetsh(t)

	outIPV4, err := runCmd("netsh", "interface", "ipv4", "show", "address")
	if err != nil {
		t.Fatal(err)
	}
	outIPV6, err := runCmd("netsh", "interface", "ipv6", "show", "address", "level=verbose")
	if err != nil {
		t.Fatal(err)
	}

	ift, err := Interfaces()
	if err != nil {

	// 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) {