}

        @ParameterizedTest
        @MethodSource("flagsProvider")
        void verifiesCreateDisposition(int flags, int expected) {
            SmbComNTCreateAndX req = createRequest(flags, 0);
            // Use reflection to read the private field createDisposition
            int actual = (int) getPrivateField(req, "createDisposition");
            assertEquals(expected, actual, "createDisposition should match");
        }

  }

  @Benchmark
  void concurrentHashMap(int rep) {
    for (int i = 0; i < rep; i++) {
      map.get(TEST_KEY);
    }
  }

  @Benchmark
  void cacheBuilder_stats(int rep) {
    for (int i = 0; i < rep; i++) {
      cache.getIfPresent(TEST_KEY);
    }
  }

  @Benchmark
  void cacheBuilder(int rep) {
    for (int i = 0; i < rep; i++) {
      cacheNoStats.getIfPresent(TEST_KEY);
    }

    @Param(value = { "10000000" })
    int entries;

    private StreamInput streamInput;

    @Setup
    public void initResults() throws IOException {
        final BytesStreamOutput tmp = new BytesStreamOutput();
        for (int i = 0; i < entries / 2; i++) {
            tmp.writeVInt(i);
        }
        for (int i = 0; i < entries / 2; i++) {
            tmp.writeVInt(Integer.MAX_VALUE - i);

   */
  @CanIgnoreReturnValue
  @Override
  public int drainTo(Collection<? super E> c, int maxElements) {
    checkNotNull(c);
    checkArgument(c != this);
    if (maxElements <= 0) return 0;
    E[] items = this.items;
    Monitor monitor = this.monitor;
    monitor.enter();
    try {
      int i = takeIndex;
      int n = 0;
      int max = (maxElements < count) ? maxElements : count;
      while (n < max) {

    private int flags;
    private String newNodeAddress;

    // Notification flags
    /** Resource state is unknown */
    public static final int WITNESS_RESOURCE_STATE_UNKNOWN = 0x00000000;
    /** Resource is available for use */
    public static final int WITNESS_RESOURCE_STATE_AVAILABLE = 0x00000001;
    /** Resource is unavailable */
    public static final int WITNESS_RESOURCE_STATE_UNAVAILABLE = 0x000000FF;

        long overallStart = System.nanoTime();

        for (int t = 0; t < threadCount; t++) {
            final int threadId = t;
            executor.submit(() -> {
                try {
                    startLatch.await();

                    long threadStart = System.nanoTime();
                    for (int i = 0; i < operationsPerThread; i++) {
                        try {

 *     inserting the element at `insertionPoint` will retain sorted order.
 */
inline fun binarySearch(
  position: Int,
  limit: Int,
  compare: (Int) -> Int,
): Int {
  // Do the binary searching bit.
  var low = position
  var high = limit - 1
  while (low <= high) {
    val mid = (low + high) / 2
    val compareResult = compare(mid)

     * result[2] = "root5"
     * result[3] = "link2\foo\bar.txt"
     */
    private static int dfsPathSplit(final String path, final String[] result) {
        int ri = 0;
        final int rlast = result.length - 1;
        int i = 0, b = 0;
        final int len = path.length();
        int strip = 0;

        do {
            if (ri == rlast) {
                result[rlast] = path.substring(b);

 * DNS resolvable hosts.
 */

public class UniAddress {

    private static final int RESOLVER_WINS = 0;
    private static final int RESOLVER_BCAST = 1;
    private static final int RESOLVER_DNS = 2;
    private static final int RESOLVER_LMHOSTS = 3;

    private static int[] resolveOrder;
    private static InetAddress baddr;

    private static LogStream log = LogStream.getInstance();

  }

  enum TargetSupplier {
    STRING_WRITER {
      @Override
      Appendable get(int sz) {
        return new StringWriter(sz);
      }
    },
    STRING_BUILDER {
      @Override
      Appendable get(int sz) {
        return new StringBuilder(sz);
      }
    };

    abstract Appendable get(int sz);
  }

  @Param CopyStrategy strategy;
  @Param TargetSupplier target;