If you want to block when reading or writing, you must enable it:

```go
	rb := ringbuffer.New(1024).SetBlocking(true)
```

Enabling blocking will cause the ring buffer to behave like a buffered [io.Pipe](https://pkg.go.dev/io#Pipe).

Regular Reads will block until data is available, but not wait for a full buffer. 
Writes will block until there is space available and writes bigger than the buffer will wait for reads to make space.

    /**
     * Share type constant for disk shares (file shares).
     */
    public static final byte SMB2_SHARE_TYPE_DISK = 0x1;
    /**
     * Share type constant for named pipe shares (IPC).
     */
    public static final byte SMB2_SHARE_TYPE_PIPE = 0x2;
    /**
     * Share type constant for printer shares.
     */
    public static final byte SMB2_SHARE_TYPE_PRINT = 0x3;

    /**

        // Given
        String url = "smb://server/share/pipe";
        int pipeType = 1;
        SmbPipeResource mockPipe = mock(SmbPipeResource.class);
        when(mockContext.getPipe(url, pipeType)).thenReturn(mockPipe);

        // When
        SmbPipeResource pipe = mockContext.getPipe(url, pipeType);

        // Then
        assertEquals(mockPipe, pipe);
        verify(mockContext).getPipe(url, pipeType);
    }

     * or
     * proto:[key1=val1,key2=val2]
     *
     * If a key is absent it is assumed to be 'endpoint'. Thus the
     * following are equivalent:
     * proto:\\ts0.win.net[endpoint=\pipe\srvsvc]
     * proto:ts0.win.net[\pipe\srvsvc]
     *
     * If the server is absent it is set to "127.0.0.1"
     */
    /**
     * Parses a DCERPC binding string into a DcerpcBinding object
     * @param str the binding string to parse

    /**
     * Configuration class that holds parsed configuration values for a field.
     * This class parses pipe-separated configuration values and provides methods
     * to check for specific configuration options.
     */
    public static class Config {

        /**
         * Array of parsed configuration values split by pipe character and trimmed.
         */
        private final String[] values;

        /**

    @Mock
    SmbTreeHandleImpl tree;

    @Mock
    SmbNamedPipe pipe;

    @Mock
    SmbFileHandleImpl fileHandle;

    private SmbPipeOutputStream newStream() throws CIFSException {
        // Arrange common constructor collaborators to avoid touching network/state
        when(handle.getPipe()).thenReturn(pipe);
        when(tree.isSMB2()).thenReturn(true);

	// Race condition is because of io.PipeWriter implementation. i.e consider the following
	// sequent of operations:
	// 1) pipe.Write()
	// 2) pipe.Close()
	// Now pipe.Close() can return before the data is read on the other end of the pipe and written to the disk
	// Hence an immediate Read() on the file can return incorrect data.
	if b.canClose != nil {
		b.canClose.Wait()
	}

    }

    @Test
    void testGetPipe() throws CIFSException, MalformedURLException {
        // Test getPipe(String url, int pipeType) method
        String url = "smb://server/IPC$/pipeName"; // Corrected URL for named pipe
        int pipeType = 1;
        SmbPipeResource mockSmbPipeResource = mock(SmbNamedPipe.class);

        // Similar to testGetSmbResource, we cannot directly mock `new SmbNamedPipe()`.

	err = r.PipeReader.CloseWithError(err)
	r.wait()
	return err
}

// WaitPipe implements wait-group backend io.Pipe to provide
// synchronization between read() end with write() end.
func WaitPipe() (*PipeReader, *PipeWriter) {
	r, w := io.Pipe()
	var wg sync.WaitGroup
	wg.Add(1)
	return &PipeReader{
			PipeReader: r,
			wait:       wg.Wait,
		}, &PipeWriter{
			PipeWriter: w,

        assertEquals(SmbFile.TYPE_PRINTER, printerShare.getType());

        // Test for TYPE_NAMED_PIPE
        SmbShareInfo pipeShare = new SmbShareInfo("PIPE", 3, "A named pipe");
        assertEquals(SmbFile.TYPE_NAMED_PIPE, pipeShare.getType());

        // Test for TYPE_SHARE (disk share)
        SmbShareInfo diskShare = new SmbShareInfo("DISK", 0, "A disk share");