new File(projectDirectory, "gradle.properties") << "\norg.gradle.workers.max=${maxWorkers}\n"

}

private void setMaxHeap(File projectDirectory, String maxHeap) {
    new File(projectDirectory, "gradle.properties") << "\norg.gradle.jvmargs=-Xmx${maxHeap}\n"

}

private void setParallel(File projectDirectory, boolean parallel) {
    new File(projectDirectory, "gradle.properties") << "\norg.gradle.parallel=${parallel}\n"

        configurationCache.assertStateStored()
        outputContains "because the set of Gradle properties has changed."

        where:
        dynamicPropertyExpression << [
            'gradleProp',
            'ext.gradleProp'
        ]
    }

    @Issue("https://github.com/gradle/gradle/issues/19793")
    def "gradle properties must be accessible from task in #build"() {
        given:

 * limitations under the License.
 */

package org.gradle.internal.properties.bean;

import org.gradle.internal.properties.PropertyVisitor;
import org.gradle.internal.reflect.validation.TypeValidationContext;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

/**
 * Walks properties declared by the type.
 */
@ServiceScope(Scope.Global.class)

 */
val hashtableCodec: Codec<Hashtable<Any?, Any?>> = mapCodec { Hashtable(it) }


/*
 * Decodes Properties as Properties instead of Hashtable.
 */
val propertiesCodec: Codec<Properties> = mapCodec { Properties() }


val treeMapCodec: Codec<TreeMap<Any?, Any?>> = codec(
    {
        write(it.comparator())
        writeMap(it)
    },
    {

        if (jvmArguments != null) {
            daemonParams.setJvmArgs(jvmArguments);
        }

        daemonParams.setRequestedJvmCriteria(properties.getDaemonJvmProperties());

        // Include the system properties that are defined in the daemon JVM args
        properties = properties.merge(daemonParams.getSystemProperties());

        Map<String, String> envVariables = operationParameters.getEnvironmentVariables(null);

        return new FilePropertyContainer<T>();
    }

    public void add(T property) {
        properties.add(property);
        changed = true;
    }

    @Override
    public Iterator<T> iterator() {
        if (changed) {
            for (T propertySpec : properties) {
                String propertyName = propertySpec.getPropertyName();
                if (propertyName == null) {

    }

    /**
     * @return all jvm args including system properties
     */
    public List<String> getAllJvmArgs() {
        List<String> args = new ArrayList<>();
        formatSystemProperties(getMutableSystemProperties(), args);

        // We have to add these after the system properties so they can override any system properties
        // (identical properties later in the command line override earlier ones)

        String oldProperty
        @Console
        boolean console
    }

    def "can get annotated properties of simple task"() {
        when:
        def properties = metadataStore.getTypeMetadata(SimpleTask).propertiesMetadata

        then:

              schema:
                type: object
                properties:
                  record_count:
                    type: integer
                    example: 9
                  data:
                    type: array
                    items:
                      type: object
                      properties:
                        label:
                          type: string

public interface TypeMetadata {
    void visitValidationFailures(@Nullable String ownerPropertyPath, TypeValidationContext validationContext);

    /**
     * Returns the set of relevant properties, that is, those properties annotated with a relevant annotation.
     */
    Set<PropertyMetadata> getPropertiesMetadata();

    boolean hasAnnotatedProperties();

    PropertyAnnotationHandler getAnnotationHandlerFor(PropertyMetadata propertyMetadata);