*/
public interface BuildEventListener {

    void sessionStarted(ExecutionEvent event);

    void projectStarted(String projectId);

    void projectLogMessage(String projectId, String event);

    void projectFinished(String projectId);

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

    void mojoStarted(ExecutionEvent event);

    void finish(int exitCode) throws Exception;

        this.repositoryIds = new HashSet<>(original.repositoryIds);
    }

    @Override
    public void addRepository(org.apache.maven.model.Repository repository) throws InvalidRepositoryException {
        addRepository(repository, false);
    }

    @Override
    public void addRepository(final Repository repository, boolean replace) throws InvalidRepositoryException {

 */
@Deprecated(since = "4.0.0")
class FileToRawModelMerger extends MavenMerger {

    @Override
    protected void mergeBuild_Extensions(
            Build.Builder builder, Build target, Build source, boolean sourceDominant, Map<Object, Object> context) {
        // don't merge
    }

    @Override
    protected void mergeBuildBase_Resources(
            BuildBase.Builder builder,
            BuildBase target,

      }
    }
  }

  public void testDrainOverflow() throws InterruptedException {
    Queues.drain(new SynchronousQueue<>(), new ArrayList<>(), /* numElements= */ 0, MAX_DURATION);
  }

  public void testDrainUninterruptiblyOverflow() {
    Queues.drainUninterruptibly(
        new SynchronousQueue<>(), new ArrayList<>(), /* numElements= */ 0, MAX_DURATION);
  }

  public void testZeroElements() throws Exception {

public class ExecutionListBenchmark {
  private static final int NUM_THREADS = 10; // make a param?

  // simple interface to wrap our two implementations.
  interface ExecutionListWrapper {
    void add(Runnable runnable, Executor executor);

    void execute();

    /** Returns the underlying implementation, useful for the Footprint benchmark. */
    Object getImpl();
  }

  enum Impl {
    NEW {
      @Override

@GwtCompatible
@NullUnmarked
public class VerifyTest extends TestCase {
  public void testVerify_simple_success() {
    verify(true);
  }

  public void testVerify_simple_failure() {
    assertThrows(VerifyException.class, () -> verify(false));
  }

  public void testVerify_simpleMessage_success() {
    verify(true, "message");
  }

  public void testVerify_simpleMessage_failure() {

@GwtCompatible
@NullMarked
public class TablesTest extends TestCase {

  @GwtIncompatible // SerializableTester
  public void testImmutableEntrySerialization() {
    Cell<String, Integer, Character> entry = immutableCell("foo", 1, 'a');
    SerializableTester.reserializeAndAssert(entry);
  }

  public void testImmutableEntryToString() {
    Cell<String, Integer, Character> entry = immutableCell("foo", 1, 'a');

    }

    @Override
    public void write(int b) throws IOException {
        super.write(b);
        if (buf.isEol()) {
            String line = new String(buf.toByteArray(), 0, buf.size() - LINE_SEP.length);
            ProjectBuildLogAppender.updateMdc();
            consumer.accept(line);
            buf.reset();
        }
    }

    public void forceFlush() {
        if (buf.size() > 0) {

@GwtCompatible
final class TestPlatform {
  static void verifyGetOnPendingFuture(Future<?> future) {
    checkNotNull(future);
    try {
      pseudoTimedGetUninterruptibly(future, 10, MILLISECONDS);
      fail();
    } catch (TimeoutException expected) {
    } catch (ExecutionException e) {
      throw new AssertionError(e);
    }
  }

  static void verifyTimedGetOnPendingFuture(Future<?> future) {
    try {

  private static class TestListeningExecutorService extends AbstractListeningExecutorService {

    @Override
    public void execute(Runnable runnable) {
      assertThat(runnable).isInstanceOf(TrustedListenableFutureTask.class);
      runnable.run();
    }

    @Override
    public void shutdown() {}

    @Override
    public List<Runnable> shutdownNow() {
      return ImmutableList.of();
    }

    @Override