import org.codehaus.plexus.classworlds.realm.NoSuchRealmException;
import org.codehaus.plexus.component.repository.exception.ComponentRepositoryException;
import org.codehaus.plexus.configuration.PlexusConfigurationException;

/**
 * Exception in the plugin manager.
 */
public class PluginManagerException extends Exception {

    private final String pluginGroupId;

    private final String pluginArtifactId;

     */
    @Nonnull
    Optional<MojoExecution> getMojoExecution();

    /**
     * Gets the exception that caused the event (if any).
     *
     * @return the exception or {@code empty()} if none
     */
    Optional<Exception> getException();

    class DependencyInferenceTests {

        @Test
        @DisplayName("should remove dependency version for project artifact")
        void shouldRemoveDependencyVersionForProjectArtifact() throws Exception {
            String parentPomXml = PomBuilder.create()
                    .namespace("http://maven.apache.org/POM/4.1.0")
                    .modelVersion("4.1.0")
                    .groupId("com.example")

    MetadataGraphEdge e1;
    MetadataGraphEdge e2;
    MetadataGraphEdge e3;

    // ------------------------------------------------------------------------------------------
    @BeforeEach
    void setUp() throws Exception {
        policy = new DefaultGraphConflictResolutionPolicy();
        e1 = new MetadataGraphEdge("1.1", true, null, null, 2, 1);
        e2 = new MetadataGraphEdge("1.2", true, null, null, 3, 2);

    }

    protected ArtifactRepository getLocalRepository() throws Exception {
        File repoDir = new File(getBasedir(), "target/local-repo").getAbsoluteFile();

        return repositorySystem.createLocalRepository(repoDir);
    }

    @Test
    void testThatASystemScopedDependencyIsNotResolvedFromRepositories() throws Exception {
        //

 *
 */
@Deprecated
public class RepositoryMetadataResolutionException extends Exception {
    public RepositoryMetadataResolutionException(String message) {
        super(message);
    }

    public RepositoryMetadataResolutionException(String message, Exception e) {
        super(message, e);
    }

package org.apache.maven.lifecycle;

/**
 * Signals a failure to execute a lifecycle phase or mojo because a project is required but not present.
 *
 */
public class MissingProjectException extends Exception {

    /**
     * Creates a new exception.
     *
     * @param message The detail message, may be {@code null}.
     */
    public MissingProjectException(String message) {
        super(message);
    }

 */
@Experimental
public class ArtifactInstallerException extends MavenException {

    /**
     * @param message the message of the error
     * @param e {@link Exception}
     */
    public ArtifactInstallerException(String message, Exception e) {
        super(message, e);
    }

        }
    }

    @Override
    public CacheRecord put(Key key, PluginResolutionException exception) {
        Objects.requireNonNull(exception, "exception cannot be null");

        assertUniqueKey(key);

        CacheRecord record = new CacheRecord(exception);

        cache.put(key, record);

        return record;
    }

    @Override
    public void flush() {

def test_depend_validation():
    """
    Verify that a validation in a dependency invokes the correct exception handler
    """
    caught = []

    @websocket_middleware
    async def catcher(websocket, call_next):
        try:
            return await call_next()
        except Exception as e:  # pragma: no cover
            caught.append(e)
            raise