}
	for _, rt := range tests {
		t.Run(rt.apiEndpoint, func(t *testing.T) {
			apiEndpoint, err := APIEndpointFromString(rt.apiEndpoint)
			if (err != nil) != rt.expectedErr {
				t.Errorf("expected error %v, got %v, error: %v", rt.expectedErr, err != nil, err)
			}
			if !reflect.DeepEqual(apiEndpoint, rt.expectedEndpoint) {
				t.Errorf("expected API endpoint: %v; got: %v", rt.expectedEndpoint, apiEndpoint)
			}
		})

					rt.args,
					actual,
					rt.expected,
					(actual == nil),
				)
			}

			if rt.expected {
				matched, err := regexp.MatchString(rt.regex, stdout)
				if err != nil {
					t.Fatalf("encountered an error while trying to match 'kubeadm version %s' stdout: %v", rt.args, err)
				}
				if !matched {
					t.Errorf("'kubeadm version %s' stdout did not match expected regex; wanted: [%q], got: [%s]", rt.args, rt.regex, stdout)

		},
	}

	for _, rt := range initTest {
		t.Run(rt.name, func(t *testing.T) {
			_, _, _, err := runKubeadmInit(t, rt.args)
			if (err == nil) != rt.expected {
				t.Fatalf(dedent.Dedent(`
					CmdInitToken test case %q failed with an error: %v
					command 'kubeadm init %s'
						expected: %t
						err: %t
					`),
					rt.name,
					err,
					rt.args,
					rt.expected,
					(err == nil),
				)

	}

	kubeadmPath := getKubeadmPath()
	for _, rt := range initTest {
		t.Run(rt.name, func(t *testing.T) {
			_, _, _, actual := RunCmd(kubeadmPath, "join", rt.args, "--ignore-preflight-errors=all")
			if (actual == nil) != rt.expected {
				t.Errorf(
					"failed CmdJoinConfig running 'kubeadm join %s' with an error: %v\n\texpected: %t\n\t  actual: %t",
					rt.args,
					actual,
					rt.expected,
					(actual == nil),
				)
			}

			expectedIdx:   -1,
			startIdx:      -1,
		},
	}

	for _, rt := range tests {
		t.Run(rt.testName, func(t *testing.T) {
			value, idx := GetArgValue(rt.args, rt.name, rt.startIdx)
			if idx != rt.expectedIdx {
				t.Errorf("expected index: %v, got: %v", rt.expectedIdx, idx)
			}
			if value != rt.expectedValue {
				t.Errorf("expected value: %s, got: %s", rt.expectedValue, value)
			}
		})
	}
}

			CAFile: "../../client/testdata/myCA.cer",
		},
	}

	rt, err := MakeInsecureTransport(config)
	if err != nil {
		t.Errorf("Not expecting an error #%v", err)
	}
	if rt == nil {
		t.Error("rt should not be nil")
	}

	req, err := http.NewRequest(http.MethodGet, testServer.URL, nil)
	if err != nil {
		t.Fatal(err)
	}
	response, err := rt.RoundTrip(req)
	if err != nil {
		t.Fatal(err)
	}

func (rt *transportDialTesterRoundTrip) wantDone(c *transportDialTesterConn) {
	rt.t.Helper()
	<-rt.done
	if rt.err != nil {
		rt.t.Fatalf("RoundTrip %v: want success, got err %v", rt.roundTripID, rt.err)
	}
	if rt.conn != c {
		rt.t.Fatalf("RoundTrip %v: want on conn %v, got conn %v", rt.roundTripID, c.connID, rt.conn.connID)
	}
}

// finish completes a RoundTrip by sending the request body, consuming the response body,

					rt.expectedHandled,
					handled,
					rt.action,
				)
			}

			if !bytes.Equal(objBytes, rt.expectedObjectJSON) {
				t.Errorf(
					"failed HandleGetAction:\n\texpected object: %q\n\t  actual: %q",
					rt.expectedObjectJSON,
					objBytes,
				)
			}

			if (actualErr != nil) != rt.expectedErr {
				t.Errorf(

			expectedErr: false,
		},
	}

	for _, rt := range tests {
		t.Run(rt.name, func(t *testing.T) {
			key, val, actual := parseArgument(rt.arg)
			if (actual != nil) != rt.expectedErr {
				t.Errorf("failed parseArgument:\nexpected error:\n%t\nsaw error:\n%v", rt.expectedErr, actual)
			}
			if (key != rt.expectedKey) || (val != rt.expectedVal) {

				certificatesDir: /etc/kubernetes/pki
				ignorePreflightErrors:
				- a
				- b
			`),
		},
	}

	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
			}