// 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

            }
        """.stripIndent()

        def sync = server.expectAndBlock("waiting")
        def resultHandler = new TestResultHandler()

        when:
        def connector = toolingApi.connector()
        ProjectConnection connection = connector.connect()

        def query = connection.model(EclipseProject)
        query.get(resultHandler)
        sync.waitForAllPendingCalls(resultHandler)

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

package copylock

import "sync"

func BadFunc() {
	var x *sync.Mutex
	p := x
	var y sync.Mutex
	p = &y
	*p = *x // ERROR "assignment copies lock value to \*p: sync.Mutex"

                    ${coordinator.callFromBuild('sync')}
                }
                dependsOn firstUse
            }

            task reuseClient(type: SftpTask) {
                credentials = creds
                dependsOn block
            }
        """
        sftpServer.expectLstat("/")
        def sync = coordinator.expectAndBlock('sync')

        when:

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

package main

/*
int sync;

void Notify(void)
{
	__sync_fetch_and_add(&sync, 1);
}

void Wait(void)
{
	while(__sync_fetch_and_add(&sync, 0) == 0) {}
}
*/
import "C"

func main() {
	data := 0
	go func() {
		data = 1
		C.Notify()
	}()
	C.Wait()
	_ = data

#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),
		},

		return false
	}

	userIP, _ := netip.ParseAddr(ip)
	return userIP.IsLoopback()
}

// Syncz dumps the synchronization status of all Envoys connected to this Pilot instance
func (s *DiscoveryServer) Syncz(w http.ResponseWriter, req *http.Request) {
	namespace := req.URL.Query().Get("namespace")

	syncz := make([]SyncStatus, 0)
	for _, con := range s.SortedClients() {
		node := con.proxy

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) {