for (Iterator it = filesToDelete.iterator(); it.hasNext(); ) {
            File file = (File) it.next();

            if (file.exists()) {
                if (file.isDirectory()) {
                    FileUtils.deleteDirectory(file);
                } else {
                    file.delete();
                }
            }

            it.remove();
        }

            classLoader = getClass().getClassLoader();
        }
        try {
            for (Iterator<URL> it = classLoader
                            .getResources("META-INF/maven/org.apache.maven.api.di.Inject")
                            .asIterator();
                    it.hasNext(); ) {
                URL url = it.next();
                List<String> lines;
                try (InputStream is = url.openStream();

        for (Iterator<Dependency> it = deps.iterator(); it.hasNext(); ) {
            Dependency dependency = it.next();

            if (!("pom".equals(dependency.getType()) && "import".equals(dependency.getScope()))
                    || "bom".equals(dependency.getType())) {
                continue;
            }

            it.remove();

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * An implementation of a workspace reader that knows how to search the Maven reactor for artifacts, either as packaged
 * jar if it has been built, or only compile output directory if packaging hasn't happened yet.
 *
 */
@Named(ReactorReader.HINT)
@SessionScoped
class ReactorReader implements MavenWorkspaceReader {

    // ----------------------------------------------------------------------
    //
    // p1 inherits from p0
    // p0 inherits from super model
    //
    // or we can show it graphically as:
    //
    // p1 ---> p0 --> super model
    //
    // ----------------------------------------------------------------------

    @Test
    void testProjectInheritance() throws Exception {

    // ----------------------------------------------------------------------
    //
    // p1 inherits from p0
    // p0 inherits from super model
    //
    // or we can show it graphically as:
    //
    // p1 ---> p0 --> super model
    //
    // ----------------------------------------------------------------------

    @Test

        assertNotNull(paths);
        assertEquals(10, paths.size());
        assertEquals("test-extension-1.jar", paths.get(0).getFileName().toString());

        // JUnit has an "Automatic-Module-Name", so it appears on the module path.
        Map<PathType, List<Path>> dispatched = session.resolveDependencies(
                coord, PathScope.TEST_COMPILE, Arrays.asList(JavaPathType.CLASSES, JavaPathType.MODULES));

        MavenProject project = new MavenProject( new Model() );

        Set<Artifact> result = project.createArtifacts( dependencyFilter );

        for (Iterator<Artifact> it = result.iterator(); it.hasNext(); )
        {
            Artifact artifact = it.next();

            if ( "test-artifact2".equals( artifact.getArtifactId() ) )
            {
                ArtifactFilter filter = artifact.getDependencyFilter();

                } else {
                    /*
                     * NOTE: Other configurators like the map-oriented one don't call into the listener, so do it the
                     * hard way.
                     */
                    validateParameters(mojoDescriptor, configuration, expressionEvaluator);
                }
            }

    }

    /**
     * This method produces "surrogate" type registry that is static: it aims users that want to use
     * Maven-Resolver without involving Maven Core and related things.
     * <p>
     * This type registry is NOT used by Maven Core: Maven replaces it during Session creation with a type registry
     * that supports extending it (i.e. via Maven Extensions).
     * <p>