@ValidateTypeFailure
    public Integer depth;

    @Min(value = 0)
    @Max(value = 9223372036854775807L)
    @ValidateTypeFailure
    public Long maxAccessCount;

    @Required
    @Size(max = 200)
    public String userAgent;

    @Required
    @Min(value = 1)
    @Max(value = 2147483647)
    @ValidateTypeFailure
    public Integer numOfThread;

    @Required
    @Min(value = 0)

    @Override
    public int add(E element, int occurrences) {
      checkArgument(occurrences >= 0);
      Integer frequency = backingMap.get(element);
      if (frequency == null) {
        frequency = 0;
      }
      if (occurrences == 0) {
        return frequency;
      }
      checkArgument(occurrences <= Integer.MAX_VALUE - frequency);
      backingMap.put(element, frequency + occurrences);
      return frequency;
    }

     *
     */
    @Test
    public void testIsAssignableFrom() {
        assertThat(ClassUtil.isAssignableFrom(Number.class, Integer.class), is(true));
        assertThat(ClassUtil.isAssignableFrom(Integer.class, Number.class), is(not(true)));
        assertThat(ClassUtil.isAssignableFrom(int.class, Integer.class), is(true));
    }

    /**
     *
     */
    @Test
    public void testGetPackageName() {

public class RegularImmutableMapWithUnhashableValuesMapInterfaceTest
    extends AbstractImmutableMapMapInterfaceTest<Integer, UnhashableObject> {
  @Override
  protected Map<Integer, UnhashableObject> makeEmptyMap() {
    return ImmutableMap.of();
  }

  @Override
  protected Map<Integer, UnhashableObject> makePopulatedMap() {
    Unhashables unhashables = new Unhashables();

@GwtCompatible
public class ImmutableMapWithBadHashesMapInterfaceTest
    extends AbstractImmutableMapMapInterfaceTest<Object, Integer> {
  @Override
  protected Map<Object, Integer> makeEmptyMap() {
    throw new UnsupportedOperationException();
  }

  @Override
  protected Map<Object, Integer> makePopulatedMap() {
    Colliders colliders = new Colliders();
    return ImmutableMap.of(
        colliders.e0(), 0,

    super(false, false, false);
  }

  @Override
  protected Map<String, Collection<Integer>> makeEmptyMap() {
    return ImmutableSetMultimap.<String, Integer>of().asMap();
  }

  @Override
  protected Map<String, Collection<Integer>> makePopulatedMap() {
    Multimap<String, Integer> delegate = HashMultimap.create();
    populate(delegate);
    return ImmutableSetMultimap.copyOf(delegate).asMap();
  }

    super(false, false, true, true, false);
  }

  @Override
  Table<String, Character, Integer> makeTable() {
    Table<String, Character, Integer> table = HashBasedTable.create();
    return transformValues(table, DIVIDE_BY_2);
  }

  @Override
  protected Map<String, Integer> makePopulatedMap() {
    Table<String, Character, Integer> table = HashBasedTable.create();
    table.put("one", 'a', 1);
    table.put("two", 'a', 2);

  }

  @Override
  RowSortedTable<String, Integer, Character> makeTable() {
    RowSortedTable<String, Integer, Character> original = TreeBasedTable.create();
    return unmodifiableRowSortedTable(original);
  }

  @Override
  protected SortedMap<String, Map<Integer, Character>> makePopulatedMap() {
    RowSortedTable<String, Integer, Character> table = TreeBasedTable.create();
    table.put("foo", 1, 'a');

    super(false, false, false, false, false);
  }

  @Override
  Table<Character, String, Integer> makeTable() {
    Table<Character, String, Integer> table = HashBasedTable.create();
    return unmodifiableTable(table);
  }

  @Override
  protected Map<String, Integer> makePopulatedMap() {
    Table<Character, String, Integer> table = HashBasedTable.create();
    table.put('a', "one", 1);
    table.put('a', "two", 2);

  int elements;

  Set<Set<Integer>> powerSet;

  @BeforeExperiment
  void setUp() {
    Set<Integer> set = ContiguousSet.create(Range.closed(1, elements), integers());
    powerSet = Sets.powerSet(set);
  }

  @Benchmark
  int iteration(int reps) {
    int sum = 0;
    for (int i = 0; i < reps; i++) {
      for (Set<Integer> subset : powerSet) {
        for (Integer value : subset) {
          sum += value;