void testRoundTripProfiles() {
        Random entropy = new Random();
        ActivationFile af = ActivationFile.newBuilder()
                .exists("exists" + Long.toHexString(entropy.nextLong()))
                .missing("missing" + Long.toHexString(entropy.nextLong()))
                .build();
        ActivationProperty ap = ActivationProperty.newBuilder()
                .name("name" + Long.toHexString(entropy.nextLong()))

import org.apache.maven.artifact.versioning.OverConstrainedVersionException;

/**
 * Specific problems during resolution that we want to account for:
 * <ul>
 *   <li>missing metadata</li>
 *   <li>version range violations</li>
 *   <li>version circular dependencies</li>
 *   <li>missing artifacts</li>
 *   <li>network/transfer errors</li>
 *   <li>file system errors: permissions</li>
 * </ul>
 *

 * under the License.
 */
package org.apache.maven.api.services;

/**
 * The transformerContextBuilder is responsible for initializing the TransformerContext.
 * In case rawModels are missing, it could do new buildingRequests on the ModelBuilder.
 *
 * @since 4.0.0
 */
public interface ModelTransformerContextBuilder {
    /**
     * This method is used to initialize the TransformerContext
     *

import org.codehaus.plexus.component.configurator.ConfigurationListener;

/**
 * A configuration listener to help validate the plugin configuration. For instance, check for required but missing
 * parameters.
 *
 */
class ValidatingConfigurationListener implements ConfigurationListener {
    private final Object mojo;

    private final ConfigurationListener delegate;

    }

    private void printErrors(ArtifactResolutionResult result) {
        if (result.hasMissingArtifacts()) {
            for (Artifact artifact : result.getMissingArtifacts()) {
                System.err.println("Missing: " + artifact);
            }
        }

        if (result.hasExceptions()) {
            for (Exception e : result.getExceptions()) {
                e.printStackTrace();
            }
        }

     * @param foreignImports The packages/types to import from foreign realms, may be {@code null}.
     * @param artifacts The artifacts to add to the realm, may be {@code null}. Unresolved artifacts (i.e. with a
     *            missing file) will automatically be excluded from the realm.
     * @return The created class realm, never {@code null}.
     */
    private ClassRealm createRealm(
            String baseRealmId,
            RealmType type,

                Collection<Artifact> missing = new HashSet<>(e.getMissingArtifacts());

                for (Iterator<Artifact> it = missing.iterator(); it.hasNext(); ) {
                    String key = ArtifactUtils.key(it.next());
                    if (projectIds.contains(key)) {
                        it.remove();
                    }
                }

                if (!missing.isEmpty()) {
                    throw e;

                        .exists(settingsFile.getExists())
                        .missing(settingsFile.getMissing())
                        .location("exists", toLocation(settingsFile.getLocation("exists")))
                        .location("missing", toLocation(settingsFile.getLocation("missing")))
                        .build());
            }

                scenario("Selected optional project")
                        .activeOptionalProjects(MODULE_B)
                        .expectResult(MODULE_B),
                scenario("Selected missing optional project")
                        .activeOptionalProjects("non-existing-module")
                        .expectResult(
                                PARENT_MODULE,
                                MODULE_C,

        if (models != null) {
            ToolchainFactory fact = factories.get(type);

            if (fact == null) {
                logger.error(
                        "Missing toolchain factory for type: " + type + ". Possibly caused by misconfigured project.");
            } else {
                for (ToolchainModel model : models) {
                    try {