return !tasks.isEmpty();
    }

    void runNext() {
      assertTrue("expected at least one task to run", hasNext());
      tasks.remove().run();
    }

    void runAll() {
      while (hasNext()) {
        runNext();
      }
    }
  }

  private FakeExecutor fakePool;
  private SequentialExecutor e;

  @Override
  public void setUp() {
    fakePool = new FakeExecutor();

                        b = b * 10 + c - '0';
                    }
                    ip = (ip << 8) + b;
                }
                while (i < data.length && Character.isWhitespace(data[i])) {
                    i++;
                }
                j = i;
                while (j < data.length && !Character.isWhitespace(data[j])) {
                    j++;
                }

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

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

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

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

        ProjectBuildingException exception = new ProjectBuildingException(results);
        String message = exception.getMessage();

        assertTrue(
                message.contains("3 problems were encountered while processing the POMs (2 errors)"),
                "Message should contain problem count and error count");

        assertTrue(message.contains("[com.example:project1:1.0]"), "Message should contain project1 identifier");

      queueForThread.offer(new Event(event, subscribers));

      if (!dispatching.get()) {
        dispatching.set(true);
        try {
          Event nextEvent;
          while ((nextEvent = queueForThread.poll()) != null) {
            while (nextEvent.subscribers.hasNext()) {
              nextEvent.subscribers.next().dispatchEvent(nextEvent.event);
            }
          }
        } finally {

                final long atime = src.lastAccess();
                int i = 0;
                long off = 0L;
                while (true) {
                    final int read = fis.read(b[i]);
                    synchronized (w) {
                        w.checkException();
                        while (!w.isReady()) {
                            try {
                                w.wait();

        for (AnnotationExpr child : node.getAnnotations()) {
            if (child instanceof SingleMemberAnnotationExpr && child.getNameAsString().endsWith("ReplacedBy")) {
                currentElement.setReplacement(((SingleMemberAnnotationExpr) child).getMemberValue().asLiteralStringValueExpr().getValue());
            }
            currentElement.addAnnotationTypeName(child.getNameAsString());
        }
    }

        if (executed) {
          return;
        }
        executed = true;
        list = runnables;
        runnables = null; // allow GC to free listeners even if this stays around for a while.
      }
      while (list != null) {
        executeListener(list.runnable, list.executor);
        list = list.next;
      }
    }

    private static void executeListener(Runnable runnable, Executor executor) {

                        b = b * 10 + c - '0';
                    }
                    ip = (ip << 8) + b;
                }
                while (i < data.length && Character.isWhitespace(data[i])) {
                    i++;
                }
                j = i;
                while (j < data.length && !Character.isWhitespace(data[j])) {
                    j++;
                }