assertPathWithNormalizedFileSeparators(pom.getValue("build/testSourceDirectory"));
        assertPathWithNormalizedFileSeparators(pom.getValue("build/resources[1]/directory"));
        assertPathWithNormalizedFileSeparators(pom.getValue("build/testResources[1]/directory"));
        assertPathWithNormalizedFileSeparators(pom.getValue("build/filters[1]"));
        assertPathWithNormalizedFileSeparators(pom.getValue("reporting/outputDirectory"));

     *
     * @param scopeFilter a filter returning {@code true} for the artifact scopes to accept.
     * @param includeTestDir whether to include the test directory in the classpath elements.
     * @return paths of all artifacts placed on the classpath.
     * @throws DependencyResolutionRequiredException if an artifact file is used, but has not been resolved
     */

 *
 */
public interface ModelPathTranslator {

    /**
     * Resolves the well-known paths of the specified model against the given base directory. Paths within plugin
     * configuration are not processed.
     *
     * @param model The model whose paths should be resolved, may be {@code null}.

/**
 * A path translator that resolves relative paths against a specific base directory.
 *
 */
public class BasedirBeanConfigurationPathTranslator implements BeanConfigurationPathTranslator {

    private final File basedir;

    /**
     * Creates a new path translator using the specified base directory.
     *
     * @param basedir The base directory to resolve relative paths against, may be {@code null} to disable path

     */
    PathModularizationCache() {
        moduleInfo = new HashMap<>();
        pathTypes = new HashMap<>();
    }

    /**
     * Gets module information for the given JAR file or output directory.
     * Module descriptors are read when first requested, then cached.
     */
    PathModularization getModuleInfo(Path path) throws IOException {
        PathModularization info = moduleInfo.get(path);

@Deprecated
public interface ArtifactDeployer {
    String ROLE = ArtifactDeployer.class.getName();

    /**
     * Deploy an artifact from a particular directory. The artifact handler is used to determine the
     * filename of the source file.
     *
     * @param basedir the directory where the artifact is stored
     * @param finalName the name of the artifact without extension
     * @param artifact the artifact definition

    public String pathOfRemoteRepositoryMetadata(ArtifactMetadata metadata) {
        return pathOfRepositoryMetadata(metadata, metadata.getRemoteFilename());
    }

    private String formatAsDirectory(String directory) {
        return directory.replace(GROUP_SEPARATOR, PATH_SEPARATOR);
    }

    @Override
    public String toString() {
        return getId();
    }

        build.setDirectory("expected-directory");
        build.setFinalName("expected-finalName");

        Model model = new Model();
        model.setBuild(build);

        ExpressionEvaluator expressionEvaluator =
                createExpressionEvaluator(new MavenProject(model), null, new Properties());

        Object value = expressionEvaluator.evaluate("${project.build.directory}" + FS + "${project.build.finalName}");

import org.apache.maven.project.MavenProject;
import org.apache.maven.project.ProjectBuildingException;

/**
 * Strategy to collect projects based on the <code>-f</code> CLI parameter or the pom.xml in the working directory.
 */
@Named("RequestPomCollectionStrategy")
@Singleton
public class RequestPomCollectionStrategy implements ProjectCollectionStrategy {
    private final ProjectsSelector projectsSelector;

    @Inject

 */
package org.apache.maven.artifact.repository.metadata;

import org.apache.maven.artifact.Artifact;
import org.apache.maven.artifact.repository.ArtifactRepository;

/**
 * Metadata for the artifact version directory of the repository.
 *
 * TODO split instantiation (versioning, plugin mappings) from definition
 */
@Deprecated
public class SnapshotArtifactRepositoryMetadata extends AbstractRepositoryMetadata {