def "can define subtype of `ApplicationBinarySpec`"() {
        buildFile << """
@Managed
interface TheApp extends ApplicationSpec {}
@Managed
interface TheAppBinary extends ApplicationBinarySpec {}

class MyRules extends RuleSource {

    @ComponentType
    void registerComponent(TypeBuilder<TheApp> builder) {}

    @ComponentType
    void registerBinary(TypeBuilder<TheAppBinary> builder) {}

     * @param normalizedCacheSize The maximum number of entries to cache in-heap, given a 'typical' heap size. The actual size may vary based on the actual heap available.
     * @param calculator The calculator to use to compute the value for a given file.
     * @param serializer The serializer to use to write values to persistent cache.
     */

	}
	fmt.Println("OK")
}

func GCPhys() {
	// This test ensures that heap-growth scavenging is working as intended.
	//
	// It attempts to construct a sizeable "swiss cheese" heap, with many
	// allocChunk-sized holes. Then, it triggers a heap growth by trying to
	// allocate as much memory as would fit in those holes.
	//
	// The heap growth should cause a large number of those holes to be
	// returned to the OS.

	bufHdr.Data = unsafe.Pointer(ptr)
	bufHdr.Len = int(filesize)
	bufHdr.Cap = int(filesize)

	// copy heap to new mapping
	if uint64(oldlen+len(out.heap)) > filesize {
		panic("mmap size too small")
	}
	copy(out.buf[oldlen:], out.heap)
	out.heap = out.heap[:0]
	return nil
}

func (out *OutBuf) munmap() {
	if out.buf == nil {
		return
	}

	)

	// Assumptions and observations of Go's garbage collector, as of Go 1.17-1.20:

	// - the initial heap goal is 4M, by fiat.  It is possible for Go to start
	//   with a heap as small as 512k, so this may change in the future.

	// - except for the first heap goal, heap goal is a function of
	//   observed-live at the previous GC and current GOGC.  After the first
	//   GC, adjusting GOGC immediately updates GOGC; before the first GC,

// limitations under the License.

package queue

import (
	"container/heap"
	"runtime"
	"sync"
	"time"

	"istio.io/istio/pkg/log"
)

type delayTask struct {
	do      func() error
	runAt   time.Time
	retries int
}

const maxTaskRetry = 3

var _ heap.Interface = &pq{}

// pq implements an internal priority queue so that tasks with the soonest expiry will be run first.

	p := leaktoret(&x)
	_ = p
}

func f3() {
	var x int // ERROR "moved to heap: x"
	p := leaktoret(&x)
	gp = p
}

func f4() {
	var x int // ERROR "moved to heap: x"
	p, q := leaktoret2(&x)
	gp = p
	gp = q
}

func f5() {
	var x int
	leaktoret22(leaktoret2(&x))
}

func f6() {
	var x int // ERROR "moved to heap: x"
	px1, px2 := leaktoret22(leaktoret2(&x))
	gp = px1
	_ = px2
}

}

var ptr unsafe.Pointer

func Storep() {
	var x int // ERROR "moved to heap: x"
	atomic.StorepNoWB(unsafe.Pointer(&ptr), unsafe.Pointer(&x))
}

func Casp1() {
	// BAD: should always be "does not escape"
	x := new(int) // ERROR "escapes to heap|does not escape"
	var y int     // ERROR "moved to heap: y"
	atomic.Casp1(&ptr, unsafe.Pointer(x), unsafe.Pointer(&y))

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

package main

// The -fsanitize=address option of C compier can detect stack-use-after-return bugs.
// In the following program, the local variable 'local' was moved to heap by the Go
// compiler because foo() is returning the reference to 'local', and return stack of
// foo() will be invalid. Thus for main() to use the reference to 'local', the 'local'

	// over the lifetime of the program.
	totalAllocated uint64

	// totalFreed is the total bytes of heap objects freed
	// over the lifetime of the program.
	totalFreed uint64

	// totalAllocs is the number of heap objects allocated over
	// the lifetime of the program.
	totalAllocs uint64

	// totalFrees is the number of heap objects freed over
	// the lifetime of the program.