then:
        1 * fileResolver.resolve("src1") >> file1
        1 * fileResolver.resolve("src2") >> file2
        files as List == [file1, file2]
    }

    def "can use nested objects to specify the contents of the collection"() {
        given:
        def file1 = new File("1")
        def file2 = new File("2")

        when:

func createTimeIncrementingPodWorkers() (*timeIncrementingWorkers, map[types.UID][]syncPodRecord) {
	nested, runtime, processed := createPodWorkers()
	w := &timeIncrementingWorkers{
		w:       nested,
		runtime: runtime,
	}
	nested.workerChannelFn = func(uid types.UID, in chan struct{}) <-chan struct{} {
		ch := make(chan struct{})
		go func() {
			defer close(ch)

        then:
        resolve.expectGraph {
            root(":", ":test:") {
                module('org.gradle.test:lib:1.0')
            }
        }
    }

    def "can use nested accessors to declare a dependency version"() {
        settingsFile << """
            dependencyResolutionManagement {
                versionCatalogs {
                    libs {

			"<script>var a = `\\u0024\\u007b asd \\u0060\\u0060 \\u007d`</script>",
		},
		{
			"JS template lit special characters, nested lit",
			"<script>var a = `${ `{{.I}}` }`</script>",
			"<script>var a = `${ `\\u0024\\u007b asd \\u0060\\u0060 \\u007d` }`</script>",
		},
		{
			"JS template lit, nested JS",
			"<script>var a = `${ var a = \"{{\"a \\\" d\"}}\" }`</script>",
			"<script>var a = `${ var a = \"a \\u0022 d\" }`</script>",

====
include::sample[dir="snippets/files/sampleJavaProject/kotlin",files="build.gradle.kts[tags=nested-specs]"]
include::sample[dir="snippets/files/sampleJavaProject/groovy",files="build.gradle[tags=nested-specs]"]
====

Notice how the `src/dist` configuration has a nested inclusion specification; it is the child copy spec.
You can, of course, add content filtering and renaming here as required.

    define_values = {"no_xla_deps_in_cuda": "true"},
    visibility = ["//visibility:public"],
)

# Crosses between framework_shared_object and a bunch of other configurations
# due to limitations in nested select() statements.
config_setting(
    name = "framework_shared_object",
    define_values = {"framework_shared_object": "true"},
    visibility = ["//visibility:public"],
)

config_setting(

	// module's selected version changes, we assume that it remains direct if the
	// previous version was a direct dependency. That assumption might not hold in
	// rare cases (such as if a dependency splits out a nested module, or merges a
	// nested module back into a parent module).
	direct map[string]bool

	graphOnce sync.Once // guards writes to (but not reads from) graph
	graph     atomic.Pointer[cachedGraph]
}

                sb.append("]");
            }
            sb.append("; ");
            target = target.getCause();
            if (target != null) {
                sb.append("nested: ");
            }
        }
        return sb.toString();
    }

    protected void processLabelRequest(final HttpServletRequest request, final HttpServletResponse response, final FilterChain chain) {

				"self.mapOfList.map(k, k).map(k, k).size() == 1":     32,
				"self.listOfMap.map(e, e).map(e, e).size() == 1":     32,
				"self.listOfListMap.map(e, e).map(e, e).size() == 1": 32,

				// nested comprehensions
				"self.mapOfMap.map(k, self.mapOfMap[k].map(m, m)).size() == 1":         34,
				"self.mapOfListMap.map(k, self.mapOfListMap[k].map(m, m)).size() == 1": 34,

    // CHECK-NEXT: ^{{.+}}({{.+}}: tensor<i1>):
    ^cond(%carg0: tensor<i1>):
      // CHECK-NEXT: [[WHILE_REGION_COND:%.+]] = "tf.Const"
      // CHECK-SAME: value = dense<true> : tensor<i1>
      %10 = "tf.VarIsInitializedOp"(%arg0) : (!tf_res) -> tensor<i1>
      // CHECK-NEXT: "tf.Yield"([[WHILE_REGION_COND]])
      "tf.Yield"(%10) : (tensor<i1>) -> ()
    // CHECK-NEXT: }, {
    }, {