RequestTrace.newChild(null, "foo").newChild("bar").newChild("baz");
        assertThat(ReverseTreeRepositoryListener.lookupCollectStepData(doesNotHaveIt), nullValue());

        final CollectStepData data = mock(CollectStepData.class);

        RequestTrace haveItFirst = RequestTrace.newChild(null, data)
                .newChild("foo")
                .newChild("bar")
                .newChild("baz");

            project.getModel().addDependency(dependency);
        }

        @Override
        public void afterSessionStart(MavenSession session) {
            session.getUserProperties().setProperty("injected", "bar");
        }
    }

    public static class InjectReactorDependency extends AbstractMavenLifecycleParticipant {
        @Override
        public void afterProjectsRead(MavenSession session) {

     *   <li>If this type was created by {@code JavaPathType.patchModule("foo.bar")}, then the method returns
     *       {@code "--patch-module foo.bar=path1:path2"} on Unix or {@code "--patch-module foo.bar=path1;path2"}
     *       on Windows.</li>
     * </ul>
     *
     * @param paths the path to format as a string

        /**
         * Returns the programmatic name of this path type, including the module to patch.
         * For example, if this type was created by {@code JavaPathType.patchModule("foo.bar")},
         * then this method returns {@code "PathType[PATCH_MODULE:foo.bar]")}.
         *
         * @return the programmatic name together with the module name on which it applies
         */
        @Nonnull
        @Override

        MavenArtifactRepositorySubclass r2 = new MavenArtifactRepositorySubclass("foo");
        MavenArtifactRepositorySubclass r3 = new MavenArtifactRepositorySubclass("bar");

        assertTrue(r1.hashCode() == r2.hashCode());
        assertFalse(r1.hashCode() == r3.hashCode());

        assertTrue(r1.equals(r2));
        assertTrue(r2.equals(r1));

        assertNotNull(versionFilter);
        assertTrue(versionFilter instanceof PredicateVersionFilter);

        // chained
        request.getUserProperties().put("maven.versionFilters", "h(5);s;e(org.foo:bar:1)");
        versionFilter = systemSessionFactory.newRepositorySession(request).getVersionFilter();
        assertNotNull(versionFilter);
        assertTrue(versionFilter instanceof ChainedVersionFilter);
    }

pass over the examined Iterable yields at least one item that is equal to the specified item. Whilst matching, the traversal of the examined Iterable will stop as soon as a matching item is found. For example: assertThat(Arrays.asList("foo", "bar"), hasItem("bar")) Parameters: item - the item to compare against the items provided by the examined Iterable hasItem public static <T> Matcher<java.lang.Iterable<? super T>> hasItem(Matcher<? super T> itemMatcher) Creates a matcher for Iterables that only...

     * </ul>
     * Example filter expression: {@code "h(5);s;e(org.foo:bar:1)} will cause: ranges are filtered for "top 5" (instead
     * full range), snapshots are banned if root project is not a snapshot, and if range for {@code org.foo:bar} is
     * being processed, version 1 is omitted.
     *
     * @since 4.0.0
     */

org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; public class Foo { static Log log = LogFactory.getLog(Foo.class); public void foo() { ... try { if (log.isDebugEnabled()) { log.debug("About to do something to object " + name); } name.bar(); } catch (IllegalStateExceptio e) { log.error("Something bad happened to " + name, e); } ... } Unless you configure things differently, all log output will be written to System.err. Therefore, you really will want to review the remainder of this page...

  <parent>
    <groupId>org.my.group</groupId>
    <artifactId>parent</artifactId>
  </parent>
  <artifactId>child</artifactId>
  <packaging>jar</packaging>

  <properties>
    <prop-child>bar</prop-child>
  </properties>
  <dependencies>
    <dependency>
      <groupId>org.slf4j</groupId>
      <artifactId>slf4j-api</artifactId>
    </dependency>
  </dependencies>