}

    /**
     * When the daemon is started on *nix, we need to detach it from the terminal session of the parent process,
     * otherwise if a ctrl-c is entered on the terminal, it will kill all processes in the session.  This test compiles
     * a native executable that can retrieve the session id of a process so that we can verify that the session id

        return visitor.visitEntry(this);
    }

    @Override
    default SnapshotVisitResult accept(RelativePathTracker pathTracker, RelativePathTrackingFileSystemSnapshotHierarchyVisitor visitor) {
        pathTracker.enter(getName());
        try {
            return visitor.visitEntry(this, pathTracker);
        } finally {
            pathTracker.leave();
        }
    }

   2: yes - application and library projects
Enter selection (default: no - only one application project) [1..2] 2

Select implementation language:
  1: C++
  2: Groovy
  3: Java
  4: Kotlin
  5: Scala
  6: Swift
Enter selection (default: Java) [1..6] ${languageIndex.raw}

Select build script DSL:
  1: Groovy
  2: Kotlin
Enter selection (default: Groovy) [1..2] 1
${testFrameworkChoice.raw}

        def event = new YesNoQuestionPromptEvent(123, "question?")

        expect:
        def result = event.convert(input)
        result.response == null
        result.newPrompt == "Please enter 'yes' or 'no': "

        where:
        input   | _
        ''      | _
        'bla'   | _
        'y'     | _
        'Y'     | _
        'ye'    | _
        'YES'   | _
        'n'     | _

    fun putInstance(id: Int, instance: Any) {
        instanceIds[id] = instance
    }
}


class CircularReferences {

    private
    val refs = ReferenceOpenHashSet<Any>()

    fun enter(reference: Any) {
        require(refs.add(reference))
    }

    operator fun contains(reference: Any) =
        refs.contains(reference)

    fun leave(reference: Any) {
        require(refs.remove(reference))

        "temp directory"          | JAVA_IO_TMPDIR_KEY       | "/some/tmp/folder"
    }

    def "can enter debug mode"() {
        def opts = createOpts()
        when:
        opts.debug = true
        then:
        opts.debug
    }

    def "can enter debug mode after setting other options"() {
        def opts = createOpts()
        when:

	HotPgoInitial          = HotPgo | HotInitial                // special case; single block loop, initial block is header block has a flow-in entry, but PGO says it is hot
	HotPgoInitialNotFLowIn = HotPgo | HotInitial | HotNotFlowIn // PGO says it is hot, and the loop is rotated so flow enters loop with a branch

        String trimmed = text.trim();
        if (YES_NO_CHOICES.contains(trimmed)) {
            return PromptResult.response(BooleanUtils.toBoolean(trimmed));
        }
        return PromptResult.newPrompt("Please enter 'yes' or 'no': ");
    }

}

//===----------------------------------------------------------------------===//
// tf_executor.Enter
//===----------------------------------------------------------------------===//

// Default number for the parallel_iterations attributes on Enter nodes.
static constexpr int kDefaultParallelIterations = 10;

void EnterOp::print(OpAsmPrinter &p) {
  p << ' ';
  p.printOperands(getOperands());

  p << " frame \"";

    /**
     * Was the given capability already seen which might require a conflict check later?
     * This is needed to determine if also implicit capabilities need to enter conflict detection.
     */
    boolean hasSeenCapability(Capability capability);

    interface Candidate {
        NodeState getNode();
        Capability getCapability();