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 + "): ");
        }
    }

            .ask() == 1
    }

    def "always returns default for int question"() {
        expect:
        userInputHandler.askIntQuestion('Enter something', 1, 2) == 2
    }

    def "always returns default for text question"() {
        expect:
        userInputHandler.askQuestion('Enter something', 'ok') == 'ok'
    }

            builder.append(i + 1);
            builder.append(": ");
            builder.append(options.get(i));
            builder.append(TextUtil.getPlatformLineSeparator());
        }
        builder.append("Enter selection (default: ");
        builder.append(options.get(defaultOption));
        builder.append(") [1..");
        builder.append(options.size());
        builder.append("] ");
        return builder.toString();
    }

  if (loop_var_idx > 0) strings::StrAppend(&result, "_", loop_var_idx);
  return result;
}

// Creates the `loop_var_idx`-th Merge node of a loop being constructed with
// `scope`. `enter_output` is the `loop_var_idx`-th Enter node's output.
Status CreateMerge(const Scope& scope, int loop_var_idx,
                   const Output& enter_output, Output* merge_output) {
  // The merge nodes accept the while loop's back edges as an input (i.e. the

        }
        gradleHandle.stdinPipe.write(input.bytes)
        gradleHandle.stdinPipe.write(TextUtil.platformLineSeparator.bytes)
        poll {
            assert gradleHandle.standardOutput.contains("Please enter 'yes' or 'no': ")
        }
        writeToStdInAndClose(gradleHandle, "yes")
        gradleHandle.waitForFinish()
        gradleHandle.standardOutput.contains("result = true")

        where:

      }
    }

    // Sometimes we have VariableShape nodes in while loop (after Enter nodes).
    // They won't be constant-folded because TensorFlow constant folding does
    // not handle Enter nodes (and thus does not handle any nodes after Enter
    // nodes). We try to replace such VariableShape nodes with Const nodes here.
    if (n->type_string() == "VariableShape") {

Setting up a new Gradle job can be achieved with just a couple of clicks.
From the left navigation bar select "New Item > Freestyle project".
Enter a new name for the project. We'll pick "gradle-site-plugin" for the project.

Select the radio button "Git" in the section "Source Code Management".
Enter the URL of the GitHub repository: `https://github.com/gradle/gradle-site-plugin.git`.

image::ci-systems/jenkins-scm.png[]

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

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