func trace_userLog(id uint64, category, message string) {
	tl := traceAcquire()
	if !tl.ok() {
		// Need to do this check because the caller won't have it.
		return
	}
	tl.eventWriter(traceGoRunning, traceProcRunning).commit(traceEvUserLog, traceArg(id), tl.string(category), tl.uniqueString(message), tl.stack(3))
	traceRelease(tl)
}

// traceThreadDestroy is called when a thread is removed from

	return &targetsList{}
}

func (tl *targetsList) get() []Target {
	tl.mu.RLock()
	defer tl.mu.RUnlock()

	return tl.list
}

func (tl *targetsList) add(t Target) {
	tl.mu.Lock()
	defer tl.mu.Unlock()

	tl.list = append(tl.list, t)
}

func (tl *targetsList) set(tgts []Target) {
	tl.mu.Lock()
	defer tl.mu.Unlock()

	tl.list = tgts
}

var (

	"istio.io/istio/pkg/kube/kclient"
	"istio.io/istio/pkg/test"
)

type directClient[T controllers.Object, PT any, TL runtime.Object] struct {
	kclient.Writer[T]
	t      test.Failer
	client kube.Client
}

func (d *directClient[T, PT, TL]) Get(name, namespace string) T {
	api := kubeclient.GetClient[T, TL](d.client, namespace)
	res, err := api.Get(context.Background(), name, metav1.GetOptions{})

    def "old Gradle version ignores task execution request"() {
        when:
        launchTestWithTestFilter { tl ->
            tl.forTasks(':help')
        }

        then:
        !taskExecuted(':help')
    }

    def "can execute task"() {
        when:
        launchTestWithTestFilter { tl ->
            tl.forTasks(':help')
        }

        then:
        taskExecuted(':help')
    }

// span containing it.
func (tl traceLocker) HeapObjectAlloc(addr uintptr, typ *abi.Type) {
	tl.eventWriter(traceGoRunning, traceProcRunning).commit(traceEvHeapObjectAlloc, traceHeapObjectID(addr), tl.rtype(typ))
}

// HeapObjectFree records that an object at addr is about to be freed.
func (tl traceLocker) HeapObjectFree(addr uintptr) {

  // CHECK: %[[RESULT2:.*]] = "tf.TensorListReserve"
  // CHECK: tf.WhileRegion
  // CHECK-SAME: (%[[RESULT1]], %[[RESULT0]])
  %tl = "tf.TensorListReserve"(%elem_shape, %size) : (tensor<2xi32>, tensor<i32>) -> tensor<!tf_type.variant<tensor<?x1xf32>>>
  %while:2 = "tf.WhileRegion"(%tl, %tl) ({
    ^bb0(%barg1: tensor<!tf_type.variant<tensor<?x1xf32>>>, %barg2: tensor<!tf_type.variant<tensor<?x1xf32>>>): // no predeceessors

func (tl traceLocker) eventWriter(goStatus traceGoStatus, procStatus traceProcStatus) traceEventWriter {
	w := tl.writer()
	if pp := tl.mp.p.ptr(); pp != nil && !pp.trace.statusWasTraced(tl.gen) && pp.trace.acquireStatus(tl.gen) {
		w = w.writeProcStatus(uint64(pp.id), procStatus, pp.trace.inSweep)
	}
	if gp := tl.mp.curg; gp != nil && !gp.trace.statusWasTraced(tl.gen) && gp.trace.acquireStatus(tl.gen) {

		} else if ldr.IsItab(s) {
			itabs = append(itabs, s)
		}
	}
	sort.Sort(typelinks)

	tl := ldr.CreateSymForUpdate("runtime.typelink", 0)
	tl.SetType(sym.STYPELINK)
	ldr.SetAttrLocal(tl.Sym(), true)
	tl.SetSize(int64(4 * len(typelinks)))
	tl.Grow(tl.Size())
	relocs := tl.AddRelocs(len(typelinks))
	for i, s := range typelinks {
		r := relocs.At(i)
		r.SetSym(s.Type)
		r.SetOff(int32(i * 4))

    %tl = "tf.TensorListReserve"(%elem_shape, %size) : (tensor<i32>, tensor<i32>) -> tensor<!tf_type.variant<tensor<*xf32>>>

    %idx = "tf.Const"() {value = dense<1> : tensor<i32>} : () -> tensor<i32>
    %elem_1 = "tf.Const"() {value = dense<10.0> : tensor<8xf32>} : () -> tensor<8xf32>

	case *k8sioapicorev1.ConfigMap:
		return c.Kube().CoreV1().ConfigMaps(namespace).(ktypes.ReadWriteAPI[T, TL])
	case *k8sioapiextensionsapiserverpkgapisapiextensionsv1.CustomResourceDefinition:
		return c.Ext().ApiextensionsV1().CustomResourceDefinitions().(ktypes.ReadWriteAPI[T, TL])
	case *k8sioapiappsv1.DaemonSet:
		return c.Kube().AppsV1().DaemonSets(namespace).(ktypes.ReadWriteAPI[T, TL])