return buffer;
        }
    }

    @Nested
    @DisplayName("Edge Case Tests")
    class EdgeCaseTests {

        @Test
        @DisplayName("Should handle maximum values")
        void testMaximumValues() throws SMBProtocolDecodingException {
            byte[] buffer = createValidCopyChunkResponse(Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE);

        assertEquals(" ", testTransformer.getName());

        // Single Unicode character
        testTransformer.setName("あ");
        assertEquals("あ", testTransformer.getName());

        // Maximum practical length (avoid OutOfMemoryError)
        StringBuilder maxName = new StringBuilder();
        for (int i = 0; i < 1000; i++) {
            maxName.append("0123456789");
        }

        // Bit 0 of byte 1 is MSB, followed by bytes 2 and 3
        assertEquals(0x012345, length);
    }

    @Test
    @DisplayName("readLength should handle maximum length")
    void testReadLengthMaximum() {
        byte[] src = { (byte) 0x00, (byte) 0x01, (byte) 0xFF, (byte) 0xFF };
        int length = SessionServicePacket.readLength(src, 0);

     * Sets the close timeout for web socket connections. A value of 0 means no timeout, otherwise
     * values must be between 1 and [Integer.MAX_VALUE] when converted to milliseconds.
     *
     * The close timeout is the maximum amount of time after the client calls [WebSocket.close] to
     * wait for a graceful shutdown. If the server doesn't respond the web socket will be canceled.
     * The default value is 60 seconds.
     */

      if (left == null) {
        return right;
      } else if (right == null) {
        return left;
      } else if (left.height >= right.height) {
        AvlNode<E> newTop = pred();
        // newTop is the maximum node in my left subtree
        newTop.left = left.removeMax(newTop);
        newTop.right = right;
        newTop.distinctElements = distinctElements - 1;
        newTop.totalCount = totalCount - oldElemCount;

            }
        }
    }

    @Nested
    @DisplayName("Edge Cases and Error Handling")
    class EdgeCasesTest {

        @Test
        @DisplayName("Should handle maximum size arrays")
        void testMaximumSizeArrays() throws SMBProtocolDecodingException {
            // Arrange
            int[] largeHashAlgos = new int[100];

   * chosen. Guarded by this.
   */
  internal var routeFailureCount = 0

  private var successCount = 0
  private var refusedStreamCount = 0

  /**
   * The maximum number of concurrent streams that can be carried by this connection. If
   * `allocations.size() < allocationLimit` then new streams can be created on this connection.
   */
  internal var allocationLimit = 1
    private set

     * Optimized for better performance with larger read sizes and reduced round trips.
     *
     * @param b the buffer to read into
     * @param off the offset in the buffer to start writing
     * @param len the maximum number of bytes to read
     * @return number of bytes read
     *
     * @throws IOException
     *             if a network error occurs
     */

import org.mockito.junit.jupiter.MockitoExtension;

import jcifs.CIFSContext;
import jcifs.CIFSException;
import jcifs.SidResolver;
import jcifs.dcerpc.rpc;

class SIDTest {

    // Helper to build a minimal sid_t
    private static rpc.sid_t buildSidT(byte revision, byte[] identAuth, int... subs) {
        rpc.sid_t s = new rpc.sid_t();
        s.revision = revision;
        s.sub_authority_count = (byte) subs.length;

  private const val PREFIX_6_BITS = 0x3f
  private const val PREFIX_7_BITS = 0x7f

  private const val SETTINGS_HEADER_TABLE_SIZE = 4_096

  /**
   * The decoder has ultimate control of the maximum size of the dynamic table but we can choose
   * to use less. We'll put a cap at 16K. This is arbitrary but should be enough for most purposes.
   */
  private const val SETTINGS_HEADER_TABLE_SIZE_LIMIT = 16_384