TreeMultimap<String, Integer> multimap = createPopulate();
    SortedMap<String, Collection<Integer>> asMap = multimap.asMap();
    assertEquals(Ordering.natural(), asMap.comparator());
    assertEquals("foo", asMap.firstKey());
    assertEquals("tree", asMap.lastKey());
    Set<Integer> fooValues = ImmutableSet.of(1, 3, 7);
    Set<Integer> googleValues = ImmutableSet.of(2, 6);

    ImmutableMultimap.Builder<String, Integer> builder = new Builder<>();
    StringHolder holder = new StringHolder();
    holder.string = "one";
    Entry<String, Integer> entry =
        new AbstractMapEntry<String, Integer>() {
          @Override
          public String getKey() {
            return holder.string;
          }

          @Override
          public Integer getValue() {
            return 1;

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

    /** The interval time between crawl requests in milliseconds (required, 0 to 2147483647). */
    @Required
    @Min(value = 0)
    @Max(value = 2147483647)
    @ValidateTypeFailure
    public Integer intervalTime;

    /** The boost value for search ranking (required). */
    @Required

        serverData.sflags2 = Integer.MAX_VALUE;
        serverData.smaxMpxCount = Integer.MAX_VALUE;
        serverData.maxBufferSize = Integer.MAX_VALUE;
        serverData.sessKey = Integer.MAX_VALUE;
        serverData.scapabilities = Integer.MAX_VALUE;

        assertEquals(Integer.MAX_VALUE, serverData.sflags2);
        assertEquals(Integer.MAX_VALUE, serverData.smaxMpxCount);

        @Override
        public BigInteger apply(Long n) {
          return BigInteger.valueOf(n);
        }
      };

  private static final Function<Integer, Integer> NEGATE_INT =
      new Function<Integer, Integer>() {
        @Override
        public Integer apply(Integer x) {
          return -x;
        }
      };

  private static final Function<Long, Long> NEGATE_LONG =
      new Function<Long, Long>() {

    }

    /**
     * Converts to {@link Integer}.
     *
     * @param o
     *            The object to convert
     * @param pattern
     *            The pattern string
     * @return The converted {@link Integer}
     */
    public static Integer toInteger(final Object o, final String pattern) {
        return switch (o) {
        case null -> null;
        case Integer i -> i;
        case Number n -> n.intValue();

            .createTestSuite());
    return suite;
  }

  private TreeBasedTable<String, Integer, Character> sortedTable;

  protected TreeBasedTable<String, Integer, Character> create(
      Comparator<? super String> rowComparator,
      Comparator<? super Integer> columnComparator,
      Object... data) {
    TreeBasedTable<String, Integer, Character> table =
        TreeBasedTable.create(rowComparator, columnComparator);

            false, false, "Long", 0, 0, null, null, false, null, null, null, null, null, false);
    protected final ColumnInfo _columnMaxSize = cci("maxSize", "maxSize", null, null, Integer.class, "maxSize", null, false, false, false,
            "Integer", 0, 0, null, null, false, null, null, null, null, null, false);

  }

  @Override
  protected Map<String, Collection<Integer>> makeEmptyMap() {
    return Multimaps.transformValues(
            ArrayListMultimap.<String, Integer>create(), Functions.<Integer>identity())
        .asMap();
  }

  @Override
  protected Map<String, Collection<Integer>> makePopulatedMap() {
    ListMultimap<String, Integer> delegate = ArrayListMultimap.create();
    populate(delegate);

        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);
    }