* writer each time it is called.
   *
   * <p>The caller is responsible for ensuring that the returned writer is closed.
   *
   * @throws IOException if an I/O error occurs while opening the writer
   */
  public abstract Writer openStream() throws IOException;

  /**
   * Opens a new buffered {@link Writer} for writing to this sink. The returned stream is not

  @J2ktIncompatible
  @GwtIncompatible // concurrency
  public static void awaitUninterruptibly(CountDownLatch latch) {
    boolean interrupted = false;
    try {
      while (true) {
        try {
          latch.await();
          return;
        } catch (InterruptedException e) {
          interrupted = true;
        }
      }
    } finally {
      if (interrupted) {

expression: WHILE
text: while (b) {
        4
    }

fun test() {

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

fun test() {

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

    for (auto type : while_op->getOperandTypes()) {
      if (mlir::isa<TupleType>(type)) return failure();
    }

    // Creates a TF::WhileRegionOp to replace the mhlo::WhileOp. HLO WhileOp
    // currently doesn't support stateless and shape invariant, so these
    // parameters are set to the default values.
    auto new_while = rewriter.create<TF::WhileRegionOp>(

        /**
         * Returns an action that represents some deferred execution of the user code. While the returned action is running, the details of this application are restored.
         */
        <T> Action<T> reapplyLater(Action<T> action);

        /**
         * Runs an action that represents some deferred execution of the user code. While the action is running, the details of this application are restored.
         */

                }
            }

            apply type: RulePlugin
        '''

        then:
        fails "tasks"

        and:
        failure.assertHasCause("Exception thrown while executing model rule: RulePlugin#name")
        failure.assertHasCause("Attempt to modify a read only view of model element 'person' of type 'Person' given to rule RulePlugin#name")
    }

    @Test
    void testNoProblems() {
        ToolchainsBuildingException e = new ToolchainsBuildingException(Collections.<Problem>emptyList());
        assertEquals("0 problems were encountered while building the effective toolchains" + LS, e.getMessage());
    }

    @Test
    void testOneProblem() {
        ProblemCollector problemCollector = ProblemCollectorFactory.newInstance(null);

        return;
      } catch (InterruptedException ie) {
        throw new RuntimeException("Unexpected interrupt while waiting for future", ie);
      } catch (TimeoutException tryHarder) {
        /* OK */
      }
    } while (System.nanoTime() - deadline < 0);
    throw formatRuntimeException("Future not done within %d second timeout", timeoutSeconds);
  }

  /**