}
    }

    def expectTestPasses() {
        suiteDescriptor.id >> "suite"
        suiteDescriptor.parent >> null
        suiteDescriptor.composite >> true

        testDescriptor.id >> "test"
        testDescriptor.parent >> suiteDescriptor
        testDescriptor.composite >> false
        testDescriptor.className >> "class"
        testDescriptor.classDisplayName >> "class"
        testDescriptor.name >> "method"

        @Override
        public CompositeIdGenerator.CompositeId read(Decoder decoder) throws Exception {
            return new CompositeIdGenerator.CompositeId(decoder.readLong(), decoder.readLong());
        }

        @Override
        public void write(Encoder encoder, CompositeIdGenerator.CompositeId value) throws Exception {

        0 * _
    }

    def "can add no-op action to composite set"() {
        def action1 = Mock(Action)
        def action2 = Mock(Action)

        expect:
        def set = ImmutableActionSet.of(action1, action2)
        set.add(Actions.doNothing()).is(set)
    }

    def "can add empty set to composite set"() {
        def action1 = Mock(Action)
        def action2 = Mock(Action)

                options.annotationProcessorPath = files()
            }
        """
        file("my-composite-app/settings.gradle") << "rootProject.name = 'my-composite-app'"

        settingsFile << """
        rootProject.name='root'
        includeBuild 'my-composite-app'
        """
        mavenHttpRepo.module('org.foo', 'app-dep').publish().allowAll()
    }

 * limitations under the License.
 */

package org.gradle.integtests.composite

import org.gradle.integtests.fixtures.build.BuildTestFile
import org.gradle.integtests.fixtures.resolve.ResolveTestFixture
import spock.lang.Issue

/**
 * Tests for resolving dependency graph with substitution within a composite build.
 */

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) {

		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.

        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'
"""

        "@llvm-project//mlir:SCFDialect",
        "@llvm-project//mlir:ShapeDialect",
        "@llvm-project//mlir:Support",
        "@pybind11",
    ],
)

py_strict_library(
    name = "composite",
    srcs = ["python/composite.py"],
    srcs_version = "PY3",
)

py_strict_library(
    name = "tfr_gen",
    srcs = ["python/tfr_gen.py"],
    srcs_version = "PY3",
    deps = [
        ":tfr_wrapper",