},
	}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			token := outputapiv1alpha3.BootstrapToken{
				BootstrapToken: bootstraptokenv1.BootstrapToken{
					Token:       &bootstraptokenv1.BootstrapTokenString{ID: tc.id, Secret: tc.secret},
					Description: tc.description,
					Usages:      tc.usages,
					Groups:      tc.extraGroups,
				},
			}
			buf := bytes.Buffer{}

			input: `<Transition>
			<Days>1</Days>
		  </Transition>`,
			err: errXMLNotWellFormed,
		},
	}

	for i, tc := range trTests {
		var tr Transition
		err := xml.Unmarshal([]byte(tc.input), &tr)
		if err != nil {
			t.Fatalf("%d: xml unmarshal failed with %v", i+1, err)
		}
		if err = tr.Validate(); err != tc.err {
			t.Fatalf("%d: Invalid transition %v: err %v", i+1, tr, err)
		}
	}

	ntrTests := []struct {

		{
			name:  "one nil pool, one empty pool",
			a:     nil,
			b:     emptyPool,
			equal: false,
		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			equal := tc.a.Equal(tc.b)
			if equal != tc.equal {
				t.Errorf("Unexpected Equal result: got %t, want %t", equal, tc.equal)
			}
		})
	}

			if !reflect.DeepEqual(sets.List(volumesFailedReconstruction), tc.expectedVolumesFailedReconstruction) {
				t.Errorf("Expected volumesFailedReconstruction:\n%v\n got:\n%v", tc.expectedVolumesFailedReconstruction, sets.List(volumesFailedReconstruction))
			}

			if tc.verifyFunc != nil {
				if err := tc.verifyFunc(rcInstance, fakePlugin); err != nil {
					t.Errorf("Test %s failed: %v", tc.name, err)
				}
			}
		})
	}
}

		},
	}

	for _, tc := range testCases {
		options := mergeDNSOptions(tc.existingDNSConfigOptions, tc.dnsConfigOptions)
		// Options order may be changed after conversion.
		if !sets.New[string](options...).Equal(sets.New[string](tc.expectedOptions...)) {
			t.Errorf("%s: mergeDNSOptions(%v, %v)=%v, want %v", tc.desc, tc.existingDNSConfigOptions, tc.dnsConfigOptions, options, tc.expectedOptions)
		}
	}
}

	assert.NoError(t, err)

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			// We don't validate the result. It was parsed with the json parser, we trust that.
			_, err = m.parseUserNsFileAndRecord(types.UID(tc.name), []byte(tc.file))
			if (tc.success && err == nil) || (!tc.success && err != nil) {
				return
			}

			t.Errorf("expected success: %v but got error: %v", tc.success, err)
		})
	}
}

			expectedPath: "lish",
		},
	}

	for name, tc := range testCases {
		t.Run(name, func(t *testing.T) {
			mounter := &fakeMounter{
				mountRefs:  tc.mountRefs,
				raiseError: tc.raiseError,
			}

			path, err := hu.GetDeviceNameFromMount(mounter, path, path)
			if tc.expectedError != "" {
				if err == nil || err.Error() != tc.expectedError {

		},
	} {
		source := &packedInts{tc.uint64s, tc.int64s}
		if got, want := marshal(source), tc.encoded; !reflect.DeepEqual(got, want) {
			t.Errorf("failed encode %d, got %v, want %v", i, got, want)
		}

		dest := new(packedInts)
		if err := unmarshal(tc.encoded, dest); err != nil {
			t.Errorf("failed decode %d: %v", i, err)
			continue
		}
		if got, want := dest.uint64s, tc.uint64s; !reflect.DeepEqual(got, want) {

			shouldFail: true,
		},
	}

	for _, tc := range testCases {
		// Arrange & Act
		err := PluginHandler.ValidatePlugin(tc.pluginName, tc.endpoint, tc.versions)

		// Assert
		if tc.shouldFail && err == nil {
			t.Fatalf("expecting ValidatePlugin to fail, but got nil error for testcase: %#v", tc)
		}
		if !tc.shouldFail && err != nil {

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			for _, expressionAccessor := range tc.expressionAccessors {
				_, err := compiler.CompileClaimsExpression(expressionAccessor)
				if err == nil {
					t.Errorf("expected error but got nil")
				}
				if !strings.Contains(err.Error(), tc.wantErr) {