}

    @Override
    public TokenStream create(TokenStream tokenStream) {
        if (removeTrailing) {
            return new StopFilter(tokenStream, stopWords);
        } else {
            return new SuggestStopFilter(tokenStream, stopWords);
        }
    }

    public Set<?> stopWords() {
        return stopWords;
    }

    public boolean ignoreCase() {

                this.selectedCipher = enc.getCiphers()[0];
                this.supportsEncryption = true;
            } else if (ncr.getContextType() == EncryptionNegotiateContext.NEGO_CTX_ENC_TYPE) {
                log.debug("Multiple encryption negotiate contexts");
                return false;
            } else if (!foundPreauth && ncr.getContextType() == PreauthIntegrityNegotiateContext.NEGO_CTX_PREAUTH_TYPE) {

                        // Some threads wipe password
                        auth.secureWipePassword();
                    } else if (index % 3 == 1) {
                        // Some threads close authenticator
                        auth.close();
                    } else {
                        // Some threads try to read password
                        try {

            buf.dec_ndr_short(); /* cancel count */
        }
        if (this.ptype == 3 || this.ptype == 13) { /* Fault */
            this.result = buf.dec_ndr_long();
        } else { /* Bind_ack or Response */
            decode_out(buf);
        }
    }

    /**
     * Get the operation number for this DCERPC message.
     * @return the operation number
     */

        boolean result = dosFileFilter.accept(mockFile);

        // Then the result should be as expected
        if (expectedResult) {
            assertTrue(result, "File should be accepted");
        } else {
            assertFalse(result, "File should not be accepted");
        }
    }

    /**
     * Tests that the accept method returns true when the file has more attributes

        if (infoLevel == FileInformation.FILE_BASIC_INFO) {
            assertTrue(response.getInfo() instanceof FileBasicInfo);
        } else if (infoLevel == FileInformation.FILE_STANDARD_INFO) {
            assertTrue(response.getInfo() instanceof FileStandardInfo);
        } else if (infoLevel == FileInformation.FILE_INTERNAL_INFO) {
            assertTrue(response.getInfo() instanceof FileInternalInfo);
        }
    }

     */
    public MultipleCrawlingAccessException(final String message, final Throwable[] throwables) {
        super(message);
        if (throwables == null) {
            this.throwables = new Throwable[0];
        } else {
            this.throwables = throwables;
        }
    }

    @Override
    public void printStackTrace(final PrintStream s) {
        super.printStackTrace(s);

        int count = 1;

            pipe.send(new TransWaitNamedPipe(path), new TransWaitNamedPipeResponse());
            pipe.send(new TransCallNamedPipe(path, b, off, len), new TransCallNamedPipeResponse(pipe));
        } else if ((pipe.pipeType & SmbNamedPipe.PIPE_TYPE_TRANSACT) == SmbNamedPipe.PIPE_TYPE_TRANSACT) {
            ensureOpen();
            final TransTransactNamedPipe req = new TransTransactNamedPipe(pipe.fid, b, off, len);

            if (entry == null) {
                entry = new CacheEntry(hostName, addr, expiration);
                ADDRESS_CACHE.put(hostName, entry);
            } else {
                entry.address = addr;
                entry.expiration = expiration;
            }
        }
    }

    static void cacheAddressArray(final NbtAddress[] addrs) {

                if (logger.isDebugEnabled()) {
                    logger.debug("Metadata response.", e);
                }
                saveInfo(e.getMessageCode());
            } else {
                logger.warn("Failed to process metadata.", e);
                saveError(e.getMessageCode());
            }
            return redirect(LoginAction.class);
        }
    }

    /**