then:
        1 * globalScopedCacheBuilderFactory.baseDirForCrossVersionCache("user-id.txt") >> storeFile

        and:
        1 * storeFactory.create(storeFile, _) >> store

        and:
        1 * store.maybeUpdate(_) >> { ObjectHolder.UpdateAction action ->
            action.update(null)
        }

        and:
        idFactory.create() >> newId

        and:
        id == newId
    }

        1 * serializer.write(_, "a")

        when: // same value is not written
        def r = cache.maybeUpdate { it }

        then:
        r == "a"
        1 * serializer.read(_)

        and:
        0 * serializer.write(_, _)

        when: // different value is written back
        r = cache.maybeUpdate { "b" }

        then:
        1 * serializer.read(_)

        and:

    public T update(final UpdateAction<T> updateAction) {
        return doUpdate(updateAction, () -> delegate.update(updateAction));
    }

    @Override
    public T maybeUpdate(final UpdateAction<T> updateAction) {
        return doUpdate(updateAction, () -> delegate.maybeUpdate(updateAction));
    }

    private T doUpdate(UpdateAction<T> updateAction, Supplier<T> work) {
        try {
            return work.get();

     *
     * An exclusive lock is held while the update action is executing.
     * The result of the update is returned, which may not be the object returned by the update action.
     */
    T maybeUpdate(UpdateAction<T> updateAction);

        @Override
        public CompilationState update(UpdateAction<CompilationState> updateAction) {
            throw new UnsupportedOperationException();
        }

        @Override
        public CompilationState maybeUpdate(UpdateAction<CompilationState> updateAction) {
            throw new UnsupportedOperationException();
        }
    }

                } else {
                    result = oldValue;
                }
            }
        }

        MaybeUpdater maybeUpdater = new MaybeUpdater(updateAction);
        fileAccess.updateFile(maybeUpdater);
        return maybeUpdater.result;
    }

    private void serialize(T newValue) {
        try {
            if (!cacheFile.isFile()) {

        return buildTreeScopedCacheBuilderFactory;
    }

    private UniqueId get(ScopeParams params) {
        ObjectHolder<UniqueId> store = store(params);

        return store.maybeUpdate(new ObjectHolder.UpdateAction<UniqueId>() {
            @Override
            public UniqueId update(UniqueId oldValue) {
                if (oldValue == null) {
                    return generator.create();

        CompilationState update(ObjectHolder.UpdateAction<CompilationState> updateAction) {
            throw new UnsupportedOperationException()
        }

        @Override
        CompilationState maybeUpdate(ObjectHolder.UpdateAction<CompilationState> updateAction) {
            throw new UnsupportedOperationException()
        }
    }

    class DummyResolver implements SourceIncludesResolver {