import java.io.IOException
import java.util.zip.Deflater
import okio.Buffer
import okio.ByteString
import okio.ByteString.Companion.decodeHex
import okio.DeflaterSink

private val EMPTY_DEFLATE_BLOCK = "000000ffff".decodeHex()
private const val LAST_OCTETS_COUNT_TO_REMOVE_AFTER_DEFLATION = 4

class MessageDeflater(
  private val noContextTakeover: Boolean,
) : Closeable {
  private val deflatedBytes = Buffer()

    }

    int writeHeaderWireFormat(final byte[] dst, int dstIndex) {
        dst[dstIndex] = (byte) type;
        dstIndex++;
        if (length > 0x0000FFFF) {
            dst[dstIndex] = (byte) 0x01;
        }
        dstIndex++;
        writeInt2(length, dst, dstIndex);
        return HEADER_LENGTH;
    }

    }

    int writeHeaderWireFormat(final byte[] dst, int dstIndex) {
        dst[dstIndex] = (byte) this.type;
        dstIndex++;
        if (this.length > 0x0000FFFF) {
            dst[dstIndex] = (byte) 0x01;
        }
        dstIndex++;
        writeInt2(this.length, dst, dstIndex);
        return HEADER_LENGTH;
    }

    void testFaultCodeValueRanges() {
        // Standard fault codes (0x00000000 - 0x0000FFFF range)
        assertTrue(DcerpcError.DCERPC_FAULT_OTHER >= 0 && DcerpcError.DCERPC_FAULT_OTHER <= 0x0000FFFF,
                "DCERPC_FAULT_OTHER should be in standard range");
        assertTrue(DcerpcError.DCERPC_FAULT_ACCESS_DENIED >= 0 && DcerpcError.DCERPC_FAULT_ACCESS_DENIED <= 0x0000FFFF,
                "DCERPC_FAULT_ACCESS_DENIED should be in standard range");

            // File access constants should fit in lower 16 bits (0x0000FFFF)
            assertTrue(ACE.FILE_READ_DATA <= 0x0000FFFF, "FILE_READ_DATA should fit in lower 16 bits");
            assertTrue(ACE.FILE_WRITE_DATA <= 0x0000FFFF, "FILE_WRITE_DATA should fit in lower 16 bits");
            assertTrue(ACE.FILE_WRITE_ATTRIBUTES <= 0x0000FFFF, "FILE_WRITE_ATTRIBUTES should fit in lower 16 bits");

package okhttp3.internal.ws

import java.io.Closeable
import java.io.IOException
import java.util.zip.Inflater
import okio.Buffer
import okio.InflaterSource

private const val OCTETS_TO_ADD_BEFORE_INFLATION = 0x0000ffff

class MessageInflater(
  private val noContextTakeover: Boolean,
) : Closeable {
  private val deflatedBytes = Buffer()

  private val inflater =
    Inflater(
      // nowrap (omits zlib header):

	ADD	$0x000fffff, R0, R1 // ADD $1048575, R0, R1    // 011680e2011041e2
	ADC	$0x000fffff, R0, R1 // ADC $1048575, R0, R1    // 0116a0e2011041e2
	SUB	$0x000fffff, R0, R1 // SUB $1048575, R0, R1    // 011640e2011081e2
	SBC	$0x000fffff, R0, R1 // SBC $1048575, R0, R1    // 0116c0e2011081e2
	RSB	$0x000fffff, R0, R1 // RSB $1048575, R0, R1    // 011660e2011041e2

    @Test
    @DisplayName("Should maintain correct wire format structure")
    void testWireFormatStructure() {
        // Given
        request.setNotifyFlags(0x0001);
        request.setCompletionFilter(0x00000FFF);

        // When
        byte[] buffer = new byte[512];
        int written = request.writeBytesWireFormat(buffer, 0);

        // Then
        assertEquals(32, written);

        leftt = inInts[0];
        right = inInts[1];

        work = (leftt >>> 4 ^ right) & 0x0f0f0f0f;
        right ^= work;
        leftt ^= work << 4;

        work = (leftt >>> 16 ^ right) & 0x0000ffff;
        right ^= work;
        leftt ^= work << 16;

        work = (right >>> 2 ^ leftt) & 0x33333333;
        leftt ^= work;
        right ^= work << 2;

        assertEquals("0000", Hexdump.toHexString(0, 4));
        assertEquals("00", Hexdump.toHexString(0, 2));

        // Test positive values
        assertEquals("000000FF", Hexdump.toHexString(255, 8));
        assertEquals("00FF", Hexdump.toHexString(255, 4));
        assertEquals("FF", Hexdump.toHexString(255, 2));

        // Test larger values