this.scopes = new HashSet<>();

        if (filters != null) {
            for (CumulativeScopeArtifactFilter filter : filters) {
                addScopes(filter.getScopes());
            }
        }
    }

    private void addScopes(Collection<String> scopes) {
        if (scopes != null) {
            for (String scope : scopes) {
                addScope(scope);

        if (Artifact.SCOPE_COMPILE.equals(artifact.getScope())) {
            return compileScope;
        } else if (Artifact.SCOPE_RUNTIME.equals(artifact.getScope())) {
            return runtimeScope;
        } else if (Artifact.SCOPE_TEST.equals(artifact.getScope())) {
            return testScope;
        } else if (Artifact.SCOPE_PROVIDED.equals(artifact.getScope())) {
            return providedScope;

    public void manageArtifactScope(Artifact artifact, Artifact replacement) {
        // only show msg if a change is actually taking place
        if (!replacement.getScope().equals(artifact.getScope())) {
            String msg = indent + artifact + " (applying artifactScope: " + replacement.getScope() + ")";
            logger.debug(msg);
        }
    }

    public void manageArtifactSystemPath(Artifact artifact, Artifact replacement) {

        System.out.println("b = " + artifact.getScope());
        assertEquals("test", artifact.getScope(), "Check scope");
        artifact = getArtifact(project, "maven-test-test", "scope-default");
        assertEquals("test", artifact.getScope(), "Check scope");
        artifact = getArtifact(project, "maven-test-test", "scope-runtime");
        assertEquals("test", artifact.getScope(), "Check scope");

        assertEquals("system", artifact.getScope());
        assertEquals("system", artifact2.getScope());
        assertEquals("system", artifact3.getScope());
        assertEquals("system", artifact4.getScope());
        assertEquals("system", artifact5.getScope());
    }

                Artifact artifact;
                if (d.getScope().equals(Artifact.SCOPE_TEST) || d.getScope().equals(Artifact.SCOPE_PROVIDED)) {
                    /* don't call createDependencyArtifact as it'll ignore test and provided scopes */
                    artifact = artifactFactory.createArtifact(
                            d.getGroupId(), d.getArtifactId(), d.getVersion(), d.getScope(), d.getType());
                } else {

        System.out.println(a.getScope());
        assertTrue(a.getScope().equals("test"), "Incorrect scope for " + a.getDependencyConflictId());

        // transitive dep, overridden b depMgmt
        assertTrue(b.getScope().equals("runtime"), "Incorrect scope for " + b.getDependencyConflictId());

        // direct dep, overrides depMgmt

            return objectsEqual(version, e.version)
                    && ArtifactScopeEnum.checkScope(scope)
                            .getScope()
                            .equals(ArtifactScopeEnum.checkScope(e.scope).getScope())
                    && depth == e.depth;
        }
        return false;
    }

    // ----------------------------------------------------------------------------

        }

        if ((artifact.getScope() != null)
                && (!node.isChildOfRootNode() || node.getArtifact().getScope() == null)) {
            fireEvent(ResolutionListener.MANAGE_ARTIFACT_SCOPE, listeners, node, artifact);
            node.getArtifact().setScope(artifact.getScope());
        }

        if (Artifact.SCOPE_SYSTEM.equals(node.getArtifact().getScope())

        assertNotNull( artifact, "dependency artifact not found in map." );
        assertEquals( Artifact.SCOPE_COMPILE, artifact.getScope(), "dependency artifact has wrong scope." );

        //check for back-propagation of default scope.
        assertEquals( Artifact.SCOPE_COMPILE, dep.getScope(), "default scope NOT back-propagated to dependency." );
        */
    }

    @Test
    @Disabled