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)
			}
			actual := strings.Contains(stderr, "could not find officially supported version of etcd")

		{"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,
					actual,
					rt.expected,
					(actual == nil),
				)
			}
		})
	}

func (rt *RTimedMetrics) addsize(size int64, err error) {
	// failures seen since uptime
	atomic.AddInt64(&rt.SinceUptime.Bytes, size)
	atomic.AddInt64(&rt.SinceUptime.Count, 1)
	rt.LastMinute.addsize(size)
	rt.LastHour.addsize(size)
	if err != nil && minio.ToErrorResponse(err).Code == "AccessDenied" {
		if rt.ErrCounts == nil {
			rt.ErrCounts = make(map[string]int)
		}
		rt.ErrCounts["AccessDenied"]++
	}
}

[dryrun] Resource name: "my-pod"
`),
		},
	}
	for _, rt := range tests {
		t.Run(rt.name, func(t *testing.T) {
			rt.buf = bytes.NewBufferString("")
			logDryRunAction(rt.action, rt.buf, DefaultMarshalFunc)
			actualBytes := rt.buf.Bytes()

			if !bytes.Equal(actualBytes, rt.expectedBytes) {
				t.Errorf(
					"failed LogDryRunAction:\n\texpected bytes: %q\n\t  actual: %q",
					rt.expectedBytes,
					actualBytes,
				)
			}

				    unsafeSkipCAVerification: true
				  timeout: 5m0s
				  tlsBootstrapToken: abcdef.0123456789abcdef
			`),
		},
	}

	for _, rt := range tests {
		t.Run(rt.name, func(t2 *testing.T) {
			cfgPath := filepath.Join(tmpdir, rt.name)
			err := os.WriteFile(cfgPath, []byte(rt.fileContents), 0644)
			if err != nil {
				t.Errorf("Couldn't create file: %v", err)
				return
			}

	}

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

  $result.on("mousedown", "a.link", function(e) {
    var docId = $(this).attr("data-id"),
      rt = $("#rt").val(),
      queryId = $("#queryId").val(),
      order = $(this).attr("data-order"),
      url = $(this).attr("href"),
      buf = [],
      hashIndex,
      hashStr;
    buf.push(contextPath);
    buf.push("/go/?rt=");
    buf.push(rt);
    buf.push("&docId=");
    buf.push(docId);
    buf.push("&queryId=");

	mapVal.AddField(nested)
	//rule := rt.ConvertToRule(testValue(t, 11, mapVal))
	//if rule == nil {
	//	t.Error("map could not be converted to rule")
	//}
	//if rule.GetID() != 11 {
	//	t.Errorf("got %d as the rule id, wanted 11", rule.GetID())
	//}
	//ruleVal := rt.NativeToValue(rule)
	//if ruleVal == nil {
	//	t.Error("got CEL rule value of nil, wanted non-nil")
	//}

	opts, err := rt.EnvOptions(stdEnv.TypeProvider())

				"line 2\n" +
				"### SEE ALSO\n" +
				"line 3",
			expectedMarkdown: "line 2\n",
		},
	}
	for _, rt := range tests {
		actual := cleanupForInclude(rt.markdown)
		if actual != rt.expectedMarkdown {
			t.Errorf(
				"failed cleanupForInclude:\n\texpected: %s\n\t  actual: %s",
				rt.expectedMarkdown,
				actual,
			)
		}
	}

				},
			},
			expect: false,
		},
	}
	for _, rt := range tests {
		t.Run(rt.name, func(t *testing.T) {
			config := rt.d
			config.Timeouts = &kubeadm.Timeouts{
				Discovery: &metav1.Duration{Duration: 1 * time.Minute},
			}
			_, actual := For(&config)
			if (actual == nil) != rt.expect {
				t.Errorf(
					"failed For:\n\texpected: %t\n\t  actual: %t",
					rt.expect,
					(actual == nil),
				)
			}
		})
	}