.collect(Collectors.toList());

        if (remainingProjects.isEmpty()) {
            LOGGER.info("No remaining projects found, resuming the build would not make sense.");
            return Optional.empty();
        }

        return Optional.of(new BuildResumptionData(remainingProjects));
    }

---------------

+ Make sure you have a [JIRA account](https://issues.apache.org/jira/).
+ Make sure you have a [GitHub account](https://github.com/signup/free).
+ If you're planning to implement a new feature, it makes sense to discuss your changes
  on the [dev list](https://maven.apache.org/mailing-lists.html) first.
  This way you can make sure you're not wasting your time on something that isn't
  considered to be in Apache Maven's scope.

 * under the License.
 */
package org.apache.maven.execution;

import java.util.Optional;

/**
 * Instances of this class are responsible for determining whether it makes sense to "resume" a build (i.e., using
 * the {@code --resume} flag.
 */
public interface BuildResumptionAnalyzer {
    /**
     * Construct an instance of {@link BuildResumptionData} based on the outcome of the current Maven build.

                assertSame( dependencyFilter, filter );
            }
        }
        */
    }

    @Test
    @Disabled("TODO restore these if it makes sense")
    void testShouldUseCompileScopeIfDependencyScopeEmpty() throws Exception {
        /*
        String groupId = "org.apache.maven";
        String artifactId = "maven-model";

        Dependency dep = new Dependency();

.<T>instanceOf(type); } /** * Creates a matcher that wraps an existing matcher, but inverts the logic by which * it will match. * <p/> * For example: * <pre>assertThat(cheese, is(not(equalTo(smelly))))</pre> * * @param matcher * the matcher whose sense should be inverted */ public static <T> org.hamcrest.Matcher<T> not(org.hamcrest.Matcher<T> matcher) { return org.hamcrest.core.IsNot.<T>not(matcher); } /** * A shortcut to the frequently used <code>not(equalTo(x))</code>. * <p/> * For example: * ...

     * one specific module. Used for compilation and execution among others.
     *
     * <p><b>Context-sensitive interpretation:</b>
     * This path type makes sense only when a main module is added on the module-path by another dependency.
     * In no main module is found, the patch dependency may be added on the class-path or module-path

public static <T> Matcher<T> not(Matcher<T> matcher) Creates a matcher that wraps an existing matcher, but inverts the logic by which it will match. For example: assertThat(cheese, is(not(equalTo(smelly)))) Parameters: matcher - the matcher whose sense should be inverted not public static <T> Matcher<T> not(T value) A shortcut to the frequently used not(equalTo(x)). For example: assertThat(cheese, is(not(smelly))) instead of: assertThat(cheese, is(not(equalTo(smelly)))) Parameters: value - the value...