return requestBody;
    }

    @Override
    protected Map<String, Object> getUpdateMap() {
        final Map<String, Object> updateMap = new HashMap<>();
        updateMap.put("value", "newValue");
        return updateMap;
    }

    @Test
    void crudTest() {
        testCreate();
        testRead();
        testUpdate();
        testDelete();
    }

	// the first one we make around, we can avoid generating
	// more than one per racing thread.
	var (
		toInsert     *T // Keep this around to keep it alive.
		toInsertWeak weak.Pointer[T]
	)
	newValue := func() weak.Pointer[T] {
		if toInsert == nil {
			toInsert = new(T)
			*toInsert = clone(value, &m.cloneSeq)
			toInsertWeak = weak.Make(toInsert)
		}
		return toInsertWeak
	}
	var ptr *T
	for {

        outputContains("execution value = someValue")

        when:
        configurationCacheRun("${setterSwitch}property=newValue")

        then:
        configurationCache.assertStateStored()
        outputContains("configuration value = newValue")
        outputContains("execution value = newValue")

        where:
        providerType     | setterSwitch
        "systemProperty" | "-D"
        "gradleProperty" | "-P"

    T update(Function<T, T> updateFunction);

    /**
     * Sets the current value.
     *
     * <p>The calling thread must own the mutable state from which the value is calculated.</p>
     */
    void set(T newValue);

        when:
        run "someTask"

        then:
        skipped(":someTask")
    }

    def "task is out of date when property type changes #oldValue -> #newValue"() {
        buildFile << """
task someTask {
    inputs.property("a", $oldValue).optional(true)
    outputs.file "out"
    doLast ${Actions.name}.doNothing() // attach an action that is not defined by the build script

        return writeOperation(p -> p.remove(key, value));
    }

    @Override
    public synchronized boolean replace(Object key, Object oldValue, Object newValue) {
        return writeOperation(p -> p.replace(key, oldValue, newValue));
    }

    @Override
    public synchronized Object replace(Object key, Object value) {
        return writeOperation(p -> p.replace(key, value));
    }

		newValue:       nil,
		expectError:    true, // populated by defaulting and required when feature is enabled
	}, {
		name:           "feature disabled, nil->nil",
		featureEnabled: false,
		oldValue:       nil,
		newValue:       nil,
		expectError:    false,
	}, {
		name:           "feature disabled, nil->set",
		featureEnabled: false,
		oldValue:       nil,

        private CompilationState compilationState

        CompilationState get() {
            return compilationState
        }

        void set(CompilationState newValue) {
            this.compilationState = newValue
        }

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

        for (i in 0 until url.querySize) {
          val parameterName = url.queryParameterName(i)
          val newValue = if (parameterName in queryParamsNameToRedact) "██" else url.queryParameterValue(i)

          addEncodedQueryParameter(parameterName, newValue)
        }
      }.toString()
    }

    private fun logHeader(
      headers: Headers,
      i: Int,
    ) {

   *
   * @param currentValue the current value (of either base or a cell)
   * @param newValue the argument from a user update call
   * @return result of the update function
   */
  abstract long fn(long currentValue, long newValue);

  /**
   * Handles cases of updates involving initialization, resizing, creating new Cells, and/or