cliflag "k8s.io/component-base/cli/flag"
	"k8s.io/klog/v2"

	"k8s.io/kubernetes/cmd/kubeadm/app/cmd"
)

// Run creates and executes new kubeadm command
func Run() error {
	var allFlags flag.FlagSet
	klog.InitFlags(&allFlags)
	// only add the flags that are still supported for kubeadm
	allFlags.VisitAll(func(f *flag.Flag) {
		switch f.Name {
		case "v", "add_dir_header", "skip_headers":
			flag.CommandLine.Var(f.Value, f.Name, f.Usage)

)

// KlogVerboseFlag returns verbose flag from the klog library.
// After parsing it contains the parsed verbosity value.
func klogVerboseFlag() *goflag.Flag {
	klogFlagSetOnce.Do(func() {
		klog.InitFlags(klogFlagSet)
	})
	// --v= flag of klog.
	return klogFlagSet.Lookup("v")
}

// EnableKlogWithVerbosity sets the klog verbosity directly.

)

//nolint:logcheck // Several functions are normally not okay in a package.
func ExampleHandleErrorWithContext() {
	state := klog.CaptureState()
	defer state.Restore()
	var fs flag.FlagSet
	klog.InitFlags(&fs)
	for flag, value := range map[string]string{
		"one_output":  "true",
		"logtostderr": "false",
	} {
		if err := fs.Set(flag, value); err != nil {
			fmt.Printf("Unexpected error configuring klog: %v", err)

	if leaderelection.Changed("leader-elect-resource-namespace") {
		cfg.LeaderElection.ResourceNamespace = o.LeaderElection.ResourceNamespace
	}

	o.ComponentConfig = cfg
}

// initFlags initializes flags by section name.
func (o *Options) initFlags() {
	if o.Flags != nil {
		return
	}

	nfs := cliflag.NamedFlagSets{}
	fs := nfs.FlagSet("misc")

	"k8s.io/klog/v2"
	"k8s.io/kubernetes/pkg/volume"
)

// TestMain starting point for all tests.
// Surfaces klog flags by default to enable
// go test -v ./ --args <klog flags>
func TestMain(m *testing.M) {
	klog.InitFlags(flag.CommandLine)
	os.Exit(m.Run())
}

func makeTestPVWithMountOptions(name string, sizeGig int, driverName, volID string, mountOptions []string) *api.PersistentVolume {
	pv := makeTestPV(name, sizeGig, driverName, volID)

	"k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/promise"
	testeventclock "k8s.io/apiserver/pkg/util/flowcontrol/fairqueuing/testing/eventclock"
	"k8s.io/klog/v2"
)

func TestMain(m *testing.M) {
	klog.InitFlags(nil)
	os.Exit(m.Run())
}

func TestCountingWriteOnceSet(t *testing.T) {
	oldTime := time.Now()
	cval := &oldTime
	doneCh := make(chan struct{})
	now := time.Now()

	conflictingClaim      = makePVC(testPodName+"-"+ephemeralVolumeName, testNamespace, nil)
	otherNamespaceClaim   = makePVC(testPodName+"-"+ephemeralVolumeName, otherNamespace, nil)
)

func init() {
	klog.InitFlags(nil)
}

func TestSyncHandler(t *testing.T) {
	tests := []struct {
		name            string
		podKey          string
		pvcs            []*v1.PersistentVolumeClaim
		pods            []*v1.Pod

	"k8s.io/kubernetes/pkg/kubelet/pluginmanager/cache"
)

var (
	supportedVersions = []string{"v1beta1", "v1beta2"}
)

func init() {
	var logLevel string

	klog.InitFlags(flag.CommandLine)
	flag.Set("alsologtostderr", fmt.Sprintf("%t", true))
	flag.StringVar(&logLevel, "logLevel", "6", "test")
	flag.Lookup("v").Value.Set(logLevel)
}

func initTempDir(t *testing.T) string {

	testVersionPrevious   = &EtcdVersion{semver.MustParse("3.0.17")}
	testVersionLatest     = &EtcdVersion{semver.MustParse("3.1.12")}
)

func init() {
	// Enable klog which is used in dependencies
	klog.InitFlags(nil)
	flag.Set("logtostderr", "true")
	flag.Set("v", "9")
}

func TestMigrate(t *testing.T) {
	migrations := []struct {
		title            string
		memberCount      int
		startVersion     string

				t.Fatal(err)
			}
		})
	}
}

func TestLogTransformErr(t *testing.T) {
	klog.InitFlags(nil)
	tests := []struct {
		name        string
		ctx         context.Context
		err         error
		message     string
		expectedLog string
	}{
		{
			name: "log error with request info",