request.setWatchTree(false);  // Non-recursive for now
                    
                    Smb2ChangeNotifyResponse response = (Smb2ChangeNotifyResponse) 
                        handle.directoryFile.getTree().send(request);
                    
                    if (response.isSuccess()) {
                        processChangeNotification(handle, response);
                    }
                    

        }

        @Test
        @DisplayName("Should define getFree method")
        void shouldDefineGetFreeMethod() throws NoSuchMethodException {
            // Verify method exists with correct signature
            assertNotNull(AllocInfo.class.getMethod("getFree"));
            assertEquals(long.class, AllocInfo.class.getMethod("getFree").getReturnType());
        }

        @Test

            // Then
            long expectedFree = free * sectPerAlloc * bytesPerSect;
            assertEquals(expectedFree, fileFsSizeInfo.getFree());
            assertEquals(2097152L, fileFsSizeInfo.getFree()); // 512 * 8 * 512
        }

        @Test
        @DisplayName("Should handle overflow in capacity calculation")

            // Then
            long expectedFree = callerFree * sectPerAlloc * bytesPerSect;
            assertEquals(expectedFree, fileFsFullSizeInfo.getFree());
            assertEquals(2097152L, fileFsFullSizeInfo.getFree()); // 512 * 8 * 512
        }

        @Test
        @DisplayName("Should handle overflow in capacity calculation")

        // Verify - all zeros should result in 0 capacity and free
        assertEquals(0L, smbInfoAllocation.getCapacity());
        assertEquals(0L, smbInfoAllocation.getFree());
    }

    @Test
    @DisplayName("Test getFree with maximum values")
    void testGetFreeWithMaximumValues() throws SMBProtocolDecodingException {
        // Prepare test data with maximum int values
        byte[] buffer = new byte[22];

        when(mockAllocInfo.getFree()).thenReturn(400L);

        assertEquals(1000L, mockAllocInfo.getCapacity(), "capacity should match stubbed value");
        assertEquals(400L, mockAllocInfo.getFree(), "free space should match stubbed value");
        verify(mockAllocInfo, times(1)).getCapacity();
        verify(mockAllocInfo, times(1)).getFree();
    }

    /**

        SmbInfoAllocation info = (SmbInfoAllocation) response.getInfo();
        assertEquals(8L * 1000000L * 512L, info.getCapacity());
        assertEquals(8L * 500000L * 512L, info.getFree());
    }

    @Test
    void testReadDataWireFormat_FileFsSizeInformation() throws Exception {
        // Test reading FS_SIZE_INFO data

        assertEquals(512, info.bytesPerSect);
        assertEquals(1000L * 100 * 512, info.getCapacity(), "Capacity calculation should be correct");
        assertEquals(500L * 100 * 512, info.getFree(), "Free space calculation should be correct");
    }

    /**
     * Tests the readDataWireFormat method with the SMB_QUERY_FS_SIZE_INFO information level.
     */
    @Test

            assertEquals(20, bytesDecoded);
            assertEquals(8L * 4096L * 512L, smbInfoAllocation.getCapacity());
            assertEquals(8L * 2048L * 512L, smbInfoAllocation.getFree());
        }

        @Test
        @DisplayName("Should calculate capacity correctly")
        void testCapacityCalculation() throws SMBProtocolDecodingException {
            byte[] buffer = new byte[24];

        when(shared.acquire(false)).thenReturn(shared);

        setTree(c1, shared);
        setTree(c2, shared);
        assertTrue(c1.isSame(c2));

        SmbTreeImpl other = mock(SmbTreeImpl.class);
        when(other.acquire(false)).thenReturn(other);
        setTree(c2, other);
        assertFalse(c1.isSame(c2));
    }

    @Test