ContiguousSet<Integer> empty = ContiguousSet.create(Range.closedOpen(1, 1), integers());
    assertTrue(empty instanceof EmptyContiguousSet);
    reserializeAndAssert(empty);

    ContiguousSet<Integer> regular = ContiguousSet.create(Range.closed(1, 3), integers());
    assertTrue(regular instanceof RegularContiguousSet);
    reserializeAndAssert(regular);

    /*

     * we always return a new instance with a null valueComparator, as we already do if the input is
     * empty or a partial view?
     *
     * Related: Should methods that do accept a comparator (like fromMapEntries, or like this one if
     * we were to choose to *preserve* an input comparator) return not the generic empty of()
     * instance but instead an empty ImmutableSetMultimap instance with the requested

      // Overridden to prevent a ton of boxing
      return (target instanceof Double)
          && Doubles.indexOf(array, (Double) target, start, end) != -1;
    }

    @Override
    public int indexOf(@Nullable Object target) {
      // Overridden to prevent a ton of boxing
      if (target instanceof Double) {
        int i = Doubles.indexOf(array, (Double) target, start, end);
        if (i >= 0) {

    return ordering.<@NonNull S>nullsLast();
  }

  @Override
  public boolean equals(@Nullable Object object) {
    if (object == this) {
      return true;
    }
    if (object instanceof NullsFirstOrdering) {
      NullsFirstOrdering<?> that = (NullsFirstOrdering<?>) object;
      return this.ordering.equals(that.ordering);
    }
    return false;
  }

  @Override
  public int hashCode() {

      // Overridden to prevent a ton of boxing
      return (target instanceof Long) && Longs.indexOf(array, (Long) target, start, end) != -1;
    }

    @Override
    public int indexOf(@Nullable Object target) {
      // Overridden to prevent a ton of boxing
      if (target instanceof Long) {
        int i = Longs.indexOf(array, (Long) target, start, end);
        if (i >= 0) {

     * TODO(lowasser): consider checking for Multiset here
     */
    // Don't refer to ImmutableSortedSet by name so it won't pull in all that code
    if (elements instanceof ImmutableSet && !(elements instanceof SortedSet)) {
      @SuppressWarnings("unchecked") // all supported methods are covariant
      ImmutableSet<E> set = (ImmutableSet<E>) elements;
      if (!set.isPartialView()) {
        return set;

    MyInt(int i) {
      this.i = i;
    }

    @Override
    public int hashCode() {
      return i;
    }

    @Override
    public boolean equals(Object o) {
      return o instanceof MyInt && ((MyInt) o).i == i;
    }
  }

  public void testAsFunction_simplistic() {
    String canonical = "a";
    String not = new String("a");

    Function<String, String> internerFunction =

                (field, text, boost) -> QueryBuilders.matchQuery(field, text).boost(boost));

        // Should build default query
        assertNotNull(result);
        assertTrue(result instanceof DefaultQueryBuilder);
    }

    /**
     * Test convertWithFieldCheck() with search field.
     */
    @Test
    public void test_convertWithFieldCheck_withSearchField() {

     * we always return a new instance with a null valueComparator, as we already do if the input is
     * empty or a partial view?
     *
     * Related: Should methods that do accept a comparator (like fromMapEntries, or like this one if
     * we were to choose to *preserve* an input comparator) return not the generic empty of()
     * instance but instead an empty ImmutableSetMultimap instance with the requested

    public void deleteSearchLog(final Object e) {
        if (e instanceof final ClickLog clickLog) {
            clickLogBhv.delete(clickLog);
        } else if (e instanceof final FavoriteLog favoriteLog) {
            favoriteLogBhv.delete(favoriteLog);
        } else if (e instanceof final UserInfo userInfo) {
            userInfoBhv.delete(userInfo);
        } else if (e instanceof final SearchLog searchLog) {