public class KaAnnotationApplicationValue @KaAnalysisApiInternals constructor(
    annotationValue: KaAnnotation,
    token: KaLifetimeToken
) : KaAnnotationValue(token) {
    public val annotationValue: KaAnnotation = annotationValue
        get() = withValidityAssertion { field }

    override val sourcePsi: KtElement?
        get() = withValidityAssertion { annotationValue.psi }
}

                .documentedAt(Documentation.userManual("id", "section"))
                .severity(annotationValue(propertyMetadata))
                .details("this is a test")
        );
    }

    private Severity annotationValue(PropertyMetadata propertyMetadata) {
        return propertyMetadata.getAnnotationForCategory(AnnotationCategory.TYPE)

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.normalization.java.impl;

public class SimpleAnnotationValue extends AnnotationValue<Object> {

    public SimpleAnnotationValue(String name, Object value) {
        super(name, value);
    }

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.normalization.java.impl;

public class AnnotationAnnotationValue extends AnnotationValue<AnnotationMember> {

    public AnnotationAnnotationValue(String name, AnnotationMember value) {
        super(name, value);
    }

	if node.Annotations == nil {
		return 0, false
	}
	annotationValue, ok := node.Annotations[annotationKey]
	if !ok {
		return 0, false
	}
	intValue, err := strconv.Atoi(annotationValue)
	if err != nil {
		logger := klog.FromContext(ctx)
		logger.Info("Could not convert the value with annotation key for the node", "annotationValue",
			annotationValue, "annotationKey", annotationKey, "node", klog.KObj(node))

 * Initializer of property of annotation, which can not be which cannot be represented as Kotlin const value,
 *   but can be represented as [KaAnnotationValue]
 */
public class KaConstantValueForAnnotation(
    public val annotationValue: KaAnnotationValue,
    override val initializerPsi: KtExpression?

			assert.Equal(t, test.expectEnabled, test.ctx.Enabled())
		})
	}
}

func TestAddAuditAnnotation(t *testing.T) {
	const (
		annotationKeyTemplate = "test-annotation-%d"
		annotationValue       = "test-annotation-value"
		annotationExtraValue  = "test-existing-annotation"
		numAnnotations        = 10
	)

	expectAnnotations := func(t *testing.T, annotations map[string]string) {

		return "", fmt.Errorf("invalid name %q, last '%c' should be alphanumeric", name, c)
	}

	return annotationPrefix + name, nil
}

// annotationValue returns an annotation value for the given devices.
func annotationValue(devices []string) (string, error) {
	value, sep := "", ""
	for _, d := range devices {
		if _, _, _, err := parseQualifiedName(d); err != nil {
			return "", err
		}

        append(value.callableId?.asSingleFqName()?.asString())
    }

    private fun StringBuilder.renderAnnotationConstantValue(application: KaAnnotationApplicationValue) {
        renderAnnotationApplication(application.annotationValue)
    }

    private fun StringBuilder.renderAnnotationApplication(value: KaAnnotation) {
        append(value.classId)
        if (value.arguments.isNotEmpty()) {
            append("(")

			b := NewBackend(fb, defaultConfig, auditv1.SchemeGroupVersion)
			b.ProcessEvents(tc.event)

			require.Equal(t, !tc.wantDropped, event != nil, "Incorrect event presence")
			if tc.wantTruncated {
				require.Equal(t, annotationValue, event.Annotations[annotationKey], "Annotation should be present")
				require.Nil(t, event.RequestObject, "After truncation request should be nil")
				require.Nil(t, event.ResponseObject, "After truncation response should be nil")