import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertSame;

class BuildListCalculatorTest {

    @Test
    void testCalculateProjectBuilds() throws Exception {
        LifecycleTaskSegmentCalculator lifecycleTaskSegmentCalculator = getTaskSegmentCalculator();
        BuildListCalculator buildListCalculator = new BuildListCalculator();

    public ExtensionPropertiesSummaryRenderer(PropertyTableRenderer propertyTableRenderer) {
        this.propertyTableRenderer = propertyTableRenderer;
    }

    public void renderTo(ClassExtensionDoc extension, Element parent) {
        if (extension.getExtensionProperties().isEmpty()) {
            return;
        }

        Document document = parent.getOwnerDocument();

            List<MavenProject> sortedProjects = graph.getSortedProjects();
            result.sort(comparing(sortedProjects::indexOf));
        }

        return result;
    }

    private void enrichRequestFromResumptionData(List<MavenProject> projects, MavenExecutionRequest request) {
        if (request.isResume()) {
            projects.stream()
                    .filter(MavenProject::isExecutionRoot)

    }

    public void addCommandRegistry(CommandRegistry commandRegistry) {
        requireNonNull(commandRegistry, "commandRegistry");
        this.commandRegistries.add(commandRegistry);
    }

    public CommandRegistry[] getCommandRegistries() {
        return commandRegistries.toArray(new CommandRegistry[0]);
    }

    @Override
    public void close() throws Exception {

        }
    }

    /**
     * Resolves the names in the given type into fully qualified names.
     */
    public void resolve(final TypeMetaData type, final ClassMetaData classMetaData) {
        type.visitTypes(new Action<TypeMetaData>() {
            @Override
            public void execute(TypeMetaData t) {
                t.setName(resolve(t.getName(), classMetaData));
            }
        });
    }

    /**

                    + ", you should define versions in pluginManagement section of your " + "pom.xml or parent");
        }

        return executionPlan;
    }

    public void handleBuildError(
            final ReactorContext buildContext,
            final MavenSession rootSession,
            final MavenSession currentSession,
            final MavenProject mavenProject,

    DeployRequest remapDeployArtifacts(RepositorySystemSession session, DeployRequest request);

    void injectTransformedArtifacts(RepositorySystemSession session, MavenProject currentProject) throws IOException;

    void transform(MavenProject project, RepositorySystemSession session, ModelSource src, Path tgt)
            throws ModelBuilderException, XMLStreamException, IOException;

import java.util.Arrays;
import java.util.List;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertTrue;

/**
 */
class FilterHashEqualsTest {

    @Test
    void testIncludesExcludesArtifactFilter() {
        List<String> patterns = Arrays.asList("c", "d", "e");

        IncludesArtifactFilter f1 = new IncludesArtifactFilter(patterns);

/**
 * Tests {@link OrArtifactFilter}.
 *
 */
@Deprecated
class OrArtifactFilterTest {

    private ArtifactFilter newSubFilter() {
        return artifact -> false;
    }

    @Test
    void testEquals() {
        OrArtifactFilter filter1 = new OrArtifactFilter();

        OrArtifactFilter filter2 = new OrArtifactFilter(Arrays.asList(newSubFilter()));

        this.delegate = requireNonNull(delegate, "delegate cannot be null");
        this.childrenTracking = parent;
    }

    public Object getDelegate() {
        return delegate;
    }

    public void update(Object newDelegate) {
        if (delegate != newDelegate) {
            if (childrenTracking != null) {
                childrenTracking.replace(delegate, newDelegate);
            }
            delegate = newDelegate;