final Set<Class<?>> categories = new HashSet<Class<?>>();
        Category annotation = description.getAnnotation(Category.class);
        if (annotation != null) {
            categories.addAll(Arrays.asList(annotation.value()));
        }

        if (parent != null) {
            annotation = parent.getAnnotation(Category.class);
            if (annotation != null) {

        }

        ToolingApiVersion toolingVersionAnnotation = testDetails.getAnnotation(ToolingApiVersion)
        Spec<GradleVersion> toolingVersionSpec = toVersionSpec(toolingVersionAnnotation)
        if (!toolingVersionSpec.isSatisfiedBy(this.toolingApiVersion)) {
            return false
        }
        TargetGradleVersion gradleVersionAnnotation = testDetails.getAnnotation(TargetGradleVersion)

                return constructor.getGenericParameterTypes();
            }

            @Nullable
            @Override
            public <S extends Annotation> S getAnnotation(Class<S> annotation) {
                return constructor.getAnnotation(annotation);
            }

            @Override
            public int getModifiers() {
                return constructor.getModifiers();
            }
        }

 */
class ToBeFixedForIsolatedProjectsRule implements TestRule {

    @Override
    Statement apply(@NotNull Statement base, @NotNull Description description) {
        def annotation = description.getAnnotation(ToBeFixedForIsolatedProjects.class)
        if (GradleContextualExecuter.isNotIsolatedProjects() || annotation == null) {
            return base
        }

                }
                add(configurers, method);
            } else if (method.getName().startsWith("create") || method.getName().startsWith("decorate")) {
                if (method.getAnnotation(Provides.class) == null) {
                    throw new ServiceValidationException(String.format("Method %s.%s() must be annotated with @Provides.", type.getName(), method.getName()));
                }

    return declaration;
  }

  @Override
  public boolean isAnnotationPresent(Class<? extends Annotation> annotationType) {
    return getAnnotation(annotationType) != null;
  }

  @Override
  @CheckForNull
  public <A extends Annotation> A getAnnotation(Class<A> annotationType) {
    checkNotNull(annotationType);
    for (Annotation annotation : annotations) {
      if (annotationType.isInstance(annotation)) {

    private boolean canUseToolChain(AvailableToolChains.ToolChainCandidate toolChain) {
        RequiresInstalledToolChain toolChainRequirement = target.getAnnotation(RequiresInstalledToolChain.class);
        if (toolChainRequirement != null) {
            return toolChain.meets(toolChainRequirement.value());
        }

    Method getGetter();

    String getPropertyName();

    boolean isAnnotationPresent(Class<? extends Annotation> annotationType);

    <T extends Annotation> Optional<T> getAnnotation(Class<T> annotationType);

    ImmutableMap<AnnotationCategory, Annotation> getAnnotations();

    TypeToken<?> getDeclaredType();

    @Nullable
    Object getPropertyValue(Object object);

     */
    @Hoge(bbb = "3")
    @Test
    public void testGetProperties() throws Exception {
        final Method m = ClassUtil.getMethod(getClass(), "testGetProperties");
        final Annotation anno = m.getAnnotation(Hoge.class);
        final Map<String, Object> props = AnnotationUtil.getProperties(anno);
        assertThat((String) props.get("aaa"), is("123"));
        assertThat((String) props.get("bbb"), is("3"));

                }
            }
        }

        private boolean suppressCleanupErrors() {
            return suppressCleanupErrors
                || testClass().getAnnotation(LeaksFileHandles.class) != null
                || description.getAnnotation(LeaksFileHandles.class) != null;
        }

        private Class<?> testClass() {
            return description.getTestClass();
        }