{Name: "a", Value: "b"},
				{Name: "c", Value: "d"},
			},
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			actual := convertToArgs(tc.args)
			if !reflect.DeepEqual(tc.expectedArgs, actual) {
				t.Errorf("expected args: %v\n\t got: %v\n\t", tc.expectedArgs, actual)
			}
		})
	}
}

func TestConvertFromArgs(t *testing.T) {
	var tests = []struct {

			expectNoMatch: true,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			printFlags := NamePrintFlags{
				Operation: tc.operation,
			}

			p, err := printFlags.ToPrinter(tc.outputFormat)
			if tc.expectNoMatch {
				if !IsNoCompatiblePrinterError(err) {
					t.Fatalf("expected no printer matches for output format %q", tc.outputFormat)
				}
				return
			}

								InitialDelaySeconds: 10,
							},
						},
					},
				},
			},
		},
	} {
		patchRewriteProbe(annotations, tc.pod, 15020)
		if !reflect.DeepEqual(tc.pod, tc.expected) {
			t.Errorf("[%v] failed, want %v, got %v", tc.name, tc.expected, tc.pod)
		}
	}

			expectedRevs: RevVerMap{
				"a": "",
			},
		},
	}

	for _, tc := range tcs {
		t.Run(tc.name, func(t *testing.T) {
			err := validate(tc.settings)
			if tc.expectErr {
				if err == nil {
					t.Error("expected error but got none")
				}
				return
			}
			if tc.expectedRevs != nil {
				if diff := cmp.Diff(tc.expectedRevs, tc.settings.Revisions); diff != "" {

			switch {
			case err != nil && tc.valid:
				t.Errorf("GetKubeletVersion: unexpected error for %q. Error: %v", tc.output, err)
			case err == nil && !tc.valid:
				t.Errorf("GetKubeletVersion: error expected for key %q, but result is %q", tc.output, ver)
			case ver != nil && ver.String() != tc.expected:
				t.Errorf("GetKubeletVersion: unexpected version result for key %q. Expected: %q Actual: %q", tc.output, tc.expected, ver)
			}
		})
	}

		},
	}
	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			t.Logf("%s: Test preconf %s, expected %s", tc.name, tc.preConfFile, tc.expectedOutputFile)
			install.RunInstallCNITest(t, tc.chainedCNIPlugin, tc.preConfFile, tc.resultFileName, tc.delayedConfFile, tc.expectedOutputFile,
				tc.expectedPostCleanFile, tc.cniConfDirOrderedFiles)
		})
	}

					},
				}},
		},
	}

	for _, tc := range testcases {
		t.Run(tc.name, func(t *testing.T) {
			config, err := LoadConfiguration(bytes.NewBuffer([]byte(tc.input)))

			if len(tc.expectErr) > 0 {
				if err == nil {
					t.Fatal("expected err, got none")
				}
				if !strings.Contains(err.Error(), tc.expectErr) {
					t.Fatalf("expected err containing %q, got %v", tc.expectErr, err)
				}
				return
			}

		},
	}

	for id, tc := range testCases {
		t.Run(id, func(t *testing.T) {
			exp, err := GetExp(tc.jwt)
			if err != nil && tc.expectedErr == nil || err == nil && tc.expectedErr != nil {
				t.Errorf("%s: Got error \"%v\", expected error \"%v\"", id, err, tc.expectedErr)
			} else if err != nil && tc.expectedErr != nil && err.Error() != tc.expectedErr.Error() {

		},
	}

	for id, tc := range testCases {
		t.Run(id, func(t *testing.T) {
			ctx := context.Background()
			if tc.metadata != nil {
				if tc.token != "" {
					token := security.BearerTokenPrefix + tc.token
					tc.metadata.Append("authorization", token)
				}
				ctx = metadata.NewIncomingContext(ctx, tc.metadata)
			}

			tokenReview := &k8sauth.TokenReview{

			code:    codes.Internal,
		},
	}

	for k, tc := range testCases {
		caErr := NewError(tc.eType, tc.err)
		if caErr.Error() != tc.err.Error() {
			t.Errorf("[%s] unexpected error: '%s' VS (expected)'%s'", k, caErr.Error(), tc.err.Error())
		}
		if caErr.ErrorType() != tc.message {
			t.Errorf("[%s] unexpected error type message: '%s' VS (expected)'%s'", k, caErr.ErrorType(), tc.message)
		}
		if caErr.HTTPErrorCode() != tc.code {