if name == "" {
					subName := field.Name
					const key = "COMPOSITE"
					if composite, found := settings[key]; found {
						if len(composite) == 0 || composite == key {
							err = fmt.Errorf(
								"The composite tag of %s.%s cannot be empty",
								field.Schema.Name,
								field.Name)
							return
						}
						subName = composite
					}
					name = field.Schema.namer.IndexName(

class BiActionsTest extends Specification {

    def "composite action executes all actions that are part of it"() {
        given:
        BiAction<List<String>, List<String>> first = {a, b -> a << "first a"; b << "first b" }
        BiAction<List<String>, List<String>> second = {a, b -> a << "second a"; b << "second b" }
        def composite = BiActions.composite(first, second)
        def a = []
        def b = []

        when:

            details.testDescriptor.className == null
            details.testDescriptor.composite == true
        }
        with(iterator.next()) {
            details.testDescriptor.name ==~ "Gradle Test Executor \\d+"
            details.testDescriptor.className == null
            details.testDescriptor.composite == true
        }
        checkForSuiteOperations(iterator, "org.gradle.ASuite")

The composable TF framework allows the user to define portable TF ops as
compositions of other TF ops. It translates a Python function used to define the
composition directly into a portable IR at build time, and uses it to expand the
composite op in the TF program during compilation / execution. By using this
expansion mechanism, new op are readily available on different platforms without
extra work. Moreover, since the expansion is optional, the backend can easily

 * limitations under the License.
 */

package org.gradle.integtests.composite

import org.gradle.integtests.fixtures.build.BuildTestFile

class CompositeBuildRootProjectIntegrationTest extends AbstractCompositeBuildIntegrationTest {

    def "root of a composite build cannot refer to own subprojects by GA coordinates by default"() {
        given:

 * limitations under the License.
 */

package org.gradle.integtests.composite

import org.gradle.integtests.fixtures.build.BuildTestFile
import spock.lang.Ignore

@Ignore("No longer works with parallel execution of included builds. See gradle/composite-builds#114")
class CompositeBuildDestroyablesIntegrationTest extends AbstractCompositeBuildIntegrationTest {
    BuildTestFile buildB

== Using composite builds in a hierarchical multirepo project

This sample demonstrates how composite builds can be used to develop a hierarchical project that is composed from different Git repositories. Instead of Gradle subprojects in a multiproject build, this example uses separate Gradle builds included into a composite.

import java.util.Collection;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.stream.Collectors;

/**
 * Provides a dependency substitution rule for composite build,
 * that substitutes a project within the composite with any dependency with a matching ModuleIdentifier.
 */
public class CompositeBuildDependencySubstitutions implements Action<DependencySubstitution> {

// license that can be found in the LICENSE file.

package p

type S1 struct{}
type S2 struct{}

func _[P *S1|*S2]() {
	_= []P{{ /* ERROR "invalid composite literal element type P (no core type)" */ }}
}

func _[P *S1|S1]() {
	_= []P{{ /* ERROR "invalid composite literal element type P (no core type)" */ }}

    def rootDescriptor = new SimpleTestDescriptor(displayName: "Test Run", className: null, composite: true)
    def workerDescriptor = new SimpleTestDescriptor(displayName: "Gradle Worker 2", className: null, composite: true, parent: rootDescriptor)
    def outerSuiteDescriptor = new SimpleTestDescriptor(name: "com.OuterSuiteClass", displayName: "OuterSuiteClass", composite: true, parent: workerDescriptor)