MetadataRequest metadataRequest = new MetadataRequest(metadata, repository, request.getRequestContext());
            metadataRequest.setDeleteLocalCopyIfMissing(true);
            metadataRequest.setTrace(trace);
            metadataRequests.add(metadataRequest);
        }

        List<MetadataResult> metadataResults = metadataResolver.resolveMetadata(session, metadataRequests);

    public static final MojoDescriptor PROCESS_RESOURCES = createMojoDescriptor("process-resources");

    public static final MojoDescriptor COMPILE = createMojoDescriptor("compile", true);

    public static final MojoDescriptor TEST = createMojoDescriptor("test");

    public static final MojoDescriptor PACKAGE = createMojoDescriptor("package");

            repositories = remoteRepositoryManager.aggregateRepositories(session, repositories, newRepositories, true);
        } else {
            pomRepositories =
                    remoteRepositoryManager.aggregateRepositories(session, pomRepositories, newRepositories, true);
            repositories = remoteRepositoryManager.aggregateRepositories(

    public MavenXpp3ReaderEx() {
        this(null);
    }

    public MavenXpp3ReaderEx(ContentTransformer contentTransformer) {
        super(contentTransformer != null ? contentTransformer::transform : null, true);
    }

    @Override
    public Model read(Reader reader, boolean strict, InputSource source) throws IOException, XmlPullParserException {
        return super.read(reader, strict, source);
    }

    @Override

    /**
     * Builds the effective model by completing the specified interim result which was produced by a previous call to
     * {@link #build(ModelBuildingRequest)} with {@link ModelBuildingRequest#isTwoPhaseBuilding()} being {@code true}.
     * The model building request passed to this method must be the same as the one used for the first phase of the
     * model building.
     *

            hash = hash * 31 + this.version.hashCode();
            hashCode = hash;
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj) {
                return true;
            }

            if (!(obj instanceof CacheKey)) {
                return false;
            }

            CacheKey that = (CacheKey) obj;

        for (ThreadGroup aTgList : tgList) {
            if (!aTgList.getName().equals(DefaultArtifactResolver.DaemonThreadCreator.THREADGROUP_NAME)) {
                continue;
            }

            seen = true;

            tg = aTgList;
            Thread[] ts = new Thread[tg.activeCount()];
            tg.enumerate(ts);

            for (Thread active : ts) {
                String name = active.getName();

            Artifact artifact = (Artifact) iter.next();
            System.out.println("Artifact: " + artifact.getDependencyConflictId() + " " + artifact.getVersion()
                    + " Optional=" + (artifact.isOptional() ? "true" : "false"));
            assertTrue(
                    artifact.getVersion().equals("1.0"), "Incorrect version for " + artifact.getDependencyConflictId());
        }
    }

        cl.delegate = builder
        cl.call()
        return builder.elements[0]
    }

    public static void leftShift(Node parent, Node node) {
        parent.appendChild(parent.ownerDocument.importNode(node, true))
    }

    public static void addFirst(Node parent, Closure cl) {
        DomBuilder builder = new DomBuilder(parent.ownerDocument, null)
        cl.delegate = builder
        cl.call()

                td.appendChild(caution);
                caution.appendChild(document.createTextNode("Incubating"));
            }
            td.appendChild(document.importNode(methodDoc.getDescription(), true));
        }
    }