// The number of bytes in the input.
    private long b = 0;

    // The final 64-bit chunk includes the last 0 through 7 bytes of m followed by null bytes
    // and ending with a byte encoding the positive integer b mod 256.
    private long finalM = 0;

    SipHasher(int c, int d, long k0, long k1) {
      super(CHUNK_SIZE);
      this.c = c;
      this.d = d;
      this.v0 ^= k0;
      this.v1 ^= k1;
      this.v2 ^= k0;

@DisplayName("CIFSUnsupportedCryptoException Tests")
class CIFSUnsupportedCryptoExceptionTest extends BaseTest {

    private static final String CRYPTO_ERROR_MESSAGE = "Unsupported cryptographic algorithm: AES-256-GCM";
    private static final String ALGORITHM_NAME = "AES-256-GCM";

    @Test
    @DisplayName("Default constructor should create exception with null message and cause")
    void testDefaultConstructor() {
        // Given & When

    /**
     * Kerberos checksum type for HMAC-SHA1-96 with AES-128.
     */
    public static final int HMAC_SHA1_96_AES128 = 0x0000000F;
    /**
     * Kerberos checksum type for HMAC-SHA1-96 with AES-256.
     */
    public static final int HMAC_SHA1_96_AES256 = 0x00000010;

    /**
     * Kerberos encryption type for ARCFOUR-HMAC (RC4-HMAC).
     */
    public static final int ETYPE_ARCFOUR_HMAC = 23;
    /**

        setDataCountMethod.setAccessible(true);
        setDataCountMethod.invoke(response, 256);

        int responseLength = response.getResponseLength();
        assertEquals(256, responseLength);
    }

    @Test
    void testGetResponseLengthZero() {
        // Test getResponseLength when dataCount is zero (default)

    }

    @Test
    @DisplayName("Test context encoding")
    public void testEncoding() {
        byte[] buffer = new byte[256];
        int encodedSize = context.encode(buffer, 0);

        assertTrue(encodedSize > 8); // Minimum size: count + padding + flags + algorithms
        assertEquals(context.size(), encodedSize);
    }

    @Test

    }

    @Test
    void testReadLength_LongForm() throws IOException {
        // Definite-length long form (length 256)
        InputStream s = new ByteArrayInputStream(new byte[] { (byte) 0x82, 0x01, 0x00 });
        int length = ASN1Util.readLength(s, 500, false);
        assertEquals(256, length);
    }

    @Test
    void testReadLength_Indefinite() throws IOException {
        // Indefinite-length

        // Test with buffer and length larger than needed
        byte[] buffer = new byte[100];

        // Fill test pattern
        for (int i = 0; i < buffer.length; i++) {
            buffer[i] = (byte) (i % 256);
        }

        int bytesConsumed = response.decode(buffer, 0, 50);

        assertEquals(28, bytesConsumed, "Should consume exactly 28 bytes regardless of extra length");

            // Test various boundary values
            assertEquals(0, new NdrShort(0).value);
            assertEquals(255, new NdrShort(255).value);
            assertEquals(0, new NdrShort(256).value); // 256 & 0xFF = 0
            assertEquals(255, new NdrShort(-1).value); // -1 & 0xFF = 255
            assertEquals(128, new NdrShort(-128).value); // -128 & 0xFF = 128
        }

        @Test

     */
    protected byte[] createTestData(int size) {
        byte[] data = new byte[size];
        for (int i = 0; i < size; i++) {
            data[i] = (byte) (i % 256);
        }
        return data;
    }

    /**
     * Create a test string with specified length
     */
    protected String createTestString(int length) {
        StringBuilder sb = new StringBuilder(length);

 */
package okhttp3.internal.http1

import okhttp3.Headers
import okio.BufferedSource

/**
 * Parse all headers delimited by "\r\n" until an empty line. This throws if headers exceed 256 KiB.
 */
class HeadersReader(
  val source: BufferedSource,
) {
  private var headerLimit = HEADER_LIMIT.toLong()

  /** Read a single line counted against the header size limit. */
  fun readLine(): String {