allocator: add unit test and optimize constraint funcs

This commit aims to:
1. optimize Constraint's set functions
2. add some unit tests for Constraint

Signed-off-by: Chao Wu <chaowu@linux.alibaba.com>

Author: studychao

crates/db-allocator/src/lib.rs

@@ -7,9 +7,28 @@
 
 mod interval_tree;
 pub use interval_tree::{IntervalTree, NodeState, Range};
+use std::fmt::{Display, Formatter};
+use std::result;
+
+/// Error conditions that may appear during `Allocator` related operations.
+#[derive(Debug, PartialEq)]
+pub enum Error {
+    /// Invalid Constraint Max and Min
+    InvalidBoundary(u64, u64),
+}
+
+impl Display for Error {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Error::InvalidBoundary(max, min) => {
+                write!(f, "invalid constraint max ({}) and min ({})", max, min)
+            }
+        }
+    }
+}
 
 /// Policy for resource allocation.
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, PartialEq)]
 pub enum AllocPolicy {
     /// Default allocation policy.
     Default,
@@ -32,6 +51,9 @@ pub struct Constraint {
     pub policy: AllocPolicy,
 }
 
+/// Generic result type that may return `Allocator` errors.
+pub type Result<T> = result::Result<T, Error>;
+
 impl Constraint {
     /// Create a new constraint object with default settings.
     pub fn new<T>(size: T) -> Self
@@ -48,35 +70,82 @@ impl Constraint {
     }
 
     /// Set the min constraint.
-    pub fn min<T>(mut self, min: T) -> Self
+    pub fn min<T>(&mut self, min: T)
     where
         u64: From<T>,
     {
         self.min = u64::from(min);
-        self
     }
 
     /// Set the max constraint.
-    pub fn max<T>(mut self, max: T) -> Self
+    pub fn max<T>(&mut self, max: T)
     where
         u64: From<T>,
     {
         self.max = u64::from(max);
-        self
     }
 
     /// Set the alignment constraint.
-    pub fn align<T>(mut self, align: T) -> Self
+    pub fn align<T>(&mut self, align: T)
     where
         u64: From<T>,
     {
         self.align = u64::from(align);
-        self
     }
 
     /// Set the allocation policy.
-    pub fn policy(mut self, policy: AllocPolicy) -> Self {
+    pub fn policy(&mut self, policy: AllocPolicy) {
         self.policy = policy;
-        self
+    }
+
+    /// Validate the constraint
+    pub fn validate(&self) -> Result<()> {
+        if self.max < self.min {
+            return Err(Error::InvalidBoundary(self.max, self.min));
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_set_min() {
+        let mut constraint = Constraint::new(2_u64);
+        constraint.min(1_u64);
+        assert_eq!(constraint.min, 1_u64);
+    }
+
+    #[test]
+    fn test_set_max() {
+        let mut constraint = Constraint::new(2_u64);
+        constraint.max(100_u64);
+        assert_eq!(constraint.max, 100_u64);
+    }
+
+    #[test]
+    fn test_set_align() {
+        let mut constraint = Constraint::new(2_u64);
+        constraint.align(8_u64);
+        assert_eq!(constraint.align, 8_u64);
+    }
+
+    #[test]
+    fn test_set_policy() {
+        let mut constraint = Constraint::new(2_u64);
+        constraint.policy(AllocPolicy::FirstMatch);
+        assert_eq!(constraint.policy, AllocPolicy::FirstMatch);
+    }
+
+    #[test]
+    fn test_set_invalid_boundary() {
+        let mut constraint = Constraint::new(2_u64);
+        constraint.max(999_u64);
+        constraint.min(1000_u64);
+        assert_eq!(
+            constraint.validate(),
+            Err(Error::InvalidBoundary(999_u64, 1000_u64))
+        )
     }
 }