try {
                owner.lockReleased(this);
            } finally {
                coordinationService.getCurrent().registerUnlocked(this);
            }
        }
    }

    @Override
    public boolean isLocked() {
        failIfNotInResourceLockStateChange();
        return doIsLocked();
    }

    @Override

     * fails.
     */
    void registerLocked(ResourceLock resourceLock);

    /**
     * Registers a resource lock that has been unlocked during the transform so that the coordination service can
     * notify threads waiting on a lock.
     */
    void registerUnlocked(ResourceLock resourceLock);

    /**

                }
                lockedResources.add(resourceLock);
            }
        }

        @Override
        public void registerUnlocked(ResourceLock resourceLock) {
            if (!rollback && (lockedResources == null || !lockedResources.remove(resourceLock))) {
                if (unlockedResources == null) {
                    unlockedResources = new HashSet<ResourceLock>();
                }

                @Override
                ResourceLockState.Disposition transform(ResourceLockState resourceLockState) {
                    resourceLockState.registerUnlocked(lock2)
                    return FINISHED
                }
            })

            thread.blockUntil.executed2
        }

        then:
        lock1.lockedState

        given:
        _ * coordinationService.current >> resourceLockState

        when:
        lock.tryLock()

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

        when:
        lock.unlock()

        then:
        1 * container.lockReleased(lock)
    }

    def "throws exception when methods are called without coordination service transform"() {