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

			err := updateDataInConfigMap(configmaps, tc.existingConfigMap, []byte(caBundle))
			if err != nil && err.Error() != tc.expectedErr {
				t.Errorf("actual error (%s) different from expected error (%s).", err.Error(), tc.expectedErr)
			}
			if err == nil {
				if tc.expectedErr != "" {
					t.Errorf("expecting error %s but got no error", tc.expectedErr)
				} else if err := checkActions(fake.Actions(), tc.expectedActions); err != nil {

		},
	}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			c := filterCompiler{compiler: NewCompiler(environment.MustBaseEnvSet(environment.DefaultCompatibilityVersion(), tc.enableStrictCostEnforcement))}
			f := c.Compile(tc.validations, OptionalVariableDeclarations{HasParams: tc.hasParamKind, HasAuthorizer: true, StrictCost: tc.enableStrictCostEnforcement}, environment.NewExpressions)

		},
	}

	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			err := tc.mutators.mutate(tc.input)
			if (err != nil) != tc.expectedError {
				t.Fatalf("expected error: %v, got: %v, error: %v", tc.expectedError, (err != nil), err)
			}
			if err != nil {
				return
			}
			diff := cmp.Diff(tc.expected, tc.input)
			if (len(diff) > 0) != tc.expectedDiff {

			},
			0x11a6d6d6,
		},
	}
	for _, tc := range tests {
		t.Run(tc.name, func(t *testing.T) {
			containerCopy := tc.container.DeepCopy()
			hash := HashContainer(tc.container)
			assert.Equal(t, tc.expectedHash, hash, "[%s]", tc.name)
			assert.Equal(t, containerCopy, tc.container, "[%s]", tc.name)
		})
	}

		},
		{
			name:  "EmptySlice",
			slice: []int{},
			v:     1,
			want:  false,
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			if got := Contains(tc.slice, tc.v); got != tc.want {
				t.Errorf("Contains(%v, %v) = %v; want %v", tc.slice, tc.v, got, tc.want)
			}
		})
	}
}

func TestFindFunc(t *testing.T) {
	emptyElement := []string{}

	if tc.podName != "" {
		newPod := controllervolumetesting.NewPodWithVolume(tc.podName, tc.volName, tc.podNodeName)
		_, err = adc.kubeClient.CoreV1().Pods(newPod.ObjectMeta.Namespace).Create(tCtx, newPod, metav1.CreateOptions{})
		if err != nil {
			t.Fatalf("Run failed with error. Failed to create a new pod: <%v>", err)
		}
		podInformer.GetIndexer().Add(newPod)
	}
	if tc.pvName != "" {

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

		// byte, and 2-bit LZW literals.
		b.WriteString("\x2c\x00\x00\x00\x00\x02\x00\x01\x00\x00\x02")
		if tc.nPix > 0 {
			enc := lzwEncode(make([]byte, tc.nPix))
			if len(enc)+tc.extraExisting > 0xff {
				t.Errorf("nPix=%d, extraExisting=%d, extraSeparate=%d: compressed length %d is too large",
					tc.nPix, tc.extraExisting, tc.extraSeparate, len(enc))
				continue
			}

			// Write the size of the data sub-block containing the LZW data.

			new:     []string{"v1/set/bob", "v1/pod/foo"},
			changed: false,
		},
	}
	for _, tc := range testCases {
		if ownerRefsChanged(toRefs(tc.orig), toRefs(tc.new)) != tc.changed {
			t.Errorf("Expected change=%t but got %t for %v vs %v", tc.changed, !tc.changed, tc.orig, tc.new)
		}
	}
}

func TestGetParentNameAndOrdinal(t *testing.T) {
	set := newStatefulSet(3)