}
	return nil
}

func prometheusAPI(address string) (promv1.API, error) {
	promClient, err := api.NewClient(api.Config{Address: address})
	if err != nil {
		return nil, fmt.Errorf("could not build prometheus client: %v", err)
	}
	return promv1.NewAPI(promClient), nil
}

func metrics(promAPI promv1.API, workload string, duration time.Duration) (workloadMetrics, error) {

// limitations under the License.

package api

import (
	"context"
	"encoding/json"
	"fmt"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"time"

	promv1 "github.com/prometheus/client_golang/api/prometheus/v1"
	"github.com/prometheus/common/model"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

	"istio.io/istio/pkg/config/protocol"
	"istio.io/istio/pkg/http/headers"

	if d != signed && d != unsigned {
		return
	}

	// Additional facts we know given the relationship between len and cap.
	//
	// TODO: Since prove now derives transitive relations, it
	// should be sufficient to learn that len(w) <= cap(w) at the
	// beginning of prove where we look for all len/cap ops.
	if v.Op == OpSliceLen && r&lt == 0 && ft.caps[v.Args[0].ID] != nil {
		// len(s) > w implies cap(s) > w

prop-prov-1.png...

            return prompt(prompt, defaultValue, sanitizedValue -> sanitizedValue);
        }

        private <T> T prompt(PromptOutputEvent prompt, final T defaultValue, final Transformer<T, String> parser) {
            T result = prompt(prompt, sanitizedInput -> {
                if (sanitizedInput.isEmpty()) {
                    return defaultValue;
                }
                return parser.transform(sanitizedInput);
            });

        // Start capturing input prior to displaying the prompt so that the input received after the prompt is displayed will be captured.
        // This does leave a small window where some text may be captured prior to the prompt being fully displayed, however this is
        // better than doing things in the other order, where there will be a small window where text may not be captured after prompt is fully displayed.

/**
 * Requests that the client present the given prompt to the user and return the user's response as a single line of text.
 *
 * The response is delivered to the {@link UserInputReader} service.
 */
public abstract class PromptOutputEvent extends RenderableOutputEvent implements InteractiveEvent {
    public PromptOutputEvent(long timestamp) {
        super(timestamp, "prompt", LogLevel.QUIET, null);
    }

    @Override

            runBuildWithStandardInput(connection, 'something one', 'something two')
        }

        then:
        output.contains(FOO.prompt)
        output.contains(FOO.answerOutput('something one'))
        output.contains(BAR.prompt)
        output.contains(BAR.answerOutput('something two'))
    }

    def "can capture multiple user input if standard input was provided using default values"() {

    }

    @Override
    public String prompt(String message) throws PrompterException {
        return prompt(message, null, null);
    }

    @Override
    public String prompt(String message, String defaultReply) throws PrompterException {
        return prompt(message, null, defaultReply);
    }

    @Override
    public String prompt(String message, List possibleValues) throws PrompterException {

    private final String prompt;

    public UserInputValidationProblemEvent(long timestamp, String prompt) {
        super(timestamp, "prompt", LogLevel.QUIET, null);
        this.prompt = prompt;
    }

    @Override
    public void render(StyledTextOutput output) {
        output.text(prompt);
    }

    @Override