*
     * @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)

            .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,

 *
 * @since 4.5
 */
public enum WarningMode {
    /**
     * Show all warnings.
     */
    All(true),

    /**
     * Display a summary at the end of the build instead of rendering all warnings into the console output.
     */
    Summary(false),

    /**
     * No deprecation warnings at all.
     */
    None(false),

    /**

 * with regard to console rendering and effectively emulate.
 *
 * Ideally, we would emit a more concrete model.
 * This would be something like more clearly separating logging output from “user code” from Gradle's “UI” output,
 * and separately observing it from rendering instructions.
 * This may come later.
 *
 * @since 4.7
 */