*/
        public int prefmaxlen;
        /**
         * DFS enumeration structure containing results
         */
        public DfsEnumStruct info;
        /**
         * Total number of entries available
         */
        public NdrLong totalentries;

        /**
         * Constructs a NetrDfsEnumEx request
         * @param dfs_name the DFS name to enumerate

        // Check that filename is written correctly (starting at offset 6)
        // The filename should be null-terminated Unicode string
        assertTrue(written > 6);

        // Verify the total bytes written is reasonable
        assertTrue(written > TEST_FILENAME.length());
    }

    @ParameterizedTest
    @CsvSource({ "4, 257", // FILE_BASIC_INFO -> 0x0101

        }

        Map<EventType, Long> stats = logger.getStatistics();
        assertEquals(Long.valueOf(threadCount * eventsPerThread), stats.get(EventType.AUTHENTICATION_SUCCESS),
                "Should have correct total number of events");
    }

   */
  public double expectedFpp() {
    return Math.pow((double) bits.bitCount() / bitSize(), numHashFunctions);
  }

  /**
   * Returns an estimate for the total number of distinct elements that have been added to this
   * Bloom filter. This approximation is reasonably accurate if it does not exceed the value of
   * {@code expectedInsertions} that was used when constructing the filter.

   *
   * @param arrays zero or more {@code char} arrays
   * @return a single array containing all the values from the source arrays, in order
   * @throws IllegalArgumentException if the total number of elements in {@code arrays} does not fit
   *     in an {@code int}
   */
  public static char[] concat(char[]... arrays) {
    long length = 0;
    for (char[] array : arrays) {

   * c}}.
   *
   * @param arrays zero or more {@code short} arrays
   * @return a single array containing all the values from the source arrays, in order
   * @throws IllegalArgumentException if the total number of elements in {@code arrays} does not fit
   *     in an {@code int}
   */
  public static short[] concat(short[]... arrays) {
    long length = 0;
    for (short[] array : arrays) {

        return asJson(new ApiConfigsResponse<EditBody>().settings(list.stream().map(this::createEditBody).collect(Collectors.toList()))
                .total(pager.getAllRecordCount())
                .status(Status.OK)
                .result());
    }

    /**
     * Retrieves a specific boost document rule setting by ID.
     *

        return asJson(
                new ApiResult.ApiConfigsResponse<EditBody>().settings(list.stream().map(this::createEditBody).collect(Collectors.toList()))
                        .total(pager.getAllRecordCount())
                        .status(ApiResult.Status.OK)
                        .result());
    }

    // GET /api/admin/group/setting/{id}
    /**
     * Returns specific group setting by ID.

 * (method {@link #add}) are contended across threads, the set of variables may grow dynamically to
 * reduce contention. Method {@link #sum} (or, equivalently, {@link #longValue}) returns the current
 * total combined across the variables maintaining the sum.
 *
 * <p>This class is usually preferable to {@link AtomicLong} when multiple threads update a common

        }
        return leastLoadedChannel != null ? leastLoadedChannel : channels.iterator().next();
    }

    private ChannelInfo selectWeightedRandom(Collection<ChannelInfo> channels) {
        // Calculate total weight
        int totalWeight = 0;
        for (ChannelInfo channel : channels) {
            totalWeight += channel.getScore();
        }

        if (totalWeight == 0) {