"runtime/debug"
	"sync/atomic"
	"testing"
)

func parallelReader(m *RWMutex, clocked chan bool, cunlock *atomic.Bool, cdone chan bool) {
	m.RLock()
	clocked <- true
	for !cunlock.Load() {
	}
	m.RUnlock()
	cdone <- true
}

func doTestParallelReaders(numReaders int) {
	GOMAXPROCS(numReaders + 1)
	var m RWMutex
	m.Init()
	clocked := make(chan bool, numReaders)
	var cunlock atomic.Bool
	cdone := make(chan bool)

// blocked goroutines, LockOSThread, pipes, and GOMAXPROCS).

//go:build ignore

package main

import (
	"log"
	"net"
	"os"
	"runtime"
	"runtime/trace"
	"sync"
	"time"
)

func main() {
	var wg sync.WaitGroup
	done := make(chan bool)

	// Create a goroutine blocked before tracing.
	wg.Add(1)
	go func() {
		<-done
		wg.Done()

import org.gradle.internal.Factory

class DefaultWorkerLeaseServiceTest extends AbstractWorkerLeaseServiceTest {
    def workerLeaseService = workerLeaseService(1)

    def "can use withLocks to execute a runnable with resources locked"() {
        boolean executed = false
        def lock1 = resourceLock("lock1", false)
        def lock2 = resourceLock("lock1", false)

        when:
        workerLeaseService.withLocks([lock1, lock2], runnable {

     *     <li>Using {@link org.gradle.cache.FileLockManager.LockMode#Exclusive} will lock the cache on open() in the exclusive mode and keep it locked until {@link PersistentCache#close()} is called.</li>
     *     <li>Using {@link org.gradle.cache.FileLockManager.LockMode#Shared} will lock the cache on open() in the shared mode and keep it locked until {@link PersistentCache#close()} is called.</li>

     */
    ListProperty<String> getIgnoredDependencies();

    /**
     * Confirms that the given lock is not locked.
     * This allows the lock state for the lock to be dropped if it existed before.
     *
     * @param lockId the ID of the lock to confirm is not locked
     */
    void confirmNotLocked(String lockId);

package clause

const (
	LockingStrengthUpdate    = "UPDATE"
	LockingStrengthShare     = "SHARE"
	LockingOptionsSkipLocked = "SKIP LOCKED"
	LockingOptionsNoWait     = "NOWAIT"
)

type Locking struct {
	Strength string
	Table    Table
	Options  string
}

// Name where clause name
func (locking Locking) Name() string {
	return "FOR"
}

// Build build where clause
func (locking Locking) Build(builder Builder) {

        }
        return ignoredEntryFilter;
    }

    @Nullable
    private List<String> findLockedModules(String lockId) {
        List<String> result = allLockState.get(lockId);
        if (result == null) {
            result = lockFileReaderWriter.readLockFile(lockId);
        }
        return result;
    }

    private synchronized void loadLockState() {
        if (!uniqueLockStateLoaded) {

}

// send processes a send operation on an empty channel c.
// The value ep sent by the sender is copied to the receiver sg.
// The receiver is then woken up to go on its merry way.
// Channel c must be empty and locked.  send unlocks c with unlockf.
// sg must already be dequeued from c.
// ep must be non-nil and point to the heap or the caller's stack.
func send(c *hchan, sg *sudog, ep unsafe.Pointer, unlockf func(), skip int) {

    }
    // endregion Warnings

    private void assertUsageLockedFailure(String configurationName, String roleName = null) {
        String suffix = roleName ? "as it was locked upon creation to the role: '$roleName'." : "as it has been locked."
        failure.assertHasCause("Cannot change the allowed usage of configuration ':$configurationName', $suffix")
    }

import static java.util.Collections.emptySet

class NoOpDependencyLockingProviderTest extends Specification {

    @Subject
    def provider = NoOpDependencyLockingProvider.instance

    def 'does not find locked dependencies'() {
        when:
        def result = provider.loadLockState('conf', Describables.of("foo"))

        then:
        !result.mustValidateLockState()
    }

    def 'does nothing on persist'() {