@Test
    @DisplayName("writeWireFormat should handle large lengths correctly")
    void testWriteWireFormatLargeLength() {
        packet.type = SessionServicePacket.SESSION_MESSAGE;
        packet.trailerLength = 0x10000; // Length requiring extended bit

        byte[] dst = new byte[100];
        packet.writeWireFormat(dst, 0);

        assertEquals((byte) 0x01, dst[1]); // Extended length bit should be set
    }

      table.map(-1, Buffer())
    }
    table.map(0, Buffer()) // Lowest legal code point.
    table.map(0x10ffff, Buffer()) // Highest legal code point.
    assertFailsWith<IllegalArgumentException> {
      table.map(0x110000, Buffer())
    }
  }

  @Test fun binarySearchEvenSizedRange() {
    val table = listOf(1, 3, 5, 7, 9, 11)

    // Search for matches.

        byte[] maxData = new byte[0xFFFF];
        Arrays.fill(maxData, (byte) 0x55);
        transCallNamedPipe = new TransCallNamedPipe(mockConfig, TEST_PIPE_NAME, maxData, 0, maxData.length);
        byte[] dst = new byte[0x10000];

        // When
        int bytesWritten = transCallNamedPipe.writeDataWireFormat(dst, 0);

        // Then
        assertEquals(maxData.length, bytesWritten);
    }

    @Test

            val low = (if (i + 1 < limit) this[i + 1] else '\u0000')
            if (c.isLowSurrogate() || !low.isLowSurrogate()) {
              '?'.code
            } else {
              i++
              0x010000 + (c.code and 0x03ff shl 10 or (low.code and 0x03ff))
            }
          }

          else -> c.code
        }
      i++
    }
    return result
  }

    int WRITE_OWNER = 0x00080000; // 19
    /**
     * Permission to synchronize.
     */
    int SYNCHRONIZE = 0x00100000; // 20
    /**
     * All generic permissions.
     */
    int GENERIC_ALL = 0x10000000; // 28
    /**
     * Generic execute permission.
     */
    int GENERIC_EXECUTE = 0x20000000; // 29
    /**
     * Generic write permission.
     */
    int GENERIC_WRITE = 0x40000000; // 30

    /** Write owner access right */
    int WRITE_OWNER = 0x00080000; // 19
    /** Synchronize access right */
    int SYNCHRONIZE = 0x00100000; // 20
    /** Generic all access right */
    int GENERIC_ALL = 0x10000000; // 28
    /** Generic execute access right */
    int GENERIC_EXECUTE = 0x20000000; // 29
    /** Generic write access right */
    int GENERIC_WRITE = 0x40000000; // 30
    /** Generic read access right */

            0x00010000, // DELETE
            0x00020000, // READ_CONTROL
            0x00040000, // WRITE_DAC
            0x00080000, // WRITE_OWNER
            0x00100000, // SYNCHRONIZE
            0x10000000, // GENERIC_ALL
            0x20000000, // GENERIC_EXECUTE
            0x40000000, // GENERIC_WRITE
            0x80000000 // GENERIC_READ (as int will be negative)
    })

    assertThat(frame.exhausted()).isTrue()
  }

  @Test fun tooLargeDataFrame() {
    assertFailsWith<IllegalArgumentException> {
      sendDataFrame(Buffer().write(ByteArray(0x1000000)))
    }.also { expected ->
      assertThat(expected.message).isEqualTo("FRAME_SIZE_ERROR length > 16384: 16777216")
    }
  }

  @Test fun windowUpdateRoundTrip() {

    }

    @Test
    @DisplayName("Test buffer configuration getters")
    void testBufferConfigurationGetters() {
        assertEquals(0xFFFF - 512, config.getTransactionBufferSize());
        assertEquals(0x10000, config.getMaximumBufferSize());
        assertEquals(16, config.getBufferCacheSize());
        assertEquals(200, config.getListCount());
        assertEquals(65435, config.getListSize());

     */
    public static final int SMB2_FLAGS_PRIORITY_MASK = 0x00000070;
    /**
     * Flag indicating the operation is a DFS operation.
     */
    public static final int SMB2_FLAGS_DFS_OPERATIONS = 0x10000000;
    /**
     * Flag indicating this is a replay operation.
     */
    public static final int SMB2_FLAGS_REPLAY_OPERATION = 0x20000000;

    private int command;
    private int flags;