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

// 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);

[[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();

    }

    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
        }
    }

        project.buildFile << """
            normalization {
                runtimeClasspath {
                    properties('**/foo.properties') {
                        ignoreProperty '${IGNORE_ME}'
                    }
                    properties('some/path/to/foo.properties') {
                        ignoreProperty '${IGNORE_ME_TOO}'
                    }
                }
            }
        """

    }

    /**
     * Gets the user properties to use for interpolation and profile activation. The user properties have been
     * configured directly by the user on his discretion, e.g. via the {@code -Dkey=value} parameter on the command
     * line.
     *
     * @return The user properties, never {@code null}.
     */
    public Properties getUserProperties() {
        return request.getUserProperties();

        pomReader.properties['project.groupId'] == 'group-one'
        pomReader.properties['pom.groupId'] == 'group-one'
        pomReader.properties['groupId'] == 'group-one'
        pomReader.properties['project.artifactId'] == 'artifact-one'
        pomReader.properties['pom.artifactId'] == 'artifact-one'
        pomReader.properties['artifactId'] == 'artifact-one'
        pomReader.properties['project.version'] == 'version-one'

----

This flag overrides any settings that disable the Daemon in your project or user `gradle.properties` files.

To enable the Daemon by default in older Gradle versions, add the following setting to the `gradle.properties` file in the project root or your Gradle User Home (`GRADLE_USER_HOME`:

====
.gradle.properties
[source,properties]
----
org.gradle.daemon=true
----
====

[[sec:disabling_the_daemon]]