! go list -m vcs-test.golang.org/auth/ormanylines@latest
stderr '\tserver response:\n(.|\n)*\tline 8\n\t\[Truncated: too many lines.\]$'

# Server responses should be truncated to some reasonable number of characters.
! go list -m vcs-test.golang.org/auth/oronelongline@latest
! stderr 'blah{40}'
stderr '\tserver response: \[Truncated: too long\.\]$'

# Responses from servers using the 'mod' protocol should be propagated.

	f("1", 2, 3.1, "4")
	f(1, 0.5, "hello", 4, 5) // ERROR "too many arguments|incompatible type"
	g(1, 0.5)                // ERROR "not enough arguments|incompatible type"
	g("1", 2, 3.1)
	g(1, 0.5, []int{3, 4}...) // ERROR "not enough arguments|incompatible type"
	g("1", 2, 3.1, "4", "5")
	g(1, 0.5, "hello", 4, []int{5, 6}...) // ERROR "too many arguments|truncated to integer"

	// A negative entry in the result indicates that the struct is too large.
	Offsetsof(fields []*Var) []int64

	// Sizeof returns the size of a variable of type T.
	// Sizeof must implement the size guarantees required by the spec.
	// A negative result indicates that T is too large.
	Sizeof(T Type) int64
}

// StdSizes is a convenience type for creating commonly used Sizes.

go build -x -n main.go
stderr '"-I[^"]+c flags"' # find quoted c flags
! stderr '"-I[^"]+c flags".*"-I[^"]+c flags"' # don't find too many quoted c flags per line
stderr '"-L[^"]+ld flags"' # find quoted ld flags
! stderr '"-L[^"]+c flags".*"-L[^"]+c flags"' # don't find too many quoted ld flags per line

-- main.go --
package main
// #cgo CFLAGS: -I"c flags"
// #cgo LDFLAGS: -L"ld flags"
import "C"

// After the slice is allocated with the capacity, it should be
// built using append. This will avoid allocating too much memory
// if the capacity is large and incorrect.
//
// A negative result means that the value is always too big.
func SliceCapWithSize(size, c uint64) int {
	if int64(c) < 0 || c != uint64(int(c)) {
		return -1
	}
	if size > 0 && c > (1<<64-1)/size {

	// A negative entry in the result indicates that the struct is too large.
	Offsetsof(fields []*Var) []int64

	// Sizeof returns the size of a variable of type T.
	// Sizeof must implement the size guarantees required by the spec.
	// A negative result indicates that T is too large.
	Sizeof(T Type) int64
}

// StdSizes is a convenience type for creating commonly used Sizes.

	outstr := string(out)
	if err == nil {
		println("go run issue9862.go succeeded, should have failed\n", outstr)
		return
	}
	if !strings.Contains(outstr, "symbol too large") {
		println("go run issue9862.go gave unexpected error; want symbol too large:\n", outstr)
	}

# CHECK:     y = tf.math.betainc(x, 0.5, 1.0)  # Not supported
# CHECK:     ^
# CHECK: <unknown>:0: error: failed while converting: 'main'

# pylint: enable=line-too-long


def main(argv):
  if len(argv) > 1:
    raise app.UsageError('Too many command-line arguments.')

  try:
    TestGraphDebugInfo().testConcreteFunctionDebugInfo()
  except Exception as e:  # pylint: disable=broad-except

	var x int
	return x // ERROR "not enough (arguments to return|return values)\n\thave \(int\)\n\twant \(int, error\)"
}

func _() int {
	return 1, 2 // ERROR "too many (arguments to return|return values)\n\thave \(number, number\)\n\twant \(int\)"
}

func _() {
	return 1 // ERROR "too many (arguments to return|return values)\n\thave \(number\)\n\twant \(\)"

			if a != b {
				t.Errorf("asmAdd diff: x=%x y=%x got=%s want=%s\n", x, y, a, b)
			}
			coverage[a] = true
		}
	}
	if len(coverage) != 9 { // TODO: can we cover all outputs?
		t.Errorf("coverage too small, got %d want 9", len(coverage))
	}
}

func TestSubFlagsNative(t *testing.T) {
	var numbers = []int64{
		1, 0, -1,
		2, -2,
		1<<63 - 1, -1 << 63,
	}
	coverage := map[flagConstant]bool{}