version = constructVersion(repoMetadata.getVersioning(), artifact.getBaseVersion());
        }

        if (version == null) {
            // use the local copy, or if it doesn't exist - go to the remote repo for it
            version = artifact.getBaseVersion();
        }

        // TODO also do this logging for other metadata?
        // TODO figure out way to avoid duplicated message

        assertFalse(toolchain.matchesRequirements(Collections.singletonMap("name", "John Doe")));
        verify(logger).debug("Toolchain {} doesn't match required property: {}", toolchain, "name");
    }

    @Test
    void testEquals() {
        ToolchainModel tm1 = new ToolchainModel();
        tm1.setType("jdk");

                return false;
            }
            if (!matcher.matches(requirement.getValue())) {
                getLog().debug("Toolchain {} doesn't match required property: {}", this, key);
                return false;
            }
        }
        return true;
    }

    protected Logger getLog() {
        return logger;
    }

 *
 * As a non-default component this now gets a negative priority relative to other implementations
 * of the same interface. Since we want to allow overriding this doesn't matter in this case.
 * (if it did we could add @Priority of 0 to match the priority given to default components.)
 */
@Named
@Singleton
public class DefaultModelProcessor implements ModelProcessor {

        return result;
    }

    private static boolean policyEquals(RepositoryPolicy p1, RepositoryPolicy p2) {
        if (p1 == p2) {
            return true;
        }
        // update policy doesn't affect contents
        return p1.isEnabled() == p2.isEnabled() && Objects.equals(p1.getChecksumPolicy(), p2.getChecksumPolicy());
    }

     * <p>
     * Supported filters:
     * <ul>
     *     <li>"h" or "h(num)" - highest version or top list of highest ones filter</li>
     *     <li>"l" or "l(num)" - lowest version or bottom list of lowest ones filter</li>
     *     <li>"s" - contextual snapshot filter</li>
     *     <li>"e(G:A:V)" - predicate filter (leaves out G:A:V from range, if hit, V can be range)</li>
     * </ul>

    </dependency>
    <dependency>
      <groupId>org.apache.maven.resolver</groupId>
      <artifactId>maven-resolver-transport-file</artifactId>
    </dependency>
    <!-- HTTP/1.1, lowest priority, Java8+ (still must as some ITs force it) -->
    <dependency>
      <groupId>org.apache.maven.resolver</groupId>
      <artifactId>maven-resolver-transport-wagon</artifactId>
    </dependency>

        // snapshot timestamp, or some other timestamp later encoded into the metadata.
        // TODO this needs to be repeated here so the merging doesn't interfere with the written metadata
        //  - we'd be much better having a pristine input, and an ongoing metadata for merging instead

        Map<ArtifactRepository, Metadata> previousMetadata = new HashMap<>();

        // default does nothing
    }

    public void projectSucceeded(ExecutionEvent event) {
        // default does nothing
    }

    public void projectFailed(ExecutionEvent event) {
        // default does nothing
    }

    public void forkStarted(ExecutionEvent event) {
        // default does nothing
    }

    public void forkSucceeded(ExecutionEvent event) {
        // default does nothing
    }

package org.apache.maven.artifact;

import org.codehaus.plexus.component.repository.exception.ComponentLookupException;

/**
 * Exception which is meant to occur when a layout specified for a particular
 * repository doesn't have a corresponding {@link org.apache.maven.artifact.repository.layout.ArtifactRepositoryLayout}
 * component in the current container.
 *
 */
@Deprecated