void lockOSThreadC(void) {
	lockOSThreadCallback();
}

void issue7978c(uint32_t *sync) {
	while(__atomic_load_n(sync, __ATOMIC_SEQ_CST) != 0)
		;
	__atomic_add_fetch(sync, 1, __ATOMIC_SEQ_CST);
	while(__atomic_load_n(sync, __ATOMIC_SEQ_CST) != 2)
		;
	issue7978cb();
	__atomic_add_fetch(sync, 1, __ATOMIC_SEQ_CST);
	while(__atomic_load_n(sync, __ATOMIC_SEQ_CST) != 6)
		;
}

void f7665(void) {

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package race_test

import (
	"sync"
	"testing"
	"time"
)

func TestRaceMutexRWMutex(t *testing.T) {
	var mu1 sync.Mutex
	var mu2 sync.RWMutex
	var x int16 = 0
	_ = x
	ch := make(chan bool, 2)
	go func() {
		mu1.Lock()
		defer mu1.Unlock()
		x = 1
		ch <- true
	}()
	go func() {

	// This is typically only needed for leader election controllers, as otherwise the controller lifecycle
	// is typically the same as the informer.
	c.pods.ShutdownHandlers()
}

// HasSynced asserts we have "synced", meaning we have processed the initial state.
func (c *Controller) HasSynced() bool {
	// We could check `c.pods` as well, but it is redundant due to the Run() implementation.
	// Instead, just check `c.queue`.

	// will clobber the test pattern created by the caller
	ADDU	$(1024*8), R29

	// Ask signaller to setgid
	MOVW	$1, R1
	SYNC
	MOVW	R1, ·Baton(SB)
	SYNC

	// Wait for setgid completion
loop:
	SYNC
	MOVW	·Baton(SB), R1
	OR	R2, R2, R2	// hint that we're in a spin loop
	BNE	R1, loop
	SYNC

	// Restore stack
	ADDU	$(-1024*8), R29

#include "textflag.h"

#define SYNC	WORD $0xf

TEXT ·RewindAndSetgid(SB),NOSPLIT|NOFRAME,$0-0
	// Rewind stack pointer so anything that happens on the stack
	// will clobber the test pattern created by the caller
	ADDV	$(1024*8), R29

	// Ask signaller to setgid
	MOVW	$1, R1
	SYNC
	MOVW	R1, ·Baton(SB)
	SYNC

	// Wait for setgid completion
loop:
	SYNC
	MOVW	·Baton(SB), R1

var (
	// EndpointsAddedPerSync tracks the number of endpoints added on each
	// Endpoints sync.
	EndpointsAddedPerSync = metrics.NewHistogramVec(
		&metrics.HistogramOpts{
			Subsystem:      EndpointSliceMirroringSubsystem,
			Name:           "endpoints_added_per_sync",
			Help:           "Number of endpoints added on each Endpoints sync",
			StabilityLevel: metrics.ALPHA,
			Buckets:        metrics.ExponentialBuckets(2, 2, 15),
		},

go work init ./m1_22_0 ./m1_22_1
grep '^go 1.50$' go.work
! grep toolchain go.work

# work sync with older modules should leave go 1.50 in the go.work.
go work sync
cat go.work
grep '^go 1.50$' go.work
! grep toolchain go.work

# work sync with newer modules should update go 1.21 -> 1.22.1 and toolchain -> go1.22.9 in go.work
env TESTGO_VERSION=go1.21
env TESTGO_VERSION_SWITCH=switch

		return md.resultError
	})
	return md.resultMetrics, md.resultError
}

// Copied from sync.Once but we don't want to cache the results if there is an
// error
type cacheOnce struct {
	m    sync.Mutex
	done uint32
}

// Copied from sync.Once but we don't want to cache the results if there is an
// error
func (o *cacheOnce) cache(f func() error) {

	c.(internalCollection[O]).dump()
}

type TestingDummyContext struct{}

func (t TestingDummyContext) _internalHandler() {
}

func (t TestingDummyContext) registerDependency(d *dependency, s Syncer, f func(f erasedEventHandler)) {
}

func (t TestingDummyContext) name() string {
	return "testing"
}

var (
	_ registerDependency = TestingDummyContext{}
	_ HandlerContext     = TestingDummyContext{}

//     backed buffer that will get synced to disk.
//   - Munmap the output file
//
// And finally, it provides a mechanism by which you can multithread the
// writing of output files. This mechanism is accomplished by copying a OutBuf,
// and using it in the thread/goroutine.
//
// Parallel OutBuf is intended to be used like:
//
//	func write(out *OutBuf) {
//	  var wg sync.WaitGroup
//	  for i := 0; i < 10; i++ {