Consider an application streaming a video over http/2. Perhaps the user pauses the video and the application stops reading bytes from this stream. The buffer will fill up, and flow control prevents the server from sending more data on this stream. When the user unpauses her video the buffer drains, the read is acknowledged, and the server proceeds to stream data.

            // Assert: message is meaningful
            assertEquals("Structure size is not 4", ex.getMessage());
        }

        @Test
        @DisplayName("Null buffer leads to NullPointerException from readInt2")
        void nullBuffer_throwsNPE() {
            // Arrange
            Smb2LogoffResponse resp = newResponse();

            // Act & Assert

import jcifs.internal.smb2.ioctl.Smb2IoctlRequest;
import jcifs.internal.smb2.ioctl.Smb2IoctlResponse;
import jcifs.internal.smb2.ioctl.SrvPipePeekResponse;

/**
 * Input stream for reading from SMB named pipes.
 *
 * This class provides a stream-based interface for reading
 * data from SMB named pipes over the network.
 *
 * @author mbechler
 */
public class SmbPipeInputStream extends SmbFileInputStream {

            "type" : "keyword"
          },
          "createdTime" : {
            "type" : "long"
          },
          "permissions" : {
            "type" : "keyword"
          },
          "reading" : {
            "type" : "keyword"
          },
          "suggestWord" : {
            "type" : "keyword"
          },
          "updatedBy" : {
            "type" : "keyword"
          },

        assertEquals(4, written, "Should report 4 bytes written");
        // StructureSize (2 bytes, LE) == 4
        assertEquals(4, SMBUtil.readInt2(buf, offset));
        // Reserved (2 bytes, LE) == 0
        assertEquals(0, SMBUtil.readInt2(buf, offset + 2));
    }

    @Test
    @DisplayName("writeBytesWireFormat throws when buffer too small")
    void writeBytesWireFormat_throwsIfInsufficientSpace() {

    }

    @Test
    @DisplayName("Reading with zero-length array returns 0")
    void readZeroLengthArrayReturnsZero() throws IOException {
        // Create stream with a message containing data
        byte[] data = new byte[] { 1, 2 };
        InputStream in = new ByteArrayInputStream(concat(messageHeader(2), data));
        SocketInputStream sis = new SocketInputStream(in);

                String token = null;
                String segmentation = null;
                String reading = null;
                String pos = null;
                switch (values.length) {
                case 4:
                    pos = values[3];
                case 3:
                    reading = values[2];
                case 2:
                    segmentation = values[1];
                case 1:

        this.nextEntryOffset = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        if (this.nextEntryOffset % 4 != 0) {
            throw new SMBProtocolDecodingException("Non aligned nextEntryOffset");
        }

        this.action = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        this.fileNameLength = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

 */
public class InputStreamThread extends Thread {
    /** Logger instance for this class */
    private static final Logger logger = LogManager.getLogger(InputStreamThread.class);

    /** Buffered reader for reading from the input stream */
    private final BufferedReader br;

    /** Maximum buffer size constant */
    public static final int MAX_BUFFER_SIZE = 1000;

    /** List storing recent lines from the input stream */

     * Creates an {@link java.io.InputStream} for reading bytes from a file on
     * an SMB server addressed by the <code>url</code> parameter. See {@link
     * jcifs.smb1.smb1.SmbFile} for a detailed description and examples of the smb
     * URL syntax.
     *
     * @param url An smb URL string representing the file to read from
     */

    /**
     * Creates an input stream for reading from the specified SMB URL
     *