)

func TestValidateAuthenticationConfiguration(t *testing.T) {
	featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.StructuredAuthenticationConfiguration, true)

	testCases := []struct {
		name              string
		in                *api.AuthenticationConfiguration
		disallowedIssuers []string
		want              string
	}{
		{
			name: "jwt authenticator is empty",

		}
		if err := file.Copy(filepath.Join(certDir, "key.pem"), dir, "key.pem"); err != nil {
			t.Fatal(err)
		}
		checkSign(t, cli, false)
	})
}

func TestCitadelClient(t *testing.T) {
	testCases := map[string]struct {
		server       mockCAServer
		expectedCert []string
		expectedErr  string
		expectRetry  bool
	}{
		"Valid certs": {
			server:       mockCAServer{Certs: fakeCert, Err: nil},

     */
    TestClassExecutionResult assertTestsExecuted(String... testNames);

    /**
     * Asserts that the given tests (and only the given tests) were executed for the given test class.
     *
     * This supports JUnit5 parameterized tests where the test name and display name may not match.
     */
    TestClassExecutionResult assertTestsExecuted(TestCase... testCases);

			}

			cmdWithClusterID := []string{
				"entry", "configure",
				"-f", path.Join("testdata/vmconfig", dir.Name(), "workloadgroup.yaml"),
				"--internalIP", testCases[dir.Name()]["internalIP"],
				"--ingressIP", testCases[dir.Name()]["ingressIP"],
				"--clusterID", constants.DefaultClusterName,
				"--revision", "rev-1",
				"-o", testdir,
			}

	}

	s := &Test{Ns: "http://example.com/ns", Body: "hello world"}
	return Marshal(s)
}

func TestIssue11405(t *testing.T) {
	testCases := []string{
		"<root>",
		"<root><foo>",
		"<root><foo></foo>",
	}
	for _, tc := range testCases {
		d := NewDecoder(strings.NewReader(tc))
		var err error
		for {
			_, err = d.Token()
			if err != nil {
				break
			}
		}

    @Override
    def indyModes() {
        return [true]
    }

    @Override
    def testCases() {
        // static import calls (are handled differently by the dynamic Groovy's codegen)
        return [
            // varInitializer | processCreator | expectedPwdSuffix | expectedEnvVar

				},
			},
		},
	}

	for _, testcase := range testCases {
		updatePVC := MergeResizeConditionOnPVC(testcase.pvc, testcase.newConditions)

		updateConditions := updatePVC.Status.Conditions
		if !reflect.DeepEqual(updateConditions, testcase.finalConditions) {
			t.Errorf("Expected updated conditions for test %s to be %v but got %v",
				testcase.description,
				testcase.finalConditions, updateConditions)
		}
	}

		}

		binding := validNewBinding()
		binding.UID = testCase.podUIDGetter(podCreated.(*api.Pod))
		binding.ResourceVersion = testCase.podResourceVersionGetter(podCreated.(*api.Pod))

		if _, err := bindingStorage.Create(ctx, binding.Name, binding, rest.ValidateAllObjectFunc, &metav1.CreateOptions{}); !testCase.errOK(err) {
			t.Errorf("%s: unexpected error: %v", k, err)
		}

    @Override
    def indyModes() {
        return [true]
    }

    @Override
    def testCases() {
        return [
            // varInitializer | processCreator | expectedPwdSuffix | expectedEnvVar
            [fromString(), "command.execute()", "", ""],
            [fromGroovyString(), "command.execute()", "", ""],

					t.Errorf("Case %s: expecting cert to be (%s) but got (%s) at position [%d] of cert chain.",
						id, mockCertChain, v, i)
				}
			}
		}
	}
}

func TestCreateCertificate(t *testing.T) {
	testCases := map[string]struct {
		authenticators []security.Authenticator
		ca             CertificateAuthority
		certChain      []string
		code           codes.Code
	}{
		"No authenticator": {
			authenticators: nil,