// introduce a call to runtime.newobject.

package codegen

func zeroAllocNew1() *struct{} {
	// 386:-`CALL\truntime\.newobject`
	// amd64:-`CALL\truntime\.newobject`
	// arm:-`CALL\truntime\.newobject`
	// arm64:-`CALL\truntime\.newobject`
	return new(struct{})
}

func zeroAllocNew2() *[0]int {
	// 386:-`CALL\truntime\.newobject`
	// amd64:-`CALL\truntime\.newobject`
	// arm:-`CALL\truntime\.newobject`

		badRevision = stripObjectMeta(newControllerRevision("validname", "validns", newObject(), -1))
		emptyName   = stripObjectMeta(newControllerRevision("", "validns", newObject(), 0))
		invalidName = stripObjectMeta(newControllerRevision("NoUppercaseOrSpecialCharsLike=Equals", "validns", newObject(), 0))

	var (
		valid       = newControllerRevision("validname", "validns", newObject(), 0)
		badRevision = newControllerRevision("validname", "validns", newObject(), -1)
		emptyName   = newControllerRevision("", "validns", newObject(), 0)
		invalidName = newControllerRevision("NoUppercaseOrSpecialCharsLike=Equals", "validns", newObject(), 0)
		emptyNs     = newControllerRevision("validname", "", newObject(), 100)

	F2(0, 1, uintptr(unsafe.Pointer(&v)), 2)  // ERROR "live at call to newobject: .?autotmp" "live at call to F2: .?autotmp" "escapes to heap" "stack object .autotmp_[0-9]+ unsafe.Pointer$"
}

func TestF4() {
	var v2 int                                // ERROR "moved to heap"

				initDataScanner(GlobalContext, newObject)
			}
		})

		// Initialize background replication
		bootstrapTrace("initBackgroundReplication", func() {
			initBackgroundReplication(GlobalContext, newObject)
		})

		// Initialize background ILM worker poool
		bootstrapTrace("initBackgroundExpiry", func() {
			initBackgroundExpiry(GlobalContext, newObject)
		})

package p

var global *[]byte

type Q struct{}

type T struct{ M string }

var b bool

func f1(q *Q, xx []byte) interface{} { // ERROR "live at call to newobject: xx$" "live at entry to f1: xx$"
	// xx was copied from the stack to the heap on the previous line:
	// xx was live for the first two prints but then it switched to &xx
	// being live. We should not see plain xx again.
	if b {

	}

	updater := internal.NewManagedFieldsUpdater(NoopManager{})

	newObject, _, err := updater.Apply(obj, obj.DeepCopyObject(), managed, "some_manager", false)
	if err != nil {
		t.Fatalf("failed to apply configuration %v", err)
	}

	if newObject == obj {
		t.Fatalf("returned newObject must not be the same instance as the passed in liveObj")
	}

	}

	store := &objectCache{
		listObject:    listObject,
		watchObject:   watchObject,
		newObject:     newObject,
		isImmutable:   isImmutable,
		groupResource: groupResource,
		clock:         clock,
		maxIdleTime:   maxIdleTime,
		items:         make(map[objectKey]*objectCacheItem),
	}

	go wait.Until(store.startRecycleIdleWatch, time.Minute, stopCh)
	go store.shutdownWhenStopped(stopCh)

	}
}

func TestLargeLastApplied(t *testing.T) {
	tests := []struct {
		name      string
		oldObject *unstructured.Unstructured
		newObject *unstructured.Unstructured
	}{
		{
			name: "old object + new object last-applied annotation is too big",
			oldObject: func() *unstructured.Unstructured {
				u := &unstructured.Unstructured{}

    private
    fun objectByIdentity(key: ObjectAccessKey, newObject: () -> Any?): Any? {
        // This code does not use `computeIfAbsent` because `newObject` can make reentrant calls, leading to CME.
        // Also, it does not check for the value being null, because null values are potentially allowed
        if (key !in reflectionIdentityObjects) {
            val newInstance = newObject()
            reflectionIdentityObjects[key] = newInstance