}

    /**
     * Encodes a small integer (1 byte) in NDR format.
     *
     * @param s the small integer value to encode
     */
    public void enc_ndr_small(final int s) {
        this.buf[this.index] = (byte) (s & 0xFF);
        advance(1);
    }

    /**
     * Decodes a small integer (1 byte) from NDR format.
     *
     * @return the decoded small integer value
     */

    Table<String, Integer, Character> table1 = HashBasedTable.create(100, 20);
    table1.put("foo", 1, 'a');
    assertEquals((Character) 'a', table1.get("foo", 1));

    Table<String, Integer, Character> table2 = HashBasedTable.create(100, 0);
    table2.put("foo", 1, 'a');
    assertEquals((Character) 'a', table2.get("foo", 1));

    Table<String, Integer, Character> table3 = HashBasedTable.create(0, 20);

        return this;
    }

    public void setSortOrder_Equal(Integer sortOrder) {
        setSortOrder_Term(sortOrder, null);
    }

    public void setSortOrder_Equal(Integer sortOrder, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setSortOrder_Term(sortOrder, opLambda);
    }

    public void setSortOrder_Term(Integer sortOrder) {
        setSortOrder_Term(sortOrder, null);
    }

        return this;
    }

    public void setErrorCount_Equal(Integer errorCount) {
        setErrorCount_Term(errorCount, null);
    }

    public void setErrorCount_Equal(Integer errorCount, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setErrorCount_Term(errorCount, opLambda);
    }

    public void setErrorCount_Term(Integer errorCount) {
        setErrorCount_Term(errorCount, null);
    }

    create().putAll(new HashMap<String, Integer>());
  }

  public void testKeySet() {
    Map<String, Integer> map = create();
    Set<String> keySet = map.keySet();
    assertTrue(keySet instanceof SynchronizedSet);
    assertThat(((SynchronizedSet<?>) keySet).mutex).isSameInstanceAs(mutex);
  }

  public void testValues() {
    Map<String, Integer> map = create();

        long result = (long) a + (long) b;
        if (result > Integer.MAX_VALUE || result < Integer.MIN_VALUE) {
            failedValidations.incrementAndGet();
            integerOverflowsPrevented.incrementAndGet();
            log.warn("Integer overflow in addition: {} + {} = {}", a, b, result);
            throw new SmbException("Integer overflow detected");
        }
        return (int) result;
    }

            false, "Integer", 0, 0, null, null, false, null, null, null, null, null, false);
    protected final ColumnInfo _columnTimeToLive = cci("timeToLive", "timeToLive", null, null, Integer.class, "timeToLive", null, false,
            false, false, "Integer", 0, 0, null, null, false, null, null, null, null, null, false);

  @Param({"3", "30", "300"})
  int size;

  @Param MultisetSupplier implSupplier;

  private Multiset<Integer> multiset;
  private ImmutableList<Integer> keys;
  private ExecutorService threadPool;

  @BeforeExperiment
  void setUp() throws Exception {
    multiset = implSupplier.get();
    ImmutableList.Builder<Integer> builder = ImmutableList.builder();
    for (int i = 0; i < size; i++) {
      builder.add(i);
    }

  /** Proxy to throw a {@link RuntimeException} out of the {@link #get()} method. */
  public static class BadFuture extends SimpleForwardingListenableFuture<Integer> {
    protected BadFuture(ListenableFuture<Integer> delegate) {
      super(delegate);
    }

    @Override
    public Integer get() {
      throw new BadFutureRuntimeException();
    }
  }

  /** Proxy to throw a {@link RuntimeException} out of the {@link #get()} method. */
  public static class BadFuture extends SimpleForwardingListenableFuture<Integer> {
    protected BadFuture(ListenableFuture<Integer> delegate) {
      super(delegate);
    }

    @Override
    public Integer get() {
      throw new BadFutureRuntimeException();
    }
  }