if err := deleteIop(cs, iopName); err != nil {
					t.Errorf("failed to delete iopfile: %v", err)
				}

				retry.UntilSuccessOrFail(t, func() error {
					exist, checkErr := checkIopExist(cs, iopName)
					if checkErr != nil {
						return checkErr
					}

					if exist {
						return fmt.Errorf("fail to delete iop")
					}

					return nil
				}, retry.Timeout(deletionTimeout), retry.Delay(retryDelay))

			name:     "3MB of deeply nested slices",
			checkErr: successOrMaxDepthError,
			data:     []byte(`{"a":` + strings.Repeat(`[`, 3*1024*1024/2) + strings.Repeat(`]`, 3*1024*1024/2) + "}"),
		},
		{
			name:     "3MB of unbalanced nested slices",
			checkErr: nonNilError,
			data:     []byte(`{"a":` + strings.Repeat(`[`, 3*1024*1024)),
		},
		{
			name:     "3MB of deeply nested maps",
			checkErr: successOrMaxDepthError,

		}

		fmt.Fprint(os.Stderr, msg)
	}
	os.Exit(code)
}

// CheckErr prints a user friendly error to STDERR and exits with a non-zero
// exit code. Unrecognized errors will be printed with an "error: " prefix.
//
// This method is generic to the command in use and may be used by non-Kubectl
// commands.
func CheckErr(err error) {
	checkErr(err, fatal)
}

func unmapBindMountDevice(v VolumePathHandler, mapPath string, linkName string) error {
	// Check bind mount exists
	linkPath := filepath.Join(mapPath, string(linkName))
	if isMountExist, checkErr := v.IsDeviceBindMountExist(linkPath); checkErr != nil {
		return checkErr
	} else if !isMountExist {
		klog.Warningf("Warning: Unmap skipped because bind mount does not exist on the path: %v", linkPath)

		// Check if linkPath still exists

	_ "k8s.io/client-go/plugin/pkg/client/auth"
)

func main() {
	command := cmd.NewDefaultKubectlCommand()
	if err := cli.RunNoErrOutput(command); err != nil {
		// Pretty-print the error and exit with an error.
		util.CheckErr(err)
	}

		{"preflight error", &pferror{}, PreFlightExitCode},
	}

	for _, rt := range tests {
		t.Run(rt.name, func(t *testing.T) {
			codeReturned = 0
			checkErr(rt.e, errHandle)
			if codeReturned != rt.expected {
				t.Errorf(
					"failed checkErr:\n\texpected: %d\n\t  actual: %d",
					rt.expected,
					codeReturned,
				)
			}
		})
	}
}

func TestFormatErrMsg(t *testing.T) {

limitations under the License.
*/

package main

import (
	"k8s.io/kubernetes/cmd/kubeadm/app"
	kubeadmutil "k8s.io/kubernetes/cmd/kubeadm/app/util"
)

func main() {
	kubeadmutil.CheckErr(app.Run())

		t.Run(tc.name, func(t *testing.T) {
			_, ctx := ktesting.NewTestContext(t)
			ctx, cancel := context.WithCancel(ctx)
			defer cancel()
			m, err := NewMap(ctx, tc.cfgs, fakeRegistry, nilRecorderFactory)
			if err := checkErr(err, tc.wantErr); err != nil {
				t.Fatal(err)
			}
			if len(tc.wantErr) != 0 {
				return
			}
			if len(m) != len(tc.cfgs) {
				t.Errorf("got %d profiles, want %d", len(m), len(tc.cfgs))
			}

		for i := 0; i < 1000; i++ {
			if test.compressed {
				// Otherwise this compresses too well.
				_, err := io.ReadFull(rand.Reader, chunk)
				checkErr(err, "rand.Reader ReadFull")
			}
			wr.Write(chunk)
		}
		if test.compressed {
			err := wr.(*gzip.Writer).Close()
			checkErr(err, "compressor close")
		}
		if test.chunked {
			buf.WriteString("0\r\n\r\n")
		}
		buf.WriteString("Next Request Here")

}

func setupClientWithVolumeMountGroup(t *testing.T, stageUnstageSet bool, volumeMountGroupSet bool) csiClient {
	return newFakeCsiDriverClientWithVolumeMountGroup(t, stageUnstageSet, volumeMountGroupSet)
}

func checkErr(t *testing.T, expectedAnError bool, actualError error) {
	t.Helper()

	errOccurred := actualError != nil

	if expectedAnError && !errOccurred {
		t.Error("expected an error")
	}