}

    def rebuildsCacheWhenPropertyIsAdded() {
        given:
        def dir = createCacheDir()
        def properties = properties + [newProp: 'newValue']
        def cache = new DefaultPersistentDirectoryCache(dir, "<display-name>", properties, mode(FileLockManager.LockMode.Shared), initializationAction, cacheCleanup, lockManager, Mock(ExecutorFactory), buildOperationRunner)

                data.set(key, value);
            }

            @Override
            public <T> boolean replace(@Nonnull Key<T> key, @Nullable T oldValue, @Nullable T newValue) {
                return data.set(key, oldValue, newValue);
            }

            @Nullable
            @Override
            @SuppressWarnings("unchecked")
            public <T> T get(@Nonnull Key<T> key) {

     * thereafter.
     */
    private void maybeWarnOnChangingUsage(String methodName, boolean current, boolean newValue) {
        if (isInLegacyRole()) {
            return;
        }

        // Error will be thrown later. Don't emit a duplicate warning.
        if (!usageCanBeMutated && (current != newValue)) {
            return;
        }

		errMaxDepth: true,
	}}

	targets := []struct {
		CaseName
		newValue func() any
	}{{
		CaseName: Name("unstructured"),
		newValue: func() any {
			var v any
			return &v
		},
	}, {
		CaseName: Name("typed named field"),
		newValue: func() any {
			v := struct {
				A any `json:"a"`
			}{}
			return &v
		},
	}, {

        }

        when:
        configurationCacheRun("-DCI=$newValue")

        then: 'undeclared inputs are treated as inputs'
        configurationCache.assertStateStored()
        noExceptionThrown()

        where:
        read                                                                        | defaultValue | newValue

			scope.err(err, w, req)
			return
		}

		// transform fields
		// TODO: DecodeParametersInto should do this.
		if opts.FieldSelector != nil {
			fn := func(label, value string) (newLabel, newValue string, err error) {
				return scope.Convertor.ConvertFieldLabel(scope.Kind, label, value)
			}
			if opts.FieldSelector, err = opts.FieldSelector.Transform(fn); err != nil {

			for _, atvs := range atvSet.Value {
				for _, atv := range atvs {
					specifiedExtensions[atv.Type.String()] = true
				}
			}

			newValue := make([]pkix.AttributeTypeAndValue, 0, len(atvSet.Value[0])+len(extensions))
			newValue = append(newValue, atvSet.Value[0]...)

			for _, e := range extensions {
				if specifiedExtensions[e.Id.String()] {
					// Attributes already contained a value for

                }
            }

            @Override
            public void onChange(Object key, Object newValue) {
                listener().systemPropertyChanged(key, newValue, consumer);
            }

            @Override
            public void onRemove(Object key) {
                listener().systemPropertyRemoved(key, consumer);
            }

        given:
        buildScript """
            task (copy, type:Copy) {
               from ('src') {
                  def newValue = providers.systemProperty('new-value').present
                  if (newValue) {
                        $newValue
                  } else {
                        $oldValue
                  }
               }
               into 'dest'
            }

    @CheckForNull
    public T get() {
      return value;
    }

    public void checkAndSet(@CheckForNull T expected, @CheckForNull T newValue) {
      if (value != expected) {
        throw new ConcurrentModificationException();
      }
      value = newValue;
    }

    void clear() {
      value = null;
    }
  }

  private static final class AvlNode<E extends @Nullable Object> {