*
     * @return this
     */
    Choice<T> whenNotConnected(T defaultOption);

    /**
     * Specifies how to display each option.
     *
     * @return this
     */
    Choice<T> renderUsing(Function<T, String> renderer);

    /**
     * Prompts the user to select an option.
     */
    T ask();

            .whenNotConnected(2)
            .ask() == 2
    }

    def "ignores option renderer"() {
        expect:
        userInputHandler.choice('Select count', [1, 2, 3])
            .renderUsing { throw new RuntimeException() }
            .ask() == 1
    }

    def "always returns default for int question"() {
        expect:
        userInputHandler.askIntQuestion('Enter something', 1, 2) == 2
    }

        private T defaultOption;

        NonInteractiveChoiceBuilder(Collection<T> options) {
            defaultOption = options.iterator().next();
        }

        @Override
        public Choice<T> renderUsing(Function<T, String> renderer) {
            // Ignore, the values are never rendered
            return this;
        }

        @Override
        public Choice<T> defaultOption(T defaultOption) {

            this.options = options;
            this.question = question;
            defaultOption = options.iterator().next();
        }

        @Override
        public Choice<T> renderUsing(Function<T, String> renderer) {
            this.renderer = renderer;
            return this;
        }

        @Override
        public Choice<T> defaultOption(T defaultOption) {

        }
        return userQuestions.choice("Select application structure", initializer.getModularizationOptions())
            .renderUsing(ModularizationOption::getDisplayName)
            .ask();
    }

    private boolean shouldUseIncubatingAPIs(UserQuestions userQuestions) {
        if (this.useIncubatingAPIs.isPresent()) {

        and:
        input == 13
    }

    def "can define how to render select options"() {
        when:
        def input = ask {
            it.choice("select option", [11, 12, 13])
                .renderUsing { it + "!" }
                .ask()
        }

        then:
        1 * outputEventBroadcaster.onOutput(_ as UserInputRequestEvent)

        } 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: