// ReadMultipleResp contains a single response from a ReadMultipleReq.
type ReadMultipleResp struct {
	Bucket  string    `msg:"bk"`           // Bucket as given by request.
	Prefix  string    `msg:"pr,omitempty"` // Prefix as given by request.
	File    string    `msg:"fl"`           // File name as given in request.
	Exists  bool      `msg:"ex"`           // Returns whether the file existed on disk.

    /**
     * Test the constructor of MsrpcDfsRootEnum.
     * Verifies that the object is initialized with the correct default values.
     */
    @Test
    void testConstructor() {
        // Given
        String serverName = "test-server";

        // When
        MsrpcDfsRootEnum dfsRootEnum = new MsrpcDfsRootEnum(serverName);

        // Then

			if err != nil {
				// Error conditions should be checked above.
				panic(err)
			}
			enc = e
		})
		return enc
	}
	return
}

// EncodeData encodes the given data and returns the erasure-coded data.
// It returns an error if the erasure coding failed.
func (e *Erasure) EncodeData(ctx context.Context, data []byte) ([][]byte, error) {
	if len(data) == 0 {

     * @return whether the server supports DFS
     */
    boolean isDFSSupported();

    /**
     * Sets up the given request with negotiated parameters.
     *
     * @param request the request to configure
     */
    void setupRequest(CommonServerMessageBlock request);

    /**
     * Sets up the given response with negotiated parameters.
     *
     * @param resp the response to configure
     */

        if (inLen < 100 || inLen == IN_SIZE) {
            throw new IOException("Error reading jcifs/smb1/util/mime.map resource");
        }
        is.close();
    }

    /**
     * Returns the MIME type for the given file extension.
     * If no mapping is found, returns "application/octet-stream" as the default.
     *
     * @param extension the file extension to look up (without the dot)

   * ordering.
   *
   * @throws NullPointerException if any element is null
   */
  public static <E extends Comparable<? super E>> ImmutableSortedMultiset<E> of(
      E e1, E e2, E e3, E e4) {
    return copyOf(Ordering.natural(), Arrays.asList(e1, e2, e3, e4));
  }

  /**
   * Returns an immutable sorted multiset containing the given elements sorted by their natural

 * @author Kurt Alfred Kluever
 * @since 11.0
 */
@GwtCompatible
public final class Queues {
  private Queues() {}

  // ArrayBlockingQueue

  /**
   * Creates an empty {@code ArrayBlockingQueue} with the given (fixed) capacity and nonfair access
   * policy.
   */
  @J2ktIncompatible
  @GwtIncompatible // ArrayBlockingQueue
  public static <E> ArrayBlockingQueue<E> newArrayBlockingQueue(int capacity) {

    /**
     * Returns a freshly created entry, typed at the {@code E} type, for the given {@code segment}.
     */
    E newEntry(S segment, K key, int hash, @Nullable E next);

    /**
     * Returns a freshly created entry, typed at the {@code E} type, for the given {@code segment},
     * that is a copy of the given {@code entry}.
     */
    E copy(S segment, E entry, @Nullable E newNext);

    /**

  /**
   * Returns statistics over a dataset containing the given values.
   *
   * @param values a series of values
   */
  public static Stats of(double... values) {
    StatsAccumulator accumulator = new StatsAccumulator();
    accumulator.addAll(values);
    return accumulator.snapshot();
  }

  /**
   * Returns statistics over a dataset containing the given values.
   *
   * @param values a series of values

   * Callable}.
   *
   * @param callable the callable task
   * @since 10.0
   */
  public static <V extends @Nullable Object> ListenableFutureTask<V> create(Callable<V> callable) {
    return new ListenableFutureTask<>(callable);
  }

  /**
   * Creates a {@code ListenableFutureTask} that will upon running, execute the given {@code