StabilityLevel: metrics.ALPHA,
		},
		[]string{"status", "apiserver_id_hash"},
	)
)

var registerMetrics sync.Once
var hashPool *sync.Pool

func RegisterMetrics() {
	registerMetrics.Do(func() {
		hashPool = &sync.Pool{
			New: func() interface{} {
				return sha256.New()
			},
		}
		legacyregistry.MustRegister(authorizationConfigAutomaticReloadsTotal)

	// to sync makes sure that the lister will be valid before we begin.  There may still be races for CRDs added after startup,
	// but we won't go healthy until we can handle the ones already present.
	s.GenericAPIServer.AddPostStartHookOrDie("crd-informer-synced", func(context genericapiserver.PostStartHookContext) error {

		cidr, _ := cidrset.NewCIDRSet(clusterCIDRRange, 24)
		tc.fake.logger = logger
		sync := New(&tc.fake, &tc.fake, &tc.fake, tc.mode, "node1", cidr)
		doneChan := make(chan struct{})

		// Do a single step of the loop.
		go sync.Loop(logger, doneChan)
		sync.Update(tc.node)
		close(sync.opChan)
		<-doneChan
		tc.fake.dumpTrace()

		if !reflect.DeepEqual(tc.fake.events, tc.events) {

    yield state["/async"]
    state["/async"] = "asyncgen completed"


def generator_state(state: Dict[str, str] = Depends(get_state)):
    state["/sync"] = "generator started"
    yield state["/sync"]
    state["/sync"] = "generator completed"


async def asyncgen_state_try(state: Dict[str, str] = Depends(get_state)):
    state["/async_raise"] = "asyncgen raise started"
    try:

        given:
        goodCode()
        def sync = server.expectAndBlock('sync')

        when:
        def result = []
        withConnection { ProjectConnection connection ->
            connection.newBuild().forTasks('test').addProgressListener({ ProgressEvent event ->
                result << event
                if (!killed) {
                    sync.waitForAllPendingCalls()
                    sync.releaseAll()

    def "client can cancel during execution of a continuous build"() {
        given:
        setupCancellationBuild()
        def sync = server.expectAndBlock('sync')

        when:
        runBuild {
            sync.waitForAllPendingCalls()
            cancellationTokenSource.cancel()
            sync.releaseAll()
        }

        then:
        assert buildResult.failure instanceof BuildCancelledException

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package metrics

import (
	"sync"
	"sync/atomic"
	"testing"
)

var _ MetricRecorder = &fakePodsRecorder{}

type fakePodsRecorder struct {
	counter int64
}

func (r *fakePodsRecorder) Inc() {
	atomic.AddInt64(&r.counter, 1)
}

	ssLister       appsv1listers.StatefulSetLister
	ssListerSynced cache.InformerSynced

	// PodDisruptionBudget keys that need to be synced.
	queue        workqueue.TypedRateLimitingInterface[string]
	recheckQueue workqueue.TypedDelayingInterface[string]

	// pod keys that need to be synced due to a stale DisruptionTarget condition.
	stalePodDisruptionQueue   workqueue.TypedRateLimitingInterface[string]

func newBufferedMonitor(store model.ConfigStore, bufferSize int, sync bool) Monitor {
	handlers := make(map[config2.GroupVersionKind][]Handler)

	for _, s := range store.Schemas().All() {
		handlers[s.GroupVersionKind()] = make([]Handler, 0)
	}

	return &configStoreMonitor{
		store:    store,
		handlers: handlers,
		eventCh:  make(chan ConfigEvent, bufferSize),
		sync:     sync,
	}
}

package foo

import (
	"fmt"
	"sync"
)

func sayhi(n int, wg *sync.WaitGroup) {
	fmt.Println("hi", n)
	fmt.Println("hi", n)
	wg.Done()