import jcifs.Configuration;
import jcifs.internal.util.SMBUtil;

/**
 * SMB1 transaction subcommand for peeking at data in a named pipe.
 *
 * This class implements the TRANS_PEEK_NAMED_PIPE transaction which allows
 * reading data from a pipe without removing it, useful for checking if data
 * is available before performing a blocking read.
 */
public class TransPeekNamedPipe extends SmbComTransaction {

    private final int fid;

    /**

import java.io.IOException;
import java.io.Reader;
import java.nio.CharBuffer;
import java.util.ArrayDeque;
import java.util.Queue;
import org.jspecify.annotations.Nullable;

/**
 * A class for reading lines of text. Provides the same functionality as {@link
 * java.io.BufferedReader#readLine()} but for all {@link Readable} objects, not just instances of
 * {@link Reader}.
 *
 * @author Chris Nokleberg
 * @since 1.0
 */

        IOException exception = assertThrows(IOException.class, () -> {
            SessionServicePacket.readPacketType(bais, buffer, 0);
        });

        assertEquals("unexpected EOF reading netbios session header", exception.getMessage());
    }

    @Test
    @DisplayName("readPacketType should throw IOException on incomplete header")
    void testReadPacketTypeIncompleteHeader() {

//
// Subsequently this allows golang http RoundTripper
// to reuse the same connection for future requests.
func DrainBody(respBody io.ReadCloser) {
	// Callers should close resp.Body when done reading from it.
	// If resp.Body is not closed, the Client's underlying RoundTripper
	// (typically Transport) may not be able to reuse a persistent TCP
	// connection to the server for a subsequent "keep-alive" request.

	readerIndex := 0
	var wg sync.WaitGroup
	// if readTrigger is true, it implies next disk.ReadAt() should be tried
	// if readTrigger is false, it implies previous disk.ReadAt() was successful and there is no need
	// to try reading the next disk.
	for readTrigger := range readTriggerCh {
		newBufLK.RLock()
		canDecode := p.canDecode(newBuf)
		newBufLK.RUnlock()
		if canDecode {
			break
		}
		if readerIndex == len(p.readers) {

    }

    public void test_isUrlChar_extendedAscii() {
        // Test extended ASCII characters (not valid URL chars without encoding)
        assertFalse(CharUtil.isUrlChar('\u00A0')); // non-breaking space
        assertFalse(CharUtil.isUrlChar('\u00FF')); // ÿ
    }

    public void test_isUrlChar_unicode() {
        // Test Unicode characters (not valid URL chars without encoding)

		if f, err := os.Open(sessionPolicyFile); err != nil {
			log.Fatalf("Unable to open session policy file: %v", err)
		} else {
			defer f.Close()
			bs, err := io.ReadAll(f)
			if err != nil {
				log.Fatalf("Error reading session policy file: %v", err)
			}
			policy = string(bs)
		}
		stsOpts.Policy = policy
	}
	if expiryDuration != 0 {
		stsOpts.DurationSeconds = int(expiryDuration.Seconds())
	}

import com.google.common.cache.TestingCacheLoaders.IncrementingLoader;
import com.google.common.testing.FakeTicker;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

/**
 * Tests relating to automatic cache refreshing.
 *
 * @author Charles Fry
 */
@NullUnmarked
public class CacheRefreshTest extends TestCase {
  public void testAutoRefresh() {
    FakeTicker ticker = new FakeTicker();

# Blocking vs Non-blocking

The default behavior of the ring buffer is non-blocking, 
meaning that reads and writes will return immediately with an error if the operation cannot be completed.
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).

import jcifs.Configuration;

/**
 * SMB1 transaction subcommand for calling a named pipe.
 *
 * This class implements the TRANS_CALL_NAMED_PIPE transaction which allows
 * writing data to and reading data from a named pipe in a single operation.
 */
public class TransCallNamedPipe extends SmbComTransaction {

    private static final Logger log = LoggerFactory.getLogger(TransCallNamedPipe.class);