[short] skip

# Only the main module has a root directory in vendor mode.
go mod vendor
go list -f {{.Module.Dir}} example.com/main
stdout $PWD
go list -f {{.Module.Dir}} example.com/stack
! stdout .

# The program prints a file name from a vendored package.
# Without -trimpath, the name should include the vendor directory.
go run main.go
stdout vendor

# With -trimpath, everything before the package path should be trimmed.

	v := New()
	r := "hi\n"
	v.Insert(i4)
	v.Insert(i3)
	v.Insert(i2)
	v.Insert(i1)
	v.Insert(i0)
	for i := 0; i < v.nelem; i++ {
		var x *I
		x = v.At(i).(*I)
		r += fmt.Sprintln(i, x.val) // prints correct list
	}
	for i := 0; i < v.nelem; i++ {
		r += fmt.Sprintln(i, v.At(i).(*I).val)
	}
	expect := `hi
0 44444
1 3333
2 222
3 11
4 0
0 44444
1 3333
2 222
3 11
4 0
`

func NewWarningPrinter(out io.Writer, opts WarningPrinterOptions) *WarningPrinter {
	h := &WarningPrinter{out: out, opts: opts}
	return h
}

// Print prints warnings to the configured writer.
func (w *WarningPrinter) Print(message string) {
	if w.opts.Color {
		fmt.Fprintf(w.out, "%sWarning:%s %s\n", yellowColor, resetColor, message)
	} else {

# This test checks that 'go test' prints a reasonable error when fuzzing is
# enabled, and multiple package or multiple fuzz targets match.
# TODO(#46312): support fuzzing multiple targets in multiple packages.

[!fuzz] skip
[short] skip
env GOCACHE=$WORK/cache

# With fuzzing disabled, multiple targets can be tested.
go test ./...

# With fuzzing enabled, at most one package may be tested,
# even if only one package contains fuzz targets.

var b bool

func f1(q *Q, xx []byte) interface{} { // ERROR "live at call to newobject: xx$" "live at entry to f1: xx$"
	// xx was copied from the stack to the heap on the previous line:
	// xx was live for the first two prints but then it switched to &xx
	// being live. We should not see plain xx again.
	if b {
		global = &xx
	}
	xx, _, err := f2(xx, 5) // ERROR "live at call to f2: &xx$"
	if err != nil {
		return err
	}
	return nil

// license that can be found in the LICENSE file.

// Nm lists the symbols defined or used by an object file, archive, or executable.
//
// Usage:
//
//	go tool nm [options] file...
//
// The default output prints one line per symbol, with three space-separated
// fields giving the address (in hexadecimal), type (a character), and name of
// the symbol. The types are:
//
//	T	text (code) segment symbol
//	t	static text segment symbol

var CmdTool = &base.Command{
	Run:       runTool,
	UsageLine: "go tool [-n] command [args...]",
	Short:     "run specified go tool",
	Long: `
Tool runs the go tool command identified by the arguments.
With no arguments it prints the list of known tools.

The -n flag causes tool to print the command that would be
executed but not execute it.

For more about each tool command, see 'go doc cmd/<command>'.
`,
}

var toolN bool

	}
	status := retrieveEndpointStatus(host)
	if e.Status != "" && !strings.EqualFold(core.HealthStatus_name[int32(status)], e.Status) {
		return false
	}
	return true
}

// PrintEndpointsSummary prints just the endpoints config summary to the ConfigWriter stdout
func (c *ConfigWriter) PrintEndpointsSummary(filter EndpointFilter) error {
	if c.clusters == nil {
		return fmt.Errorf("config writer has not been primed")
	}

 */

package org.gradle.internal.buildevents

import org.gradle.integtests.fixtures.AbstractIntegrationSpec

class BuildFailureIntegrationTest extends AbstractIntegrationSpec {
    def "still prints errors when exception misbehaves"() {
        // When running in-process, the NPE propagates out of the test fixtures
        executer.requireIsolatedDaemons()
        executer.requireDaemon()

        buildFile << """

	Short:     "print Go environment information",
	Long: `
Env prints Go environment information.

By default env prints information as a shell script
(on Windows, a batch file). If one or more variable
names is given as arguments, env prints the value of
each named variable on its own line.

The -json flag prints the environment in JSON format
instead of as a shell script.