Writer writer = serviceRegistry.openWriter();
        writer.write("public class ServiceRegistry {");
        for (Element service : roundEnv.getElementsAnnotatedWith(serviceAnnotation)) {
            addServiceCreationMethod(writer, (TypeElement) service);
        }
        writer.write("}");
        writer.close();
        // end::aggregating-annotation-processor[]
    }

        annotation("Service")
    ] as Set

    RoundEnvironment roundEnvironment = Stub(RoundEnvironment) {
        getRootElements() >> ([type("A"), type("B"), type("C")] as Set)
        getElementsAnnotatedWith(_ as TypeElement) >> { TypeElement annotationType ->
            if (annotationType.is(annotationTypes[0])) {
                [type("A")] as Set
            } else if (annotationType.is(annotationTypes[1])) {

        if (!annotations.equals(Collections.singleton(entityAnnotation))) {
            return false;
        }

        // tag::isolating-annotation-processor[]
        Set<? extends Element> entities = roundEnv.getElementsAnnotatedWith(entityAnnotation);
        for (Element entity : entities) {
            createRepository((TypeElement) entity);
        }
        // end::isolating-annotation-processor[]
        return true;
    }

        } else {
            for (TypeElement annotation : annotations) {
                result.getAggregatedTypes().addAll(namesOfElements(roundEnv.getElementsAnnotatedWith(annotation)));
            }
        }
    }

    private static Set<String> namesOfElements(Set<? extends Element> orig) {
        if (orig == null || orig.isEmpty()) {

                    Set<Element> elements = new HashSet<>();
                    for (TypeElement annotation : annotations) {
                         elements.addAll(roundEnv.getElementsAnnotatedWith(annotation));
                    }
                    ${generatorCode}
                    return true;
                }
            }
"""

    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        Stream<? extends Element> annotatedTypes = getSupportedAnnotations().stream()
            .flatMap(annotation -> roundEnv.getElementsAnnotatedWith(annotation).stream())
            .flatMap(element -> findActualTypesToVisit(element).stream())
            .sorted(Comparator.comparing(AbstractInstrumentationProcessor::elementQualifiedName));

                                }

                                for (final Element classElement : roundEnv.getElementsAnnotatedWith(SimpleAnnotation.class)) {
                                    final String className = String.format("%s\$\$Generated", classElement.getSimpleName().toString());

                                    Writer writer = null;

                                }

                                final String suffix = options.getOrDefault("suffix", "Generated");
                                for (final Element classElement : roundEnv.getElementsAnnotatedWith(SimpleAnnotation.class)) {
                                    final String className = String.format("%s\$\$%s", classElement.getSimpleName().toString(), suffix);