array[i] ^= Integer.MAX_VALUE;
    }
    Arrays.sort(array, fromIndex, toIndex);
    for (int i = fromIndex; i < toIndex; i++) {
      array[i] ^= Integer.MAX_VALUE;
    }
  }

  /**
   * Returns dividend / divisor, where the dividend and divisor are treated as unsigned 32-bit
   * quantities.
   *
   * <p><b>Java 8+ users:</b> use {@link Integer#divideUnsigned(int, int)} instead.
   *

    // need explicit type parameter to avoid javac warning!?
    List<Integer> none = Arrays.<Integer>asList();
    assertThat(Ints.toArray(none)).isEqualTo(EMPTY);

    List<Integer> one = Arrays.asList((int) 1);
    assertThat(Ints.toArray(one)).isEqualTo(ARRAY1);

    int[] array = {(int) 0, (int) 1, (int) 0xdeadbeef};

    List<Integer> three = Arrays.asList((int) 0, (int) 1, (int) 0xdeadbeef);

    }

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

    // Test numeric conversions
    @Test
    public void test_numericConversions() {
        // Test integer conversion
        Integer heartbeatInterval = fessConfig.getSearchEngineHeartbeatIntervalAsInteger();
        assertNotNull(heartbeatInterval);
        assertEquals(10000, heartbeatInterval.intValue());

        // Test integer conversion for cleanup days
        int cleanupDays = fessConfig.getDayForCleanup();

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

    }

    public void test_clear() {

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

    }

    public void test_clear() {

                                        "schema": {
                                            "title": "Response 500 Valid1 Valid1 Get",
                                            "type": "integer",
                                        }
                                    }
                                },
                            },
                        },
                    }
                },

@GwtCompatible
@Immutable(containerOf = {"R", "C", "V"})
final class DenseImmutableTable<R, C, V> extends RegularImmutableTable<R, C, V> {
  private final ImmutableMap<R, Integer> rowKeyToIndex;
  private final ImmutableMap<C, Integer> columnKeyToIndex;
  private final ImmutableMap<R, ImmutableMap<C, V>> rowMap;
  private final ImmutableMap<C, ImmutableMap<R, V>> columnMap;

 */
@GwtCompatible
@NullUnmarked
public class UntrustedInputFutureTest extends AbstractAbstractFutureTest {
  @Override
  AbstractFuture<@Nullable Integer> newDelegate() {
    AbstractFuture<@Nullable Integer> future = new AbstractFuture<@Nullable Integer>() {};
    assertFalse(future instanceof TrustedFuture); // sanity check
    return future;
  }

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