org.eclipse.aether.version.VersionRange.Bound bound = delegate.getUpperBound();
            if (bound == null) {
                return null;
            }
            return new Boundary() {
                @Override
                public Version getVersion() {
                    return new DefaultVersion(versionScheme, bound.getVersion());
                }

                @Override

                                .distinct()
                                .collect(Collectors.joining("\n - ", " - ", "")));
            }
        };
        injector.bindInstance(Injector.class, injector);
        bind(Injector.class).toInstance(injector);
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        if (classLoader == null) {
            classLoader = getClass().getClassLoader();
        }

                .groupId(artifact.getGroupId())
                .artifactId(artifact.getArtifactId())
                .version(artifact.getBaseVersion())
                .build();
    }

    public void bind(Artifact artifact) {
        artifacts.add(artifact);
    }

    public Object getKey() {
        return getGroupId() + ':' + getArtifactId() + ':' + getVersion();
    }

        <field>
          <name>phase</name>
          <version>4.0.0+</version>
          <type>String</type>
          <description>The build lifecycle phase to bind the goals in this execution to. If omitted,
            the goals will be bound to the default phase specified by the plugin. </description>
        </field>
        <field xml.transient="true">
          <name>priority</name>

@Target(ElementType.TYPE)
@Inherited
public @interface Mojo {
    /**
     * goal name (required).
     * @return the goal name
     */
    @Nonnull
    String name();

    /**
     * default phase to bind your mojo.
     * @return the default phase
     */
    @Nonnull
    String defaultPhase() default "";

    /**
     * does your mojo requires a project to be executed?
     * @return requires a project
     */

        </field>
        <field>
          <name>phase</name>
          <version>1.0.0+</version>
          <type>String</type>
          <description>
            Defines a default phase to bind a Mojo execution to if the user does not explicitly set a phase in the POM.
            &lt;p>&lt;b>Note:&lt;/b> This will not automagically make a Mojo run when the plugin declaration is added

                "Expected 'ModelResolverException' not thrown.");
        assertEquals("The requested version range '[1,)' does not specify an upper bound", e.getMessage());
    }

    @Test
    void testResolveParentSuccessfullyResolvesExistingParentWithoutRange() throws Exception {
        final Parent parent = Parent.newBuilder()

                throw new UnresolvableModelException(
                        String.format(
                                "The requested parent version range '%s' does not specify an upper bound",
                                parent.getVersion()),
                        parent.getGroupId(),
                        parent.getArtifactId(),
                        parent.getVersion());
            }

 * into itself leading to a stack overflow.
 *
 * A side effect of using @Typed is that it translates to explicit bindings in the container.
 * So instead of binding the component under a 'wildcard' key it is now bound with an explicit
 * key. Since this is a default component this will be a plain binding of ModelProcessor to
 * this implementation type, ie. no hint/name.
 *

                    snapshotMetadata = new RemoteSnapshotMetadata(artifact, timestamp, buildNumber);
                    snapshots.put(key, snapshotMetadata);
                }
                snapshotMetadata.bind(artifact);
            }
        }

        return snapshots.values();
    }

    @Override
    public Artifact transformArtifact(Artifact artifact) {