extends AbstractImmutableSortedMapMapInterfaceTest<String, Integer> {
  @Override
  protected SortedMap<String, Integer> makePopulatedMap() {
    return ImmutableSortedMap.of("a", 1, "b", 2, "c", 3, "d", 4, "e", 5).tailMap("b");
  }

  @Override
  protected String getKeyNotInPopulatedMap() {
    return "a";
  }

  @Override
  protected Integer getValueNotInPopulatedMap() {
    return 1;
  }

        new TypeResolver()
            .where(
                new TypeCapture<Map<Integer, T>>() {}.capture(),
                new TypeCapture<Map<? extends Number, ? extends Number>>() {}.capture())
            .resolveType(subtype);
  }

  interface TypedKeyMap<T> extends Map<Integer, T> {}

  interface TypedListKeyMap<T> extends Map<List<Integer>, T> {}

  private static <T> Type aTypeVariable() {

        assertEquals(1, reqHeaderPager.getCurrentPageNumber());
        reqHeaderPager.setCurrentPageNumber(999);
        assertEquals(999, reqHeaderPager.getCurrentPageNumber());
        List<Integer> pageNumberList = new ArrayList<Integer>(1);
        reqHeaderPager.setPageNumberList(pageNumberList);
        assertEquals(pageNumberList, reqHeaderPager.getPageNumberList());

    }

    public void test_clear() {

        assertEquals(1, webConfigPager.getCurrentPageNumber());
        webConfigPager.setCurrentPageNumber(999);
        assertEquals(999, webConfigPager.getCurrentPageNumber());
        List<Integer> pageNumberList = new ArrayList<Integer>(1);
        webConfigPager.setPageNumberList(pageNumberList);
        assertEquals(pageNumberList, webConfigPager.getPageNumberList());

    }

    public void test_clear() {

        }
        if (i2 == -1) {
            // first one is known, so it comes first
            return -1;
        }
        int rv = Integer.compare(i1, i2);
        if (rv != 0) {
            return rv;
        }
        // same execution point, now compare priorities
        return Integer.compare(p1.priority(), p2.priority());
    }

    }

    public void setQueryOffset_Equal(Integer queryOffset) {
        setQueryOffset_Term(queryOffset, null);
    }

    public void setQueryOffset_Equal(Integer queryOffset, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setQueryOffset_Term(queryOffset, opLambda);
    }

    public void setQueryOffset_Term(Integer queryOffset) {
        setQueryOffset_Term(queryOffset, null);
    }

    ExecutorService executor = newDirectExecutorService();
    ThreadLocal<Integer> threadLocalCount =
        new ThreadLocal<Integer>() {
          @Override
          protected Integer initialValue() {
            return 0;
          }
        };

    Callable<Integer> incrementTask =
        () -> {
          int i = threadLocalCount.get();
          threadLocalCount.set(i + 1);

   *     <ul>
   *       <li>{@code x} is infinite or NaN
   *       <li>{@code x}, after being rounded to a mathematical integer using the specified rounding
   *           mode, is either less than {@code Integer.MIN_VALUE} or greater than {@code
   *           Integer.MAX_VALUE}
   *       <li>{@code x} is not a mathematical integer and {@code mode} is {@link
   *           RoundingMode#UNNECESSARY}
   *     </ul>
   */

    }

    public void setPort_Equal(Integer port) {
        setPort_Term(port, null);
    }

    public void setPort_Equal(Integer port, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setPort_Term(port, opLambda);
    }

    public void setPort_Term(Integer port) {
        setPort_Term(port, null);
    }

        final BeanDesc beanDesc = new BeanDescImpl(Integer.class);
        assertThat((Integer) beanDesc.newInstance(10), is(10));
        assertThat((Integer) beanDesc.newInstance("10"), is(10));
    }

    /**
     * @throws Exception
     */
    @Test
    public void testNewInstance2() throws Exception {
        final BeanDesc beanDesc = new BeanDescImpl(Integer.class);