}
    }

    public void addFunctionScore(final Consumer<List<FilterFunctionBuilder>> functionScoreQuery) {
        final List<FilterFunctionBuilder> list = new ArrayList<>();
        functionScoreQuery.accept(list);
        queryBuilder = QueryBuilders.functionScoreQuery(queryBuilder, list.toArray(new FilterFunctionBuilder[list.size()]));
    }

    public void addQuery(final Consumer<BoolQueryBuilder> boolQuery) {

                if (logger.isDebugEnabled()) {
                    logger.debug("role(lazy loading): {}", roleSet);
                }
                lazyLoading.accept(roleSet.toArray(new String[roleSet.size()]));
            }, 0, false);
        }

        return roles;
    }

            this.supplier = supplier;
        }

        public void of(final Consumer<Stream<T>> stream) {
            try (Stream<T> s = supplier.get()) {
                stream.accept(s);
            }
        }

        public <R> R get(final Function<Stream<T>, R> stream) {
            try (Stream<T> s = supplier.get()) {
                return stream.apply(s);
            }
        }

            return; // basically no way when called in Framework (because called when SpecifyColumn exists)
        }
        __specifiedProperties = newModifiedProperties();
        __specifiedProperties.accept(__modifiedProperties);
    }

    // ===================================================================================
    //                                                                Specified Properties

            if (fnf != null && fnf.accept(this, name) == false)
                continue;
            if (name.length() > 0) {
                // if !files we don't need to create SmbFiles here
                SmbFile f = new SmbFile(this, name, e.getType(),
                            ATTR_READONLY | ATTR_DIRECTORY, 0L, 0L, 0L );
                if (ff != null && ff.accept(f) == false)
                    continue;

                throwError.accept(messages -> fessConfig.invalidIndexRequiredFields(form.doc).stream().map(s -> "doc." + s)
                        .forEach(s -> messages.addErrorsPropertyRequired(s, s)));
            }

            if (!fessConfig.validateIndexArrayFields(form.doc)) {
                throwError.accept(messages -> fessConfig.invalidIndexArrayFields(form.doc).stream().map(s -> "doc." + s)

        for (final Map.Entry<Thread, StackTraceElement[]> entry : Thread.getAllStackTraces().entrySet()) {
            writer.accept("Thread: " + entry.getKey());
            final StackTraceElement[] trace = entry.getValue();
            for (final StackTraceElement element : trace) {
                writer.accept("\tat " + element);
            }
        }
    }

        public void connect(Consumer<HttpURLConnection> actionListener, Consumer<Exception> exceptionListener) {
            try {
                actionListener.accept(new MockHttpURLConnection(new URL(url)));
            } catch (MalformedURLException e) {
                exceptionListener.accept(e);
            }
        }
    }

    class MockHttpURLConnection extends HttpURLConnection {

        MockHttpURLConnection(URL u) {

        return userInfoBhv.selectByPK(userCode).map(userInfo -> {
            final FavoriteLog favoriteLog = new FavoriteLog();
            favoriteLogLambda.accept(userInfo, favoriteLog);
            favoriteLogBhv.insert(favoriteLog);
            if (fessConfig.isLoggingSearchUseLogfile()) {
                ComponentUtil.getSearchLogHelper().writeSearchLogEvent(favoriteLog);
            }

                    }
                    if (bufferSize > 0) {
                        list.add(line);
                    }
                    if (outputCallback != null) {
                        outputCallback.accept(line);
                    }
                    if (list.size() > bufferSize) {
                        list.remove(0);
                    }
                }
            } catch (final Exception e) {