assertThat(traverser.isExistClass(TestCase.class.getName()), is(not(true)));

        final Set<String> set = new HashSet<String>();
        traverser.forEach((ClassHandler) (packageName, shortClassName) -> set.add(ClassUtil.concatName(packageName, shortClassName)));
        assertThat(set.size() > 0, is(true));
        assertThat(set.contains(DummyTest.class.getName()), is(true));

        final String path = ResourceUtil.getResourcePath(getClass());
        final int pos = path.lastIndexOf("/");
        final String baseDirectory = path.substring(0, pos);
        ResourceTraversalUtil.forEach(rootDir, baseDirectory, (ResourceHandler) (path1, is) -> {
            try {
                if (count < 10) {
                    System.out.println(path1);
                }

            final String key = LaFunctions.u(e.getKey());
            stream(e.getValue()).of(stream -> stream.filter(StringUtil::isNotBlank)
                    .forEach(s -> pagingQueryList.add("fields." + key + "=" + LaFunctions.u(s))));
        });
        form.as.entrySet().stream().filter(e -> e.getValue() != null).forEach(e -> {

                        .forEach(s -> messages.addErrorsPropertyRequired(s, s)));
            }

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

        final String key = ComponentUtil.getVirtualHostHelper().getVirtualHostKey();
        keywordList.stream().forEach(keyword -> {
            final List<Tuple3<String, QueryBuilder, ScoreFunctionBuilder<?>>> boostList = getQueryMap(key).get(toLowerCase(keyword));
            if (boostList != null) {
                boostList.forEach(pair -> list.add(new FilterFunctionBuilder(pair.getValue2(), pair.getValue3())));
            }
        });
    }

                insertList.forEach(this::writeSearchLogEvent);
                updateList.forEach(this::writeSearchLogEvent);
            }
            // insert/update user info
            userInfoBhv.batchInsert(insertList);
            userInfoBhv.batchUpdate(updateList);
            // update search log
            searchLogList.stream().forEach(searchLog -> {

                executeCallbacks.add(callback);
            }
        }
        if (executeCallbacks.size() > 0) {
            try {
                executeCallbacks.stream().forEach(callback -> callback.accept(response));
            } catch (final Exception ignore) {}
        }
        latch.countDown();
    }

    /**
     * Rejects the deferred computation with the given throwable.

    }

    @Override
    public ImmutableBiMap<K, V> inverse() {
      return RegularImmutableBiMap.this;
    }

    @Override
    public void forEach(BiConsumer<? super V, ? super K> action) {
      checkNotNull(action);
      RegularImmutableBiMap.this.forEach((k, v) -> action.accept(v, k));
    }

    @Override
    public @Nullable K get(@Nullable Object value) {
      if (value == null || valueTable == null) {

                permissionSet.add(systemHelper.getSearchRoleByUser(nameId));
                stream(groups).of(stream -> stream.forEach(s -> permissionSet.add(systemHelper.getSearchRoleByGroup(s))));
                stream(roles).of(stream -> stream.forEach(s -> permissionSet.add(systemHelper.getSearchRoleByRole(s))));
                permissions = permissionSet.toArray(new String[permissionSet.size()]);
            }

                getAliasesResponse.getAliases()
                        .entrySet()
                        .forEach(x -> x.getValue()
                                .stream()
                                .filter(y -> updateAlias.equals(y.alias()))
                                .forEach(y -> updateIndices.add(x.getKey())));
            }
            if (updateIndices.size() != 1) {