// When
        SmbPipeResource pipe = context.getPipe("smb://server/IPC$/pipe", 0);

        // Then
        assertNotNull(pipe, "Should create pipe resource");
        assertTrue(pipe.getLocator().getURL().toString().contains("pipe"), "Pipe resource should contain pipe path");
    }

    @Test
    @DisplayName("getPipe method should handle valid pipe URLs")

    }

    @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

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

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

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;

    /**

            "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.",

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;

        assertEquals(0x1, buffer[12]);
    }

    @Test
    @DisplayName("Test with special characters in pipe name")
    void testWithSpecialCharactersInPipeName() {
        // Test with special characters
        String pipeName = "\\\\?\\pipe\\test$pipe#name!";
        FsctlPipeWaitRequest request = new FsctlPipeWaitRequest(pipeName);
        byte[] nameBytes = pipeName.getBytes(StandardCharsets.UTF_16LE);

        // Arrange
        SmbPipeHandleImpl handle = newHandleWithBasicStubs(0, "\\\\pipe\\\\foo");
        when(pipe.ensureTreeConnected()).thenReturn(tree);
        when(tree.acquire()).thenReturn(tree);
        when(tree.isSMB2()).thenReturn(true);
        when(pipe.openUnshared(eq("\\\\pipe\\\\foo"), eq(0), anyInt(), anyInt(), eq(SmbConstants.ATTR_NORMAL), eq(0))).thenReturn(fh);

        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
    }