// + potential 1 byte alignment (in writeString) + fileName.length() * 2 + 2 bytes (terminating nulls)
        // Since headerStart is 0 and dstIndex starts at 1 (after initial null), (1-0)%2=1, so alignment byte added
        // Total: 1 + 1 + 12*2 + 2 = 28 bytes
        byte[] dst = new byte[30]; // Use extra buffer space to avoid index errors

        // Verify structure according to SMB2 CLOSE specification
        // Structure Size (2 bytes) - should be 24
        assertEquals(24, SMBUtil.readInt2(buffer, 0));

        // Flags (2 bytes) - should be 0 by default
        assertEquals(0, SMBUtil.readInt2(buffer, 2));

        // Reserved (4 bytes) - The implementation skips writing these bytes,
        // so they will have the initial pattern (0xCCCCCCCC)

   *     {@link ByteOrder#LITTLE_ENDIAN}, to which a BYTES-long byte representation of this instance
   *     is written. In the process increases the position of {@link ByteBuffer} by BYTES.
   */
  void writeTo(ByteBuffer buffer) {
    checkNotNull(buffer);
    checkArgument(
        buffer.remaining() >= BYTES,

 * limitations under the License.
 */
package okhttp3.internal.http2.flowcontrol

class WindowCounter(
  val streamId: Int,
) {
  /** The total number of bytes consumed. */
  var total: Long = 0L
    private set

  /** The total number of bytes acknowledged by outgoing `WINDOW_UPDATE` frames. */
  var acknowledged: Long = 0L
    private set

  val unacknowledged: Long
    @Synchronized get() = total - acknowledged

package jstream

import (
	"bufio"
	"bytes"
	"fmt"
	"io"
	"sync/atomic"
	"testing"
)

var (
	smallInput  = make([]byte, 1024*12)       // 12K
	mediumInput = make([]byte, 1024*1024*12)  // 12MB
	largeInput  = make([]byte, 1024*1024*128) // 128MB
)

func TestScanner(t *testing.T) {
	t.Skip("Unstable test")
	data := []byte("abcdefghijklmnopqrstuvwxyz0123456789")

	var i int
	r := bytes.NewReader(data)

        // Encode input parameters for WitnessAsyncNotify

        // Context handle (20 bytes)
        if (contextHandle != null) {
            buf.writeOctetArray(contextHandle, 0, Math.min(contextHandle.length, 20));
            // Pad with zeros if context handle is shorter than 20 bytes
            for (int i = contextHandle.length; i < 20; i++) {
                buf.enc_ndr_small(0);
            }

    void testInvalidMessageBytes() {
        // Given
        byte[] invalidBytes = { 1, 2, 3, 4, 5 }; // Too short and invalid

        // When/Then
        assertThrows(IOException.class, () -> {
            new Type3Message(invalidBytes);
        });
    }

    @Test
    @DisplayName("Should handle parsing null message bytes")
    void testNullMessageBytes() {

    }

    /**
     * Creates an {@link java.io.OutputStream} for writing bytes to a file
     * on an SMB server addressed by the <code>SmbFile</code> parameter. See
     * {@link jcifs.smb.SmbFile} for a detailed description and examples of
     * the smb URL syntax. If the second argument is <code>true</code>, then
     * bytes will be written to the end of the file rather than the beginning.
     *
     * @param file

            // Verify that inputBuffer.encode was called
            verify(mockInputBuffer).encode(any(byte[].class), anyInt());

            // Verify total bytes written
            assertEquals(90, bytesWritten); // 40 bytes header + 50 bytes input buffer
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    @ParameterizedTest

 * Contains flag values used in NTLM authentication attribute-value pairs.
 *
 * @author mbechler
 */
public class AvFlags extends AvPair {

    /**
     * Constructs an AV flags pair from raw bytes
     * @param raw the raw flag bytes
     */
    public AvFlags(final byte[] raw) {
        super(AvPair.MsvAvFlags, raw);
    }

    /**
     * Constructs an AV flags pair from integer flags