return this;
        }

        @Override
        public Choice<T> defaultOption(T defaultOption) {
            this.defaultOption = defaultOption;
            return this;
        }

        @Override
        public Choice<T> whenNotConnected(T defaultOption) {
            this.defaultOption = defaultOption;
            return this;
        }

        @Override
        public T ask() {

            return this;
        }

        @Override
        public Choice<T> defaultOption(T defaultOption) {
            this.defaultOption = defaultOption;
            return this;
        }

        @Override
        public Choice<T> whenNotConnected(T defaultOption) {
            // Ignore
            return this;
        }

        @Override
        public T ask() {

    private final String question;
    private final List<String> options;
    private final int defaultOption;

    public SelectOptionPromptEvent(long timestamp, String question, List<String> options, int defaultOption) {
        super(timestamp);
        this.question = question;
        this.options = options;
        this.defaultOption = defaultOption;
    }

    public String getQuestion() {
        return question;
    }

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

    /**
     * Specifies the option to use when not connected to a console. This can be different to the default option presented to the user.
     *
     * @return this
     */
    Choice<T> whenNotConnected(T defaultOption);

    /**
     * Specifies how to display each option.
     *
     * @return this

	"time"

	"istio.io/istio/pkg/test/util/assert"
)

func TestBackOff(t *testing.T) {
	var (
		testInitialInterval = 500 * time.Millisecond
		testMaxInterval     = 5 * time.Second
	)

	o := DefaultOption()
	o.InitialInterval = testInitialInterval
	o.MaxInterval = testMaxInterval
	exp := NewExponentialBackOff(o)
	exp.(ExponentialBackOff).exponentialBackOff.Multiplier = 2

func (o *Options) ConvertToClientOption() grpc.DialOption {
	return grpc.WithKeepaliveParams(keepalive.ClientParameters{
		Time:    o.Time,
		Timeout: o.Timeout,
	})
}

// DefaultOption returns the default keepalive options.
func DefaultOption() *Options {
	return &Options{
		Time:                        grpcKeepaliveInterval,
		Timeout:                     grpcKeepaliveTimeout,
		MaxServerConnectionAge:      Infinity,

     *
     * @param question The text of the question.
     * @param defaultOption The option to present to the user as the default selection, and also the value to use when not connected to a console.
     * @return the answer or the default if not connected to a console.
     */
    <T> T selectOption(String question, Collection<T> options, T defaultOption);

    /**

        1 * outputEventBroadcaster.onOutput(_) >> { SelectOptionPromptEvent event ->
            assert event.question == "select option"
            assert event.options == ["11", "12", "13"]
            assert event.defaultOption == 1
        }
        1 * userInputReader.readInput() >> new UserInputReader.TextResponse("2")
        1 * outputEventBroadcaster.onOutput(_ as UserInputResumeEvent)
        0 * outputEventBroadcaster._

            .ask() == 1
    }

    def "returns default option for choice"() {
        expect:
        userInputHandler.choice('Select count', [1, 2, 3])
            .defaultOption(2)
            .ask() == 2
        userInputHandler.choice('Select count', [1, 2, 3])
            .whenNotConnected(2)
            .ask() == 2
    }

    def "ignores option renderer"() {
        expect:

	xdsProxy *XdsProxy
}

func NewTapGrpcHandler(xdsProxy *XdsProxy) (*grpc.Server, error) {
	proxy := &tapProxy{
		xdsProxy: xdsProxy,
	}
	grpcs := grpc.NewServer(istiogrpc.ServerOptions(istiokeepalive.DefaultOption())...)
	discovery.RegisterAggregatedDiscoveryServiceServer(grpcs, proxy)
	reflection.Register(grpcs)
	return grpcs, nil
}

const (
	TypeDebugPrefix = "istio.io/debug/"
)