}
        } catch (Exception e) {
            log.error("Failed to perform emergency file handle cleanup", e);
        }
    }

    /**
     * @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));

                scrollId = response.getScrollId();
            }
        } finally {
            SuggestUtil.deleteScrollContext(client, scrollId);
        }
    }

    /**
     * Gets the total hit count from a scroll search.
     *
     * @param client The OpenSearch client
     * @param settings The suggest settings containing timeout configurations
     * @param index The index name to search

  static final byte UNSET = 0;

  /** Number of bits used to store the numbers of hash table bits (max 30). */
  private static final int HASH_TABLE_BITS_MAX_BITS = 5;

  /** Use high bits of metadata for modification count. */
  static final int MODIFICATION_COUNT_INCREMENT = 1 << HASH_TABLE_BITS_MAX_BITS;

  /** Bitmask that selects the low bits of metadata to get hashTableBits. */

            // Verify correctness
            assertTrue(result.success(), "Result should be successful");
            assertEquals(largePomSet.size(), result.processedCount(), "Should have correct processed count");
        }
    }

    Node<K, V> head;
    Node<K, V> tail;
    int count;

    KeyList(Node<K, V> firstNode) {
      this.head = firstNode;
      this.tail = firstNode;
      firstNode.previousSibling = null;
      firstNode.nextSibling = null;
      this.count = 1;
    }
  }

  private transient @Nullable Node<K, V> head; // the head for all keys

        }
        if (done) {
          break;
        }
      }
    }
  }

  /**
   * Multiple threads using same array of counters successfully update a number of times equal to
   * total count
   */
  public void testCountingInMultipleThreads() throws InterruptedException {
    AtomicDoubleArray aa = new AtomicDoubleArray(SIZE);
    for (int i = 0; i < SIZE; i++) {
      aa.set(i, (double) COUNTDOWN);

        verify(tree, times(1)).release();
    }

    @Test
    @DisplayName("release() decrements usage; closes only when count reaches zero")
    void release_decrementsAndClosesOnZero() throws CIFSException {
        when(cfg.isTraceResourceUsage()).thenReturn(false);
        stubValidTree(8L, true, true);

        FileEntry fe3 = mock(FileEntry.class);
        lenient().when(fe3.getName()).thenReturn("file3");
        when(fe3.getFileIndex()).thenReturn(3);

        // Track query count to handle multiple queries properly
        final int[] queryCount = { 0 };

        // Mock send(create) to wire a query response with fe1, fe2
        doAnswer(inv -> {
            Object arg = inv.getArgument(0);

                    .get());
            options.addOption(Option.builder(THREADS)
                    .longOpt("threads")
                    .hasArg()
                    .desc("Thread count, for instance 4 (int) or 2C/2.5C (int/float) where C is core multiplied")
                    .get());
            options.addOption(Option.builder(BUILDER)
                    .longOpt("builder")
                    .hasArg()

        CacheBuilder.newBuilder()
            .concurrencyLevel(1)
            .removalListener(listener)
            .build(computingFunction);

    // seed the map, so its segment's count > 0
    cache.getUnchecked("a");
    shouldWait.set(true);

    CountDownLatch computationStarted = new CountDownLatch(1);
    CountDownLatch computationComplete = new CountDownLatch(1);
    new Thread(