public static final Factory FACTORY = new Factory() {
    final AtomicLong nextCallId = new AtomicLong(1L);

    @Override public EventListener create(Call call) {
      long callId = nextCallId.getAndIncrement();
      System.out.printf("%04d %s%n", callId, call.request().url());
      return new PrintingEventListener(callId, System.nanoTime());
    }
  };

  final long callId;
  final long callStartNanos;

      for (int i = 0; i < passedArgs.length; i++) {
        assertEquals(
            "Parameter #" + i + " of " + method + " not forwarded", passedArgs[i], args[i]);
      }
      called.getAndIncrement();
      return returnValue;
    }

    void testInteraction(Function<? super T, ? extends T> wrapperFunction) {
      T proxy = Reflection.newProxy(interfaceType, this);

      if (handleSocketEffect(peek.onRequestStart, socket, stream)) {
        dispatchBookkeepingRequest(
          connectionIndex = connectionIndex,
          exchangeIndex = nextExchangeIndex.getAndIncrement(),
          socket = socket,
          requestLine = DEFAULT_REQUEST_LINE_HTTP_2,
        )
        return
      }

      val request = readRequest(stream)

      for (int i = 0; i < passedArgs.length; i++) {
        assertEquals(
            "Parameter #" + i + " of " + method + " not forwarded", passedArgs[i], args[i]);
      }
      called.getAndIncrement();
      return returnValue;
    }

    void testInteraction(Function<? super T, ? extends T> wrapperFunction) {
      T proxy = Reflection.newProxy(interfaceType, this);

        if (nameFormat != null) {
          // requireNonNull is safe because we create `count` if (and only if) we have a nameFormat.
          thread.setName(format(nameFormat, requireNonNull(count).getAndIncrement()));
        }
        if (daemon != null) {
          thread.setDaemon(daemon);
        }
        if (priority != null) {
          thread.setPriority(priority);
        }

      Future<?> possiblyIgnoredError =
          executorService.submit(
              new Runnable() {
                @Override
                public void run() {
                  integer.getAndIncrement();
                }
              });
    }
  }

  @AfterExperiment
  void tearDown() throws Exception {
    executorService.shutdown();
  }

                            + " synchronizing on supplier"));
                break;
              }
              Thread.yield();
            }
            count.getAndIncrement();
            return Boolean.TRUE;
          }
        };

    Supplier<Boolean> memoizedSupplier = memoizer.apply(supplier);

    for (int i = 0; i < numThreads; i++) {
      threads[i] =

                            + " synchronizing on supplier"));
                break;
              }
              Thread.yield();
            }
            count.getAndIncrement();
            return Boolean.TRUE;
          }
        };

    Supplier<Boolean> memoizedSupplier = memoizer.apply(supplier);

    for (int i = 0; i < numThreads; i++) {
      threads[i] =

    return accumulateAndGet(key, delta, Long::sum);
  }

  /**
   * Increments by one the value currently associated with {@code key}, and returns the old value.
   */
  @CanIgnoreReturnValue
  public long getAndIncrement(K key) {
    return getAndAdd(key, 1);
  }

  /**
   * Decrements by one the value currently associated with {@code key}, and returns the old value.
   */
  @CanIgnoreReturnValue

      object : EventListener() {
        override fun connectStart(
          call: Call,
          inetSocketAddress: InetSocketAddress,
          proxy: Proxy,
        ) {
          connectCount.getAndIncrement()
        }
      }
    client =
      client
        .newBuilder()
        .eventListenerFactory(clientTestRule.wrap(listener))
        .build()