}

    @Override
    public CIFSContext getTransportContext() {
        return this.pipe.getContext();
    }

    @Override
    public String getServer() {
        return this.pipe.getLocator().getServer();
    }

    @Override
    public String getServerWithDfs() {
        return this.pipe.getLocator().getServerWithDfs();
    }

    @Override

     * @param bytes the 16-byte GUID data in little-endian format (SMB wire format)
     */
    public HandleGuid(byte[] bytes) {
        if (bytes.length != 16) {
            throw new IllegalArgumentException("GUID must be 16 bytes");
        }

        // MS-SMB2 specifies little-endian byte ordering for GUID components
        // Convert from little-endian wire format to Java UUID

    }

    /**
     * Writes setup data in wire format
     * @param dst destination buffer
     * @param dstIndex starting index in destination buffer
     * @return number of bytes written
     */
    protected abstract int writeSetupWireFormat(byte[] dst, int dstIndex);

    /**
     * Writes parameters in wire format
     * @param dst destination buffer

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;

    /**

 * <li> <code>CallNamedPipe</code> A message-type pipe call that opens,
 *      writes to, reads from, and closes the pipe in a single operation.
 * <li> <code>TransactNamedPipe</code> A message-type pipe call that
 *      writes to and reads from an existing pipe descriptor in one operation.
 * <li> <code>CreateFile</code>, <code>ReadFile</code>,
 *      <code>WriteFile</code>, and <code>CloseFile</code> A byte-type pipe can

    /**
     * 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