QueueLengthLimit: 100,
							Queues:           512,
							HandSize:         8,
						}}}},
		},
		expectedErrors: field.ErrorList{
			field.Invalid(field.NewPath("spec").Child("limited").Child("limitResponse").Child("queuing").Child("handSize"), int32(8), "required entropy bits of deckSize 512 and handSize 8 should not be greater than 60"),
		},
	}, {

	}

	for _, writev := range []bool{false, true} {
		t.Run(fmt.Sprintf("writev=%v", writev), func(t *testing.T) {
			ln := newLocalListener(t, "tcp")
			defer ln.Close()

			x := int(1 << 30)
			x = x*5 + 1<<20 // just over 5 GB on 64-bit, just over 1GB on 32-bit
			done := make(chan int)
			go func() {
				defer close(done)
				c, err := ln.Accept()
				if err != nil {
					t.Error(err)
					return
				}

          Thread.sleep(100)
        }
      } catch (e: IOException) {
        break
      }
      i++
    }
    // Halfway +/- 0.5%
    assertThat(i.toFloat()).isCloseTo(512f, 5f)
  }

  @Test
  fun disconnectResponseHalfway() {
    server.enqueue(
      MockResponse()
        .setBody("ab")
        .setSocketPolicy(SocketPolicy.DISCONNECT_DURING_RESPONSE_BODY),
    )

          Thread.sleep(100)
        }
      } catch (e: IOException) {
        break
      }
      i++
    }
    // Halfway +/- 0.5%
    assertThat(i.toFloat()).isCloseTo(512f, 5f)
  }

  @Test
  fun disconnectResponseHalfway() {
    server.enqueue(
      MockResponse.Builder()
        .body("ab")
        .socketPolicy(DisconnectDuringResponseBody)
        .build(),

	Start  int64
	Len    int64
	Pid    int32
	Type   int16
	Whence int16
}

type Dirent struct {
	Fileno    uint64
	Reclen    uint16
	Namlen    uint16
	Type      uint8
	Name      [512]int8
	Pad_cgo_0 [3]byte
}

type Fsid struct {
	X__fsid_val [2]int32
}

const (
	PathMax = 0x400
)

const (
	ST_WAIT   = 0x1
	ST_NOWAIT = 0x2
)

const (

	// ppc64x:-`.*runtime\.makeslice`
	// ppc64x:-`.*runtime\.panicmakeslicelen`
	return append(s, make([]int, uint(1<<2))...)
}

// On ppc64x continue to use memclrNoHeapPointers
// for sizes >= 512.
func SliceExtensionConst512(s []int) []int {
	// amd64:-`.*runtime\.memclrNoHeapPointers`
	// ppc64x:`.*runtime\.memclrNoHeapPointers`
	return append(s, make([]int, 1<<9)...)
}

					MemoryMap: map[v1.ResourceName]*state.MemoryTable{
						v1.ResourceMemory: {
							Allocatable:    9728 * mb,
							Free:           9728 * mb,
							Reserved:       0,
							SystemReserved: 512 * mb,
							TotalMemSize:   10 * gb,
						},
						hugepages1Gi: {
							Allocatable:    5 * gb,
							Free:           5 * gb,
							Reserved:       0,
							SystemReserved: 0,

func new384() hash.Hash {
	if cpu.S390X.HasSHA3 {
		return newAsmState(sha3_384)
	}
	return new384Generic()
}

// new512 returns an assembly implementation of SHA3-512 if available,
// otherwise it returns a generic implementation.
func new512() hash.Hash {
	if cpu.S390X.HasSHA3 {
		return newAsmState(sha3_512)
	}
	return new512Generic()
}

        api(libs.tomlj)                 { version { strictly(tomljVersion) }}
        api(libs.trove4j)               { version { strictly("1.0.20200330") }}
        api(libs.jna)                   { version { strictly("5.12.1") }}
        // TODO upgrade this AGP version to recent version
        api(libs.agp)                   { version { strictly("3.0.0"); because("We use 3.0.0 for internal performance test") }}

	/*5106*/ uint16(xCondPrefix), 3,
	0xF3, 5126,
	0x66, 5120,
	0x0, 5114,
	/*5114*/ uint16(xSetOp), uint16(MOVQ),
	/*5116*/ uint16(xReadSlashR),
	/*5117*/ uint16(xArgMmM64),
	/*5118*/ uint16(xArgMm),
	/*5119*/ uint16(xMatch),
	/*5120*/ uint16(xSetOp), uint16(MOVDQA),
	/*5122*/ uint16(xReadSlashR),
	/*5123*/ uint16(xArgXmm2M128),
	/*5124*/ uint16(xArgXmm1),
	/*5125*/ uint16(xMatch),