FROM_DECLARATION_ANNOTATIONS_ONLY {
      @Override
      boolean isNullable(Invokable<?, ?> invokable) {
        return containsNullable(invokable.getAnnotations());
      }

      @Override
      boolean isNullable(Parameter param) {
        return containsNullable(param.getAnnotations());
      }
    };

    abstract boolean isNullable(Invokable<?, ?> invokable);

    abstract boolean isNullable(Parameter param);

    protected void extractAnnotations(final PDDocument doc, final StringWriter writer) {
        for (final PDPage page : doc.getPages()) {
            try {
                for (final PDAnnotation annotation : page.getAnnotations()) {
                    if (annotation instanceof final PDAnnotationFileAttachment annotationFileAttachment) {
                        final PDFileSpecification fileSpec = annotationFileAttachment.getFile();

    assertNotNull(
        rootLocaleFormat("%s must be annotated with @TesterAnnotation.", annotationClass),
        annotationClass.getAnnotation(TesterAnnotation.class));
    Retention retentionPolicy = annotationClass.getAnnotation(Retention.class);
    assertNotNull(
        rootLocaleFormat("%s must have a @Retention annotation.", annotationClass),
        retentionPolicy);
    assertEquals(

        Retention retention = Secured.class.getAnnotation(Retention.class);
        assertNotNull(retention);
        assertEquals(RetentionPolicy.RUNTIME, retention.value());

        // Check Inherited annotation
        assertNotNull(Secured.class.getAnnotation(Inherited.class));

        // Check Documented annotation
        assertNotNull(Secured.class.getAnnotation(Documented.class));
    }

    assertNotNull(
        rootLocaleFormat("%s must be annotated with @TesterAnnotation.", annotationClass),
        annotationClass.getAnnotation(TesterAnnotation.class));
    Retention retentionPolicy = annotationClass.getAnnotation(Retention.class);
    assertNotNull(
        rootLocaleFormat("%s must have a @Retention annotation.", annotationClass),
        retentionPolicy);
    assertEquals(

        final Retention retention = UriType.class.getAnnotation(Retention.class);
        assertNotNull("Retention annotation should be present", retention);
        assertEquals("Retention should be RUNTIME", RetentionPolicy.RUNTIME, retention.value());
    }

    // Test annotation target elements
    public void test_targetElements() {
        final Target target = UriType.class.getAnnotation(Target.class);

        final Retention retention = CustomSize.class.getAnnotation(Retention.class);
        assertNotNull("Retention annotation should be present", retention);
        assertEquals("Retention should be RUNTIME", RetentionPolicy.RUNTIME, retention.value());
    }

    // Test annotation target elements
    public void test_targetElements() {
        final Target target = CustomSize.class.getAnnotation(Target.class);

  final <T> T isSubtype(T sub) {
    Type returnType = method.getGenericReturnType();
    Type paramType = getOnlyParameterType();
    TestSubtype spec = method.getAnnotation(TestSubtype.class);
    assertWithMessage("%s is subtype of %s", paramType, returnType)
        .that(TypeToken.of(paramType).isSubtypeOf(returnType))
        .isTrue();

        assertNotNull(retention);
        assertEquals(java.lang.annotation.RetentionPolicy.RUNTIME, retention.value());
    }

    // Test annotation is documented
    public void test_annotationDocumented() {
        java.lang.annotation.Documented documented = CronExpression.class.getAnnotation(java.lang.annotation.Documented.class);

        assertThrows(
            ConflictingRequirementsException.class, () -> buildTesterRequirements(Tester.class));
    assertThat(e.getConflicts()).containsExactly(FOO);
    assertThat(e.getSource()).isEqualTo(Tester.class.getAnnotation(Require.class));
  }

  public void testBuildTesterRequirements_classClassConflict_inherited() {
    @Require(FOO)
    abstract class BaseTester {}
    @Require(absent = FOO)