* @param pointer the pointer/offset to the string data
     */
    public PacUnicodeString(final short length, final short maxLength, final int pointer) {
        this.length = length;
        this.maxLength = maxLength;
        this.pointer = pointer;
    }

    /**
     * Gets the actual length of the string in bytes.
     *
     * @return the string length
     */
    public short getLength() {

      TYPE_RST_STREAM -> readRstStream(handler, length, flags, streamId)
      TYPE_SETTINGS -> readSettings(handler, length, flags, streamId)
      TYPE_PUSH_PROMISE -> readPushPromise(handler, length, flags, streamId)
      TYPE_PING -> readPing(handler, length, flags, streamId)
      TYPE_GOAWAY -> readGoAway(handler, length, flags, streamId)
      TYPE_WINDOW_UPDATE -> readWindowUpdate(handler, length, flags, streamId)

        }

        if (length < 0) {
            failedValidations.incrementAndGet();
            bufferOverflowsPrevented.incrementAndGet();
            throw new SmbException("Negative length: " + length);
        }

        // Check for integer overflow
        if (offset > buffer.length - length) {
            failedValidations.incrementAndGet();

        @DisplayName("Should handle various data lengths")
        void testVariousDataLengths(int length) throws SMBProtocolDecodingException {
            int result = testResponse.decode(testBuffer, 0, length);

            assertEquals(length, result);
            assertNotNull(testResponse.getData());
            assertEquals(length, testResponse.getData().length);
        }
    }

    @Nested

            int offset = 50;
            int length = 100;
            request.setData(fullData, offset, length);

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

            // Verify only the specified portion is written
            assertEquals(48 + length, bytesWritten);

    void testConstructorInitialization() {
        // Given
        int offset = 0;
        int length = TEST_DATA.length;

        // When
        transCallNamedPipe = new TransCallNamedPipe(mockConfig, TEST_PIPE_NAME, TEST_DATA, offset, length);

        // Then
        assertNotNull(transCallNamedPipe);

      val byteCount = hpackBuffer.size
      val length = minOf(maxFrameSize - 4L, byteCount).toInt()
      frameHeader(
        streamId = streamId,
        length = length + 4,
        type = TYPE_PUSH_PROMISE,
        flags = if (byteCount == length.toLong()) FLAG_END_HEADERS else 0,
      )
      sink.writeInt(promisedStreamId and 0x7fffffff)
      sink.write(hpackBuffer, length.toLong())

        System.arraycopy(testData, 0, buffer, 10, testData.length);

        int result = response.readDataWireFormat(buffer, 10, testData.length);

        assertEquals(testData.length, result);
        // Verify data was copied to outputBuffer
        byte[] expectedData = new byte[testData.length];
        System.arraycopy(outputBuffer, 0, expectedData, 0, testData.length);
        assertArrayEquals(testData, expectedData);
    }

   */
  static @Nullable Object[] copyAsObjectArray(@Nullable Object[] elements, int offset, int length) {
    checkPositionIndexes(offset, offset + length, elements.length);
    if (length == 0) {
      return new Object[0];
    }
    @Nullable Object[] result = new Object[length];
    arraycopy(elements, offset, result, 0, length);
    return result;
  }

  @CanIgnoreReturnValue

            throw new IllegalArgumentException("Offsets and length must be non-negative");
        }
        if (srcOffset + length > src.length) {
            throw new IllegalArgumentException(
                    "Source array bounds exceeded: offset=" + srcOffset + ", length=" + length + ", array.length=" + src.length);
        }
        if (dstOffset + length > dst.length) {