go list -m -retracted -f '{{range .Retracted}}{{.}},{{end}}' example.com/retract/rationale@v1.0.1-order
stdout '^single version,degenerate range,$'

# 'go get' will only report the first retraction to avoid being too verbose.
go get example.com/retract/rationale@v1.0.0-order
stderr '^go: warning: example.com/retract/rationale@v1.0.0-order: retracted by module author: degenerate range$'
go get example.com/retract/rationale@v1.0.1-order

//
// If stdout doesn't match the expected output or if recovered is non-nil, it'll print the cause of failure to stdout.
// If the test is chatty/verbose, it'll print a success message to stdout.
// If recovered is non-nil, it'll panic with that value.
// If the test panicked with nil, or invoked runtime.Goexit, it'll be
// made to fail and panic with errNilPanicOrGoexit

typedef enum {
  CU_BRM_NORMAL = 0,  /**< Normal mode - failures and run summary are printed [default]. */
  CU_BRM_SILENT,      /**< Silent mode - no output is printed except framework error messages. */
  CU_BRM_VERBOSE      /**< Verbose mode - maximum output of run details. */
} CU_BasicRunMode;

CU_EXPORT CU_ErrorCode CU_basic_run_tests(void);
/**< 
 *  Runs all registered CUnit tests using the basic interface.

go test -run FuzzFoo/thispasses
stdout ok
! stdout 'no tests to run'

go test -run /thispasses
stdout ok
! stdout 'no tests to run'

# Same tests in verbose mode
go test -v -run FuzzFoo/thispasses
stdout '=== RUN   FuzzFoo/thispasses'
stdout '--- PASS: FuzzFoo/thispasses'
! stdout '=== RUN   FuzzFoo/thisfails'
! stdout 'no tests to run'

go test -v -run /thispasses

    MinimalJavadocOptions extDirs(File... extDirs);

    @Console
    JavadocOutputLevel getOutputLevel();

    void setOutputLevel(JavadocOutputLevel outputLevel);

    MinimalJavadocOptions verbose();

    @Internal
    boolean isVerbose();

    MinimalJavadocOptions quiet();

    @Input
    boolean isBreakIterator();

    void setBreakIterator(boolean breakIterator);

	}

	// Log with redaction
	if err := api.RedactSecrets(kcfg); err != nil {
		return kubeconfig{}, err
	}
	for _, c := range kcfg.Clusters {
		// Not actually sensitive, just annoyingly verbose.
		c.CertificateAuthority = "REDACTED"
	}
	lrcfg, err := latest.Scheme.ConvertToVersion(kcfg, latest.ExternalVersion)
	if err != nil {
		return kubeconfig{}, err
	}
	redacted, err := yaml.Marshal(lrcfg)

	}
	t.Logf("Saw %d out of %d lines without statement marks", len(nonStmtLines), len(lines))
	if testing.Verbose() {
		sort.Slice(nonStmtLines, func(i, j int) bool {
			if nonStmtLines[i].File != nonStmtLines[j].File {
				return nonStmtLines[i].File < nonStmtLines[j].File
			}
			return nonStmtLines[i].Line < nonStmtLines[j].Line

package main

import (
	"flag"
	"fmt"
	"io"
	"log"
	"math/rand"
	"net"
	"net/http"
	"net/http/httptest"
	"os/exec"
	"strconv"
	"time"
)

var (
	v         = flag.Bool("v", false, "verbose")
	doMaps    = flag.Bool("maps", true, "stress maps")
	doExec    = flag.Bool("exec", true, "stress exec")
	doChan    = flag.Bool("chan", true, "stress channels")
	doNet     = flag.Bool("net", true, "stress networking")

export VARIANT

# If we're not intending to pull from an actual remote registry, use the local kind registry
if [[ -z "${SKIP_BUILD:-}" ]]; then
  HUB="${KIND_REGISTRY}"
  export HUB
fi

# Setup junit report and verbose logging
export T="${T:-"-v -count=1"}"
export CI="true"

export ARTIFACTS="${ARTIFACTS:-$(mktemp -d)}"
trace "init" make init

if [[ -z "${SKIP_SETUP:-}" ]]; then

// `MLIR_BRIDGE_LOG_STRING_FILTER="my_string"` will dump IR only for invocations
// of `LegalizeTF` and `Canonicalizer` where the string `my_string` is contained
// in the serialized operation on which the pass is invoked. For verbose log
// level >= 1, `bridge_logger.cc` prints details about pass invocations for
// which the IR dumping was skipped because of a filter.
class BridgeLoggerConfig : public mlir::PassManager::IRPrinterConfig {
 public: