{call: "Setresgid(0,102,101)", fn: func() error { return syscall.Setresgid(0, 102, 101) }, filter: "Gid:", expect: "\t0\t102\t101\t102"},
		{call: "Setresgid(0,0,0)", fn: func() error { return syscall.Setresgid(0, 0, 0) }, filter: "Gid:", expect: "\t0\t0\t0\t0"},

		{call: "Setresuid(1,0,2)", fn: func() error { return syscall.Setresuid(1, 0, 2) }, filter: "Uid:", expect: "\t1\t0\t2\t0"},

                .build()
                .run()
        }

        then:
        projectsLoadedHandler.getResult() == "loading"
        buildFinishedHandler.getResult() == "build"
    }

    def "failures from action are received and future actions not run"() {
        def projectsLoadedHandler = new IntermediateResultHandlerCollector()

           : recurrent_weights_array->getResult(1);
  Value recurrent_to_cell_weights =
      indy ? mlir::cast<Value>(
                 CreateFlattenOP(recurrent_weights_array->getResult(2),
                                 func_op.getLoc(), builder)
                     .getResult())
           : recurrent_weights_array->getResult(2);
  Value recurrent_to_output_weights =
      indy ? mlir::cast<Value>(

    // Compute inverse of input transpose.
    llvm::SmallVector<int32_t> inverse_perm = InvertPermutation(perm_arr);

    if (tpose_arg.getResult().getType() != op->getResult(0).getType()) {
      // If types are not equal here than the transpose is taking place
      // before an implicit broadcast in the elementwise. We need

  SmallVector<Value, 4> while_input_values;
  SmallVector<Type, 4> while_input_types;
  while_input_values.push_back(const_true.getResult());
  while_input_types.push_back(const_true.getResult().getType());
  for (int i = 1; i < reduce_dataset.getNumOperands(); ++i) {
    while_input_values.push_back(reduce_dataset.getOperand(i));

    op.setOperand(0, stb_op.getInput());
    op.getResult().setType(bts_op.getResult().getType());
  }

  if (final_op_is_bts) {
    if (bts_op.getInput().getDefiningOp<TF::PadOp>()) {
      bts_op.getResult().replaceAllUsesWith(pad_op.getInput());
    } else {
      bts_op.getResult().replaceAllUsesWith(bts_op.getInput());
    }
  }

  stb_op.getResult().dropAllUses();
  return success();
}

                                arith::ConstantOp op) const {
    for (auto connected_op : op.getResult().getUsers()) {
      auto cast_op = dyn_cast_or_null<CastOp>(connected_op);
      if (!cast_op || cast_op.getResult().use_empty()) continue;

      // Get types
      Type old_result_type = op.getResult().getType();
      ShapedType new_result_type =
          mlir::dyn_cast<ShapedType>(cast_op.getType());

    for (Operation* connected_op : op.getResult().getUsers()) {
      ConvertOp convert_op = dyn_cast_or_null<ConvertOp>(connected_op);
      // Skip if no convert op exists.
      if (!convert_op || convert_op.getResult().use_empty()) continue;

      // Get types.
      const Type old_result_type = op.getResult().getType();
      const ShapedType new_result_type =

    auto new_dq_op = rewriter.create<quantfork::DequantizeCastOp>(
        new_q_op.getLoc(), transpose_op.getResult().getType(),
        new_q_op.getResult());
    transpose_op.getResult().replaceAllUsesWith(new_dq_op.getResult());
    new_q_op.setOperand(transpose_op.getResult());

    return success();
  }
};

}  // namespace TFL
}  // namespace mlir

      if (llvm::isa<tf_device::LaunchOp>(parent)) {
        new_value = parent->getResult(operand.getOperandNumber());
      } else if (auto replicate =
                     llvm::dyn_cast<tf_device::ReplicateOp>(parent)) {
        int n = replicate.getN();
        new_value = parent->getResult(operand.getOperandNumber() * n);
      } else {
        parent->emitOpError("Unsupported wrapper op.");