}

    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() {

        then:
        outputContains("Execution: ${includedBuildSystemPropertyDefinition.propertyValue()}")

        when:
        System.clearProperty(systemProp)
        configurationCacheRun fixture.task

        then:
        configurationCache.assertStateLoaded()
        outputContains("Execution: ${includedBuildSystemPropertyDefinition.propertyValue()}")

        cleanup:
        System.clearProperty(systemProp)
    }

import org.gradle.internal.operations.BuildOperationRunner;
import org.gradle.internal.operations.CallableBuildOperation;
import org.gradle.internal.operations.UncategorizedBuildOperations;
import org.gradle.internal.properties.PropertyValue;
import org.gradle.internal.snapshot.ValueSnapshot;
import org.gradle.operations.dependencies.transforms.ExecuteTransformActionBuildOperationType;

        outputContains("some.property = $propertyValue")

        when:
        configurationCacheRun("printProperty")

        then:
        configurationCache.assertStateLoaded()
        outputContains("some.property = $propertyValue")

        where:
        propertyValue | propertySetter
        "some.value"  | """System.setProperty("some.property", "$propertyValue")"""

                Object propertyValue = metaBeanProperty.getGetter().invoke(bean, new Object[0]);
                if (propertyValue instanceof LazyGroovySupport) {
                    value = propertySetTransformer.transformValue(propertyType, value);
                    ((LazyGroovySupport) propertyValue).setFromAnyValue(value);
                    return;
                }
            }

fun Project.selectStringProperties(vararg propertyNames: String): Map<String, String> =
    propertyNames.mapNotNull { propertyName ->
        stringPropertyOrNull(propertyName)?.let { propertyValue ->
            propertyName to propertyValue
        }
    }.toMap()


/**
 * Creates a [Provider] that returns `true` when this [Provider] has a value
 * and `false` otherwise. The returned [Provider] always has a value.

            // set at the configuration time. Everything that reads a mutated property value should be saved
            // as a fixed value.
            return
        }
        val propertyValue =
            if (isSystemPropertyLoaded(key)) {
                // Loaded values of the system properties are loaded from gradle.properties but never mutated.