}
        return new Result<>(result.hasErrors() || hasErrors(problems), result.get(), list);
    }

    public static <T> Result<T> addProblems(Result<T> result, Result<?>... results) {
        final List<ModelProblem> problemsList = new ArrayList<>();

        for (Result<?> result1 : results) {
            for (ModelProblem modelProblem : result1.getProblems()) {
                problemsList.add(modelProblem);
            }

        });

        ModelBuildingResult result = builder.build(request);
        Dependency dep = result.getEffectiveModel().getDelegate().getDependencyManagement().getDependencies().stream()
                .filter(d -> "test:mydep:jar".equals(d.getManagementKey()))
                .findFirst()
                .get();
        assertEquals("0.2", dep.getVersion());
        assertEquals(0, result.getProblems().size());
    }

    /**

            return addExceptionToResult(
                    result, graphResult.getProblems().iterator().next().getException());
        }

        try {
            if (result.hasExceptions()) {
                return result;
            }

            result.setTopologicallySortedProjects(session.getProjects());

            result.setProject(session.getTopLevelProject());

        boolean result = ensureAtLeastOneNonNull(os);

        if (result && os.getFamily() != null) {
            result = determineFamilyMatch(os.getFamily());
        }
        if (result && os.getName() != null) {
            result = determineNameMatch(os.getName());
        }
        if (result && os.getArch() != null) {
            result = determineArchMatch(os.getArch());
        }

            InternalScopeManager internalScopeManager) {
        ArrayList<org.eclipse.aether.scope.DependencyScope> result = new ArrayList<>();
        result.add(internalScopeManager.createDependencyScope(
                DependencyScope.COMPILE.id(), DependencyScope.COMPILE.isTransitive(), all()));
        result.add(internalScopeManager.createDependencyScope(
                DependencyScope.RUNTIME.id(),

        HashMap<String, NamedLockFactory> result = new HashMap<>();
        result.put(NoopNamedLockFactory.NAME, new NoopNamedLockFactory());
        result.put(LocalReadWriteLockNamedLockFactory.NAME, new LocalReadWriteLockNamedLockFactory());
        result.put(LocalSemaphoreNamedLockFactory.NAME, new LocalSemaphoreNamedLockFactory());
        result.put(FileLockNamedLockFactory.NAME, new FileLockNamedLockFactory());

			// Report caller of any failure
			return res.err
		}
		res.result.Type = healType
		if res.err != nil {
			res.result.Detail = res.err.Error()
		}
		if res.result.ParityBlocks > 0 && res.result.DataBlocks > 0 && res.result.DataBlocks > res.result.ParityBlocks {
			if got := countOKDrives(res.result.After.Drives); got < res.result.ParityBlocks {

        ToolchainsBuildingRequest request = new DefaultToolchainsBuildingRequest();
        ToolchainsBuildingResult result = toolchainBuilder.build(request);
        assertNotNull(result.getEffectiveToolchains());
        assertNotNull(result.getProblems());
        assertEquals(0, result.getProblems().size());
    }

    @Test
    void testBuildRequestWithUserToolchains() throws Exception {

                }
                result.addException(e);
                throw new ArtifactDescriptorException(result);
            }

            Artifact relocatedArtifact = getRelocation(session, result, model);
            if (relocatedArtifact != null) {
                if (withinSameGav(relocatedArtifact, a)) {
                    result.setArtifact(relocatedArtifact);

                nullify(artifact.getClassifier()),
                handler);

        result.setFile(artifact.getFile());
        result.setResolved(artifact.getFile() != null);

        List<String> trail = new ArrayList<>(1);
        trail.add(result.getId());
        result.setDependencyTrail(trail);

        return result;
    }

    public static void toArtifacts(