return null;
    }

    public void setRepository(ArtifactRepository remoteRepository) {
        /*
         * NOTE: Metadata at the g:a level contains a collection of available versions. After merging, we can't tell
         * which repository provides which version so the metadata manager must not restrict the artifact resolution to
         * the repository with the most recent updates.
         */
    }

        }

        return repository;
    }

    private boolean isLocalRepository(ArtifactRepository repository) {
        // unfortunately, the API doesn't allow to tell a remote repo and the local repo apart...
        return "local".equals(repository.getId());
    }

  in each project's pom.xml.

   - [modelVersion] tells maven which version of the object model this project
       is compliant with (to support future legacy concerns)

   - [artifactId] tells maven what the artifact name is for this particular
       project. Each project should have a distinct artifactId.

   - [version] tells maven what release of this artifact we're trying to produce.

        <includes>
          <include>*.xsd</include>
          <include>*.dtd</include>
          <include>*.mod</include>
          <include>log4j.properties</include>
          <include>driver.jelly</include>
          <include>driver.properties</include>
        </includes>
      </testResource>
      <testResource>
        <directory>src/messages</directory>

     *
     * @return A map of lifecycles, indexed on id
     */
    public Map<String, Lifecycle> getPhaseToLifecycleMap() {
        // If people are going to make their own lifecycles then we need to tell people how to namespace them correctly
        // so that they don't interfere with internally defined lifecycles.

        Map<String, Lifecycle> phaseToLifecycleMap = new HashMap<>();

expressive. * <p/> * For example: * <pre>assertThat(cheese, is(equalTo(smelly)))</pre> * instead of: * <pre>assertThat(cheese, equalTo(smelly))</pre> * */ @Factory public static <T> Matcher<T> is(Matcher<T> matcher) { return new Is<T>(matcher); } /** * A shortcut to the frequently used <code>is(equalTo(x))</code>. * <p/> * For example: * <pre>assertThat(cheese, is(smelly))</pre> * instead of: * <pre>assertThat(cheese, is(equalTo(smelly)))</pre> * */ @Factory public static <T> Matcher<T> is(T value) {...

    // can be passed back so that the default configuration information can be populated.
    //
    // We need to know the specific version so that we can look up the right version of the plugin descriptor
    // which tells us what the default configuration is.
    //

    /**
     * @return The plugins bound to the lifecycles of the specified packaging or {@code null} if the packaging is
     *         unknown.
     */

        <includes>
          <include>*.xsd</include>
          <include>*.dtd</include>
          <include>*.mod</include>
          <include>log4j.properties</include>
          <include>driver.jelly</include>
          <include>driver.properties</include>
        </includes>
      </resource>
      <resource>
        <directory>/src/messages</directory>
        <targetPath>org/apache/maven/messages</targetPath>

    filesystem, it will continue to be available.

  The question remaining is: Which level of offline mode will we support? It
  seems reasonable to assume that users will be able to tell when localhost is
  not active (in most cases, localhost should be available, even if the rest of
  the network is not). Therefore, let's concentrate on the state where no

value) A shortcut to the frequently used is(equalTo(x)). For example: assertThat(cheese, is(smelly)) instead of: assertThat(cheese, is(equalTo(smelly))) is public static <T> Matcher<T> is(Matcher<T> matcher) Decorates another Matcher, retaining its behaviour, but allowing tests to be slightly more expressive. For example: assertThat(cheese, is(equalTo(smelly))) instead of: assertThat(cheese, equalTo(smelly)) is public static <T> Matcher<T> is(java.lang.Class<T> type) Deprecated. use isA(Class type)...