AtomicInteger hostnameCount = new AtomicInteger();
    AtomicInteger previous = hostnames.putIfAbsent(url.host(), hostnameCount);
    if (previous != null) hostnameCount = previous;
    if (hostnameCount.getAndIncrement() >= hostLimit) return;

    Request request = new Request.Builder()
        .url(url)
        .build();
    try (Response response = client.newCall(request).execute()) {

        final byte[] sk = this.signKey;
        if (sk == null) {
            throw new CIFSException("Signing is not initialized");
        }

        final int seqNum = this.signSequence.getAndIncrement();
        final byte[] seqBytes = new byte[4];
        SMBUtil.writeInt4(seqNum, seqBytes, 0);

        final MessageDigest mac = Crypto.getHMACT64(sk);
        mac.update(seqBytes); // sequence

        }
    }

    private ChannelInfo selectRoundRobin(Collection<ChannelInfo> channels) {
        List<ChannelInfo> list = new ArrayList<>(channels);
        int index = Math.abs(roundRobinCounter.getAndIncrement() % list.size());
        return list.get(index);
    }

    private ChannelInfo selectLeastLoaded(Collection<ChannelInfo> channels) {
        ChannelInfo leastLoadedChannel = null;

  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);

                indexingHelper.sendDocuments(searchEngineClient, docList);
            }
            executeTime += processingTime;
        }

        documentSize.getAndIncrement();

        if (logger.isDebugEnabled()) {
            logger.debug("Total documents added: {}", documentSize.get());
        }

    }

    /**

    }

    /**
     * Get and increment inconsistency count
     *
     * @return the current inconsistency count
     */
    public int getInconsistencyCount() {
        return inconsistencyCount.getAndIncrement();
    }

    /**
     * Reset inconsistency count
     */
    public void resetInconsistencyCount() {
        inconsistencyCount.set(0);
    }

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

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