MojoExecutionScope scope = new MojoExecutionScope();
        scope.enter();

        final AtomicInteger beforeExecution = new AtomicInteger();
        final AtomicInteger afterExecutionSuccess = new AtomicInteger();
        final AtomicInteger afterExecutionFailure = new AtomicInteger();
        final WeakMojoExecutionListener instance = new WeakMojoExecutionListener() {
            @Override

    void testThreadSafety() throws InterruptedException {
        SimpleCircuitBreaker breaker = new SimpleCircuitBreaker("concurrent", 5, 3, 100);
        AtomicInteger successCount = new AtomicInteger(0);
        AtomicInteger failureCount = new AtomicInteger(0);

        // Create multiple threads
        Thread[] threads = new Thread[10];
        for (int i = 0; i < threads.length; i++) {
            final int index = i;

import java.util.concurrent.ThreadFactory;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * Simple {@link ThreadFactory} implementation that ensures the corresponding threads have a meaningful name.
 */
public class BuildThreadFactory implements ThreadFactory {
    private final AtomicInteger id = new AtomicInteger();

    private static final String PREFIX = "BuilderThread";

    @Override

        HALF_OPEN
    }

    private final String name;
    private final AtomicReference<State> state = new AtomicReference<>(State.CLOSED);
    private final AtomicInteger failureCount = new AtomicInteger(0);
    private final AtomicInteger successCount = new AtomicInteger(0);
    private final AtomicLong lastFailureTime = new AtomicLong(0);
    private final AtomicLong lastStateChangeTime = new AtomicLong(System.currentTimeMillis());

    /** Local endpoint address */
    protected final InetSocketAddress localAddress;
    /** Available send credits for flow control */
    protected final AtomicInteger sendCredits;
    /** Available receive credits for flow control */
    protected final AtomicInteger receiveCredits;
    /** Queue of pending RDMA work requests */
    protected final BlockingQueue<RdmaWorkRequest> pendingRequests;

    // Connection state

        final int numThreads = 10;
        final ExecutorService executor = Executors.newFixedThreadPool(numThreads);
        final CountDownLatch latch = new CountDownLatch(numThreads);
        final AtomicInteger callbackCount = new AtomicInteger(0);

        // Add listeners concurrently from multiple threads
        for (int i = 0; i < numThreads; i++) {
            executor.submit(() -> {
                try {

    while (true) {
      AtomicInteger existingCounter = safeGet(countMap, element);
      if (existingCounter == null) {
        existingCounter = countMap.putIfAbsent(element, new AtomicInteger(occurrences));
        if (existingCounter == null) {
          return 0;
        }
        // existingCounter != null: fall through to operate against the existing AtomicInteger
      }

      while (true) {

   */
  public void testAdd_withFailures() {
    AtomicInteger existing = new AtomicInteger(12);
    AtomicInteger existingZero = new AtomicInteger(0);

    // initial map.get()
    when(backingMap.get(KEY)).thenReturn(null);
    // since get returned null, try a putIfAbsent; that fails due to a simulated race
    when(backingMap.putIfAbsent(eq(KEY), isA(AtomicInteger.class))).thenReturn(existingZero);

    // Verify that all of the runnables execute in a reasonable amount of time.
    assertTrue(countDownLatch.await(1L, SECONDS));
  }

  public void testExecute_idempotent() {
    AtomicInteger runCalled = new AtomicInteger();
    list.add(
        new Runnable() {
          @Override
          public void run() {
            runCalled.getAndIncrement();
          }
        },
        directExecutor());

    private final Class<T> interfaceType;
    private final Method method;
    private final @Nullable Object[] passedArgs;
    private final @Nullable Object returnValue;
    private final AtomicInteger called = new AtomicInteger();

    InteractionTester(Class<T> interfaceType, Method method) {
      this.interfaceType = interfaceType;
      this.method = method;
      this.passedArgs = getParameterValues(method);