boolean tryLock() {
            if (!locks.contains(this) && locked) {
                return false
            }
            locked = true
            locks.add(this)
            return true
        }

        @Override
        void unlock() {
            locked = false
            locks.remove(this)
        }

        @Override
        String getDisplayName() {
            return "some lock"

		t.Logf("got mutexrate %d expected 0", n)
	}
	defer runtime.SetMutexProfileFraction(0)

	m := new(Mutex)

	m.Lock()
	if m.TryLock() {
		t.Fatalf("TryLock succeeded with mutex locked")
	}
	m.Unlock()
	if !m.TryLock() {
		t.Fatalf("TryLock failed with mutex unlocked")
	}
	m.Unlock()

	c := make(chan bool)
	for i := 0; i < 10; i++ {
		go HammerMutex(m, 1000, c)
	}

// Avoid the serialization by ensuring that ForkLock is locked
// at the first fork and unlocked when there are no more forks.
func acquireForkLock() {
	forkingLock.Lock()
	defer forkingLock.Unlock()

	if forking == 0 {
		// There is no current write lock on ForkLock.
		ForkLock.Lock()
		forking++
		return
	}

	// ForkLock is currently locked for writing.

	if hasWaitingReaders(&ForkLock) {

				newEventRequest().withNamespace("B").blocked(),
				newEventRequest().withNamespace("A").blocked(),
				// This should clear out namespace B from the lru cache
				newEventRequest().withNamespace("C"),
				newEventRequest().withNamespace("A").blocked(),
				newEventRequest().withNamespace("B"),
			},
		},
		{
			name:                     "event blocked by source+object limits",
			serverBurst:              100,

    private final Map<PluginId, String> pluginVersions = new HashMap<>();
    private boolean locked;

    public DefaultPluginResolutionStrategy(ListenerManager listenerManager) {
        listenerManager.addListener(new InternalBuildAdapter(){
            @Override
            public void projectsLoaded(Gradle gradle) {
                locked = true;
            }
        });
    }

    @Override

            }
        }

        when:
        beforeState.eachWithIndex { boolean locked, int i -> lock[i].lockedState = locked }
        coordinationService.withStateLock(outerAction)

        then:
        afterState.eachWithIndex { boolean locked, int i -> assert lock[i].lockedState == locked }

        where:
        beforeState                  | afterState

    def lockfileFixture = new LockfileFixture(testDirectory: testDirectory)

    def setup() {
        settingsFile << "rootProject.name = 'mixedDepLock'"
    }

    def 'can resolve locked and unlocked configurations'() {
        mavenRepo.module('org', 'foo', '1.0').publish()
        mavenRepo.module('org', 'foo', '1.1').publish()

        buildFile << """
repositories {
    maven {
        name 'repo'

        fails 'dependencies', '--update-locks', 'org:foo'

        then:
        failureHasCause("Locking strict mode: Configuration ':lockedConf' is locked but does not have lock state.")
        lockfileFixture.expectLockStateMissing('unlockedConf')
    }

    def 'ignores not locked configurations'() {
        mavenRepo.module('org', 'foo', '1.0').publish()

        buildFile << """
dependencyLocking {

    }

    def "locked scope with no modifications exports parent"() {
        when:
        scope.lock()

        then:
        scope.localClassLoader.is root.exportClassLoader
        scope.exportClassLoader.is root.exportClassLoader
    }

    def "locked empty scope does not define any classes"() {
        when:
        scope.lock()

// Used to die in runtime due to init goroutine exiting while
// locked to main thread.

package main

import (
	"os"
	"runtime"
)

func init() {
	c := make(chan int, 1)
	defer func() {
		c <- 0
	}()
	go func() {
		os.Exit(<-c)
	}()
	runtime.Goexit()
}

func main() {
}

/* Before fix:

invalid m->locked = 2
fatal error: internal lockOSThread error