// ---------
  //  0  1  2 <-- initial values
  //  1  2  2
  //  3  3  2
  //  6  4  2
  // 10  5  2 <-- while output values
  // outputs sum = 17
  //
  //  i  j  k
  // ---------
  //  0  2  2 <-- initial values (add 1 to j)
  //  2  3  2
  //  5  4  2
  //  9  5  2
  // 14  6  2 <-- while output values
  // outputs sum = 22
  //
  // Calculate the "slope" between j=1 and j=2:

fun test() {

    outer@while(true) {
        inner@while(false) {
            val x = <expr>break@outer</expr>
        }
    }

fun test() {
    outer@ while (cond()) {
        consume(1)
        while (cond()) {
            consume(2)
            <expr>if (cond()) {
                break
            } else if (cond()) {
                break@outer
            }</expr>
        }
    }
}

fun consume(obj: Any?) {}

 *   <li>It is easy for the user to ensure that listeners are never invoked while holding locks.
 * </ul>
 *
 * The last point is subtle. Often the observable object will be managing its own internal state
 * using a lock, however it is dangerous to dispatch listeners while holding a lock because they
 * might run on the {@code directExecutor()} or be otherwise re-entrant (call back into your

public class NamespaceBuilder {
    public static String toNamespace(String name) {
        StringBuilder result = new StringBuilder();
        int pos = 0;
        while (pos < name.length()) {
            while (pos < name.length() && !isCppIdentifierCharacterStart(name.charAt(pos))) {
                pos++;
            }
            if (pos == name.length()) {
                break;
            }

                workActionClass = ${failureExecution.name}.class
            }
        """.stripIndent()

        when:
        fails("runInWorker")

        then:
        failureHasCause("A failure occurred while executing ${failureExecution.name}")

        and:
        failureHasCause("Failure from work action")

        where:
        isolationMode << ISOLATION_MODES
    }

    sleep "$(( 2 ** attempt++ ))"
  done
  while true; do
    if ! timeout 60 "${healthcheck_command[@]}" > /dev/null; then
      echo "Container runtime ${container_runtime_name} failed!"
      systemctl kill --kill-who=main "${container_runtime_name}"
      # Wait for a while, as we don't want to kill it again before it is really up.
      sleep 120
    else

        Iterator properties = requestProperties.entrySet().iterator();
        while (properties.hasNext()) {
            Map.Entry property = (Map.Entry) properties.next();
            String key = (String) property.getKey();
            StringBuffer value = new StringBuffer();
            Iterator values = ((List) property.getValue()).iterator();
            while (values.hasNext()) {
                value.append(values.next());

  func.return %0 : tensor<1x2x3xf32>
}

// -----

// Simple While
func.func private @testWhileCond(tensor<*xf32>) -> (tensor<i1>)
func.func private @testWhileBody(tensor<*xf32>) -> (tensor<*xf32>)

// CHECK-LABEL: func @testWhileResult
func.func @testWhileResult(tensor<*xf32>) -> (tensor<*xf32>) {
^bb0(%arg0: tensor<*xf32>):
  %1 = "tf.While"(%arg0) {
    cond = @testWhileCond,
    body = @testWhileBody,

     *
     * @param stateLock Lock to hold while mutating state.
     * @param onOpen Action to run when the lock is opened. Action is called while holding state lock
     * @param onClose Action to run when the lock is closed. Action is called while holding state lock
     */