error   string
	}

	testCases := []tct{
		{
			name: "allowed properties valuevalidation, additional properties structure",
			schema: Structural{
				AdditionalProperties: &StructuralOrBool{
					Structural: &Structural{
						Generic: Generic{
							Type: "object",
						},
						Properties: map[string]Structural{
							"bar": {
								Generic: Generic{
									Type: "string",

import org.gradle.api.internal.StartParameterInternal
import org.gradle.initialization.properties.DefaultProjectPropertiesLoader
import org.gradle.initialization.properties.DefaultSystemPropertiesInstaller
import org.gradle.initialization.properties.MutableGradleProperties
import org.gradle.initialization.properties.ProjectPropertiesLoader
import org.gradle.initialization.properties.SystemPropertiesInstaller
import org.gradle.util.SetSystemProperties

        properties.getProperty(WrapperExecutor.DISTRIBUTION_BASE_PROPERTY) == wrapper.getDistributionBase().toString()
        properties.getProperty(WrapperExecutor.DISTRIBUTION_PATH_PROPERTY) == wrapper.getDistributionPath()
        properties.getProperty(WrapperExecutor.ZIP_STORE_BASE_PROPERTY) == wrapper.getArchiveBase().toString()
        properties.getProperty(WrapperExecutor.ZIP_STORE_PATH_PROPERTY) == wrapper.getArchivePath()
    }

			Schema: mustSchema(`
                properties:
                  foo:
                    type: array
                    items:
                      type: object
                      properties:
                        key:
                          type: string
                        bar:
                          type: object
                          properties:
                            baz:

    /**
     * Set the default properties of the static Properties used by <tt>Config</tt>. This permits
     * a different Properties object/file to be used as the source of properties for
     * use by the jCIFS library. The Properties must be set <i>before jCIFS
     * classes are accessed</i> as most jCIFS classes load properties statically once.
     * Using this method will also override properties loaded

// metadata.name and metadata.generateName properties are specified, making a shallow copy of the provided schema if needed.
func WithTypeAndObjectMeta(s *spec.Schema) *spec.Schema {
	if s.Properties != nil &&
		s.Properties["kind"].Type.Contains("string") &&
		s.Properties["apiVersion"].Type.Contains("string") &&
		s.Properties["metadata"].Type.Contains("object") &&
		s.Properties["metadata"].Properties != nil &&

        Object value = ee.evaluate(expr);

        assertEquals(expr, value);
    }

    @Test
    void testPOMPropertyExtractionWithMissingProject_WithDotNotation() throws Exception {
        String key = "m2.name";
        String checkValue = "value";

        Properties properties = new Properties();
        properties.setProperty(key, checkValue);

    }

    def "fails when no implementation class specified in properties file"() {
        def properties = new Properties()
        def propertiesFile = testDir.file("prop")
        GUtil.saveProperties(properties, propertiesFile)
        def url = propertiesFile.toURI().toURL()

        given:
        _ * classLoader.getResource("META-INF/gradle-plugins/noImpl.properties") >> url

        when:

[[managed_properties]]
== Using Gradle Managed Properties

Gradle's managed properties allow you to declare properties as abstract getters (Java, Groovy) or abstract properties (Kotlin).

Gradle then automatically provides the implementation for these properties, managing their state.

A property may be _mutable_, meaning that it has both a `get()` method and `set()` method:

        Properties prop1 = new Properties();
        prop1.setProperty("jcifs.smb.client.minVersion", "SMB302");
        PropertyConfiguration p1 = new PropertyConfiguration(prop1);
        assertEquals(DialectVersion.SMB302, p1.getMinimumVersion());
        assertEquals(DialectVersion.SMB302, p1.getMaximumVersion());

        Properties prop2 = new Properties();