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

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

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

            documentSize.getAndIncrement();
        }
    }

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

            if (channels.isEmpty()) {
                return null;
            }

            switch (strategy) {
            case ROUND_ROBIN:
                int index = roundRobinIndex.getAndIncrement() % channels.size();
                return channels.get(index);

            case LEAST_CONNECTIONS:
                return channels.stream()

        static final AtomicInteger THREAD_NUMBER = new AtomicInteger(1);

        @Override
        public Thread newThread(Runnable r) {
            Thread newThread = new Thread(GROUP, r, "resolver-" + THREAD_NUMBER.getAndIncrement());
            newThread.setDaemon(true);
            newThread.setContextClassLoader(null);
            return newThread;
        }
    }

    private class ResolveTask implements Runnable {

        AtomicInteger calls = new AtomicInteger();
        doAnswer(inv -> {
            int len = inv.getArgument(2);
            // First call returns len-1, second returns 1
            return calls.getAndIncrement() == 0 ? Math.max(1, len - 1) : 1;
        }).when(raf).read(any(byte[].class), anyInt(), anyInt());
        byte[] dst = new byte[4];
        assertDoesNotThrow(() -> raf.readFully(dst));

 *   static final AtomicLong seq = new AtomicLong();
 *
 *   final long seqNum;
 *   final E entry;
 *
 *   public FIFOEntry(E entry) {
 *     seqNum = seq.getAndIncrement();
 *     this.entry = entry;
 *   }
 *
 *   public E getEntry() {
 *     return entry;
 *   }
 *
 *   public int compareTo(FIFOEntry<E> other) {
 *     int res = entry.compareTo(other.entry);

            @Override
            public QueryLog read() {
                if (count.get() >= queryLogs.length) {
                    return null;
                }
                return new QueryLog(queryLogs[count.getAndIncrement()], null);
            }

            @Override
            public void close() {
                // ignore
            }
        };

        // One or more integer values could be skipped in the event of a race
        // to generate a UID for the same object from multiple threads, but
        // that shouldn't be a problem.
        uid = counter.getAndIncrement();
        Integer alreadySet = uids.putIfAbsent(obj, uid);
        if (alreadySet != null) {
          uid = alreadySet;
        }
      }
      return uid;
    }

    @Override

        // One or more integer values could be skipped in the event of a race
        // to generate a UID for the same object from multiple threads, but
        // that shouldn't be a problem.
        uid = counter.getAndIncrement();
        Integer alreadySet = uids.putIfAbsent(obj, uid);
        if (alreadySet != null) {
          uid = alreadySet;
        }
      }
      return uid;
    }

    @Override