value         string
		valueSet      bool
		expectedValue string
		expectedError bool
	}{
		{
			desc:          "value unset",
			env:           "FOO",
			valueSet:      false,
			expectedValue: "",
			expectedError: true,
		},
		{
			desc:          "value set empty",
			env:           "FOO",
			value:         "",
			valueSet:      true,
			expectedValue: "",
			expectedError: true,
		},
		{

		expression    string
		expectedValue any
	}{
		{
			name:          "not an object",
			expression:    `string(114514)`,
			expectedValue: "114514",
		},
		{
			name:          "empty",
			expression:    "Object{}",
			expectedValue: map[string]any{},
		},
		{
			name:       "Object.spec",
			expression: "Object{spec: Object.spec{replicas: 3}}",
			expectedValue: map[string]any{
				"spec": map[string]any{

	if err := testutil.GatherAndCompare(legacyregistry.DefaultGatherer, strings.NewReader(expectedValue), metrics...); err != nil {
		t.Fatal(err)
	}
}

func TestAuthenticationConfigAutomaticReloadLastTimestampSeconds(t *testing.T) {
	testCases := []struct {
		expectedValue string
		resultLabel   string
		timestamp     int64
	}{
		{
			expectedValue: `

			expectedValue: "myValue",
		},
		{
			version:       "v1",
			label:         "spec.host",
			value:         "127.0.0.1",
			expectedLabel: "spec.nodeName",
			expectedValue: "127.0.0.1",
		},
		{
			version:       "v1",
			label:         "status.podIPs",
			value:         "10.244.0.6,fd00::6",
			expectedLabel: "status.podIPs",
			expectedValue: "10.244.0.6,fd00::6",
		},

	if err := testutil.GatherAndCompare(registry, strings.NewReader(expectedValue), metricNames...); err != nil {
		t.Fatal(err)
	}
}

func TestEncryptionConfigAutomaticReloadLastTimestampSeconds(t *testing.T) {
	testCases := []struct {
		expectedValue string
		resultLabel   string
		timestamp     int64
	}{
		{
			expectedValue: `

	for _, tc := range []struct {
		name          string
		expression    string
		expectedValue any
	}{
		{
			name:          "not an object",
			expression:    `2 * 31 * 1847`,
			expectedValue: int64(114514), // type resolver should not interfere.
		},
		{
			name:          "empty",
			expression:    "Object{}",
			expectedValue: map[string]any{},
		},
		{
			name:          "Object.spec",

            def actualValue = getter(actual)
            def expectedValue = getter(expected)
            if (checker instanceof Closure) {
                if (expectedValue instanceof Collection) {
                    assert actualValue instanceof Collection
                    checkCollection(actualValue, expectedValue, checker)
                } else if (expectedValue instanceof Map) {
                    assert actualValue instanceof Map

        String expectedValue = 'somevalue'

        when:
        project.convention.plugins.test = new TestConvention()
        project.convention.conv = expectedValue

        then:
        project."$propertyName" == expectedValue
        project.convention."$propertyName" == expectedValue
        child1."$propertyName" == expectedValue
    }

    def setPropertyAndPropertyMissingWithConventionProperty() {

	{
		dummyAuthorizer.decision = authorizer.DecisionAllow
		_, _, _ = a.Authorize(context.Background(), nil)
		expectedValue := prefix + `
			apiserver_authorization_decisions_total{decision="allowed",name="myname",type="mytype"} 1
		`
		if err := testutil.GatherAndCompare(legacyregistry.DefaultGatherer, strings.NewReader(expectedValue), metrics...); err != nil {
			t.Fatal(err)
		}
		authorizationDecisionsTotal.Reset()
	}

	// deny
	{

	if err := testutil.GatherAndCompare(legacyregistry.DefaultGatherer, strings.NewReader(expectedValue), metrics...); err != nil {
		t.Fatal(err)
	}
}

func TestAuthorizationConfigAutomaticReloadLastTimestampSeconds(t *testing.T) {
	testCases := []struct {
		expectedValue string
		resultLabel   string
		timestamp     int64
	}{
		{
			expectedValue: `