import jcifs.internal.util.SMBUtil;

/**
 * Represents the FILE_FS_SIZE_INFORMATION structure used to query file system size information.
 * This structure provides details about the total allocation units, free allocation units,
 * sectors per allocation unit, and bytes per sector for a file system volume.
 */
public class FileFsSizeInformation implements AllocInfo {

    private long alloc; // Also handles SmbQueryFSSizeInfo

/**
 * Represents the FILE_FS_FULL_SIZE_INFORMATION structure used to query comprehensive file system size information.
 * This structure provides complete allocation details including total allocation units, caller-available free units,
 * actual free allocation units, sectors per allocation unit, and bytes per sector.
 */
public class FileFsFullSizeInformation implements AllocInfo, FileSystemInformation, Decodable {

        // Simulate setting info using reflection
        SmbInfoAllocation allocation = new SmbInfoAllocation();
        setInfoField(response, allocation);

        SmbInfoAllocation result = response.getInfo(SmbInfoAllocation.class);
        assertNotNull(result);
        assertSame(allocation, result);
    }

    @Test
    void testGetInfoWithClass_Incompatible() throws Exception {

        }

        // Check total memory allocation
        long totalSize = (long) size * (long) elementSize;
        long maxAllocation = 100 * 1024 * 1024; // 100MB max

        if (totalSize > maxAllocation) {
            failedValidations.incrementAndGet();
            log.warn("Array allocation too large: {} bytes", totalSize);
            throw new SmbException("Array allocation exceeds limit");
        }
    }

import org.junit.jupiter.api.Test;

/**
 * Security-focused test cases for BufferCache to verify buffer overflow protection.
 */
public class BufferCacheSecurityTest {

    /**
     * Test that buffer allocation validates size to prevent overflow.
     */
    @Test
    public void testBufferSizeValidation() {
        // When - Get a buffer
        byte[] buffer = BufferCache.getBuffer();

 * This structure provides allocation information for a file system including total units,
 * free units, sectors per allocation unit, and bytes per sector.
 */
public class SmbInfoAllocation implements AllocInfo {

    /**
     * Default constructor for SMB allocation information.
     */
    public SmbInfoAllocation() {
        // Default constructor
    }

            buffer.order(ByteOrder.LITTLE_ENDIAN);
            buffer.putLong(1048576L); // Total allocation units (1M)
            buffer.putLong(524288L); // Caller available allocation units (512K)
            buffer.putLong(524288L); // Actual free allocation units (512K)
            buffer.putInt(8); // Sectors per allocation unit
            buffer.putInt(512); // Bytes per sector
            byte[] bufferArray = buffer.array();

/**
 * Interface for file system allocation information providing capacity and free space details.
 * Used in SMB protocol operations to query disk space information from remote SMB shares.
 *
 * @author mbechler
 */
public interface AllocInfo extends FileSystemInformation {

    /**
     * Gets the total capacity of the allocation.
     *
     * @return total capacity
     */

            ByteBuffer buffer = ByteBuffer.allocate(24);
            buffer.order(ByteOrder.LITTLE_ENDIAN);
            buffer.putLong(1048576L); // Total allocation units (1M)
            buffer.putLong(524288L); // Free allocation units (512K)
            buffer.putInt(8); // Sectors per allocation unit
            buffer.putInt(512); // Bytes per sector
            byte[] bufferArray = buffer.array();

            // When

        final int start = bufferIndex;

        final SmbInfoAllocation info = new SmbInfoAllocation();

        // Read total allocation units.
        info.alloc = readInt8(buffer, bufferIndex);
        bufferIndex += 8;

        // read caller available allocation units
        info.free = readInt8(buffer, bufferIndex);
        bufferIndex += 8;

        // skip actual free units
        bufferIndex += 8;