memberRenderers.add(new BlocksRenderer(linkRenderer, listener));
    }

    public void mergeContent(ClassDoc classDoc, Element parent) {
        listener.start(String.format("class %s", classDoc.getName()));
        try {
            Element chapter = parent.getOwnerDocument().createElement("chapter");
            parent.appendChild(chapter);

                    throw new FessSystemException("Not found: " + baseDir.getAbsolutePath());
                }
                thumbnailTaskQueue = new LinkedBlockingQueue<>(thumbnailTaskQueueSize);
                // Don't start thread
                generating = false;
            }

            @Override
            protected void storeQueue(List<Tuple3<String, String, String>> taskList) {
                taskList.clear();

                return startPosition;
            }

            final String start = request.getParameter("start");
            if (StringUtil.isBlank(start)) {
                startPosition = fessConfig.getPagingSearchPageStartAsInteger();
            } else {
                try {
                    startPosition = Integer.parseInt(start);
                } catch (final NumberFormatException e) {

            example: Fess
        - name: start
          in: query
          description: Start position
          required: false
          schema:
            type: integer
            minimum: 0
            exclusiveMinimum: false
            default: 0
            example: 0
        - name: offset
          in: query
          description: Offset from a start position
          required: false
          schema:

    /**
     * Returns the sort.
     *
     * @return The sort.
     */
    public abstract String getSort();

    /**
     * Returns the start position.
     *
     * @return The start position.
     */
    public abstract int getStartPosition();

    /**
     * Returns the page size.
     *
     * @return The page size.
     */

    }

    @Test
    public void test_setLoggerName() {
        String originalLoggerName = crawlerStatsHelper.loggerName;
        crawlerStatsHelper.setLoggerName("test.stats.logger");
        assertEquals("test.stats.logger", crawlerStatsHelper.loggerName);
        crawlerStatsHelper.setLoggerName(originalLoggerName);
    }

    @Test
    public void test_setMaxCacheSize() {

            }
        });
    }

    private void importBulk(final String fileName, final File tempFile) {
        if (logger.isDebugEnabled()) {
            logger.debug("Bulk data import started: fileName={}", fileName);
        }

        final ObjectMapper mapper = new ObjectMapper();
        final AtomicBoolean resetJobs = new AtomicBoolean(false);

        Objects.requireNonNull(cmd, "cmd");
        if (cmd.length == 0) throw new IllegalArgumentException("cmd must not be empty");
        ProcessBuilder pb = new ProcessBuilder(cmd);
        Process p = pb.start();
        Future<String> outFuture = readStreamAsync(p.getInputStream());
        Future<String> errFuture = readStreamAsync(p.getErrorStream());
        int code = p.waitFor();
        String out = outFuture.get();

        model.stages
            .filter { it.stageName <= StageName.READY_FOR_RELEASE }
            .flatMap { it.functionalTests }
            .filter { it.os == os && !it.testType.crossVersionTests }
            .forEach {
                buildType(FlakyTestQuarantine(model, stage, it))
            }

        model.stages
            .filter { it.stageName <= StageName.READY_FOR_RELEASE }

     *
     * @param response the HTTP response
     * @param status the HTTP status code
     * @param data the data to serialize as JSON
     * @throws IOException if an I/O error occurs
     */
    protected void writeJsonResponse(final HttpServletResponse response, final int status, final Map<String, Object> data)
            throws IOException {
        response.setStatus(status);
        response.setContentType("application/json");