}

    @Override
    public String toString() {
        return getClass().getSimpleName() + " " + getDisplayName();
    }

    @Override
    public boolean tryLock() {
        if (!isLockedByCurrentThread()) {
            if (acquireLock()) {
                LOGGER.debug("{}: acquired lock on {}", Thread.currentThread().getName(), displayName);
                try {
                    owner.lockAcquired(this);

    }

    @Override
    protected boolean canAcquire() {
        // Either the "all projects" lock is not held, or it is held by this thread
        return !allProjectsLock.isLocked() || allProjectsLock.isLockedByCurrentThread();
    }

        coordinationService.addLockReleaseListener(listener)

        def lock = resourceLock("lock1", true, true)

        when:
        coordinationService.withStateLock { state ->
            assert lock.isLockedByCurrentThread()
            lock.unlock()
            return FINISHED
        }

        then:
        1 * listener.execute(lock)
        0 * listener._
    }

        super(displayName, coordinationService, owner);
        this.stateLock = stateLock;
    }

    @Override
    protected boolean canAcquire() {
        return stateLock.isLockedByCurrentThread() || stateLock.tryLock();
    }

    @Override
    protected void releaseLock() {
        super.releaseLock();
        stateLock.unlock();
    }

     * Returns true if the current thread holds a lock on this resource.  Returns false otherwise.
     *
     * @return true if the task for this operation holds the lock for this resource.
     */
    boolean isLockedByCurrentThread();

    /**
     * Attempt to lock this resource, if not already.  Does not block.
     *
     * @return true if resource is now locked, false otherwise.
     */
    boolean tryLock();

    /**

        then:
        thrown(IllegalStateException)

        when:
        lock.unlock()

        then:
        thrown(IllegalStateException)

        when:
        lock.isLockedByCurrentThread()

        then:
        thrown(IllegalStateException)

        when:
        lock.isLocked()

        then:
        thrown(IllegalStateException)
    }

        return new WorkerLease() {
            @Override
            boolean isLocked() {
                return false
            }

            @Override
            boolean isLockedByCurrentThread() {
                return false
            }

            @Override
            boolean tryLock() {
                return false
            }

            @Override

            @Override
            ResourceLockState.Disposition transform(ResourceLockState resourceLockState) {
                held.set(resourceLock.locked && resourceLock.isLockedByCurrentThread())
                return ResourceLockState.Disposition.FINISHED
            }
        })
        return held.get()
    }

                Iterator<ResourceLock> iterator = locksNotHeld.iterator();
                while (iterator.hasNext()) {
                    ResourceLock lock = iterator.next();
                    if (lock.isLockedByCurrentThread()) {
                        iterator.remove();
                    }
                }
            }
        });
        return locksNotHeld;
    }

    @Override

        MockLock(ProjectInternal project, Collection<MockLock> locks) {
            this.locks = locks
            this.project = project
        }

        @Override
        boolean isLockedByCurrentThread() {
            return locked && Thread.currentThread() == owner
        }

        @Override
        boolean tryLock() {
            if (!locks.contains(this) && locked) {
                return false