def branch6 = new DefaultMultiCauseException("sixth failure", intermediateFailure2)

        Throwable exception = new ContextAwareException(new TypedResolveException("task dependencies", "org:example:1.0", [branch1, branch2, branch3, branch4, branch5, branch6]))

        when:
        reporter.buildFinished(result(exception))
        print(output.value)

        then:
        output.value == """

  // CHECK-NEXT: [[idx:%.*]] = corert.tensorhandle_to_int32 [[th_idx]]
  // CHECK-NEXT: [[out:%.*]] = tfrt.case [[idx]] [@branch0, @branch1]([[chain]], [[branch_arg0]], [[branch_arg1]])
  %0 = "tf.Case"(%arg0, %arg1, %arg2) {_lower_using_switch_merge = true, branches = [@branch0, @branch1], is_stateless = true} : (tensor<i32>, tensor<f32>, tensor<f32>) -> tensor<f32>
  func.return %0 : tensor<f32>

  //
  // Two ops with the same groups and different branches are considered
  // parallel so are not made dependent. For example if `OpA` has parallel_ids
  //   `{group0:branch0, group1:branch0}`
  // and `OpB` has parallel_ids
  //   `{group0:branch1, graph1:branch0}`
  // then `OpA` and `OpB` are executed in parallel because `group0` is common
  // with a different branch.
  //

  // CHECK: [[idx:%.*]] = tf_mlrt.tensor_to_int32 [[tf_idx]]
  // CHECK-NEXT: [[out:%.*]] = mlrt.case [[idx]] [@branch0, @branch1]([[branch_arg0]], [[branch_arg1]])
  %0 = "tf.Case"(%arg0, %arg1, %arg2) {_lower_using_switch_merge = true, branches = [@branch0, @branch1], is_stateless = true} : (tensor<i32>, tensor<f32>, tensor<f32>) -> tensor<f32>
  func.return %0 : tensor<f32>
}

// -----

  }

  func.func private @branch0(tensor<2xf32>) -> tensor<2xf32>
  func.func private @branch1(tensor<2xf32>) -> tensor<2xf32>

  func.func @case_with_symbol_ref(%arg0: tensor<i32>, %arg1: tensor<2xf32>) -> tensor<2xf32> {
    // CHECK: tf.Case
    // expected-remark@+1 {{ops with symbol references are not supported}}

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package syntax

import "fmt"

// checkBranches checks correct use of labels and branch
// statements (break, continue, fallthrough, goto) in a function body.
// It catches:
//   - misplaced breaks, continues, and fallthroughs
//   - bad labeled breaks and continues

  %0 = "tf.Case"(%arg0, %arg1) {branches = [@branch_0, @branch_1], is_stateless = false} : (tensor<i32>, tensor<!tf_type.resource<tensor<1x2x3xf32>>>) -> tensor<1x2x3xf32>

  // CHECK: [[Result0:%.*]] = "tf.CaseRegion"
  // CHECK: [[Result1:%.*]] = func.call @branch_0
  // CHECK: "tf.Yield"([[Result1]])
  // CHECK: [[Result2:%.*]] = func.call @branch_1
  // CHECK: "tf.Yield"([[Result2]])

// branch functions to (a) drop the ununsed return values, and (b) as a result
// if some argument becomes unused in all branches, drop that argument and the
// corresponding if/case input operand.
void EliminateUnusedResultsForIfCase(Operation *op,
                                     ArrayRef<func::FuncOp> branches) {
  // Clone branch functions if needed since we will be mutating them.

  // Rewrite the branches.
  RegionRange branches = case_op.getRegions();

  for (Region* branch : branches) {
    if (failed(DecomposeTensorListOpsInternal(
            &branch->front(), module, buffer_to_size,
            decomposed_partitioned_call_callees)))
      return failure();
  }

  // Get the output buffer index to size index mapping one of the branches. It

                                branch11 = selection.getDescriptor(IvyModuleDescriptor).branch
                            } else {
                                selection.reject('not 1.1')
                            }
                        }
                    }
                }
            }
        """

        when:
        buildFile.text = """
            $commonBuildFile