}

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

    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)

    default void visitInputProperty(String propertyName, PropertyValue value, boolean optional) {}

    default void visitOutputFileProperty(String propertyName, boolean optional, PropertyValue value, OutputFilePropertyType filePropertyType) {}

    }

    private static void verifyGradlePropertiesSettingSpecified(Properties gradleProperties, String propertyName) {
        def propertyValue = gradleProperties.getProperty(propertyName)
        if (propertyValue == null || propertyValue.isEmpty()) {
            throw new IllegalArgumentException("Test project needs to specify ${propertyName} but did not.")
        }
    }

    }

    @Override
    public void applyFromProperty(Map<String, String> properties, T settings) {
        OptionValue<String> propertyValue = getFromProperties(properties);
        String value = propertyValue.getValue();
        if (value != null) {
            applyTo(value, settings, propertyValue.getOrigin());
        }
    }

    @Override
    public void configure(CommandLineParser parser) {

    }

    override fun <T : Any> getSingletonProperty(propertyType: Class<T>): T {
        val propertyValue = singletonProperty
        require(propertyValue != null && propertyType.isInstance(propertyValue)) {
            "A singleton property of type $propertyType has not been registered!"
        }
        return propertyValue.uncheckedCast()
    }

    override fun newIsolate(owner: IsolateOwner): ReadIsolate =

    @Override
    public void applyFromProperty(Map<String, String> properties, T settings) {
        OptionValue<String> propertyValue = getFromProperties(properties);
        String value = propertyValue.getValue();
        if (value != null) {
            applyTo(Integer.parseInt(value), settings, propertyValue.getOrigin());
        }
    }

    @Override
    public void configure(CommandLineParser parser) {

 * limitations under the License.
 */
package org.gradle.internal.properties.annotations;

import com.google.common.collect.ImmutableSet;
import org.gradle.internal.properties.PropertyValue;
import org.gradle.internal.properties.PropertyVisitor;
import org.gradle.internal.reflect.validation.TypeValidationContext;
import org.gradle.internal.service.scopes.Scope;

    }

    @Override
    public void applyFromProperty(Map<String, String> properties, T settings) {
        OptionValue<String> propertyValue = getFromProperties(properties);
        String value = propertyValue.getValue();
        if (value != null) {
            applyTo(isTrue(value), settings, propertyValue.getOrigin());
        }
    }

    @Override
    public void configure(CommandLineParser parser) {