apiVersion: release-notes/v2
kind: bug-fix
area: traffic-management
issue:
  - 42612
releaseNotes:
  - |

			"Warning [C1] (GrandCastle) Collapse danger: the castle is too old",
	))
}

func TestFormatter_PrintLogWithColor(t *testing.T) {
	g := NewWithT(t)

	firstMsg := diag.NewMessage(
		diag.NewMessageType(diag.Error, "B1", "Explosion accident: %v"),
		diag.MockResource("SoapBubble"),
		"the bubble is too big",
	)
	secondMsg := diag.NewMessage(

package p

type S struct {
	f1 int
	f2 bool
}

var (
	_ = S{0}                    /* ERROR "too few values in struct literal" */
	_ = struct{ f1, f2 int }{0} /* ERROR "too few values in struct literal" */

	_ = S{0, true, "foo" /* ERROR "too many values in struct literal" */}
	_ = struct{ f1, f2 int }{0, 1, 2 /* ERROR "too many values in struct literal" */}

	// ErrorTypeTooLong is used to report that the given value is too long.
	// This is similar to ErrorTypeInvalid, but the error will not include the
	// too-long value.  See TooLong().
	ErrorTypeTooLong ErrorType = "FieldValueTooLong"
	// ErrorTypeTooMany is used to report "too many". This is used to
	// report that a given list has too many items. This is similar to FieldValueTooLong,

# Go should refuse to build code that is too new according to go.mod.

# go.mod too new
env GOTOOLCHAIN=local
! go build .
stderr '^go: go.mod requires go >= 1.99999 \(running go 1\..+\)$'

# go.mod referenced from go.work too new
cp go.work.old go.work
! go build .
stderr '^go: module . listed in go.work file requires go >= 1.99999, but go.work lists go 1.10; to update it:\n\tgo work use$'

! go work sync

  - So is [testing.B].
    This is the same list paragraph.

    There is [testing.PB] in this list item, too!
-- text --
Did you know?

  - testing.T is one doc link.

  - So is testing.M.

  - So is testing.B. This is the same list paragraph.

    There is testing.PB in this list item, too!
-- markdown --
Did you know?

  - [testing.T](https://pkg.go.dev/testing#T) is one doc link.

func f(x int, y uint) {
	if true {
		return "a" > 10 // ERROR "^too many arguments to return$|return with value in function with no return|no result values expected|mismatched types"
	}
	return "gopher" == true, 10 // ERROR "^too many arguments to return$|return with value in function with no return|no result values expected|mismatched types"
}

func main() {
	f(2, 3 < "x", 10) // ERROR "too many arguments|invalid operation|incompatible type"

	EISCONN:         "Socket is already connected",
	EISDIR:          "Is a directory",
	ELOOP:           "Too many symbolic links",
	EMFILE:          "Too many open files",
	EMLINK:          "Too many links",
	EMSGSIZE:        "Message too long",
	EMULTIHOP:       "Multihop attempted",
	ENAMETOOLONG:    "File name too long",
	ENETDOWN:        "Network interface is not configured",

	MOVQ 2147483647+1(AX), AX       // ERROR "offset too large"
	MOVQ 3395469782(R10), R8        // ERROR "offset too large"
	LEAQ 3395469782(AX), AX         // ERROR "offset too large"
	ADDQ 3395469782(AX), AX         // ERROR "offset too large"
	ADDL 3395469782(AX), AX         // ERROR "offset too large"
	ADDW 3395469782(AX), AX         // ERROR "offset too large"
	LEAQ 433954697820(AX), AX       // ERROR "offset too large"

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

package p

import "unsafe"

type E [1 << 30]complex128

var a [1 << 30]E
var _ = unsafe.Sizeof(a) // ERROR "too large"

var s struct {
	_ [1 << 30]E
	x int
}
var _ = unsafe.Offsetof(s.x) // ERROR "too large"

// Test case from issue (modified so it also triggers on 32-bit platforms).

type A [1]int
type S struct {
	x A
	y [1 << 30]A
	z [1 << 30]struct{}