/**
     * Register the given listener which will receive all events.
     *
     * @param listener the listener to register
     * @throws NullPointerException if {@code listener} is null
     */
    void registerListener(@Nonnull Listener listener);

    /**
     * Unregisters a previously registered listener.
     *
     * @param listener the listener to unregister

            configurator = container.lookup(ComponentConfigurator.class, configuratorId);

            ConfigurationListener listener = new DebugConfigurationListener(logger);

            ValidatingConfigurationListener validator =
                    new ValidatingConfigurationListener(mojo, mojoDescriptor, listener);

            if (logger.isDebugEnabled()) {

        ModelBuildingListener listener = getModelBuildingListener(request);

        if (listener != null) {
            AtomicReference<Model> m = new AtomicReference<>(model);

            ModelBuildingEvent event = new DefaultModelBuildingEvent(model, m::set, request, problems);

            catapult.accept(listener, event);

            return m.get();
        }

            this.modelCache = modelCache;
            return this;
        }

        public ModelBuilderRequestBuilder listener(Object listener) {
            this.listener = listener;
            return this;
        }

        public ModelBuilderRequestBuilder interimResult(ModelBuilderResult interimResult) {
            this.interimResult = interimResult;

                            .source(modelSource)
                            .projectBuild(true)
                            .locationTracking(true)
                            .listener(listener)
                            .build();

                    if (pomFile != null) {
                        project.setRootDirectory(rootLocator.findRoot(pomFile.getParent()));
                    }

                events.add(transferEvent);
            }
        }

        TransferListener listener = new TransferListener();
        wagonManager.getArtifact(artifact, repos, listener, false);
        assertEquals(1, listener.events.size());
    }

    @Test
    void testGetMissingJar() throws TransferFailedException, UnsupportedProtocolException, IOException {

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

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

    }

    @Override
    public void registerListener(@Nonnull Listener listener) {
        listeners.add(nonNull(listener));
    }

    @Override
    public void unregisterListener(@Nonnull Listener listener) {
        listeners.remove(nonNull(listener));
    }

    @Nonnull
    @Override
    public Collection<Listener> getListeners() {
        return Collections.unmodifiableCollection(listeners);

import org.eclipse.aether.repository.RepositoryPolicy;
import org.eclipse.aether.resolution.ResolutionErrorPolicy;
import org.eclipse.aether.util.graph.version.*;
import org.eclipse.aether.util.listener.ChainedRepositoryListener;
import org.eclipse.aether.util.repository.AuthenticationBuilder;
import org.eclipse.aether.util.repository.ChainedLocalRepositoryManager;