*
 * </td>
 * <td>
 * Open the Named Pipe foo for reading and writing. The pipe will
 * behave as though the <code>CreateFile</code>, <code>ReadFile</code>,
 * <code>WriteFile</code>, and <code>CloseFile</code> interface was
 * being used.
 * </td>
 * </tr>
 * </table>
 *
 * <p>
 * See <a href="../../../pipes.html">Using jCIFS to Connect to Win32
 * Named Pipes</a> for a detailed description of how to use jCIFS with

        return this.handle.ensureOpen();
    }

    /**
     * Gets the pipe handle implementation for this output stream.
     *
     * @return the handle
     */
    protected SmbPipeHandleImpl getHandle() {
        return this.handle;
    }

    @Override
    public void close() {
        // ignore, the shared file descriptor is closed by the pipe handle
    }

    }

    @Test
    @DisplayName("Test with various pipe name formats")
    void testVariousPipeNameFormats() {
        // Test various pipe name formats
        String[] pipeNames =
                { "\\\\server\\PIPE\\testpipe", "\\PIPE\\LANMAN", "\\PIPE\\srvsvc", "\\PIPE\\wkssvc", "PIPE\\test", "testpipe" };

        for (String pipeName : pipeNames) {
            // Act

import jcifs.Configuration;
import jcifs.internal.SMBProtocolDecodingException;

/**
 * Response for SMB1 TRANS_CALL_NAMED_PIPE transaction.
 *
 * This response contains the data returned from the named pipe
 * after a call transaction has been processed by the server.
 */
public class TransCallNamedPipeResponse extends SmbComTransactionResponse {

    private final byte[] outputBuffer;

    /**

    private final boolean dcePipe;

    Object lock;

    TransactNamedPipeInputStream(final SmbNamedPipe pipe) throws SmbException, MalformedURLException, UnknownHostException {
        super(pipe, pipe.pipeType & 0xFFFF00FF | SmbFile.O_EXCL);
        this.dcePipe = (pipe.pipeType & SmbNamedPipe.PIPE_TYPE_DCE_TRANSACT) != SmbNamedPipe.PIPE_TYPE_DCE_TRANSACT;
        lock = new Object();
    }

    @Override

    /**
     * Pipe is used for DCE
     */
    int PIPE_TYPE_DCE_TRANSACT = 0x0200 | 0x0400;

    /**
     * Pipe should use it's own exclusive transport connection
     */
    int PIPE_TYPE_UNSHARED = 0x800;

    /**
     * Gets the type of this pipe.
     *
     * @return the type of the pipe
     */
    int getPipeType();

    /**
     * Create a pipe handle
     *

            "All pipe instances are busy.", "All pipe instances are busy.", "The pipe state is invalid.", "All pipe instances are busy.",
            "No process is on the other end of the pipe.", "The pipe is being closed.",
            "Waiting for a process to open the other end of the pipe.", "Access is denied.", "A duplicate name exists on the network.",

    }

    @Test
    @DisplayName("getPipe, getPipeType, getUncPath delegate to underlying pipe")
    void testBasicAccessors() {
        when(pipe.getPipeType()).thenReturn(0x123456);
        assertSame(pipe, target.getPipe());
        assertEquals(0x123456, target.getPipeType());
        assertEquals("\\\\pipe\\\\my-pipe", target.getUncPath());
    }

    @Test

import jcifs.Encodable;
import jcifs.internal.util.SMBUtil;

/**
 * File System Control Code (FSCC) request for pipe wait operations.
 * Implements the FSCTL_PIPE_WAIT control code used to wait for a named pipe
 * to become available when attempting to connect to a busy pipe.
 *
 * @author mbechler
 */
public class FsctlPipeWaitRequest implements Encodable {

    private final byte[] nameBytes;

 */

package jcifs.smb1.smb1;

class TransTransactNamedPipeResponse extends SmbComTransactionResponse {

    private final SmbNamedPipe pipe;

    TransTransactNamedPipeResponse(final SmbNamedPipe pipe) {
        this.pipe = pipe;
    }

    @Override
    int writeSetupWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override