* See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.integtests.composite

class CompositeBuildCleanupIntegrationTest extends AbstractCompositeBuildIntegrationTest {

    def "stale outputs are removed from composite builds"() {
        given:
        dependency("org.test:buildB:1.0")

        def buildB = singleProjectBuild("buildB") {

 *  <li>or as composite/multi-type codecs, backed by a set of bindings, via {@link org.gradle.internal.serialize.graph.codecs.Bindings#build()} - see below for more on Bindings.
 *  </ul>
 *
 * <h3>Building Composite Codecs using Bindings</h3>

import org.gradle.internal.build.BuildIncluder;
import org.gradle.internal.build.BuildStateRegistry;
import org.gradle.internal.composite.ChildBuildRegisteringSettingsLoader;
import org.gradle.internal.composite.CommandLineIncludedBuildSettingsLoader;
import org.gradle.internal.composite.CompositeBuildSettingsLoader;

import java.util.List;

public class DefaultSettingsLoaderFactory implements SettingsLoaderFactory {

 * limitations under the License.
 */

package org.gradle.composite.internal;

import org.gradle.api.artifacts.component.ComponentSelector;
import org.gradle.api.capabilities.Capability;
import org.gradle.api.internal.artifacts.dsl.CapabilityNotationParserFactory;
import org.gradle.api.internal.attributes.ImmutableAttributesFactory;
import org.gradle.api.internal.composite.CompositeBuildContext;
import org.gradle.api.model.ObjectFactory;

  func.func private @test_add_roundtrip(%arg0: tensor<i64>) -> tensor<i64> {
    // CHECK-ROUNDTRIP:  %0 = stablehlo.composite "stablehlo.add_n" %arg0 {composite_attributes = {test_bool = false, test_int = 2 : i64, test_string = "test"}, decomposition = @add_n.impl} : (tensor<i64>) -> tensor<i64>

include "tensorflow/compiler/mlir/quantization/common/attrs_and_constraints.td"

// Re-orders the Identity op following a quantized composite function. This
// allows the QuantizeCompositeFunctionsPass to merge the DequantizeCast with
// the quantized composite function to optimize the requantization part.
def ReorderIdentityFollowingQuantizedFunction : Pat<
  (quantfork_DequantizeCastOp:$output
    (quantfork_StorageCastOp

 * - ...one version exists as 'project' in the build (either through multi-project or composite)
 *
 * This abstract specification leaves out the concrete implementation of setting up the project structure.
 * Subclasses can do that via multi-project or composite build.
 */
abstract class AbstractProjectDependencyConflictResolutionIntegrationSpec extends AbstractIntegrationSpec {

        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)

    }

    def "serializes CompositeId"() {
        def id = new CompositeIdGenerator.CompositeId(1L, 2L)

        when:
        def result = serialize(id)

        then:
        result instanceof CompositeIdGenerator.CompositeId
        result == id
    }

    def "serializes DefaultTestSuiteDescriptor"() {
        def id = new CompositeIdGenerator.CompositeId(1L, 2L)

        this.generator = generator;
    }

    @Override
    public Object generateId() {
        return new CompositeId(scope, generator.generateId());
    }

    public static class CompositeId implements Serializable {
        private final Object scope;
        private final Object id;

        public CompositeId(Object scope, Object id) {
            this.id = id;
            this.scope = scope;
        }