protected void searchPaging(final RenderData data, final SearchForm form) {
        RenderDataUtil.register(data, "failureUrlItems", failureUrlService.getFailureUrlList(failureUrlPager)); // page navi

        // restore from pager
        copyBeanToBean(failureUrlPager, form, op -> op.include("url", "errorCountMin", "errorCountMax", "errorName"));
    }

    // -----------------------------------------------------

    }

    protected void searchPaging(final RenderData data, final SearchForm form) {
        RenderDataUtil.register(data, "jobLogItems", jobLogService.getJobLogList(jobLogPager)); // page navi

        // restore from pager
        copyBeanToBean(jobLogPager, form, op -> op.include("id"));
    }

    // ===================================================================================

        // page navi
        RenderDataUtil.register(data, "stopwordsItemItems", stopwordsService.getStopwordsList(form.dictId, stopwordsPager));

        // restore from pager
        BeanUtil.copyBeanToBean(stopwordsPager, form, op -> {
            op.exclude(Constants.PAGER_CONVERSION_RULE);
        });
    }

     *
     * <p>If the Thread in use is interrupted before or during execution of the tasks in {@link
     * #queue}, the Executor will complete its tasks, and then restore the interruption. This means
     * that once the Thread returns to the Executor that this Executor composes, the interruption
     * will still be present. If the composed Executor is an ExecutorService, it can respond to

   * method.
   */
  public void callAndAssertWaits(String methodName, Object conditionLikeObject) throws Exception {
    checkNotNull(methodName);
    checkNotNull(conditionLikeObject);
    // TODO: Restore the following line when Monitor.hasWaiters() no longer acquires the lock.
    // assertEquals(false, invokeMethod("hasWaiters", conditionLikeObject));
    sendRequest(methodName, conditionLikeObject);

     *
     * <p>If the Thread in use is interrupted before or during execution of the tasks in {@link
     * #queue}, the Executor will complete its tasks, and then restore the interruption. This means
     * that once the Thread returns to the Executor that this Executor composes, the interruption
     * will still be present. If the composed Executor is an ExecutorService, it can respond to

        });
    }

    protected void searchPaging(final RenderData data, final SearchForm form) {
        RenderDataUtil.register(data, "roleItems", roleService.getRoleList(rolePager)); // page navi

        // restore from pager
        copyBeanToBean(rolePager, form, op -> op.include("id"));
    }

    // ===================================================================================

        });
    }

    protected void searchPaging(final RenderData data, final SearchForm form) {
        RenderDataUtil.register(data, "groupItems", groupService.getGroupList(groupPager)); // page navi

        // restore from pager
        copyBeanToBean(groupPager, form, op -> op.include("id"));
    }

    // ===================================================================================

    protected void searchPaging(final RenderData data, final SearchForm form) {
        RenderDataUtil.register(data, "pathMappingItems", pathMappingService.getPathMappingList(pathMapPager)); // page navi

        // restore from pager
        copyBeanToBean(pathMapPager, form, op -> op.include("regex", "replacement"));
    }

    // ===================================================================================

    assertThrows(IllegalStateException.class, () -> peekingIterator.remove());

    assertEquals(
        "After remove() throws exception, peek should still be ok", "B", peekingIterator.peek());

    /* Should recover to be able to remove() after next(). */
    assertEquals("B", peekingIterator.next());
    peekingIterator.remove();
    assertEquals("Should have removed an element", 2, list.size());