assertEquals("guest", permissionHelper.encode("guest"));

        final FessConfig fessConfig = ComponentUtil.getFessConfig();
        ComponentUtil.setFessConfig(new FessConfig.SimpleImpl() {
            private static final long serialVersionUID = 1L;

            @Override
            public String getRoleSearchUserPrefix() {

    @Test
    public void test_concurrentResolve_onlyOneWins() throws Exception {
        final int threadCount = 10;
        final Deferred<SuggestResponse> deferred = new Deferred<>();
        final AtomicInteger callbackCount = new AtomicInteger(0);
        final CountDownLatch startLatch = new CountDownLatch(1);
        final CountDownLatch doneLatch = new CountDownLatch(threadCount);

    }

    private static final Pattern UNIX_PID_PATTERN = Pattern.compile("([0-9]+)");
    private static final Pattern WINDOWS_PID_PATTERN = Pattern.compile("([0-9]+)\\s*$");
    private static final String MY_PID = String.valueOf(ProcessHandle.current().pid());
    private static final String JAVA_EXECUTABLE_PATTERN_STR = "java(?:\\.exe)?";
    private static final String GRADLE_MAIN_CLASS_PATTERN_STR = "(org\\.gradle\\.[a-zA-Z]+)";

   * be added without necessarily executing immediately.
   */
  private static final class PerListenerQueue<L> implements Runnable {
    final L listener;
    final Executor executor;

    @GuardedBy("this")
    final Queue<ListenerCallQueue.Event<L>> waitQueue = new ArrayDeque<>();

    @GuardedBy("this")
    final Queue<Object> labelQueue = new ArrayDeque<>();

    @GuardedBy("this")

     */
    public ContentIndexingOperations(final Client client, final SuggestSettings settings, final ExecutorService threadPool,
            final IndexingOperations indexingOps, final ContentsParser contentsParser, final SuggestAnalyzer analyzer,
            final ReadingConverter readingConverter, final ReadingConverter contentsReadingConverter, final Normalizer normalizer,
            final boolean parallel) {
        this.client = client;

pkg regexp, method (*Regexp) ExpandString([]uint8, string, string, []int) []uint8
pkg regexp, method (*Regexp) Find([]uint8) []uint8
pkg regexp, method (*Regexp) FindAll([]uint8, int) [][]uint8
pkg regexp, method (*Regexp) FindAllIndex([]uint8, int) [][]int
pkg regexp, method (*Regexp) FindAllString(string, int) []string
pkg regexp, method (*Regexp) FindAllStringIndex(string, int) [][]int

        final SearchResponse mockScrollResponse = mock(SearchResponse.class);
        final SearchHits mockScrollHits = mock(SearchHits.class);
        final ActionFuture<SearchResponse> mockScrollFuture = mock(ActionFuture.class);

        final BulkRequestBuilder mockBulkBuilder = mock(BulkRequestBuilder.class);

        } catch (AuthorizationException e) {
            throw new TransferFailedException("Authorization failed: " + e.getMessage(), e);
        } finally {
            // Remove remaining TransferListener instances (checksum handlers removed in above finally clause)
            if (downloadMonitor != null) {
                wagon.removeTransferListener(downloadMonitor);
            }

            disconnectWagon(wagon);

public class SimpleLookup implements Lookup {
    private final List<Object> objects;

    public SimpleLookup(List<Object> objects) {
        this.objects = objects;
    }

    @Override
    public <T> T lookup(Class<T> type) {
        return objects.stream()
                .filter(type::isInstance)
                .map(type::cast)
                .findAny()

    }

    private void disableOnPresentOption(
            final CommandLine commandLine, final String option, final Consumer<Boolean> setting) {
        if (commandLine.hasOption(option)) {
            setting.accept(false);
        }
    }

    private void disableOnPresentOption(
            final CommandLine commandLine, final char option, final Consumer<Boolean> setting) {