long changeTime = creationTime + 3000000L;
            SMBUtil.writeInt8(changeTime, buffer, bufferIndex + 32);
            // Allocation Size (8 bytes)
            SMBUtil.writeInt8(4096, buffer, bufferIndex + 40);
            // End of File (8 bytes)
            SMBUtil.writeInt8(1024, buffer, bufferIndex + 48);
            // File Attributes (4 bytes)

public final class NGramSynonymTokenizer extends Tokenizer {

    public static final int DEFAULT_N_SIZE = 2;

    public static final String DEFAULT_DELIMITERS = " 　\t\n\r";

    static final int BUFFER_SIZE = 4096;

    private final int n;

    private final String delimiters;

    private final boolean expand;

    private final boolean ignoreCase;

    private final SynonymLoader synonymLoader;

   *  * A stale connection. The request was made on a reused connection and that reused connection
   *    has since been closed by the server.
   *  * A client timeout (HTTP 408).
   *  * A authorization challenge (HTTP 401 and 407) that is satisfied by the [Authenticator].
   *  * A retryable server failure (HTTP 503 with a `Retry-After: 0` response header).
   *  * A misdirected request (HTTP 421) on a coalesced connection.
   */

        byte[] buffer = new byte[22];
        int idFileSystem = 0xABCDEF00;
        int sectPerAlloc = 4;
        long alloc = 500000L;
        long free = 250000L;
        int bytesPerSect = 4096;

        // Encode test data
        int offset = 0;
        SMBUtil.writeInt4(idFileSystem, buffer, offset);
        offset += 4;
        SMBUtil.writeInt4(sectPerAlloc, buffer, offset);
        offset += 4;

 */
public abstract class ReaderUtil {

    /**
     * Do not instantiate.
     */
    protected ReaderUtil() {
    }

    /** Default buffer size */
    private static final int BUF_SIZE = 4096;

    /**
     * Creates a {@link Reader} to read from a file with the specified encoding.
     *
     * @param is
     *            the input stream (must not be {@literal null})
     * @param encoding

    private static final int FILE_NOTIFY_CHANGE_ALL = 0x00000FFF;

    @BeforeEach
    void setUp() {
        MockitoAnnotations.openMocks(this);
        when(mockConfig.getNotifyBufferSize()).thenReturn(4096);
        when(mockConfig.getTransactionBufferSize()).thenReturn(65535);
    }

    @Test
    @DisplayName("Test constructor initialization with basic parameters")
    void testConstructorBasic() {

     *
     * @return the content as a string.
     * @throws CurlException if an error occurs while accessing the content.
     */
    public String getContentAsString() {
        final byte[] bytes = new byte[4096];
        try (BufferedInputStream bis = new BufferedInputStream(getContentAsStream());
                ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
            int length = bis.read(bytes);

class Http2Reader(
  /** Creates a frame reader with max header table size of 4096. */
  private val source: BufferedSource,
  private val client: Boolean,
) : Closeable {
  private val continuation: ContinuationSource = ContinuationSource(this.source)
  private val hpackReader: Hpack.Reader =
    Hpack.Reader(
      source = continuation,
      headerTableSizeSetting = 4096,
    )

  @Throws(IOException::class)

            int chunkStart = startIndex + HEADER_SIZE;
            assertEquals(1024L, SMBUtil.readInt8(buffer, chunkStart));
            assertEquals(2048L, SMBUtil.readInt8(buffer, chunkStart + 8));
            assertEquals(4096, SMBUtil.readInt4(buffer, chunkStart + 16));
        }

        @Test
        @DisplayName("Should encode multiple chunks correctly")
        void testEncodeMultipleChunks() {
            // Given

  private static void copy(URL url, File file) throws IOException {
    InputStream in = url.openStream();
    try {
      OutputStream out = new FileOutputStream(file);
      try {
        byte[] buf = new byte[4096];
        for (int read = in.read(buf); read != -1; read = in.read(buf)) {
          out.write(buf, 0, read);
        }
      } finally {
        out.close();
      }
    } finally {
      in.close();