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

  input: "Case/branch0/_0/mul/y"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
}
node {
  name: "Case/branch1/_1/mul_0"
  op: "Mul"
  input: "Case/Case/input_0/_7:1"
  input: "Case/branch1/_1/mul/y"
  attr {
    key: "T"
    value {
      type: DT_FLOAT
    }
  }
}
node {
  name: "Case/merge/_9"
  op: "Merge"
  input: "Case/branch0/_0/mul_0"

	<dependencies>
		<dependency name="mymodule2" rev="2.0" e:attr4="value4"/>
		<dependency name="mymodule3" rev="2.0" changing="true" transitive="false"/>
		<dependency org="yourorg" name="yourmodule1" branch="trunk" rev="1.1" branchConstraint="branch1" revConstraint="1+" conf="myconf1"/>
		<dependency org="yourorg" name="yourmodule2" rev="2+" conf="myconf1->yourconf1"/>

  // 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>
}

// -----

          default:
            outputs = branches[nbranches-1](inputs);
            break;
        }
        ```
    Example: %res = mlrt.case %branch_idx [@branch0, @branch1] (%arg0, %arg1) : (i32, i32) -> (i32)
  }];

  let arguments = (ins I32:$branch_index,
                       ConfinedAttr<SymbolRefArrayAttr, [ArrayMinCount<1>]>:$branches,
                       Variadic<AnyType>:$branch_operands);

//          which represents the second branch of replicate group 0 and
//          the first branch of parallel group 0.
// First instance of "tf.OpD" after flattening will have
//          `_parallel_execution_ids = "r0:0,p0:1"`
//          which represents the first branch of replicate group 0 and
//          the second branch of parallel group 0.
// Second instance of "tf.OpD" after flattening will have

  }

  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}}

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

func.func @testCaseMismatchedNumResults(%arg0: tensor<i32>, %arg1: tensor<2xf32>) -> tensor<2xf32> {
  // expected-error @+1 {{'tf.Case' op branch #0 results (size = 2) should have the same number of values as results (size = 1)}}