return new DiscoveryNode(
            "",
            nodeId,
            new TransportAddress(TransportAddress.META_ADDRESS, portGenerator.incrementAndGet()),
            attributes,
            Sets.newHashSet(DiscoveryNodeRole.MASTER_ROLE, DiscoveryNodeRole.DATA_ROLE),
            Version.CURRENT
        );
    }

                    long delta = random.nextInt(deltaRange);
                    int behavior = random.nextInt(10);
                    switch (behavior) {
                      case 0:
                        map.incrementAndGet(key);
                        threadSum++;
                        break;
                      case 1:
                        map.decrementAndGet(key);
                        threadSum--;

        return (double) hits / total;
    }
    
    public void recordCacheHit() { cacheHits.incrementAndGet(); }
    public void recordCacheMiss() { cacheMisses.incrementAndGet(); }
    public void recordInvalidation() { cacheInvalidations.incrementAndGet(); }
    public void recordChangeNotification() { changeNotifications.incrementAndGet(); }
}

    private volatile @Nullable RemovalNotification<K, V> lastNotification;

    @Override
    public void onRemoval(RemovalNotification<K, V> notification) {
      count.incrementAndGet();
      lastNotification = notification;
    }

    public int getCount() {
      return count.get();
    }

    public K getLastEvictedKey() {
      return lastNotification.getKey();
    }

            .build(
                new CacheLoader<Integer, Integer>() {
                  @Override
                  public Integer load(Integer from) {
                    return (int) misses.incrementAndGet();
                  }
                });

    // To start, fill up the cache.
    // Each miss both increments the counter and causes the map to grow by one,

                    long delta = random.nextInt(deltaRange);
                    int behavior = random.nextInt(10);
                    switch (behavior) {
                      case 0:
                        map.incrementAndGet(key);
                        threadSum++;
                        break;
                      case 1:
                        map.decrementAndGet(key);
                        threadSum--;

        final AtomicInteger count = new AtomicInteger(0);
        coordinatorHelper.addEventHandler("config_updated", event -> count.incrementAndGet());
        coordinatorHelper.addEventHandler("config_updated", event -> count.incrementAndGet());

        final EventInfo event = new EventInfo();
        event.name = "config_updated";
        coordinatorHelper.dispatchEvent(event);

                        if (result == null || !result.equals((threadId * 1000 + i) * 2)) {
                            errors.incrementAndGet();
                        }
                    }
                } catch (final Exception e) {
                    errors.incrementAndGet();
                }
            }));
        }

        startLatch.countDown();
        for (final Future<?> future : futures) {

              numSuccessfulSetCalls.incrementAndGet();
            }
            awaitUnchecked(barrier);
            return null;
          }
        };
    Callable<@Nullable Void> cancelRunnable =
        () -> {
          if (currentFuture.get().cancel(true)) {
            numSuccessfulSetCalls.incrementAndGet();
          }
          awaitUnchecked(barrier);

            final long counter = this.nonceCounter.incrementAndGet();
            final ByteBuffer buffer = ByteBuffer.wrap(nonce, 12, 4);
            buffer.order(java.nio.ByteOrder.LITTLE_ENDIAN);
            buffer.putInt((int) counter);
        } else {
            // SMB 3.0/3.0.2 CCM: Counter-based approach as per SMB3 specification
            final long counter = this.nonceCounter.incrementAndGet();