<< node->DebugString();
    ASSERT_TRUE(node->while_ctx() != nullptr) << i;
    if (i == 0) {
      while_ctx = node->while_ctx();
      EXPECT_EQ(while_ctx->frame_name(), kFrameName);
    } else {
      EXPECT_EQ(node->while_ctx(), while_ctx) << i;
    }
  }

  // Run the loop and test we get the expected results
  Run<int>({1}, {10});
  Run<int>({11}, {11});
}

}

TEST(NodeMatchers, Attrs) {
  Scope root = Scope::NewRootScope().ExitOnError();
  Output enter = ops::internal::Enter(
      root.WithOpName("enter"),
      ops::Placeholder(root.WithOpName("data"), DT_FLOAT), "frame_name",
      ops::internal::Enter::Attrs{}.IsConstant(true));
  EXPECT_THAT(enter.node(), NodeWith(Attr("is_constant", true)));
  EXPECT_EQ(Explain(enter.node(), NodeWith(Attr("is_constant", false))),

    while loop.

    This is defined in Tensorflow as:

    REGISTER_OP("Enter")
       .Input("data: T")
       .Output("output: T")
       .Attr("T: type")
       .Attr("frame_name: string")
       .Attr("is_constant: bool = false")
       .Attr("parallel_iterations: int = 10")

    For example:

  // flow frame.
  while (!control_flow_info[src_node->id()].frame_name.empty()) {
    NodeDebugInfo debug_info(*src_node);
    NodeBuilder enter_builder(options.GetNameForOp("Enter"), "Enter",
                              options.op_registry(), &debug_info);
    enter_builder.Attr("frame_name",
                       control_flow_info[src_node->id()].frame_name);
    enter_builder.Attr("is_constant", true);

    p.printFunctionalType(getOperation());
  } else {
    p << getType(0);
  }

  p.printOptionalAttrDict(getOperation()->getAttrs(),
                          {"frame_name", "parallel_iterations", "is_constant"});
}

ParseResult EnterOp::parse(OpAsmParser &parser, OperationState &result) {
  SmallVector<OpAsmParser::UnresolvedOperand, 2> op_infos;

  // We've seen all the exit nodes for this loop and have collected all the
  // backprops. Create the gradient graph for the while loop.
  Scope while_scope =
      scope_.NewSubScope(strings::StrCat(while_ctx->frame_name(), "_grad"));
  std::vector<Output> dy;
  for (Node* n : while_ctx->exit_nodes()) dy.push_back(backprops[n]);
  std::vector<Output> dx;
  TF_RETURN_IF_ERROR(AddWhileLoopGradient(while_ctx, while_scope, dy, &dx));

// Check that Enter return value is the same type as the input.
func.func @invalid_enter(%arg0: tensor<*xf32>, %arg1: i1) -> tensor<*xf32> {
  %result = tf_executor.graph {
    %res:2 = "tf_executor.Enter"(%arg1) { frame_name = "some/fra\"me"} : (i1) -> (tensor<*xf32>, !tf_executor.control)
// expected-error@-1 {{'tf_executor.Enter' op failed to verify that data operand must be broadcastable to result}}
    tf_executor.fetch %res#0 : tensor<*xf32>

    val tracer = this.tracer
    return if (tracer == null) {
        writeAction()
    } else {
        val frameName = name()
        try {
            tracer.open(frameName)
            writeAction()
        } finally {
            tracer.close(frameName)
        }
    }

      direction,
      streamId,
      length,
      formattedType,
      windowSizeIncrement,
    )
  }

  internal fun formattedType(type: Int): String = if (type < FRAME_NAMES.size) FRAME_NAMES[type] else format("0x%02x", type)

  /**
   * Looks up valid string representing flags from the table. Invalid combinations are represented
   * in binary.
   */
  fun formatFlags(
    type: Int,

	}

	tx.Rollback()

	if err = db.First(&User{}, "name = ?", "transaction").Error; err == nil {
		t.Fatalf("Should not find record after rollback, but got %v", err)
	}

	txDB := db.Where("fake_name = ?", "fake_name")
	tx2 := txDB.Session(&gorm.Session{NewDB: true}).Begin()
	user2 := *GetUser("transaction-2", Config{})
	if err = tx2.Save(&user2).Error; err != nil {
		t.Fatalf("No error should raise, but got %v", err)
	}