package p

func f3(x *[1 << 31]byte) byte { // GC_ERROR "stack frame too large"
	for _, b := range *x {
		return b
	}
	return 0
}
func f4(x *[1 << 32]byte) byte { // GC_ERROR "stack frame too large"
	for _, b := range *x {
		return b
	}
	return 0
}
func f5(x *[1 << 33]byte) byte { // GC_ERROR "stack frame too large"
	for _, b := range *x {
		return b
	}
	return 0

// 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 /* ERROR "too large" */ .x)

// 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

type large struct {
	b [1500000000]byte
}

func (x large) f1() int { // GC_ERROR "stack frame too large"
	return 5
}

func f2(x large) int { // GC_ERROR "stack frame too large"
	return 5
}

func f3() (x large, i int) { // GC_ERROR "stack frame too large"
	return

// is reached.
//
// Poll always waits the interval before the run of 'condition'.
// 'condition' will always be invoked at least once.
//
// Some intervals may be missed if the condition takes too long or the time
// window is too short.
//
// If you want to Poll something forever, see PollInfinite.
//
// Deprecated: This method does not return errors from context, use PollUntilContextTimeout.

		},
		{
			name:         "service cidr is too big",
			expectErrors: true,
			options:      makeOptionsWithCIDRs("10.0.0.0/8", ""),
		},
		{
			name:         "service cidr IPv4 is too big but gate enbled",
			expectErrors: false,
			options:      makeOptionsWithCIDRs("10.0.0.0/8", ""),
			gate:         true,
		},
		{
			name:         "service cidr IPv6 is too big but gate enbled",
			expectErrors: false,

        checkDuration("timeout", 1, TimeUnit.NANOSECONDS)
      },
    ).hasMessage("timeout too small")
    assertThat(
      assertThrows<IllegalArgumentException> {
        checkDuration(
          "timeout",
          1L + Int.MAX_VALUE.toLong(),
          TimeUnit.MILLISECONDS,
        )
      },
    ).hasMessage("timeout too large")
  }

  @Test
  fun testDurationDuration() {

machine ignore.host macdef ignore
  login nobody
  password nothing

machine hasmacro.too macdef ignore-next-lines login user4 password pwd4
  login nobody
  password nothing

default
login anonymous
password ******@****.***

machine after.default
login oops
password too-late-in-file
`

func TestParseNetrc(t *testing.T) {
	lines := parseNetrc(testNetrc)
	want := []netrcLine{

type T struct {
	S
}

var x = 1
var a1 = S{0, X: 1}                             // ERROR "mixture|undefined" "too few values"
var a2 = S{Y: 3, Z: 2, Y: 3}                    // ERROR "duplicate"
var a3 = T{S{}, 2, 3, 4, 5, 6}                  // ERROR "convert|too many"
var a4 = [5]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} // ERROR "index|too many"
var a5 = []byte{x: 2}                           // ERROR "index"

		return "Failed Dependency"
	case StatusTooEarly:
		return "Too Early"
	case StatusUpgradeRequired:
		return "Upgrade Required"
	case StatusPreconditionRequired:
		return "Precondition Required"
	case StatusTooManyRequests:
		return "Too Many Requests"
	case StatusRequestHeaderFieldsTooLarge:
		return "Request Header Fields Too Large"
	case StatusUnavailableForLegalReasons:

	_ = append(s, s /* ERROR "cannot use s" */ )
	_ = append(s...) /* ERROR "not enough arguments" */
	_ = append(s, b, s /* ERROR "too many arguments" */ ...)
	_ = append(s, 1, 2, 3)
	_ = append(s, 1, 2, 3, x /* ERROR "cannot use x" */ , 5, 6, 6)
	_ = append(s, 1, 2 /* ERROR "too many arguments" */, s...)
	_ = append([]interface{}(nil), 1, 2, "foo", x, 3.1425, false)

	type S []byte
	type T string
	var t T