need it so that empty directory does not get deleted...

     * existing values in the execution request that are controlled by the toolchains. Hence, it is expected that this
     * method is called on a new/empty execution request before the caller mutates it to fit its needs.
     *
     * @param request The execution request to populate, must not be {@code null}.

  <name>Maven Integration Test :: MNG-3979</name>
  <description>
    Test that during inheritance the merging/joining of subtrees with equal identifier doesn't crash if the parent
    POM has a non-empty element and the child POM has an empty element to join.
  </description>

  <properties>
    <prop0>test</prop0>
  </properties>

  <repositories>
    <repository>
      <id>equal-repo-id</id>

/**
 *
 * @since 4.0.0
 */
@Experimental
public interface ArtifactManager extends Service {

    /**
     * Returns the path of the file previously associated to this artifact
     * or {@code Optional.empty()} if no path has been associated.
     */
    @Nonnull
    Optional<Path> getPath(@Nonnull Artifact artifact);

    /**
     * Associates the given file path to the artifact.
     */

    private static final Logger LOGGER = LoggerFactory.getLogger(MavenProject.class);

    public static final String EMPTY_PROJECT_GROUP_ID = "unknown";

    public static final String EMPTY_PROJECT_ARTIFACT_ID = "empty-project";

    public static final String EMPTY_PROJECT_VERSION = "0";

    private Model model;

    private MavenProject parent;

    private File file;

     * the settings builder to fail with a {@link ToolchainsBuilderException}.
     *
     * @return the problems that were encountered during the settings building, can be empty but never {@code null}
     */
    @Nonnull
    List<BuilderProblem> getProblems();

        return null;
    }

    @Override
    public <T> Optional<T> lookupOptional(Class<T> type) {
        return Optional.empty();
    }

    @Override
    public <T> Optional<T> lookupOptional(Class<T> type, String name) {
        return Optional.empty();
    }

    @Override
    public <T> List<T> lookupList(Class<T> type) {
        return List.of();
    }

    @Override

     * but cheaper to compute when the module names are not needed.
     *
     * @see #getPathType(Path)
     */
    private final Map<Path, PathType> pathTypes;

    /**
     * Creates an initially empty cache.
     */
    PathModularizationCache() {
        moduleInfo = new HashMap<>();
        pathTypes = new HashMap<>();
    }

    /**
     * Gets module information for the given JAR file or output directory.

     *
     * @return the classifier or an empty string if none, never {@code null}
     */
    @Nonnull
    String getClassifier();

    /**
     * The version of the artifact.
     *
     * @return the version
     */
    @Nonnull
    VersionConstraint getVersion();

    /**
     * The extension of the artifact.
     *
     * @return the extension or an empty string if none, never {@code null}
     */

    Collection<Phase> phases();

    /**
     * Pre-ordered list of phases.
     * If not provided, a default order will be computed.
     */
    default Optional<List<String>> orderedPhases() {
        return Optional.empty();
    }

    /**
     * A phase in the lifecycle.
     */
    interface Phase {
        String name();

        List<Plugin> plugins();
    }