projectsConfigured(":buildSrc", ":b")
            buildModelCreated()
            modelsCreated(":", ":a")
        }

        outputContains("Callback before root project 'root'")
        outputContains("Callback before project ':a'")
        outputContains("Callback before project ':b'")


        when:
        withIsolatedProjects()
        def model2 = runBuildAction(new FetchCustomModelForEachProject())

    }

    /**
     * Registers a callback to be called just before the service represented by this provider is stopped.
     * The callback runs even if the service wasn't created.
     * This provider is used as a callback argument.
     * <p>
     * The service will only be stopped after completing all registered callbacks.
     *
     * @param stopAction the callback
     */

// Copyright 2024 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

TEXT	·asm(SB),0,$0-8
	CALL	·callback(SB)

			"src", src,
			"dst", dst,
		).Infof(comment)
		return 0
	}

	// Register our callback for the nflog
	err = nf.RegisterWithErrorFunc(ctx, fn, func(e error) int {
		iptablesTrace.Warnf("log failed: %v", e)
		return 0
	})
	if err != nil {
		log.Errorf("failed to register nflog callback: %v", err)
		return
	}

	// Block util the context expires
	<-ctx.Done()

package main

import (
	"runtime"
	_ "unsafe"
)

//go:linkname asm
func asm(*int)

func main() {
	x := new(int)
	asm(x)
}

// called from asm
func callback() {
	runtime.GC() // scan stack

  return base;
}

// Wrapper that allows passing std::function across C API.
struct HostCallbackContext {
  absl::AnyInvocable<absl::Status() &&> callback;
};

// This wrapper allows calling `HostCallbackContext::callback` across C API.
// This function matches `SE_StatusCallbackFn` signature and will be passed as
// `callback_fn` to `host_callback` in `SP_StreamExecutor`.

	if handlerCallCount != 1 {
		t.Errorf("expected the given handler to be invoked once, but was actually invoked %d times", handlerCallCount)
	}
	if actionCallCount != 1 {
		t.Errorf("expected the action callback to be invoked once, but was actually invoked %d times", actionCallCount)
	}
	if filterRecordGot == nil {
		t.Fatal("expected a filter record in the request context, but got nil")
	}

	select {
	case s.Requests <- b:
		return nil
	case <-s.ctx.Done():
		return context.Cause(s.ctx)
	}
}

// Results returns the results from the remote server one by one.
// If any error is returned by the callback, the stream will be canceled.
// If the context is canceled, the stream will be canceled.
func (s *Stream) Results(next func(b []byte) error) (err error) {
	done := false
	defer func() {
		if s.cancel != nil {

// when the tags change.
type TagWatcher interface {
	Run(stopCh <-chan struct{})
	HasSynced() bool
	AddHandler(handler TagHandler)
	GetMyTags() sets.String
}

// TagHandler is a callback for when the tags revision change.
type TagHandler func(sets.String)

type tagWatcher struct {
	revision string
	handlers []TagHandler

	queue    controllers.Queue

	// and inform container to reopen log file after log rotation.
	kl.containerLogManager.Start()
	// Adding Registration Callback function for CSI Driver
	kl.pluginManager.AddHandler(pluginwatcherapi.CSIPlugin, plugincache.PluginHandler(csi.PluginHandler))
	// Adding Registration Callback function for DRA Plugin
	if utilfeature.DefaultFeatureGate.Enabled(features.DynamicResourceAllocation) {