}

    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,

            return false;
        }

        String path;
        boolean missing;

        if (file.getExists() != null && !file.getExists().isEmpty()) {
            path = file.getExists();
            missing = false;
        } else if (file.getMissing() != null && !file.getMissing().isEmpty()) {
            path = file.getMissing();
            missing = true;
        } else {
            return false;
        }

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

    @Inject
    private ArtifactRepositoryFactory artifactRepositoryFactory;

    @Test
    void testUnnecessaryRepositoryLookup() throws Exception {
        Artifact artifact = createTestPomArtifact("target/test-data/get-missing-pom");

        List<ArtifactRepository> repos = new ArrayList<>();
        repos.add(artifactRepositoryFactory.createArtifactRepository(
                "repo1", "string://url1", new ArtifactRepositoryLayoutStub(), null, null));

            return false;
        }

        if (!string.isEmpty()) {
            return true;
        }

        addViolation(problems, BuilderProblem.Severity.ERROR, fieldName, sourceHint, "is missing");

        return false;
    }

    /**
     * Asserts:
     * <p/>
     * <ul>
     * <li><code>string != null</code>
     * </ul>
     */
    private static boolean validateNotNull(

     * Builds a project descriptor for the specified artifact.
     *
     * @param projectArtifact The POM artifact to build the project from, must not be {@code null}.
     * @param allowStubModel A flag controlling the case of a missing POM artifact. If {@code true} and the specified
     *            POM artifact does not exist, a simple stub model will be returned. If {@code false}, an exception will
     *            be thrown.

        @Override
        protected ActivationFile.Builder transformActivationFile_Missing(
                Supplier<? extends ActivationFile.Builder> creator,
                ActivationFile.Builder builder,
                ActivationFile target) {
            stk.push(nextFrame("missing"));
            try {
                return super.transformActivationFile_Missing(creator, builder, target);
            } finally {
                stk.pop();

    /**
     * Post-processes the effective configuration for the specified mojo execution. This step discards all parameters
     * from the configuration that are not applicable to the mojo and injects the default values for any missing
     * parameters.
     *
     * @param mojoExecution The mojo execution whose configuration should be finalized, must not be {@code null}.
     */

        resolutionErrorHandler.throwErrors(request, result);
        assertEquals(1, result.getArtifacts().size());

        //
        // Put in a bogus file to make sure missing files cause the resolution to fail.
        //
        file = new File(getBasedir(), "src/test/repository-system/maven-monkey-2.1.0.jar");
        assertFalse(file.exists());
        d.setSystemPath(file.getCanonicalPath());