AtomicInteger count = new AtomicInteger(0);
        queryFieldConfig.highlightedFields(stream -> {
            stream.forEach(field -> {
                count.incrementAndGet();
                assertTrue(field.equals("field1") || field.equals("field2") || field.equals("field3"));
            });
        });

        assertEquals(3, count.get());
    }

    @Test

                return true;
            }, source -> {
                exportDocument(source, exportPath, excludeFields, resolvedFormatter);
                final long currentCount = processedCount.incrementAndGet();
                if (logger.isDebugEnabled() && currentCount % scrollSize == 0) {
                    logger.debug("[EXPORT] Processing: count={}", currentCount);
                }
                return true;

            // but we can verify the method signature and basic functionality
            SearchEngineUtil.scroll("test_index", hit -> {
                callbackCount.incrementAndGet();
                return true; // Continue processing
            });
        } catch (Exception e) {
            // Expected in test environment without proper SearchEngineClient

        builder.build(
            new CacheLoader<String, Object>() {
              @Override
              public Object load(String key) throws InterruptedException {
                callCount.incrementAndGet();
                startSignal.await();
                return result;
              }
            });

    List<Object> resultArray = doConcurrentGet(cache, "bar", count, startSignal);

        }
    }

    /**
     * @return a file handle with increased usage count
     */
    public SmbFileHandleImpl acquire() {
        final long usage = this.usageCount.incrementAndGet();
        if (log.isTraceEnabled()) {
            log.trace(String.format("Acquire %s (%d)", this, usage));
        }
        return this;
    }

    /**
     *
     */

    AtomicInteger calls = new AtomicInteger();
    bus.register(
        new Callback<String>() {
          @Subscribe
          @Override
          public void call(String s) {
            calls.incrementAndGet();
          }
        });

    bus.post("hello");

    assertEquals(1, calls.get());
  }

  public void testPrimitiveSubscribeFails() {
    class SubscribesToPrimitive {

    AtomicInteger calls = new AtomicInteger();
    bus.register(
        new Callback<String>() {
          @Subscribe
          @Override
          public void call(String s) {
            calls.incrementAndGet();
          }
        });

    bus.post("hello");

    assertEquals(1, calls.get());
  }

  public void testPrimitiveSubscribeFails() {
    class SubscribesToPrimitive {

                    try {
                        Configuration result = mockSession.getConfig();
                        if (result == mockConfig) {
                            successCount.incrementAndGet();
                        }
                    } finally {
                        latch.countDown();
                    }
                }).start();
            }

            if (!filter.test(problem)) {
                // drop without counting towards preserved problems
                return false;
            }
            int currentCount = totalCount.incrementAndGet();
            getCounter(problem.getSeverity()).increment();
            if (currentCount <= maxCountLimit || dropProblemWithLowerSeverity(problem.getSeverity())) {

    if (generated != null) {
      freshness.incrementAndGet();
    }
    return generated;
  }

  final <T> @Nullable T generateFresh(Class<T> type) {
    return Primitives.wrap(type).cast(generateFresh(TypeToken.of(type)));
  }

  final <T> T newFreshProxy(Class<T> interfaceType) {
    T proxy = newProxy(interfaceType);
    freshness.incrementAndGet();
    return proxy;
  }

  /**