},
	}

	for name, tc := range testcases {
		t.Run(name, func(t *testing.T) {
			tCtx := ktesting.Init(t)

			controller, createErr := NewClaimController(tc.filter, tc.requests)
			if createErr != nil {
				if !tc.expectCreateErr {
					tCtx.Fatalf("unexpected create error: %v", createErr)
				}
				return
			}
			if tc.expectCreateErr {

	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) {

	// For each test case, verify we get the expected messages as output
	for _, tc := range mcTestGrid {
		tc := tc // Capture range variable so subtests work correctly
		t.Run(tc.name, func(t *testing.T) {
			g := NewWithT(t)

			// Set up a hook to record which collections are accessed by each analyzer
			analyzerName := tc.analyzer.Metadata().Name
			cr := func(col config.GroupVersionKind) {

		expectedError string
	}{
		{goSrc: "libfuzzer1.go", expectedError: "panic: found it"},
		{goSrc: "libfuzzer2.go", cSrc: "libfuzzer2.c", expectedError: "panic: found it"},
	}
	for _, tc := range cases {
		tc := tc
		name := strings.TrimSuffix(tc.goSrc, ".go")
		t.Run(name, func(t *testing.T) {
			t.Parallel()

			dir := newTempDir(t)
			defer dir.RemoveAll(t)

			// build Go code in libfuzzer mode to a c-archive

		},
	}

	for name, tc := range tests {
		t.Run(name, func(t *testing.T) {
			featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.VolumeAttributesClass, tc.vacEnabled)

			DropDisabledSpecFields(tc.newSpec, tc.oldSpec)
			if !reflect.DeepEqual(tc.newSpec, tc.expectNewSpec) {
				t.Error(cmp.Diff(tc.newSpec, tc.expectNewSpec))
			}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			_, err := compiler.CompileCELExpression(&SubjectAccessReviewMatchCondition{
				Expression: tc.expression,
			})
			if len(tc.expectedError) > 0 && (err == nil || !strings.Contains(err.Error(), tc.expectedError)) {
				t.Fatalf("expected error: %s compiling expression %s, got: %v", tc.expectedError, tc.expression, err)
			}

				Columns: []clause.Column{{Name: "active"}},
				Values:  [][]interface{}{{true}},
			},
		},
	}

	for _, tc := range testCase {
		t.Run(tc.name, func(t *testing.T) {
			actual := ConvertMapToValuesForCreate(&gorm.Statement{}, tc.input)
			if !reflect.DeepEqual(actual, tc.expect) {
				t.Errorf("expect %v got %v", tc.expect, actual)
			}
		})
	}
}

func TestConvertSliceOfMapToValuesForCreate(t *testing.T) {

		{"Pid", unsafe.Offsetof(si.Pid), ofPid},
		{"Uid", unsafe.Offsetof(si.Uid), ofUid},
		{"Status", unsafe.Offsetof(si.Status), ofStatus},
	}

	for _, tc := range offsets {
		if int(tc.got) != tc.want {
			t.Errorf("offsetof %s: got %d, want %d", tc.name, tc.got, tc.want)
		}
	}

			expectedVal: celtypes.True,
		},
	} {
		t.Run(tc.name, func(t *testing.T) {
			_, option := NewTypeProviderAndEnvOption(&mockTypeResolverForOptional{
				mockTypeResolver: &mockTypeResolver{},
			})
			env := mustCreateEnvWithOptional(t, option)
			ast, issues := env.Compile(tc.expression)
			if issues != nil {
				if tc.expectedCompileError == "" {

			expectedErrMsg: "unable to add process counter: foo. Error code is c0000bc0",
		},
	}

	for name, tc := range testCases {
		t.Run(name, func(t *testing.T) {
			counter, err := newPerfCounter(tc.counter)
			if tc.expectErr {
				if err == nil || err.Error() != tc.expectedErrMsg {
					t.Fatalf("expected error message `%s` but got `%v`", tc.expectedErrMsg, err)
				}
				return
			}