});
        }
    }

    @Nested
    @DisplayName("Size Tests")
    class SizeTests {

        @Test
        @DisplayName("Should return correct size")
        void testSize() {
            int expectedSize = Smb2Constants.SMB2_HEADER_LENGTH + 4;
            // size8 rounds up to 8-byte boundary
            int expectedAlignedSize = (expectedSize + 7) & ~7;

        assertFalse(context.isNotificationEnabled());

        context.setNotificationFilter(0xFF);
        assertEquals(0xFF, context.getNotificationFilter());
    }

    @Test
    public void testSize() {
        Smb2LeaseKey key = new Smb2LeaseKey();
        DirectoryLeaseContext context = new DirectoryLeaseContext(key, 0, DirectoryCacheScope.IMMEDIATE_CHILDREN);

        // Context header: 16 bytes

        // Then
        assertNotNull(response);
        assertTrue(response instanceof Smb2ChangeNotifyResponse);
    }

    @Test
    @DisplayName("Should calculate correct size")
    void testSize() {
        // When
        int size = request.size();

        // Then
        // Size should be aligned to 8 bytes: SMB2_HEADER_LENGTH + 32
        int expectedSize = Smb2Constants.SMB2_HEADER_LENGTH + 32;

    /**
     * @throws Exception
     */
    @After
    public void tearDown() throws Exception {
        map = null;
    }

    /**
     * @throws Exception
     */
    @Test
    public void testSize() throws Exception {
        assertThat(map.size(), equalTo(3));
        map.put("3", "test3");
        assertThat(map.size(), equalTo(4));
    }

    /**
     * @throws Exception
     */
    @Test

        assertEquals(0L, info.getSize());
    }

    @Test
    @DisplayName("Test size method returns correct buffer size")
    void testSize() {
        assertEquals(40, fileBasicInfo.size());
    }

    @Test
    @DisplayName("Test encode method")
    void testEncode() throws SMBProtocolDecodingException {
        // Create instance with test values

        assertTrue(response instanceof Smb2TreeDisconnectResponse);
        verify(mockContext, times(1)).getConfig();
    }

    @Test
    @DisplayName("Should calculate correct message size")
    void testSize() {
        // Given
        Configuration mockConfig = mock(Configuration.class);
        Smb2TreeDisconnectRequest request = new Smb2TreeDisconnectRequest(mockConfig);

        // When

        }
    }

    @Nested
    @DisplayName("Size Method Tests")
    class SizeTests {

        @Test
        @DisplayName("Should return correct size of 24 bytes")
        void testSize() {
            // Given
            SrvCopychunk chunk = new SrvCopychunk(0, 0, 0);

            // When
            int size = chunk.size();

            // Then
            assertEquals(EXPECTED_SIZE, size);

    ByteStreams.copy(in, out);
    in.close();
    out.close();

    assertTrue(source.wasStreamClosed());
    assertArrayEquals(bytes, out.toByteArray());
  }

  public void testSize() throws IOException {
    assertEquals(bytes.length, source.size());
    assertTrue(source.wasStreamOpened() && source.wasStreamClosed());

    // test that we can get the size even if skip() isn't supported

        assertEquals(mockConfig, responseConfig);
    }

    @Test
    @DisplayName("size should return correct message size")
    void testSize() {
        int expectedSize = Smb2Constants.SMB2_HEADER_LENGTH + 24;
        // size8 method rounds up to 8-byte boundary
        int expectedAlignedSize = (expectedSize + 7) & ~7;

        assertNotNull(response);
        verify(mockContext, times(1)).getConfig();
    }

    @Test
    @DisplayName("Test size method")
    void testSize() {
        request = new Smb2SetInfoRequest(mockConfig);
        Encodable mockInfo = mock(Encodable.class);
        when(mockInfo.size()).thenReturn(100);
        request.setInfo(mockInfo);