@Shared
    def testCases = testCasesWithIndyModes()

    /**
     * Produces a list of test cases. Each test case is itself a list of the following structure:
     * {@code [varInitializer, processCreator, expectedPwdSuffix, expectedEnvVar]}.
     * @return the list of test cases
     */
    abstract def testCases()

    /**

		},
	}

	for i, testCase := range testCases {
		var req *http.Request
		var actualContent []byte

		// Generate a signed or anonymous request based on the testCase
		if testCase.accessKey != "" {
			req, err = newTestSignedRequestV4(http.MethodPost, getDeleteMultipleObjectsURL("", testCase.bucket),
				int64(len(testCase.objects)), bytes.NewReader(testCase.objects), testCase.accessKey, testCase.secretKey, nil)

	}

	for testIdx, testCase := range testCases {
		listener, listenErrs := newHTTPListener(context.Background(),
			testCase.serverAddrs,
			TCPOptions{},
		)
		for i, expectedListenErr := range testCase.expectedListenErrs {
			if !expectedListenErr {
				if listenErrs[i] != nil {

	},
) {
	for i, testCase := range testCases {
		// initialize httptest Recorder, this records any mutations to response writer inside the handler.
		rec := httptest.NewRecorder()
		// construct HTTP request
		req, err := newTestSignedRequestV4(testCase.method, getBucketLifecycleURL("", testCase.bucketName),
			int64(len(testCase.body)), bytes.NewReader(testCase.body), testCase.accessKey, testCase.secretKey, nil)

	certChainValid             = loadPEMFile("../testdata/cert-chain.pem")
	certChainValidTrailingLine = loadPEMFile("../testdata/cert-chain-trailing-line.pem")
)

func TestParsePemEncodedCertificate(t *testing.T) {
	testCases := map[string]struct {
		errMsg        string
		pem           string
		publicKeyAlgo x509.PublicKeyAlgorithm
	}{
		"Invalid PEM string": {
			errMsg: "invalid PEM encoded certificate",

	"k8s.io/utils/ptr"
)

func TestNewBackoffRecord(t *testing.T) {
	emptyStoreInitializer := func(*backoffStore) {}
	defaultTestTime := metav1.NewTime(time.Date(2009, time.November, 10, 23, 0, 0, 0, time.UTC))
	testCases := map[string]struct {
		storeInitializer  func(*backoffStore)
		uncounted         uncountedTerminatedPods
		newSucceededPods  []metav1.Time
		newFailedPods     []metav1.Time
		wantBackoffRecord backoffRecord
	}{

package helper

import (
	"fmt"
	"reflect"
	"testing"

	v1 "k8s.io/api/core/v1"
	"k8s.io/apimachinery/pkg/api/resource"
	"k8s.io/apimachinery/pkg/labels"
)

func TestIsNativeResource(t *testing.T) {
	testCases := []struct {
		resourceName v1.ResourceName
		expectVal    bool
	}{
		{
			resourceName: "pod.alpha.kubernetes.io/opaque-int-resource-foo",
			expectVal:    true,
		},
		{

	base64UrlEncodedPaddingStrippedPart = "eyJpc3MiOiJodHRwczovL2V4YW1wbGUuY29tIiwiYXVkIjoiSm9lIEFyZG_DsWV6In0"
)

func TestGetExp(t *testing.T) {
	testCases := map[string]struct {
		jwt         string
		expectedExp time.Time
		expectedErr error
	}{
		"jwt with expiration time": {
			jwt:         thirdPartyJwt,

		select {
		case event := <-recorder.Events:
			return event
		default:
			return ""
		}
	}
)

func TestParseResolvConf(t *testing.T) {
	testCases := []struct {
		data        string
		nameservers []string
		searches    []string
		options     []string
		isErr       bool
	}{
		{"", []string{}, []string{}, []string{}, false},

	line := strings.Repeat("a", blockSize)
	testBytes := []byte(line + "\n" +
		line + "\n" +
		line + "\n" +
		line + "\n" +
		line[blockSize/2:]) // incomplete line

	file.Write(testBytes)
	testCases := []struct {
		name          string
		max           int64
		longerThanMax bool
		expected      string
	}{
		{
			name:          "the max is negative",
			max:           -1,
			longerThanMax: true,