passwordField.setAccessible(true);

        // Verify password exists before wipe
        char[] passwordBefore = (char[]) passwordField.get(authenticator);
        assertNotNull(passwordBefore, "Password should exist before wipe");
        assertArrayEquals(testPassword.toCharArray(), passwordBefore, "Password should match before wipe");

        // Wipe the password
        authenticator.secureWipePassword();

    }

    @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

        void constructsWithIpcShare(String url) throws Exception {
            // Arrange & Act
            SmbNamedPipe pipe = new SmbNamedPipe(url, SmbPipeResource.PIPE_TYPE_RDWR, ctx());

            // Assert: type is named pipe and pipe type preserved
            assertEquals(SmbConstants.TYPE_NAMED_PIPE, pipe.getType(), "Type should be TYPE_NAMED_PIPE");

```JSON
{"item_id":"foo"}
```

## Parameter path dengan tipe data

Tipe data parameter path bisa didefinisikan di dalam fungsi, menggunakan anotasi tipe data standar Python:

{* ../../docs_src/path_params/tutorial002.py hl[7] *}

Dalam hal ini `item_id` didefinisikan sebagai `int`.

/// check | Periksa

                Arguments.of(WinError.ERROR_BAD_PIPE, "The pipe state is invalid."),
                Arguments.of(WinError.ERROR_PIPE_BUSY, "All pipe instances are busy."),
                Arguments.of(WinError.ERROR_NO_DATA, "The pipe is being closed."),
                Arguments.of(WinError.ERROR_PIPE_NOT_CONNECTED, "No process is on the other end of the pipe."),
                Arguments.of(WinError.ERROR_MORE_DATA, "More data is available."),

    private final String path;
    private final SmbNamedPipe pipe;
    private final byte[] tmp = new byte[1];
    private final boolean dcePipe;

    TransactNamedPipeOutputStream(final SmbNamedPipe pipe) throws IOException {
        super(pipe, false, pipe.pipeType & 0xFFFF00FF | SmbFile.O_EXCL);
        this.pipe = pipe;
        this.dcePipe = (pipe.pipeType & SmbNamedPipe.PIPE_TYPE_DCE_TRANSACT) == SmbNamedPipe.PIPE_TYPE_DCE_TRANSACT;

 * named pipe without actually removing the data from the pipe.
 */
public class TransPeekNamedPipeResponse extends SmbComTransactionResponse {

    /**
     * Named pipe status indicating the pipe is disconnected.
     */
    public static final int STATUS_DISCONNECTED = 1;

    /**
     * Named pipe status indicating the pipe is listening for connections.
     */

    }

    @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

        // Test with various pipe names
        String[] pipeNames = { "\\\\pipe\\test", "\\\\pipe\\PIPE\\sql\\query", "\\\\pipe\\spoolss", "\\\\pipe\\winreg" };

        for (String pipeName : pipeNames) {
            TransWaitNamedPipe pipe = new TransWaitNamedPipe(pipeName);
            assertEquals(pipeName, pipe.name, "Pipe name should be preserved: " + pipeName);
            assertEquals(ServerMessageBlock.SMB_COM_TRANSACTION, pipe.command);

    source2!!.close()
    assertThat(relay.isClosed).isTrue()
    assertFile(Relay.PREFIX_DIRTY, -1L, -1, null, null)
  }

  @Test
  fun racingReaders() {
    val pipe = Pipe(1024)
    val sink = pipe.sink.buffer()
    val relay = edit(file, pipe.source, metadata, 5)
    val future1 = executor.submit(sourceReader(relay.newSource()))
    val future2 = executor.submit(sourceReader(relay.newSource()))
    Thread.sleep(500)