Method processMethod = ThumbnailGenerator.class.getDeclaredMethod("process", ThumbnailGenerator.Options.class);
        processMethod.setAccessible(true);

        try {
            Integer result = (Integer) processMethod.invoke(null, options);
            assertNotNull(result);
            assertEquals(1, result.intValue());
        } catch (Exception e) {

@GwtIncompatible // SerializableTester
public class ReserializedSafeTreeMapMapInterfaceTest
    extends SortedMapInterfaceTest<String, Integer> {
  public ReserializedSafeTreeMapMapInterfaceTest() {
    super(false, true, true, true, true);
  }

  @Override
  protected SortedMap<String, Integer> makePopulatedMap() {
    NavigableMap<String, Integer> map = new SafeTreeMap<>();
    map.put("one", 1);
    map.put("two", 2);
    map.put("three", 3);

        Integer testValue = 42;
        OptionalEntity<Integer> result = OptionalUtil.ofNullable(testValue);

        assertNotNull(result);
        assertTrue(result.isPresent());
        assertEquals(Integer.valueOf(42), result.get());
    }

    public void test_ofNullable_withNullInteger() {
        Integer testValue = null;
        OptionalEntity<Integer> result = OptionalUtil.ofNullable(testValue);

  }

  public void testComplexBuilder() {
    List<Integer> colorElem = asList(0x00, 0x33, 0x66, 0x99, 0xCC, 0xFF);
    ImmutableList.Builder<Integer> webSafeColorsBuilder = ImmutableList.builder();
    for (Integer red : colorElem) {
      for (Integer green : colorElem) {
        for (Integer blue : colorElem) {
          webSafeColorsBuilder.add((red << 16) + (green << 8) + blue);
        }

     */
    @Override
    public Integer getStatus() {
        return status;
    }

    /*
     * (non-Javadoc)
     *
     * @see org.codelibs.fess.crawler.entity.AccessResult#setStatus(java.lang.Integer)
     */
    @Override
    public void setStatus(final Integer status) {
        this.status = status;
    }

    /*
     * (non-Javadoc)

        dst[++dstIndex] = (byte) (val >>= 8);
        dst[++dstIndex] = (byte) (val >> 8);
    }

    /**
     * Reads a 16-bit integer value from a byte array in little-endian format
     * @param src the source byte array
     * @param srcIndex the starting index in the source array
     * @return the 16-bit integer value
     */
    public static int readInt2(final byte[] src, final int srcIndex) {

     * @author koichik
     */
    public interface Hoge {

        /** */
        public static Map<String, Set<Integer>[]> foo = null;

        /**
         * @param arg1
         * @param arg2
         * @return List
         */
        List<String> foo(Set<Integer> arg1, Map<String, Integer> arg2);
    }

  }

  private final boolean allowsSelfLoops;
  private final ElementOrder<Integer> incidentEdgeOrder;

  public StandardMutableUndirectedGraphTest(
      boolean allowsSelfLoops, ElementOrder<Integer> incidentEdgeOrder) {
    this.allowsSelfLoops = allowsSelfLoops;
    this.incidentEdgeOrder = incidentEdgeOrder;
  }

  @Override
  public MutableGraph<Integer> createGraph() {
    return GraphBuilder.undirected()

        assertEquals("/test/path", defaultPath);
    }

    // Test default expire
    public void test_provideDefaultExpire() {
        Integer defaultExpire = cookieResourceProvider.provideDefaultExpire();
        assertEquals(Integer.valueOf(3600), defaultExpire);
    }

    // Test cookie cipher
    public void test_provideCookieCipher() {
        // provideCookieCipher is not directly exposed anymore

    array[getNumElements() / 2] = e0();
    collection = getSubjectGenerator().create(array);
    assertEquals(
        "indexOf(duplicate) should return index of first occurrence", 0, getList().indexOf(e0()));
  }