"map provider value"      | ["key1": "Hello", "key2": TestUtil.providerFactory().provider { null }] | IllegalStateException | "Null value is not allowed for the nested collection property 'nested.key2'"

 * and then the properties are visited in depth-first order.
 * Nested properties are marked with a nested annotation and are inspected for child properties that can be
 * "leaf" annotated properties, or other nested properties.
 * The {@link TypeMetadataStore} associated with the walker determines which non-nested property annotations are recognized
 * during the walk.
 * Nested {@code Map}s, {@code Iterable}s are resolved as child properties.

    String getValue()
    void setValue(String v)
}

class MyPlugin extends RuleSource {
    @Model
    void things(ModelMap<Thing> things) { }
}

apply plugin: MyPlugin
'''
    }

    def "nested create rule is executed only as required"() {
        buildFile << '''
model {
    tasks {
        show(Task) {
            doLast {
                println "value = " + $.things.test.value
            }
        }

    @Configuring
    fun nested(fn: Nested.() -> Unit) = Unit

    @get:Restricted
    val nested: Nested
        get() = TODO()
}


private
class Nested {
    @get:Restricted
    var n = 1
}


class AccessInCurrentReceiverOnlyTest {
    val schema = schemaFromTypes(TopLevelForTest::class, listOf(TopLevelForTest::class, HasAnnotatedMembers::class, Nested::class))

    @Test

            import ${ObjectFactory.name};
            import ${TaskAction.name};
            import ${Nested.name};
            import ${Inject.name};

            public class SomeTask extends DefaultTask {
                private final Params params;

                @Nested
                public Params getParams() {
                    return params;
                }

                @Inject

            import ${DefaultTask.name}
            import ${RegularFileProperty.name}
            import ${TaskAction.name}
            import ${Nested.name}

            open class ProducerTask: DefaultTask() {
                @Nested
                val params: Params = project.objects.newInstance(Params::class.java)

                @TaskAction
                fun run() {

            import ${DefaultTask.name};
            import ${TaskAction.name};
            import ${Nested.name};
            import ${Files.name};
            import ${IOException.name};

            public abstract class ProducerTask extends DefaultTask {
                @Nested
                public abstract Params getParams();

                @TaskAction

                @Internal
                Property<String> getUnused()
            }

            abstract class SomeTask extends DefaultTask {
                @Nested
                abstract Bean getBean()

                @Nested
                abstract Bean getUnusedBean()

                @Internal
                abstract Property<String> getValue()

                @Internal

 * limitations under the License.
 */

package org.gradle.internal.cc.impl

class ConfigurationCacheDependencyResolutionFailuresIntegrationTest extends AbstractConfigurationCacheIntegrationTest {

    def 'nested dependency resolution failures are surfaced to the top'() {
        given:
        def emptyRepo = createDir('empty')
        buildFile '''

            configurations {
                implementation
            }

@UnsupportedWithConfigurationCache(because = "software model")
class ManagedModelPropertyTargetingRuleIntegrationTest extends AbstractIntegrationSpec {

    def "rule can target nested element of managed element as input"() {
        when:
        buildScript '''
            @Managed
            interface Platform {
                OperatingSystem getOperatingSystem()
            }