if i == "huge" {
				// Due to a detail of gc's internals,
				// the huge constant errors happen in an
				// earlier pass than the others and inhibits
				// the next pass from running.
				// So run it as a separate check.
				thisPass = 1

	"unsafe"
)

// Assert that the size of important structures do not change unexpectedly.

func TestSizeof(t *testing.T) {
	const _64bit = unsafe.Sizeof(uintptr(0)) == 8
	var tests = []struct {
		val    any     // type as a value
		_32bit uintptr // size on 32bit platforms
		_64bit uintptr // size on 64bit platforms
	}{
		{runtime.G{}, 272, 432},   // g, but exported for testing
		{runtime.Sudog{}, 56, 88}, // sudog, but exported for testing

import (
	"reflect"
	"testing"
)

// Signal size changes of important structures.

func TestSizeof(t *testing.T) {
	const _64bit = ^uint(0)>>32 != 0

	var tests = []struct {
		val    interface{} // type as a value
		_32bit uintptr     // size on 32bit platforms
		_64bit uintptr     // size on 64bit platforms
	}{
		// Types
		{Basic{}, 16, 32},
		{Array{}, 16, 24},
		{Slice{}, 8, 16},
		{Struct{}, 24, 48},

func TestSizeof(t *testing.T) {
	const _64bit = unsafe.Sizeof(uintptr(0)) == 8

	var tests = []struct {
		val    interface{} // type as a value
		_32bit uintptr     // size on 32bit platforms
		_64bit uintptr     // size on 64bit platforms
	}{
		{Addr{}, 32, 48},
		{LSym{}, 72, 120},
		{Prog{}, 132, 200},
	}

	for _, tt := range tests {
		want := tt._32bit
		if _64bit {
			want = tt._64bit
		}

)

// Assert that the size of important structures do not change unexpectedly.

func TestSizeof(t *testing.T) {
	const _64bit = unsafe.Sizeof(uintptr(0)) == 8

	var tests = []struct {
		val    interface{} // type as a value
		_32bit uintptr     // size on 32bit platforms
		_64bit uintptr     // size on 64bit platforms
	}{
		{Sym{}, 32, 64},
		{Type{}, 64, 104},
		{Map{}, 12, 24},
		{Forward{}, 20, 32},
		{Func{}, 32, 56},

)

// Assert that the size of important structures do not change unexpectedly.

func TestSizeof(t *testing.T) {
	const _64bit = unsafe.Sizeof(uintptr(0)) == 8

	var tests = []struct {
		val    interface{} // type as a value
		_32bit uintptr     // size on 32bit platforms
		_64bit uintptr     // size on 64bit platforms
	}{
		{Value{}, 72, 112},
		{Block{}, 164, 304},
		{LocalSlot{}, 28, 40},
		{valState{}, 28, 40},
	}

import (
	"reflect"
	"testing"
)

// Signal size changes of important structures.
func TestSizeof(t *testing.T) {
	const _64bit = ^uint(0)>>32 != 0

	var tests = []struct {
		val    any     // type as a value
		_32bit uintptr // size on 32bit platforms
		_64bit uintptr // size on 64bit platforms
	}{
		// Types
		{Basic{}, 16, 32},
		{Array{}, 16, 24},
		{Slice{}, 8, 16},
		{Struct{}, 24, 48},

Daniel Morsing <******@****.***> 1359573668 +0100

	Signo       int32
	siErrnoCode                // Two int32 fields, swapped on MIPS.
	_           [is64bit]int32 // Extra padding for 64-bit hosts only.

	// End of common part. Beginning of signal-specific part.

	Pid    int32
	Uid    uint32
	Status int32

	// Pad to 128 bytes.
	_ [128 - (6+is64bit)*4]byte
}

const (
	// Possible values for SiginfoChild.Code field.
	_CLD_EXITED    int32 = 1

version: v1
jdks:
  - param: "linux.java7.oracle.64bit"
    os: linux
    arch: amd64
    vendor: "oracle"
    version: "7u80"
    sha256: bad9a731639655118740bee119139c1ed019737ec802a630dd7ad7aab4309623
  - params: [ "linux.java8.openjdk.64bit", "linux.java8.oracle.64bit" ]
    os: linux
    arch: amd64
    vendor: "oracle"
    version: "8u401"
    sha256: 19684fccd7ff32a8400e952a643f0049449a772ef63b8037d5b917cbd137d173