return wrap((SortedSetMultimap<?, ?>) delegate);
              }
            });
  }

  public void testEquals() {
    SortedSetMultimap<Integer, String> map1 = TreeMultimap.create(ImmutableMultimap.of(1, "one"));
    SortedSetMultimap<Integer, String> map2 = TreeMultimap.create(ImmutableMultimap.of(2, "two"));
    new EqualsTester()
        .addEqualityGroup(map1, wrap(map1), wrap(map1))

  }

  public void testMultipleQuantile() {
    ImmutableSet<Integer> indexes = ImmutableSet.of(50, 90, 99);
    Map<Integer, Double> referenceQuantiles =
        REFERENCE_ALGORITHM.multipleQuantiles(indexes, 100, dataset.clone());
    assertThat(referenceQuantiles.keySet()).isEqualTo(indexes);
    for (QuantilesAlgorithm algorithm : NON_REFERENCE_ALGORITHMS) {

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

                            "items": {
                                "title": "Items",
                                "type": "object",
                                "additionalProperties": {"type": "integer"},
                            }
                        },
                    },
                    "ValidationError": {
                        "title": "ValidationError",

        registerModifiedProperty("createdTime");
        this.createdTime = value;
    }

    public Integer getSortOrder() {
        checkSpecifiedProperty("sortOrder");
        return sortOrder;
    }

    public void setSortOrder(Integer value) {
        registerModifiedProperty("sortOrder");
        this.sortOrder = value;
    }

    public String getTerm() {

  }

  public static final class ExceptionWithoutThrowableConstructor extends Exception {
    public ExceptionWithoutThrowableConstructor(String s) {
      super(s);
    }
  }

  public static final class ExceptionWithWrongTypesConstructor extends Exception {
    public ExceptionWithWrongTypesConstructor(Integer i, String s) {
      super(s);
    }
  }

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

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

    public void setCreatedTime(Long value) {
        registerModifiedProperty("createdTime");
        this.createdTime = value;
    }

    public Integer getMaxSize() {
        checkSpecifiedProperty("maxSize");
        return maxSize;
    }

    public void setMaxSize(Integer value) {
        registerModifiedProperty("maxSize");
        this.maxSize = value;
    }

    public String getQuery() {

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

    }

    public void test_clear() {