assertThat(map.getInstance(int.class)).isNull();
    assertThat(map.getInstance(Integer.class)).isNull();

    assertThat(map.putInstance(int.class, 0)).isNull();
    assertThat(map.putInstance(Integer.class, 1)).isNull();
    assertEquals(2, map.size());

    assertEquals(0, (int) map.getInstance(int.class));
    assertEquals(1, (int) map.getInstance(Integer.class));

    reader.close();
  }

  @Override
  public int read() throws IOException {
    return (read(singleByte) == 1) ? toUnsignedInt(singleByte[0]) : -1;
  }

  // TODO(chrisn): Consider trying to encode/flush directly to the argument byte
  // buffer when possible.
  @Override
  public int read(byte[] b, int off, int len) throws IOException {
    // Obey InputStream contract.

     */
    @Override
    public CommonServerMessageBlockRequest createCancel() {
        return new SmbComNtCancel(getConfig(), (int) getMid());
    }

    @Override
    protected int writeParameterWordsWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;

        if (this.getCommand() != SMB_COM_NT_TRANSACT_SECONDARY) {
            dst[dstIndex++] = this.maxSetupCount;
        } else {

package lex

import (
	"text/scanner"

	"cmd/internal/src"
)

// A Slice reads from a slice of Tokens.
type Slice struct {
	tokens []Token
	base   *src.PosBase
	line   int
	pos    int
}

func NewSlice(base *src.PosBase, line int, tokens []Token) *Slice {
	return &Slice{
		tokens: tokens,
		base:   base,
		line:   line,
		pos:    -1, // Next will advance to zero.
	}
}

    }

    @Override
    public int getConnectTimeout() {
        return this.connection.getConnectTimeout();
    }

    @Override
    public void setConnectTimeout(final int timeout) {
        this.connection.setConnectTimeout(timeout);
    }

    @Override
    public int getReadTimeout() {
        return this.connection.getReadTimeout();
    }

  }

  private static final int DEFAULT_KEY_CAPACITY = 16;
  private static final int DEFAULT_VALUE_SET_CAPACITY = 2;
  @VisibleForTesting static final double VALUE_SET_LOAD_FACTOR = 1.0;

  @VisibleForTesting transient int valueSetCapacity;
  private transient MultimapIterationChain<K, V> multimapIterationChain =
      new MultimapIterationChain<>();

  private LinkedHashMultimap(int keyCapacity, int valueSetCapacity) {

        () -> Types.newParameterizedType(Map.class, String.class, Integer.class, Long.class));
  }

  public void testToString() {
    assertThat(Types.toString(int[].class)).isEqualTo(int[].class.getName());
    assertThat(Types.toString(int[][].class)).isEqualTo(int[][].class.getName());
    assertThat(Types.toString(String[].class)).isEqualTo(String[].class.getName());
    Type elementType = List.class.getTypeParameters()[0];

    // start substituting the arguments into the '%s' placeholders
    StringBuilder builder = new StringBuilder(template.length() + 16 * args.length);
    int templateStart = 0;
    int i = 0;
    while (i < args.length) {
      int placeholderStart = template.indexOf("%s", templateStart);
      if (placeholderStart == -1) {
        break;
      }

            }

            int bufferCount = pacStream.readInt();
            int version = pacStream.readInt();

            if (version != PacConstants.PAC_VERSION) {
                throw new PACDecodingException("Unrecognized PAC version " + version);
            }

            for (int bufferIndex = 0; bufferIndex < bufferCount; bufferIndex++) {
                int bufferType = pacStream.readInt();

    private final int constant;

    ConstantWeigher(int constant) {
      this.constant = constant;
    }

    @Override
    public int weigh(Object key, Object value) {
      return constant;
    }
  }

  static final class IntKeyWeigher implements Weigher<Integer, Object> {
    @Override
    public int weigh(Integer key, Object value) {
      return key;
    }
  }