if (details instanceof DefaultProblemProgressDetails) {
            Problem problem = ((DefaultProblemProgressDetails) details).getProblem();
            return Optional.of(createProblemEvent(buildOperationId, problem));
        }
        return empty();
    }

                norm(it)
            }
        }

        String getArtifactTooltip() {
            row.select("td > div[uk-tooltip]").attr("uk-tooltip") - 'title: '
        }

        String getProblem() {
            if (problems.size() != 1) {
                throw new AssertionError("Expected a single problem but there were ${problems.size()}")
            }
            problems[0]
        }
    }

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

    @Test
    void testBuildRequestWithUserToolchains() throws Exception {
        Properties props = new Properties();
        props.put("key", "user_value");

                .findFirst()
                .get();
        assertEquals("0.3", dep.getVersion());
        assertEquals(1, result.getProblems().size());
        ModelProblem problem = result.getProblems().get(0);
        assertTrue(problem.toString().contains("Ignored POM import"));
    }

    /**
     * This test has

                // that may lead to unexpected build failure, log them
                if (!modelResult.getProblems().isEmpty()) {
                    List<ModelProblem> problems = modelResult.getProblems();
                    logger.warn(
                            "{} {} encountered while building the effective model for {}",
                            problems.size(),

        if (!settingsResult.getProblems().isEmpty() && LOGGER.isWarnEnabled()) {
            LOGGER.warn("");
            LOGGER.warn("Some problems were encountered while building the effective settings");

            for (SettingsProblem problem : settingsResult.getProblems()) {
                LOGGER.warn("{} @ {}", problem.getMessage(), problem.getLocation());
            }

        }
    }

    def "Problems expose details via Tooling API events with failure"() {
        given:
        withReportProblemTask """
            getProblems().forNamespace("org.example.plugin").reporting {
                it.${targetVersion < GradleVersion.version("8.8") ? 'label("shortProblemMessage").category("main", "sub", "id")' : 'id("id", "shortProblemMessage")'}

        assertEquals(1, pex.getResults().size());
        assertNotNull(pex.getResults().get(0).getPomFile());
        assertThat(pex.getResults().get(0).getProblems().size(), greaterThan(0));
        assertThat(
                pex.getResults(),
                contains(projectBuildingResultWithProblemMessage(

        Result<? extends ProjectDependencyGraph> graphResult = buildGraph(session);

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

        try {
            session.setProjectMap(getProjectMap(session.getProjects()));
        } catch (DuplicateProjectException e) {

            }
        }
        DefaultTypeValidationContext.throwOnProblemsOf(implementation, validationContext.getProblems());
        Transform transform = new DefaultTransform(
            implementation,
            parameterObject,
            from,
            to,