public class PropertyDetailRenderer {
    private final GenerationListener listener;
    private final LinkRenderer linkRenderer;
    private final ElementWarningsRenderer warningsRenderer = new ElementWarningsRenderer();

    public PropertyDetailRenderer(LinkRenderer linkRenderer, GenerationListener listener) {
        this.linkRenderer = linkRenderer;
        this.listener = listener;
    }

            final ClassRealm realm,
            final ConfigurationListener listener)
            throws ComponentConfigurationException {
        try {
            ClassRealmConverter.pushContextRealm(realm);

            this.configureComponent(component, configuration, evaluator, (ClassLoader) realm, listener);
        } finally {
            ClassRealmConverter.popContextRealm();
        }
    }

   * <p>RuntimeExceptions thrown by a listener will be caught and logged. Any exception thrown
   * during {@code Executor.execute} (e.g., a {@code RejectedExecutionException}) will be caught and
   * logged.
   *
   * @param listener the listener to run when the service changes state is complete
   * @param executor the executor in which the listeners callback methods will be run. For fast,

import java.util.List;

public class ClassDocSuperTypeBuilder {
    private final DslDocModel model;
    private final GenerationListener listener;

    public ClassDocSuperTypeBuilder(DslDocModel model, GenerationListener listener) {
        this.model = model;
        this.listener = listener;
    }

    /**
     * Builds and attaches the supertypes of the given class
     */
    void build(ClassDoc classDoc) {

        // warm up
        test(listener, session, resource, 0);

        for (int i = 1; i < size; i++) {
            final int bytes = i;

            service.execute(() -> {
                test(listener, session, resource, bytes);
            });
        }

        // start all threads at once
        try {

        return super.getIfNewer(resourceName, destination, timestamp);
    }

    public void addTransferListener(TransferListener listener) {
        if (listener instanceof TestTransferListener) {
            testTransferListener = (TestTransferListener) listener;
        }
        super.addTransferListener(listener);
    }

        when:
        def result = parser.parse(classMetaData, listener)

        then:
        format(result.docbook) == '''<para><xref/> <xref/></para>'''
        1 * linkConverter.resolve('someClass', classMetaData, listener) >> document.createElement("xref")
        1 * linkConverter.resolve('otherClass#method(a, b) label', classMetaData, listener) >> document.createElement("xref")
        0 * linkConverter._
    }

        client.deletePits(deletePITRequest, listener);
    }

    @Override
    public void getAllPits(final GetAllPitNodesRequest getAllPitNodesRequest, final ActionListener<GetAllPitNodesResponse> listener) {
        client.getAllPits(getAllPitNodesRequest, listener);
    }

    @Override

    final ClassMetaDataRepository<ClassMetaData> repository = Mock()
    final GenerationListener listener = Mock()
    final JavadocLinkConverter converter = new JavadocLinkConverter(document, nameResolver, linkRenderer, repository)

    def convertsClassNameToLink() {
        when:
        def link = converter.resolve('someName', classMetaData, listener)

        then:
        format(link) == '<someLinkElement/>'

    }

    public ExecutionListener chainListener(ExecutionListener listener) {
        if (eventSpies.isEmpty()) {
            return listener;
        }
        return new EventSpyExecutionListener(this, listener);
    }

    public RepositoryListener chainListener(RepositoryListener listener) {
        if (eventSpies.isEmpty()) {
            return listener;
        }
        return new EventSpyRepositoryListener(this, listener);