verify(tree, times(2)).acquire();
    }

    @Test
    @DisplayName("getInput/getOutput return cached streams when open; throw when closed")
    void getInputOutput_caching_and_closed() throws Exception {
        // Arrange: minimal stubs so stream construction works
        SmbPipeHandleImpl handle = newHandleWithBasicStubs(0, "\\\\pipe\\\\foo");
        when(pipe.ensureTreeConnected()).thenReturn(tree);

            assertNotNull(is1, "Default input stream should not be null");
            assertNotNull(is2, "Input stream with sharing should not be null");
            assertNotNull(is3, "Input stream with full params should not be null");
            assertSame(mockInputStream, is1, "Should return expected input stream");
            assertSame(mockInputStream, is2, "Should return expected input stream");

        this.processDestroyTimeout = processDestroyTimeout;
    }

    /**
     * Sets the timeout for stream closing operations.
     *
     * @param streamCloseTimeout timeout in seconds for stream closing operations
     */
    public void setStreamCloseTimeout(final int streamCloseTimeout) {
        this.streamCloseTimeout = streamCloseTimeout;
    }

    /**

                }
            }

            return (int) (this.fp - start);
        }
    }

    /**
     * This stream class is unbuffered. Therefore this method will always
     * return 0 for streams connected to regular files. However, a
     * stream created from a Named Pipe this method will query the server using a
     * "peek named pipe" operation and return the number of available bytes

            });
        });
    }

    /**
     * Download the stemmer override dictionary file.
     * Streams the dictionary file as an octet-stream download.
     *
     * @param form The download form containing dictionary ID
     * @return Action response with file stream for download
     */
    @Execute
    @Secured({ ROLE, ROLE + VIEW })
    public ActionResponse download(final DownloadForm form) {

        return parseContext;
    }

    /**
     * Returns an input stream from a deferred file output stream.
     *
     * @param dfos A deferred file output stream.
     * @return An input stream.
     * @throws IOException if an I/O error occurs.
     */
    protected InputStream getContentStream(final DeferredFileOutputStream dfos) throws IOException {

        }
    }

    @Test
    public void testFileBasedCacheWithEmptyFile() throws IOException {
        tempFile = File.createTempFile("empty", ".tmp", Curl.tmpDir);
        // File is created but empty

        ContentCache cache = new ContentCache(tempFile);

        try (InputStream stream = cache.getInputStream()) {
            assertNotNull(stream);

        assertThrows(IOException.class, () -> sis.read());
    }

    @Test
    @DisplayName("Available returns underlying stream available when no message buffered")
    void availableReturnsUnderlyingWhenNoMessage() throws IOException {
        // Mock input stream that reports available bytes
        InputStream mockIn = mock(InputStream.class);
        when(mockIn.available()).thenReturn(42);

            queryBuf.append(escapeQuery(query));
        }

        stream(params.getExtraQueries())
                .of(stream -> stream.filter(q -> StringUtil.isNotBlank(q) && q.length() <= maxQueryLength).forEach(q -> {
                    appendQuery(queryBuf, q);
                }));

        stream(params.getFields()).of(stream -> stream.forEach(entry -> {
            final String key = entry.getKey();

 */
package org.codelibs.fess.app.web.admin.dataconfig;

import static org.codelibs.core.stream.StreamUtil.split;
import static org.codelibs.core.stream.StreamUtil.stream;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;