import "runtime"

var finalized bool
var err string

type HeapObj [8]int64

const filler int64 = 0x123456789abcdef0

func (h *HeapObj) init() {
	for i := 0; i < len(*h); i++ {
		h[i] = filler
	}
}
func (h *HeapObj) check() {
	for i := 0; i < len(*h); i++ {
		if h[i] != filler {
			err = "filler overwritten"
		}
	}
}

func gc(shouldFinalize bool) {
	runtime.GC()
	runtime.GC()

package main

import "runtime"

var finalized bool
var err string

type HeapObj [8]int64

const filler int64 = 0x123456789abcdef0

func (h *HeapObj) init() {
	for i := 0; i < len(*h); i++ {
		h[i] = filler
	}
}
func (h *HeapObj) check() {
	for i := 0; i < len(*h); i++ {
		if h[i] != filler {
			err = "filler overwritten"
		}
	}
}

type StackObj struct {
	h *HeapObj
}

            )
            withProblemsWithStackTraceCount(0)
        }

        and:
        outputContains("this.reference = JavaRecord[value=null, filler=101]")
        outputContains("bean.reference = JavaRecord[value=null, filler=202]")

        when:
        configurationCacheRunLenient "broken"

        then:
        problems.assertResultHasProblems(result) {

      } catch (InterruptedException e) {
        /* ignore */
      }
      try {
        // Fill up heap so soft references get cleared.
        filler = new byte[Math.max(filler.length, filler.length * 2)];
      } catch (OutOfMemoryError e) {
      }
    }

    CacheTesting.processPendingNotifications(cache);
    assertEquals(1, cache.size());
    assertEquals(1, removalListener.getCount());
  }

func (*A1[T]) m1(T) {}

type A2[T any] interface {
	m2(T)
}

type B1[T any] struct {
	filler int
	*A1[T]
	A2[T]
}

type B2[T any] interface {
	A2[T]
}

type C[T any] struct {
	filler1 int
	filler2 int
	B1[T]
}

type D[T any] struct {
	filler1 int
	filler2 int
	filler3 int
	C[T]
}

func _() {
	// calling embedded methods
	var b1 B1[string]

	b1.A1.m1("")

	m2(T)
}

type B1[T any] struct {
	filler int
	*A1[T]
	A2[T]
}

type B2[T any] interface {
	A2[T]
}

type ImpA2[T any] struct {
	f T
}

func (a2 *ImpA2[T]) m2(s T) {
	a2.f = s
}

type C[T any] struct {
	filler1 int
	filler2 int
	B1[T]
}

type D[T any] struct {
	filler1 int
	filler2 int
	filler3 int
	C[T]
}

func test1[T any](arg T) {

	if !strings.HasSuffix(f.Name(), "tracebackFunc") {
		t.Fatalf("Caller(0) = %+v, want tracebackFunc", f)
	}

	// Iterate forward until we find a different function. Back up one
	// instruction is (hopefully) an alignment instruction.
	for runtime.FuncForPC(pc) == f {
		pc++
	}
	pc--

	// Is this an alignment region filler instruction? We only check this

				// concurrently, check for it before we
				// write the filler byte.
				select {
				case err := <-doneCh:
					if err != nil {
						write([]byte{1})
						write([]byte(err.Error()))
					} else {
						write([]byte{0})
					}
					return
				default:
				}

				// Response not ready, write a filler byte.
				write([]byte{32})
				if canWrite {
					w.(http.Flusher).Flush()

type RtMetrics struct {
	Locks    uint32
	Mtu      uint32
	Hopcount uint32
	Expire   int32
	Recvpipe uint32
	Sendpipe uint32
	Ssthresh uint32
	Rtt      uint32
	Rttvar   uint32
	Pksent   uint32
	Filler   [4]uint32
}

const (
	SizeofBpfVersion = 0x4
	SizeofBpfStat    = 0x8
	SizeofBpfProgram = 0x10
	SizeofBpfInsn    = 0x8
	SizeofBpfHdr     = 0x14
)

type BpfVersion struct {

	Locks    uint32
	Mtu      uint32
	Hopcount uint32
	Expire   uint32
	Recvpipe uint32
	Sendpipe uint32
	Ssthresh uint32
	Rtt      uint32
	Rttvar   uint32
	Pksent   uint32
	Weight   uint32
	Filler   [3]uint32
}

const (
	SizeofBpfVersion    = 0x4
	SizeofBpfStat       = 0x8
	SizeofBpfZbuf       = 0xc
	SizeofBpfProgram    = 0x8
	SizeofBpfInsn       = 0x8
	SizeofBpfHdr        = 0x20