}

    @Override
    public T update(final UpdateAction<T> updateAction) {
        class Updater implements Runnable {
            private final UpdateAction<T> updateAction;

            private T result;

            private Updater(UpdateAction<T> updateAction) {
                this.updateAction = updateAction;
            }

            @Override
            public void run() {

    }

    @Override
    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 {

     * Replaces the value for this cache.
     *
     * An exclusive lock is held while the update action is executing.
     * The result of the update is returned.
     */
    T update(UpdateAction<T> updateAction);

    interface UpdateAction<T> {
        T update(T oldValue);
    }

    /**
     * Potentially replaces the value for this cache
     *

        }

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

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

		// action for verification.
		var updateAction core.UpdateAction
		for _, action := range fakeClientset.Actions() {
			switch a := action.(type) {
			case core.UpdateAction:
				if updateAction != nil {
					t.Errorf("expected only 1 update action; had %v and found %v", updateAction, a)
				} else {
					updateAction = a
				}
			}
		}
		if updateAction == nil {
			t.Errorf("expected an update action")

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

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

        and:
        idFactory.create() >> newId

        and:
        id == newId
    }

    @Override
    public void remove(final Address address) {
        lock.lock();
        try {
            LOGGER.debug("Removing daemon address: {}", address);
            cache.update(new ObjectHolder.UpdateAction<DaemonRegistryContent>() {
                @Override
                public DaemonRegistryContent update(DaemonRegistryContent oldValue) {
                    if (oldValue == null) {

	fakeClient := &fake.Clientset{}
	updater := NewRealStatefulSetStatusUpdater(fakeClient, nil)
	fakeClient.AddReactor("update", "statefulsets", func(action core.Action) (bool, runtime.Object, error) {
		update := action.(core.UpdateAction)
		return true, update.GetObject(), nil
	})
	if err := updater.UpdateStatefulSetStatus(context.TODO(), set, &status); err != nil {
		t.Errorf("Error returned on successful status update: %s", err)
	}

			approved:   true,
			verify: func(t *testing.T, as []testclient.Action) {
				if len(as) != 1 {
					t.Errorf("expected one Update action but got %d", len(as))
					return
				}
				csr := as[0].(testclient.UpdateAction).GetObject().(*capi.CertificateSigningRequest)
				if len(csr.Status.Certificate) == 0 {
					t.Errorf("expected certificate to be issued but it was not")
				}
			},
		},
		{

            this.compilationState = newValue
        }

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

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