}

    File createModule(String simpleName, Properties properties) {
        def moduleDir = tmpDir.createDir("$simpleName/build/resources/main")
        save(properties, moduleDir.file("gradle-$simpleName-classpath.properties"))
        moduleDir
    }

    private Properties properties(Map kvs = [:]) {
        new Properties().with {
            putAll(kvs)
            it
        }
    }

            def w1 = tasks.create("w1", WriteProperties) {
                destinationFile = file("w1.properties")
                properties = [v: 1]
            }
            def w2 = tasks.create("w2", WriteProperties) {
                destinationFile = file("w2.properties")
                properties = [v: 1]
            }

            tasks.create("w").dependsOn w1, w2
        """

        when:

	}

	for k, vFld := range v.Properties {
		if sFld, ok := s.Properties[k]; !ok {
			if sAdditionalPropertiesSchema == nil || !opts.AllowValidationPropertiesWithAdditionalProperties {
				allErrs = append(allErrs, field.Required(sPath.Child("properties").Key(k), fmt.Sprintf("because it is defined in %s", vPath.Child("properties").Key(k))))
			} else {
				// Allow validations on specific properties if there exists an

        "1.8",
        "1.9",
        "2.0",
    ]

    private final Factory<Properties> propertiesFactory
    private Properties properties

    KotlinGradlePluginVersions() {
        this(new ClasspathVersionSource("kotlin-versions.properties", KotlinGradlePluginVersions.classLoader))
    }

    private KotlinGradlePluginVersions(Factory<Properties> propertiesFactory) {
        this.propertiesFactory = propertiesFactory
    }

 * See the License for the specific language governing permissions and
 * 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;

                      description: Traffic policies that apply to this subset.
                      properties:
                        connectionPool:
                          properties:
                            http:
                              description: HTTP connection pool settings.
                              properties:
                                h2UpgradePolicy:
                                  description: |-

        DirCacheReference(ReferencablePersistentCache cache, Map<String, ?> properties, LockOptions lockOptions) {
            this.cache = cache;
            this.properties = properties;
            this.lockOptions = lockOptions;
            onOpen(cache);
        }

        public void addReference(ReferenceTrackingCache cache) {
            references.add(cache);
        }

        }

        val types: Iterable<KClass<*>>
            get() = properties.keys

        fun hasType(kClass: KClass<*>): Boolean = kClass in properties

        fun getAllProperties(kClass: KClass<*>): List<DataProperty> = properties[kClass]?.values.orEmpty().toList()

        fun getClaimedFunctions(kClass: KClass<*>): Set<KFunction<*>> = claimedFunctions[kClass].orEmpty()

    private final AllProperties properties;

    public Parameters(StartParameterInternal startParameter, DaemonParameters daemonParameters, AllProperties properties) {
        this.startParameter = startParameter;
        this.daemonParameters = daemonParameters;
        this.properties = properties;
    }

    public AllProperties getProperties() {
        return properties;
    }

        Map<String, String> properties = new HashMap<>();
        properties.put(ArtifactProperties.TYPE, id);
        properties.put(ArtifactProperties.LANGUAGE, language.id());
        properties.put(MavenArtifactProperties.INCLUDES_DEPENDENCIES, Boolean.toString(includesDependencies));
        properties.put(
                MavenArtifactProperties.CONSTITUTES_BUILD_PATH,