validations:
      required: false
  - type: textarea
    id: logs
    attributes:
      label: "Logs"
      description: "If possible please include gopls logs. Instructions for capturing them can be found here: https://github.com/golang/tools/blob/master/gopls/doc/troubleshooting.md#capture-logs"
    validations:

    }

    private void handleValidationProblemEvent(UserInputValidationProblemEvent event) {
        handlePrompt(event);
    }

    private void handlePromptOutputEvent(PromptOutputEvent event) {
        // Start capturing input prior to displaying the prompt so that the input received after the prompt is displayed will be captured.

    "global.meshExpansion.enabled" "Gateway and other Istio networking resources, such as in samples/multicluster/"
    "istiocoredns.enabled" "the in-proxy DNS capturing (ISTIO_META_DNS_CAPTURE)"
    "meshConfig.defaultConfig.tracing.stackdriver.debug" "Istio supported tracers"
    "meshConfig.defaultConfig.tracing.stackdriver.maxNumberOfAttributes" "Istio supported tracers"

            'eclipse', 'idea', 'version-catalog'
        ])
        if (appliesBasePlugin) {
            assert output.count("configuring :") == 2
            outputContains("configuring :help")
            // because capturing registered outputs for stale output cleanup forces configuring clean
            outputContains("configuring :clean")
        } else {
            assert output.count("configuring :") == 1

import org.gradle.operations.execution.FilePropertyVisitor;

import javax.annotation.Nullable;
import java.util.List;
import java.util.Map;

/**
 * Represents the computation of capturing the before execution state and resolving the caching state for transforms.
 * <p>
 * Must occur as a child of {@link org.gradle.operations.execution.ExecuteWorkBuildOperationType}.
 *
 * @since 8.3
 */

// run

// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Check that these do not use "by value" capturing,
// because changes are made to the value during the closure.

package main

var never bool

func main() {
	{
		type X struct {
			v int
		}
		var x X
		func() {
			x.v++
		}()
		if x.v != 1 {

	// Allow binding to a different var, for consistency with other components
	flag.AdditionalEnv(fs, constants.RedirectDNS, "ISTIO_META_DNS_CAPTURE")

	flag.BindEnv(fs, constants.CaptureAllDNS, "",
		"Instead of only capturing DNS traffic to DNS server IP, capture all DNS traffic at port 53. This setting is only effective when redirect dns is enabled.",
		&cfg.CaptureAllDNS)

	flag.BindEnv(fs, constants.InboundInterceptionMode, "m",

			return true
		}
	}
	return false
}

// IsExpectedGRPCError checks a gRPC error code and determines whether it is an expected error when
// things are operating normally. This is basically capturing when the client disconnects.
func IsExpectedGRPCError(err error) bool {
	if err == io.EOF {
		return true
	}

	if s, ok := status.FromError(err); ok {

A performance test configures various fixtures to describe each scenario. The fixtures will then run the scenario several times to warm up and then several more times, capturing metrics.
The metrics are collected in a database under `~/.gradle-performance-test-data` and a report is generated into `build/performance-tests/report`.

### Performance test builds

@Deprecated
public class MetadataGraphEdge {
    String version;
    ArtifactScopeEnum scope;
    int depth = -1;
    int pomOrder = -1;
    boolean resolved = true;
    String artifactUri;

    /**
     * capturing where this link came from
     * and where it is linked to.
     *
     *   In the first implementation only source used for explanatory function
     */
    MetadataGraphVertex source;