}

  public void testOnlyOneOpen() throws Exception {
    ByteSource source = newByteSource(0, 50);
    int[] counter = new int[1];
    ByteSource checker =
        new ByteSource() {
          @Override
          public InputStream openStream() throws IOException {
            if (counter[0]++ != 0) {
              throw new IllegalStateException("More than one source open");
            }

		t.Helper()
		if err != nil {
			t.Fatal(err)
		}
	}

	// Add a version with tiered content, one with local content
	xl := xlMetaV2{}
	counter := 1
	report := func() {
		t.Helper()
		// t.Logf("versions (%d): len = %d", counter, len(xl.versions))
		counter++
	}
	fi := FileInfo{
		Volume:           "volume",
		Name:             "object-name",
		VersionID:        "00000000-0000-0000-0000-000000000001",

            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();
            final ByteBuffer buffer = ByteBuffer.wrap(nonce);
            buffer.order(java.nio.ByteOrder.LITTLE_ENDIAN);
            buffer.putLong(counter);
            // Remaining bytes (if any) stay zero-padded

	sync.RWMutex
}

// Inc increments the api stats counter.
func (stats *HTTPAPIStats) Inc(api string) {
	if stats == nil {
		return
	}
	stats.Lock()
	defer stats.Unlock()
	if stats.apiStats == nil {
		stats.apiStats = make(map[string]int)
	}
	stats.apiStats[api]++
}

// Dec increments the api stats counter.
func (stats *HTTPAPIStats) Dec(api string) {
	if stats == nil {

import org.bouncycastle.crypto.generators.KDFCounterBytesGenerator;
import org.bouncycastle.crypto.macs.HMac;
import org.bouncycastle.crypto.params.KDFCounterParameters;

/**
 * SMB3 SP800-108 Counter Mode Key Derivation
 *
 * @author mbechler
 *
 */
public final class Smb3KeyDerivation {

    private static final byte[] SIGNCONTEXT_300 = toCBytes("SmbSign");

    private void setupMockComponentsWithCounter(final AtomicInteger counter) {
        setupMockComponents();

        // Override thumbnail manager with counter
        ThumbnailManager mockThumbnailManager = new ThumbnailManager() {
            @Override
            public int generate(ExecutorService executorService, boolean cleanup) {
                counter.incrementAndGet();
                // Return 0 to exit the loop

    for (int i = 0; i < 1000; i++) {
      AtomicInteger counter = new AtomicInteger();
      TrustedListenableFutureTask<Integer> task =
          TrustedListenableFutureTask.create(
              new Callable<Integer>() {
                @Override
                public Integer call() {
                  return counter.incrementAndGet();
                }
              });

            // If we need more bytes, hash again with counter
            int counter = 1;
            while (derived.length > hash.length * counter) {
                md.update(input);
                md.update((byte) counter);
                hash = md.digest();
                int copyLen = Math.min(length - (hash.length * counter), hash.length);

    public void test_concurrent_stores() {
        // Test thread-safe implementation
        final AtomicLong counter = new AtomicLong(0);

        IndexUpdateCallback callback = new IndexUpdateCallback() {
            @Override
            public void store(DataStoreParams paramMap, Map<String, Object> dataMap) {
                counter.incrementAndGet();
            }

            @Override
            public long getDocumentSize() {

  private fun getTestCount(): Long {
    val latch = CountDownLatch(1)
    val countRef = AtomicLong()
    val failureRef = AtomicReference<Throwable>()

    newWebSocket(
      "/getCaseCount",
      object : WebSocketListener() {
        override fun onMessage(
          webSocket: WebSocket,
          text: String,
        ) {
          countRef.set(text.toLong())
        }

        override fun onClosing(