)

const (
	bucketQuotaConfigFile = "quota.json"
	bucketTargetsFile     = "bucket-targets.json"
)

// PutBucketQuotaConfigHandler - PUT Bucket quota configuration.
// ----------
// Places a quota configuration on the specified bucket. The quota
// specified in the quota configuration will be applied by default
// to enforce total quota for the specified bucket.

        }

        @Test
        @DisplayName("Should handle quota restricted scenarios")
        void shouldHandleQuotaRestrictedScenarios() throws SMBProtocolDecodingException {
            // Given - quota restricts caller available units
            long totalClusters = 26214400L; // 100GB / 4KB
            long callerAvailable = 2621440L; // 10GB / 4KB (quota limit)
            long actualFree = 13107200L; // 50GB / 4KB (actual free)

            assertEquals(3, Smb2Constants.SMB2_0_INFO_SECURITY, "Security info level must be 3");
        }

        @Test
        @DisplayName("Quota info level should be 4")
        void testInfoQuota() {
            assertEquals(4, Smb2Constants.SMB2_0_INFO_QUOTA, "Quota info level must be 4");
        }

        @Test
        @DisplayName("All info levels should be sequential")
        void testInfoLevelsSequential() {

}

// BucketQuotaConfigNotFound - no bucket quota config found.
type BucketQuotaConfigNotFound GenericError

func (e BucketQuotaConfigNotFound) Error() string {
	return "No quota config found for bucket : " + e.Bucket
}

// BucketQuotaExceeded - bucket quota exceeded.
type BucketQuotaExceeded GenericError

func (e BucketQuotaExceeded) Error() string {
	return "Bucket quota exceeded for bucket: " + e.Bucket
}

			}
		}
	case madmin.SRBucketMetaTypeQuotaConfig:
		if item.Quota == nil {
			err = globalSiteReplicationSys.PeerBucketQuotaConfigHandler(ctx, item.Bucket, nil, item.UpdatedAt)
		} else {
			quotaConfig, err := parseBucketQuota(item.Bucket, item.Quota)
			if err != nil {
				writeErrorResponseJSON(ctx, w, toAdminAPIErr(ctx, err), r.URL)
				return
			}

                () -> response.readBytesWireFormat(buffer, bufferIndex), "Should throw exception for unknown quota info class");

        assertTrue(exception.getMessage().contains("Unknown quota info class"));
    }

    @Test
    @DisplayName("Test readBytesWireFormat with unknown info type throws exception")
    void testReadBytesWireFormatUnknownInfoType() {

                        ErrorCategory.FILE_SYSTEM, false), DISK_FULL("Disk full", ErrorCategory.RESOURCE,
                                false), QUOTA_EXCEEDED("Quota exceeded", ErrorCategory.RESOURCE, false),

        // Protocol errors
        INVALID_PARAMETER("Invalid parameter", ErrorCategory.PROTOCOL, false), NOT_SUPPORTED("Operation not supported",

		}
		return r, err
	}
	return config.ToRetention(), nil
}

// enforceRetentionForDeletion checks if it is appropriate to remove an
// object according to locking configuration when this is lifecycle/ bucket quota asking.
func enforceRetentionForDeletion(ctx context.Context, objInfo ObjectInfo) (locked bool) {
	if objInfo.DeleteMarker {
		return false
	}

	lhold := objectlock.GetObjectLegalHoldMeta(objInfo.UserDefined)

		// -- END IAM APIs --

		// GetBucketQuotaConfig
		adminRouter.Methods(http.MethodGet).Path(adminVersion+"/get-bucket-quota").HandlerFunc(
			adminMiddleware(adminAPI.GetBucketQuotaConfigHandler)).Queries("bucket", "{bucket:.*}")
		// PutBucketQuotaConfig
		adminRouter.Methods(http.MethodPut).Path(adminVersion+"/set-bucket-quota").HandlerFunc(
			adminMiddleware(adminAPI.PutBucketQuotaConfigHandler)).Queries("bucket", "{bucket:.*}")

	}
	if meta.policyConfig == nil {
		return nil, time.Time{}, BucketPolicyNotFound{Bucket: bucket}
	}
	return meta.policyConfig, meta.PolicyConfigUpdatedAt, nil
}

// GetQuotaConfig returns configured bucket quota
// The returned object may not be modified.
func (sys *BucketMetadataSys) GetQuotaConfig(ctx context.Context, bucket string) (*madmin.BucketQuota, time.Time, error) {
	meta, _, err := sys.GetConfig(ctx, bucket)