/**
     * Finalizes the property value, if possible. This makes the value final, so that it no longer changes, but not necessarily immutable.
     */
    void maybeFinalizeValue();

    PropertyValue ABSENT = new PropertyValue() {
        @Nullable
        @Override
        public Object call() {
            return null;
        }

        @Override
        public TaskDependencyContainer getTaskDependencies() {

    }

    suspend fun writeInputProperty(propertyName: String, propertyValue: Any?) =
        writeProperty(propertyName, propertyValue, PropertyKind.InputProperty)

    suspend fun writeOutputProperty(propertyName: String, propertyValue: Any?) =
        writeProperty(propertyName, propertyValue, PropertyKind.OutputProperty)

    val inputProperties = collectRegisteredInputsOf(task)

        String propertyValue()
    }

    static class RootBuild implements BuildWithSystemPropertyDefined {

        @Override
        void setup(AbstractIntegrationSpec spec, String propertyKey) {
            spec.testDirectory.file("gradle.properties") << "systemProp.$propertyKey=${propertyValue()}"
        }

        @Override
        String propertyValue() {

        when:
        object.load(inputFile)

        then:
        propertyValue == 'value'
    }

    def loadsFromDefaultResource() {
        when:
        object.loadDefaults()

        then:
        propertyValue == 'default-value'
    }

    def storesToXmlFile() {
        object.loadDefaults()
        propertyValue = 'modified-value'
        def outputFile = tmpDir.file('output.properties')

    def "adds software types as extensions when software type plugin is applied"() {
        def plugin = Mock(Plugin)
        def propertyWalker = Mock(PropertyWalker)
        def propertyValue = Mock(PropertyValue)
        def softwareType = Mock(SoftwareType)
        def extensions = Mock(ExtensionContainerInternal)
        def foo = new Foo()

        when:
        pluginTarget.applyImperative(null, plugin)

import org.gradle.internal.properties.PropertyValue
import spock.lang.Specification

class DefaultFinalizingValidatingPropertyTest extends Specification {
    def "notifies property value of start and end of execution when it implements lifecycle interface"() {
        def value = Mock(LifecycleAwareValue)
        def valueWrapper = Stub(PropertyValue)

                    propertyValue = ((File) property.getValue()).getAbsolutePath();
                } else if (property.getValue() instanceof URI) {
                    propertyValue = ((URI) property.getValue()).toASCIIString();
                } else {
                    propertyValue = property.getValue();
                }

                propertiesMapBuilder.put(property.getKey(), propertyValue);
            }

    }

    @Override
    public void visitInputProperty(String propertyName, PropertyValue value, boolean optional) {
        for (PropertyVisitor visitor : visitors) {
            visitor.visitInputProperty(propertyName, value, optional);
        }
    }

    @Override
    public void visitOutputFileProperty(String propertyName, boolean optional, PropertyValue value, OutputFilePropertyType filePropertyType) {

            return taskPropertySpecs;
        }
    }

    private static class ResolvingValue implements PropertyValue {
        private final PropertyValue delegate;
        private final Function<Object, Object> resolver;

        public ResolvingValue(PropertyValue delegate, Function<Object, Object> resolver) {
            this.delegate = delegate;
            this.resolver = resolver;
        }

import org.gradle.internal.properties.PropertyValue;

public class DefaultInputPropertySpec extends AbstractPropertySpec implements InputPropertySpec {
    private final PropertyValue value;

    public DefaultInputPropertySpec(String propertyName, PropertyValue value) {
        super(propertyName);
        this.value = value;
    }

    @Override
    public PropertyValue getValue() {
        return value;
    }