then:
        1 * dependencyLockingProvider.loadLockState(lockId, _) >> lockState
        1 * lockState.mustValidateLockState() >> true
        1 * lockState.lockedDependencies >> emptySet()
        0 * _
    }

    def 'initialises when there is no lock state'() {
        when:
        visitor.start(rootNode)

        then:
        1 * dependencyLockingProvider.loadLockState(lockId, _) >> lockState

        startParameter.isWriteDependencyLocks() >> true
        provider = newProvider()
        def modules = [module('org', 'foo', '1.0'), module('org','bar','1.3')] as Set
        provider.loadLockState('conf', owner)
        provider.persistResolvedDependencies('conf', owner, modules, emptySet())

        when:
        provider.buildFinished()

        then:

    }

    @Override
    public DependencyLockingState loadLockState(String lockId, DisplayName lockOwner) {
        recordUsage();
        loadLockState();
        if (!writeLocks || partialUpdate) {
            List<String> lockedModules = findLockedModules(lockId);

        then:

        1 * resolutionStrategy.dependencyLockingEnabled >> true
        1 * resolutionStrategy.dependencyLockingProvider >> lockingProvider
        1 * lockingProvider.loadLockState('lockedConf', _) >> lockingState
        1 * lockingState.mustValidateLockState() >> false
        1 * lockingProvider.persistResolvedDependencies('lockedConf', _, Collections.emptySet(), Collections.emptySet())
    }

    @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'() {
        given:
        def result = Mock(Set)


        when:

        return INSTANCE;
    }

    private NoOpDependencyLockingProvider() {
        // Prevent construction
    }

    @Override
    public DependencyLockingState loadLockState(String lockId, DisplayName lockOwner) {
        return DefaultDependencyLockingState.EMPTY_LOCK_CONSTRAINT;
    }

    @Override

     *
     * @throws org.gradle.internal.locking.MissingLockStateException If the {@code LockMode} is {@link LockMode#STRICT} but no lock state can be found.
     */
    DependencyLockingState loadLockState(String lockId, DisplayName lockOwner);

    /**
     * Records the resolution result to the lock with the given ID.
     *
     * @param lockId the ID of the lock to persist the results to

            DependencyLockingProvider dependencyLockingProvider = resolveContext.getResolutionStrategy().getDependencyLockingProvider();
            DependencyLockingState lockingState = dependencyLockingProvider.loadLockState(resolveContext.getDependencyLockingId(), resolveContext.getResolutionHost().displayName());
            if (lockingState.mustValidateLockState() && !lockingState.getLockedDependencies().isEmpty()) {

        this.dependencyLockingProvider = dependencyLockingProvider;
    }

    @Override
    public void start(RootGraphNode root) {
        dependencyLockingState = dependencyLockingProvider.loadLockState(lockId, lockOwner);
        if (dependencyLockingState.mustValidateLockState()) {
            Set<ModuleComponentIdentifier> lockedModules = dependencyLockingState.getLockedDependencies();

        resolutionStrategy.isDependencyLockingEnabled() >> true
        dependencyLockingProvider.loadLockState("conf", _) >> new DefaultDependencyLockingState(true, [constraint] as Set, { entry -> false })
        dependencyLockingProvider.loadLockState("child", _) >> DefaultDependencyLockingState.EMPTY_LOCK_CONSTRAINT

        when:
        def child = conf("child")
        def conf = conf()