import java.util.Set;
import javax.annotation.CheckForNull;

/**
 * An implementation of {@link NetworkConnections} for undirected networks with parallel edges.
 *
 * @author James Sexton
 * @param <N> Node parameter type
 * @param <E> Edge parameter type
 */
@ElementTypesAreNonnullByDefault
final class UndirectedMultiNetworkConnections<N, E>
    extends AbstractUndirectedNetworkConnections<N, E> {

    return new HashMultiset<>();
  }

  /**
   * Creates a new, empty {@code HashMultiset} with the specified expected number of distinct
   * elements.
   *
   * @param distinctElements the expected number of distinct elements
   * @throws IllegalArgumentException if {@code distinctElements} is negative
   */
  public static <E extends @Nullable Object> HashMultiset<E> create(int distinctElements) {

import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Tag
import org.junit.jupiter.api.Timeout
import org.junit.jupiter.api.extension.RegisterExtension
import org.junit.jupiter.params.ParameterizedTest
import org.junit.jupiter.params.provider.MethodSource

@Suppress("UsePropertyAccessSyntax")
@Timeout(6)
@Tag("slow")
class SocketChannelTest {
  @JvmField @RegisterExtension
  val platform = PlatformRule()

   * case of an error.
   *
   * @param event the callback to execute on {@link #dispatch}
   */
  public void enqueue(Event<L> event) {
    enqueueHelper(event, event);
  }

  /**
   * Enqueues an event to be run on currently known listeners, with a label.
   *
   * @param event the callback to execute on {@link #dispatch}
   * @param label a description of the event to use in the case of an error
   */

func ErrorRespToObjectError(err error, params ...string) error {
	if err == nil {
		return nil
	}

	bucket := ""
	object := ""
	versionID := ""
	if len(params) >= 1 {
		bucket = params[0]
	}
	if len(params) >= 2 {
		object = params[1]
	}
	if len(params) >= 3 {
		versionID = params[2]
	}

	if xnet.IsNetworkOrHostDown(err, false) {

 * the License.
 */

package com.google.common.collect;

import static java.util.Arrays.sort;

import com.google.caliper.BeforeExperiment;
import com.google.caliper.Benchmark;
import com.google.caliper.Param;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Random;

/**
 * A benchmark to determine the overhead of sorting with {@link Ordering#from(Comparator)}, or with

import static com.google.common.math.MathBenchmarking.randomPositiveDouble;

import com.google.caliper.BeforeExperiment;
import com.google.caliper.Benchmark;
import com.google.caliper.Param;
import java.math.RoundingMode;

/**
 * Benchmarks for the rounding methods of {@code DoubleMath}.
 *
 * @author Louis Wasserman
 */
public class DoubleMathRoundingBenchmark {

import javax.annotation.CheckForNull;

/**
 * An interface for representing and manipulating an origin node's adjacent nodes and incident edges
 * in a {@link Network}.
 *
 * @author James Sexton
 * @param <N> Node parameter type
 * @param <E> Edge parameter type
 */
@ElementTypesAreNonnullByDefault
interface NetworkConnections<N, E> {

  Set<N> adjacentNodes();

  Set<N> predecessors();

  Set<N> successors();

 *
 */
public class Smb2TreeConnectRequest extends ServerMessageBlock2Request<Smb2TreeConnectResponse> {

    private int treeFlags;
    private String path;


    /**
     * @param config
     * @param path
     */
    public Smb2TreeConnectRequest ( Configuration config, String path ) {
        super(config, SMB2_TREE_CONNECT);
        this.path = path;
    }


    @Override

     * to find the POM file, else if no locator is provided, a file named 'pom.xml' needs to be
     * used by the requested model source.
     *
     * @param locator locator used to locate the pom file
     * @param relPath path of the requested model source relative to this model source POM
     * @return related model source or <code>null</code> if no such model source
     */