rootProject.name = 'my-composite'

includeBuild 'my-app'

    private final CompositeIdGenerator.CompositeId parentId;
    private final String displayName;

    public DefaultNestedTestSuiteDescriptor(Object id, String name, String displayName, CompositeIdGenerator.CompositeId parentId) {
        super(id, name);
        this.displayName = displayName;
        this.parentId = parentId;
    }

    public CompositeIdGenerator.CompositeId getParentId() {
        return parentId;
    }

namespace {

using ::stablehlo::quantization::CalibrationOptions;
using ::stablehlo::quantization::Method;

constexpr StringRef kQuantTraitAttrName = "_tfl_quant_trait";

// Whether the op is a call op to lifted composite function.
bool IsCallToQuantizableLiftedFunction(Operation *op) {
  if (!op) return false;
  if (auto xla_call_module_op = dyn_cast_or_null<TF::XlaCallModuleOp>(op);
      xla_call_module_op != nullptr) {

        def c1 = new DefaultDomainObjectSet<String>(String, callbackActionDecorator)
        def c2 = new DefaultDomainObjectSet<String>(String, callbackActionDecorator)
        given:
        def composite = CompositeDomainObjectSet.<String>create(String, c1, c2)
        def set = new DefaultDomainObjectSet<String>(String, composite.getStore(), callbackActionDecorator)

        when:

		return false
	}
	if !isSimpleName(n.X) {
		// not a special composite literal assignment
		return false
	}
	x := n.X.(*ir.Name)
	if !types.Identical(n.X.Type(), n.Y.Type()) {
		// not a special composite literal assignment
		return false
	}
	if x.Addrtaken() {
		// If x is address-taken, the RHS may (implicitly) uses LHS.

            }
        }
}

/**
 * Uses the given [factory] to merge all providers of type [T] with the given [mergeTargets] strategy. Other providers (not of type [T]) are
 * added to the resulting composite provider unmerged.
 */
public inline fun <P : KotlinComposableProvider, reified T : P> List<P>.mergeSpecificProviders(
    factory: KotlinCompositeProviderFactory<P>,
    crossinline mergeTargets: (List<T>) -> P,
): P {

					"ear",
					"plugins-distribution",
					"build-cache-local"
				]
			},
			{
				"parallelizationMethod":{
					"name":"TestDistribution"
				},
				"subprojects":[
					"composite-builds",
					"declarative-dsl-core",
					"problems",
					"plugins-test-report-aggregation",
					"resources-sftp",
					"build-cache-http",
					"testing-base",
					"model-groovy",

        checkDependenciesFails()

        then:
        failure.assertHasCause("Module version 'org.test:b1:2.0' is not unique in composite: can be provided by [project :buildB:b1, project :buildC:b1].")
    }

    def "resolve transitive project dependency that is ambiguous in the composite"() {
        given:
        transitiveDependencyIsAmbiguous("project(':b1')")

        when:
        checkDependencies()

    }

    def "ignores the lock entry that matches a composite"() {
        given:
        lockfileFixture.createLockfile('lockedConf', ['org:composite:1.1'], false)

        file("composite/settings.gradle") << """
rootProject.name = 'composite'
"""
        file("composite/build.gradle") << """
apply plugin: 'java'
group = 'org'
version = '1.1'
"""

     */
    CONFLICT_RESOLUTION("conflict resolution"),

    /**
     * This component was selected as a participant of a composite.
     */
    COMPOSITE_BUILD("composite build substitution"),

    /**
     * This component was selected because another version was rejected by a rule
     */
    REJECTION("rejection"),

    /**