*/
package org.apache.maven.logwrapper;

import java.util.HashMap;
import java.util.Map;

import org.slf4j.event.Level;

/**
 * Responsible for keeping state of whether the threshold of the --fail-on-severity flag has been hit.
 */
public class LogLevelRecorder {
    private static final Map<String, Level> ACCEPTED_LEVELS = new HashMap<>();

    static {
        ACCEPTED_LEVELS.put("WARN", Level.WARN);

        private volatile MavenSession session;

        public void run() {
            try {
                latch.await();
            } catch (InterruptedException ignore) {
                // Test may fail if we get interrupted
            }
            session = defaultLegacySupport.getSession();
        }

        public MavenSession getSession() {
            return session;
        }
    }

        assertThrows(
                ChecksumFailedException.class,
                () -> wagonManager.getArtifact(artifact, repo, null, false),
                "Checksum verification did not fail");

        wagon.clearExpectedContent();
        wagon.addExpectedContent("path", "lower-case-checksum");
        wagon.addExpectedContent("path.md5", "50b2cf50a103a965efac62b983035cac");

     * verify the path and resolve the artifact if the path actually denotes an existing file. If the path isn't valid,
     * resolution will fail and no attempts to search local/remote repositories are made.
     */
    public static final String LOCAL_PATH = "localPath";

    private MavenArtifactProperties() {
        // hide constructor
    }

        if (repositoryUrl.contains("${")) {
            // the repository url contains unresolved properties and getting the basedir is not possible
            // in JDK 20+ 'new URL(string)' will fail if the string contains a curly brace
            this.basedir = null;
        } else {
            try {
                URL url = new URL(repository.getUrl());
                if ("file".equals(url.getProtocol())) {

        }
    }

    private void parseInvalid(String range) {
        try {
            versionParser.parseVersionRange(range);
            fail(range + " should be invalid");
        } catch (VersionParserException e) {
            assertTrue(true);
        }
    }

    private void assertContains(VersionRange range, String version) {

    public boolean isSnapshot() {
        return parent.isSnapshot();
    }

    public void addMetadata(ArtifactMetadata metadata) {
        // ignore. The parent artifact will handle metadata.
        // we must fail silently here to avoid problems with the artifact transformers.
    }

    public Collection<ArtifactMetadata> getMetadataList() {
        return Collections.emptyList();
    }

     * {@link ModelProblem.Severity#WARNING} and below are reported here. Problems with a higher severity level cause
     * the model builder to fail with a {@link ModelBuildingException}.
     *
     * @return The problems that were encountered during the model building, can be empty but never {@code null}.
     */
    List<ModelProblem> getProblems();

        return sb.toString();
    }

    public Artifact find(Artifact artifact) {
        File artifactFile = new File(getBasedir(), pathOf(artifact));

        // We need to set the file here or the resolver will fail with an NPE, not fully equipped to deal
        // with multiple local repository implementations yet.
        artifact.setFile(artifactFile);

        if (artifactFile.exists()) {
            artifact.setResolved(true);

import java.util.Set;
import java.util.function.Predicate;

import static java.util.stream.Collectors.toSet;

/**
 * Container for storing the request from the user to activate or de-activate certain profiles and optionally fail the
 * build if those profiles do not exist.
 */
public class ProfileActivation {
    private final Map<String, ActivationSettings> activations = new HashMap<>();

    /**