/**
 * 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 {

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

        byte[] buffer = new byte[28];
        // Mock data for SmbQueryFSSizeInfo
        writeInt8(2000, buffer, 0); // total allocation units
        writeInt8(1000, buffer, 8); // free allocation units
        writeInt4(8, buffer, 16); // sectors per allocation unit
        writeInt4(4096, buffer, 20); // bytes per sector

        int bytesRead = response.readDataWireFormat(buffer, 0, buffer.length);

        // 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 {

 * 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
    }

/**
 * 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
     */

        }

        // 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();

        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;

      type == TYPE_PUSH_PROMISE && flags and FLAG_END_PUSH_PROMISE != 0 -> {
        result.replace("HEADERS", "PUSH_PROMISE") // TODO: Avoid allocation.
      }

      type == TYPE_DATA && flags and FLAG_COMPRESSED != 0 -> {
        result.replace("PRIORITY", "COMPRESSED") // TODO: Avoid allocation.
      }

      else -> {
        result
      }
    }
  }