}
                }
            }
        }
    }

    @Issue("GRADLE-2555")
    void "can deal with transitive with parent in conflict"() {
        /*
            Graph looks like…

            \--- org:a:1.0
                 \--- org:in-conflict:1.0 -> 2.0
                      \--- org:target:1.0
                           \--- org:target-child:1.0
            \--- org:b:1.0

    display: inline-block;
}
button.page-search-header {
    border: none;
    cursor: pointer;
}
span#page-search-link {
    text-decoration: underline;
}
.module-graph span, .sealed-graph span {
    display:none;
    position:absolute;
}
.module-graph:hover span, .sealed-graph:hover span {
    display:block;
    margin: -100px 0 0 100px;
    z-index: 1;
}
.inherited-list {

// masks will complicate the strided_slice computation logic, we can simplify
// the logic by inserting a reshape op to pad the inputs so strided_slice can
// be easier to handle.
//
// So the graph may looks like below:
//   original_input -> strided_slice -> output
//      (transforms)
//   original_input -> reshape -> strided_slice -> output
//
// And the new shape is computed based on the masks.
//

  let description = [{
Asynchronously executes a function, potentially across multiple devices but
within a single process. The kernel places and partitions a given function's
underlying graph, and executes each of the partitioned subgraphs as a function.
  }];

  let arguments = (ins
    Variadic<TF_Tensor>:$args,

    FlatSymbolRefAttr:$f,
    StrAttr:$config,
    StrAttr:$config_proto,

  }

  std::vector<const tflite::OperatorT*> queue;
  for (int32_t output : output_indices) {
    if (auto& op = defining_op[output]) {
      queue.push_back(op);
    }
  }

  // Traverse the graph towards inputs.
  absl::flat_hash_set<const tflite::OperatorT*> visited;
  while (!queue.empty()) {
    const tflite::OperatorT* op = queue.back();
    queue.pop_back();
    if (!visited.insert(op).second) {

        and:
        outputDoesNotContain("Cannot set attributes for constraint \"org:test:1.0\": it was probably created by a plugin using internal APIs")
    }

    def "attributes declared on constraints contribute to graph selection"() {
        given:
        settingsFile << """
            include 'producer'
        """
        file("producer/build.gradle") << """
            plugins {
                id("base")

  ModuleOp module = getOperation();

  // When allow_tensorlist_pass_through_ == false the target dynamic legal
  // checks will cause this pass to fail if there are any variant type tensors
  // in the graph. The graph should still be treated as valid as long as those
  // variant tensors are not from tf-dialect tensorlist ops. Rather than change
  // the dynamic legalization predicates

        }

        ExecutorService createExecutor(int parallelism) {
            //
            // We need an executor that will not block.
            // We can't use work stealing, as we are building a graph
            // and this could lead to cycles where a thread waits for
            // a task to finish, then execute another one which waits
            // for the initial task...

  - Value: 'extra' selects variant: 'bar'
  - Value: 'extra 2' selects variant: 'bar2'"""
    }

    def "context travels down to transitive dependencies with external dependencies in graph"() {
        given:
        createDirs("a", "b", "c")
        file('settings.gradle') << "include 'a', 'b', 'c'"
        buildFile << """
            $typeDefs

            allprojects {

// Note that this checks for identical condition as
// quantize_conv_with_bias_dynamic_fn, omitting stablehlo.maximum.
// This is because activation clipping which includes 0.0f can be simply
// omitted from the graph as the lifted function's out_scale and out_zp are
// already calculated based on the clipped distribution.
// Note that the resulting scale and zero point should be calculated based on
// clipped range [0, r_max].