} catch (Exception e) {
            String valueClass = value != null ? String.valueOf(value.getClass()) : "null";
            LOGGER.warn("Rendering of the property '{}' with value type '{}' failed with exception", name, valueClass, e);
            strValue = valueClass + " [Rendering failed]";
        }
        getTextOutput().formatln("%s: %s", name, strValue);
    }

 */
package org.gradle.api.tasks.diagnostics.internal;

/**
 * Renders the model of a project dependency report.
 */
public interface DependencyReportRenderer extends ReportRenderer {

    /**
     * Starts rendering the given configuration.
     *
     * @param configuration The configuration.
     */
    void startConfiguration(ConfigurationDetails configuration);

    /**

		"manifest_patch_error_total",
		"Number of times K8S patch overlays failed",
	)

	// ManifestRenderErrorTotal counts errors occurred while rendering manifest.
	ManifestRenderErrorTotal = monitoring.NewSum(
		"manifest_render_error_total",
		"Number of times error occurred during rendering output manifest",
	)

	// LegacyPathTranslationTotal counts the translations from legacy API to new one.

        when:
        task.action()

        then:
        1 * renderer.addProperty('group', '')
        1 * renderer.addProperty('version', 'unspecified')
    }

    def "uses placeholder for rendering 'properties' property"() {
        when:
        task.action()

        then:
        1 * renderer.addProperty('properties', '{...}')
    }

    def "can show a single property"() {
        given:

        then:
        reportModel.configurations.size() == 2
        reportModel.configurations[0].name == conf1.name
        reportModel.configurations[1].name == conf2.name
    }

    def "rendering can be limited to specific configurations"() {
        given:
        project.configurations.create("a")
        def bConf = project.configurations.create("b")
        task.configurations = [bConf] as Set

        when:

the language generators; it digests the Op registry and API definitions to build
the model and provides utilities for the language generators.

The *View* and rendering classes map the language-independent Model classes
(`OpSpec`, `ArgSpec`, `AttrSpec`, etc.) to language-specific `SourceCode`. The
framework does not impose any design on the language-specific generators, but

    }

    @Override
    protected void generateReportFor(ProjectDetails project, PropertyReportModel model) {
        for (PropertyWarning warning : model.warnings) {
            getLogger().warn(
                "Rendering of the property '{}' with value type '{}' failed with exception",
                warning.name, warning.valueClass, warning.exception
            );
        }
        for (Pair<String, String> entry : model.properties) {

    StyledLabel getStatusBar();

    /**
     * Flushes any pending updates. Updates may or may not be buffered, and this method should be called to finish rendering and pending updates, such as updating the status bar.
     */
    void flush();

            .forEach(problem -> {
                // Because our deprecation warning system doesn't support multiline strings (bummer!) both in rendering
                // **and** testing (no way to capture multiline deprecation warnings), we have to resort to removing details
                // and rendering
                String warning = convertToSingleLine(renderMinimalInformationAbout(problem, false, false));

import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
import org.jetbrains.kotlin.diagnostics.KtDiagnostic
import org.jetbrains.kotlin.diagnostics.KtPsiDiagnostic
import org.jetbrains.kotlin.diagnostics.rendering.RootDiagnosticRendererFactory

internal abstract class KaAbstractFirDiagnostic<PSI : PsiElement>(
    private val firDiagnostic: KtPsiDiagnostic,
    override val token: KaLifetimeToken,