}

    @Test
    @DisplayName("Should handle parsing invalid message bytes")
    void testInvalidMessageBytes() {
        // Given
        byte[] invalidBytes = { 1, 2, 3, 4, 5 }; // Too short and invalid

        // When/Then
        assertThrows(IOException.class, () -> {
            new Type1Message(invalidBytes);
        });
    }

    @Test

        }

        @Test
        void shouldReturnInetAddressHostAddressWhenWrappedIsInetAddress() {
            when(mockInetAddress.getHostAddress()).thenReturn("1.2.3.4");
            UniAddress uniAddress = new UniAddress(mockInetAddress);
            assertEquals("1.2.3.4", uniAddress.getHostAddress());
        }

        @Test
        void shouldReturnNbtAddressHostAddressWhenWrappedIsNbtAddress() {

            b[off + 1] = 0x34;
            return 2;
        }).when(raf).read(any(byte[].class), anyInt(), eq(2));
        assertEquals(0x1234, raf.readUnsignedShort());
        assertEquals((short) 0x1234, raf.readShort());
        assertEquals((char) 0x1234, raf.readChar());
    }

    @Test
    @DisplayName("readInt/Long/Float/Double: big-endian decoding")
    void read_multiByteVariants() throws Exception {

                    example: 20
                  page_numbers:
                    type: array
                    items:
                      type: string
                    example: ["1", "2", "3", "4", "5"]
                  partial:
                    type: boolean
                    example: false
                  search_query:
                    type: string
                    example: "(Fess OR n2sm)"

        @DisplayName("Should maintain data integrity through encode/decode cycle")
        void testEncodeDecodeCycle() throws SMBProtocolDecodingException {
            // Arrange
            int[] hashAlgos = new int[] { 1, 2, 3, 4, 5 };
            byte[] salt = "TestSaltValue123".getBytes();
            PreauthIntegrityNegotiateContext originalContext = new PreauthIntegrityNegotiateContext(mockConfig, hashAlgos, salt);

            // Act

        Name sourceName = new Name(mockConfig, "SourceName", 0x1C, "source.scope");
        sourceName.srcHashCode = 12345;

        Name name = new Name(mockConfig, sourceName);

        assertEquals("SOURCENAME", name.name);
        assertEquals(0x1C, name.hexCode);
        assertEquals("source.scope", name.scope);
        assertEquals(12345, name.srcHashCode);
    }

    @Test
    void getName_shouldReturnName() {

        void testConstructorAndOpnum() {
            // When: Creating open alias message
            samr.SamrOpenAlias message = new samr.SamrOpenAlias(mockPolicyHandle, 123, 456, mockPolicyHandle);

            // Then: Should have correct values
            assertEquals(0x1b, message.getOpnum());
            assertEquals(mockPolicyHandle, message.domain_handle);

        ndrBuffer.enc_ndr_short(0x1234);
        assertEquals(4, ndrBuffer.getIndex()); // Aligned from 1 to 2, then advanced by 2
        assertEquals(4, ndrBuffer.getLength());
        assertEquals((byte) 0x34, buffer[2]);
        assertEquals((byte) 0x12, buffer[3]);

        ndrBuffer.setIndex(2);
        val = ndrBuffer.dec_ndr_short();
        assertEquals(0x1234, val);
        assertEquals(4, ndrBuffer.getIndex());

        @DisplayName("Should return tree ID")
        void testGetTid() {
            // Given
            when(mockResponse.getTid()).thenReturn(12345);

            // When
            int tid = mockResponse.getTid();

            // Then
            assertEquals(12345, tid, "Should return the configured tree ID");
            verify(mockResponse).getTid();
        }

        @Test

        assertEquals(-1, mockResponse.getErrorCode());

        // Verify the method was called
        verify(mockResponse, times(1)).getErrorCode();
    }

    @Test
    void testSetMid() {
        long mid = 12345L;
        mockResponse.setMid(mid);

        // Verify that the method was called with the correct argument
        verify(mockResponse, times(1)).setMid(mid);
    }

    @Test
    void testGetMid() {