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))),

<dl>
	<dt>Field</dt>
	<dd>
		You can search any field by typing the field name followed by a colon
		":" and then the term you are looking for. If you want to find
		documents which has "Fess" as the document title, you can enter:
		<pre>title:Fess</pre>
		The available fields are "url", "host", "site", "title", "content",
		"content_length", "last_modified" and "mimetype", and they are
		customizable.
	</dd>
	<dt>Sort</dt>
	<dd>

                description = "Enter the git 'user.email' configuration to commit change under",
                display = ParameterDisplay.PROMPT,
                allowEmpty = true
            )
            text(
                "confirmationCode",
                "",
                label = "Confirmation Code",

import spock.lang.Specification

class IntQuestionPromptEventTest extends Specification {
    def "formats prompt"() {
        def event = new IntQuestionPromptEvent(123, "question?", 2, 4)
        assert event.prompt == "enter value (min: 2, default: 4): "
    }

    def "accepts valid input"() {
        def event = new IntQuestionPromptEvent(123, "question?", 2, 4)

        expect:
        def result = event.convert(input)

  const string unique_suffix = absl::StrCat("_", GetUniqueScopeId());

  std::vector<Node*> starts;
  starts.push_back(start);
  auto enter = [&](Node* n) { AddOrAppendXlaInternalScope(n, unique_suffix); };
  ReverseDFSFrom(*graph_, starts, enter, /*leave=*/nullptr,
                 /*stable_comparator=*/NodeComparatorName());
}

void ClusterScopingPassImpl::AddScopeToAllTransitiveSuccessors(Node* start) {

  Output capture_enter_outer = ops::internal::Enter(
      root.WithOpName("capture_enter_outer"), captured, "outer_loop",
      ops::internal::Enter::Attrs().IsConstant(true));
  Output capture_enter_inner = ops::internal::Enter(
      root.WithOpName("capture_enter_inner"), capture_enter_outer, "inner_loop",
      ops::internal::Enter::Attrs().IsConstant(true));

  }
  attr {
    key: "value"
    value {
      tensor {
        dtype: DT_INT32
        tensor_shape {
        }
        int_val: 0
      }
    }
  }
}
node {
  name: "while/Enter"
  op: "Enter"
  input: "Const"
  attr {
    key: "T"
    value {
      type: DT_INT32
    }
  }
  attr {
    key: "frame_name"
    value {
      s: "while/while_context"
    }
  }
  attr {

    @Test
    void testNestedEnter() throws Exception {
        MojoExecutionScope scope = new MojoExecutionScope();

        scope.enter();

        Object o1 = new Object();
        scope.seed(Object.class, o1);
        assertSame(o1, scope.scope(Key.get(Object.class), null).get());

        scope.enter();
        Object o2 = new Object();
        scope.seed(Object.class, o2);

        def event = new SelectOptionPromptEvent(123, "question", ["11", "12", "13"], 1)

        assert event.prompt == TextUtil.toPlatformLineSeparators("""question:
  1: 11
  2: 12
  3: 13
Enter selection (default: 12) [1..3] """)
    }

    def "accepts valid input"() {
        def event = new SelectOptionPromptEvent(123, "question", ["1", "2", "3", "4"], 1)

        expect:

                return PromptResult.response(result);
            }
            return PromptResult.newPrompt("Please enter an integer value >= " + minValue + " (default: " + defaultValue + "): ");
        } catch (NumberFormatException e) {
            return PromptResult.newPrompt("Please enter an integer value (min: " + minValue + ", default: " + defaultValue + "): ");
        }
    }