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.
     * @param t The throwable.

            SmbFile smbFile = mock(SmbFile.class);
            when(delegate.accept(smbFile)).thenReturn(true);

            // Act
            boolean result = (boolean) invokePrivate(wrapper, "accept", new Class<?>[] { SmbResource.class }, smbFile);

            // Assert
            assertTrue(result);
            verify(delegate, times(1)).accept(smbFile);
        }

        @Test

            if (!(parent instanceof SmbFile)) {
                return false;
            }
            return fnf.accept((SmbFile) parent, name);
        }, ff == null ? null : resource -> {
            if (!(resource instanceof SmbFile)) {
                return false;
            }
            return ff.accept((SmbFile) resource);
        })) {

            final List<String> list = new ArrayList<>();

        @Test
        @DisplayName("Constructor accepts null challenge")
        void testConstructorAcceptsNullChallenge() {
            UniAddress dc = mock(UniAddress.class);

            NtlmChallenge nc = new NtlmChallenge(null, dc);

            assertNull(nc.challenge);
            assertSame(dc, nc.dc);
        }

        @Test
        @DisplayName("Constructor accepts null dc")
        void testConstructorAcceptsNullDc() {

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

            if (!fessConfig.validateIndexArrayFields(doc)) {
                throwError.accept(messages -> fessConfig.invalidIndexArrayFields(doc)

     * as the specified wildcard and attributes are passed to the server for
     * filtering there (although attributes are largely ignored by servers
     * they are filtered locally by the default accept method).
     *
     * @param wildcard the wildcard pattern for matching file names (e.g., "*.txt")
     * @param attributes the DOS file attributes to match (e.g., ATTR_DIRECTORY)
     */

     */
    protected void extractFrontMatterMetadata(final Node document, final ExtractData extractData) {
        final YamlFrontMatterVisitor visitor = new YamlFrontMatterVisitor();
        document.accept(visitor);

        final Map<String, List<String>> frontMatter = visitor.getData();
        for (final Map.Entry<String, List<String>> entry : frontMatter.entrySet()) {

    private void runServer() {
        while (running.get() && !serverSocket.isClosed()) {
            try {
                Socket clientSocket = serverSocket.accept();
                // In a real implementation, this would handle RPC requests
                // For the mock, we just accept connections and close them
                clientSocket.close();
            } catch (IOException e) {
                if (running.get()) {

     * as the specified wildcard and attributes are passed to the server for
     * filtering there (although attributes are largely ignored by servers
     * they are filtered locally by the default accept method).
     *
     * @param wildcard the wildcard pattern for matching file names (e.g., "*.txt")
     * @param attributes the DOS file attributes to match (e.g., ATTR_DIRECTORY)
     */

    @FunctionalInterface
    protected interface ContentWriter {
        /**
         * Accepts a writer.
         * @param writer A writer.
         * @throws IOException if an I/O error occurs.
         * @throws TikaException if a Tika exception occurs.
         * @throws SAXException if a SAX exception occurs.
         */
        void accept(Writer writer) throws IOException, TikaException, SAXException;
    }

    /**