R result = (R) finalAccum;
        assertEquivalent(expectedResult, result);
      }
      assertEquivalent(expectedResult, collector.finisher().apply(finalAccum));
    }
  }

  private void assertEquivalent(R expected, R actual) {
    assertTrue(
        "Expected " + expected + " got " + actual + " modulo equivalence " + equivalence,

    // the run latch.
    exec.execute(task);
    runLatch.await();
    assertEquals(1, listenerLatch.getCount());
    assertFalse(task.isDone());
    assertFalse(task.isCancelled());

    // Finish the task by unblocking the task latch.  Then wait for the
    // listener to be called by blocking on the listener latch.
    taskLatch.countDown();
    assertEquals(25, task.get().intValue());

            propertiesBuilder.build(classDoc);
            methodsBuilder.build(classDoc);
            extensionsBuilder.build(classDoc);
            classDoc.mergeContent();
        } finally {
            listener.finish();
        }
    }

   * finite. Call either {@link LinearTransformationBuilder#and} or {@link
   * LinearTransformationBuilder#withSlope} on the returned object to finish building the instance.
   */
  public static LinearTransformationBuilder mapping(double x1, double y1) {
    checkArgument(isFinite(x1) && isFinite(y1));
    return new LinearTransformationBuilder(x1, y1);
  }

  /**

        R result = (R) finalAccum;
        assertEquivalent(expectedResult, result);
      }
      assertEquivalent(expectedResult, collector.finisher().apply(finalAccum));
    }
  }

  private void assertEquivalent(R expected, R actual) {
    assertTrue(
        "Expected " + expected + " got " + actual + " modulo equivalence " + equivalence,

            chapter.setAttribute("id", classDoc.getId());
            descriptionRenderer.renderTo(classDoc, chapter);
            merge(classDoc, chapter);
        } finally {
            listener.finish();
        }
    }

    void merge(ClassDoc classDoc, Element chapter) {
        for (ClassDocMemberRenderer memberRenderer : memberRenderers) {
            memberRenderer.renderSummaryTo(classDoc, chapter);
        }

    @Override
    public void executionFailure(String projectId, boolean halted, String exception) {}

    @Override
    public void mojoStarted(ExecutionEvent event) {}

    @Override
    public void finish(int exitCode) throws Exception {}

    @Override
    public void fail(Throwable t) throws Exception {}

    @Override
    public void log(String msg) {
        output.accept(msg);
    }

    @Override

    void projectFinished(String projectId);

    void executionFailure(String projectId, boolean halted, String exception);

    void mojoStarted(ExecutionEvent event);

    void finish(int exitCode) throws Exception;

    void fail(Throwable t) throws Exception;

    void log(String msg);

    void transfer(String projectId, TransferEvent e);

		writer.payloadBufferIndex = 0
	}
	return result
}

// Finish is the last call to the message writer - it sends any
// remaining record payload, then sends statistics and finally the end
// message.
func (writer *messageWriter) Finish(bytesScanned, bytesProcessed int64) error {
	select {
	case <-writer.doneCh:
		return fmt.Errorf("messageWriter is done")
	default:

    }

    @Override
    public void start(String context) {
        contextStack.addFirst(context);
    }

    @Override
    public void finish() {
        contextStack.removeFirst();
    }