*/
@GwtCompatible(emulated = true)
@Ignore // Affects only Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class SetHashCodeTester<E> extends AbstractSetTester<E> {
  public void testHashCode() {
    int expectedHashCode = 0;
    for (E element : getSampleElements()) {
      expectedHashCode += ((element == null) ? 0 : element.hashCode());
    }

import junit.framework.TestCase;

/**
 * Tests that the different algorithms benchmarked in {@link QuantilesBenchmark} are actually all
 * returning more-or-less the same answers.
 */
public class QuantilesAlgorithmTest extends TestCase {

  private static final Random RNG = new Random(82674067L);
  private static final int DATASET_SIZE = 1000;
  private static final double ALLOWED_ERROR = 1.0e-10;

 * @param <E> the type of elements held in this collection
 * @since 4.0
 */
@J2ktIncompatible
@GwtIncompatible
@ElementTypesAreNonnullByDefault
public abstract class ForwardingBlockingQueue<E> extends ForwardingQueue<E>
    implements BlockingQueue<E> {

  /** Constructor for use by subclasses. */
  protected ForwardingBlockingQueue() {}

  @Override
  protected abstract BlockingQueue<E> delegate();

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package jcifs.smb1.dcerpc;

import jcifs.smb1.dcerpc.ndr.*;

public class DcerpcBind extends DcerpcMessage {

    static final String[] result_message = {
        "0",
        "DCERPC_BIND_ERR_ABSTRACT_SYNTAX_NOT_SUPPORTED",
        "DCERPC_BIND_ERR_PROPOSED_TRANSFER_SYNTAXES_NOT_SUPPORTED",

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

package jcifs.smb1.netbios;

import java.io.InputStream;
import java.io.IOException;

class SocketInputStream extends InputStream {

    private static final int TMP_BUFFER_SIZE = 256;

    private InputStream in;
    private SessionServicePacket ssp;
    private int tot, bip, n;
    private byte[] header, tmp;

import jcifs.internal.fscc.FileInformation;
import jcifs.internal.smb1.trans.SmbComTransaction;
import jcifs.internal.util.SMBUtil;
import jcifs.util.Hexdump;


/**
 * 
 */
public class Trans2QueryPathInformation extends SmbComTransaction {

    private final int informationLevel;


    /**
     * 
     * @param config
     * @param filename
     * @param informationLevel
     */

import jcifs.Configuration;
import jcifs.internal.CommonServerMessageBlockRequest;
import jcifs.internal.util.SMBUtil;


/**
 * @author mbechler
 *
 */
public class Smb2CancelRequest extends ServerMessageBlock2 implements CommonServerMessageBlockRequest {

    /**
     * @param config
     * @param mid
     * @param asyncId
     */

import org.eclipse.aether.transfer.TransferResource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Slf4jMavenTransferListener
 */
public class Slf4jMavenTransferListener extends AbstractTransferListener {

    protected final Logger out;

    public Slf4jMavenTransferListener() {
        this.out = LoggerFactory.getLogger(Slf4jMavenTransferListener.class);
    }

 * The resolution will actually download the dependencies (or artifacts) that have been computed.
 *
 * @since 4.0.0
 */
@Experimental
@Immutable
public interface Dependency extends Artifact {
    /**
     * {@return the type of the dependency}
     * A dependency can be a <abbr>JAR</abbr> file,
     * a modular-<abbr>JAR</abbr> if it is intended to be placed on the module-path,

import org.apache.maven.api.annotations.Nonnull;

/**
 * Service used to create {@link Artifact} objects.
 *
 * @since 4.0.0
 */
@Experimental
public interface ArtifactFactory extends Service {

    /**
     * Creates an artifact.
     *
     * @param request the request holding artifact creation parameters
     * @return an {@code Artifact}, never {@code null}