initializeLock()
        lock.lockInterruptibly()
    }

    @Override
    boolean tryLock() {
        initializeLock()
        return lock.tryLock()
    }

    @Override
    boolean tryLock(long time, @NotNull TimeUnit unit) throws InterruptedException {
        initializeLock()
        return tryLock(time, unit)
    }

    @Override
    Condition newCondition() {
        initializeLock()

        when:
        resourceLock.tryLock()

        then:
        thrown(IllegalStateException)

        when:
        resourceLock.unlock()

        then:
        thrown(IllegalStateException)
    }

    def "can lock and unlock a resource"() {
        when:
        coordinationService.withStateLock(tryLock(resourceLock))

        then:
        resourceLock.doIsLocked()

        then:
        result.failures.empty

        1 * workerLeaseService.currentWorkerLease >> workerLease

        then:
        1 * cancellationHandler.isCancellationRequested() >> false
        1 * workerLease.tryLock() >> true
        1 * workSource.executionState() >> WorkSource.State.MaybeWorkReadyToStart
        1 * workSource.selectNext() >> WorkSource.Selection.of(node)
        1 * worker.execute(node)

	}
}

// TryLock tries to lock rw for writing and reports whether it succeeded.
//
// Note that while correct uses of TryLock do exist, they are rare,
// and use of TryLock is often a sign of a deeper problem
// in a particular use of mutexes.
func (rw *RWMutex) TryLock() bool {
	if race.Enabled {
		_ = rw.w.state
		race.Disable()
	}
	if !rw.w.TryLock() {
		if race.Enabled {
			race.Enable()

        when:
        lock.tryLock()

        then:
        registry.getResourceLocksByCurrentThread() == [lock]
    }

    def "does not get locks associated with other threads"() {
        when:
        def lock = registry.getResourceLock("test")
        inNewThread { registry.getResourceLock("another").tryLock() }

        and:
        lock.tryLock()

        then:

	}
	// Slow path (outlined so that the fast path can be inlined)
	m.lockSlow()
}

// TryLock tries to lock m and reports whether it succeeded.
//
// Note that while correct uses of TryLock do exist, they are rare,
// and use of TryLock is often a sign of a deeper problem
// in a particular use of mutexes.
func (m *Mutex) TryLock() bool {
	old := m.state
	if old&(mutexLocked|mutexStarving) != 0 {
		return false
	}

    }

    public FileLockOutcome tryLockInfo(boolean shared) throws IOException {
        return lockInfoAccess.tryLock(lockFileAccess, shared);
    }

    public FileLockOutcome tryLockState(boolean shared) throws IOException {
        return lockStateAccess.tryLock(lockFileAccess, shared);
    }

    /**
     * Reads the lock state from the lock file.
     */

    def "tracks the lock in the current resource lock state and calls provided actions"() {
        given:
        _ * coordinationService.current >> resourceLockState

        when:
        lock.tryLock()

        then:
        1 * container.lockAcquired(lock)
        1 * resourceLockState.registerLocked(lock)

        when:
        lock.unlock()

        then:
        1 * container.lockReleased(lock)

        lockFileAccess.setLength(Math.min(lockFileAccess.length(), infoRegionPos));
    }

    public FileLockOutcome tryLock(RandomAccessFile lockFileAccess, boolean shared) throws IOException {
        try {
            FileLock fileLock = lockFileAccess.getChannel().tryLock(infoRegionPos, INFORMATION_REGION_SIZE - infoRegionPos, shared);
            if (fileLock == null) {

        } catch (EOFException e) {
            return protocol.createInitialState();
        }
    }

    public FileLockOutcome tryLock(RandomAccessFile lockFileAccess, boolean shared) throws IOException {
        try {
            FileLock fileLock = lockFileAccess.getChannel().tryLock(REGION_START, stateRegionSize, shared);
            if (fileLock == null) {
                return FileLockOutcome.LOCKED_BY_ANOTHER_PROCESS;