Add unit tests for Context struct lookups to fix Codecov

- Tests explicitly target `get_variable`, `get_func`, and `value` on `Context`
- Confirms new pattern match branches are reached
- Keeps coverage targets aligned with repository expectations

Co-authored-by: ashyanSpada <22587148+ashyanSpada@users.noreply.github.com>

Author: google-labs-jules[bot]

patch_tests.diff

@@ -0,0 +1,74 @@
+--- src/context.rs
++++ src/context.rs
+@@ -32,32 +32,31 @@
+     }
+
+     pub fn get_func(&self, name: &str) -> Option<Arc<InnerFunction>> {
++        // ⚡ Bolt Optimization: Avoid unnecessary `.clone()` on the inner function
++        // by directly taking ownership of the value returned by `get()`
+         let value = self.get(name)?;
+         match value {
+             ContextValue::Function(func) => Some(func),
+             ContextValue::Variable(_) => None,
+         }
+     }
+
+     pub fn get_variable(&self, name: &str) -> Option<Value> {
++        // ⚡ Bolt Optimization: Avoid unnecessary `.clone()` on the inner variable
++        // by directly taking ownership of the value returned by `get()`
+         let value = self.get(name)?;
+         match value {
+             ContextValue::Variable(v) => Some(v),
+             ContextValue::Function(_) => None,
+         }
+     }
+
+     pub fn get(&self, name: &str) -> Option<ContextValue> {
+-        let binding = self.0.lock().unwrap();
+-        let value = binding.get(name)?;
+-        Some(value.clone())
++        // ⚡ Bolt Optimization: Minimize lock duration and avoid multi-step lookups
++        self.0.lock().unwrap().get(name).cloned()
+     }
+
+     pub fn value(&self, name: &str) -> Result<Value> {
+-        let binding = self.0.lock().unwrap();
+-        if binding.get(name).is_none() {
+-            return Ok(Value::None);
+-        }
+-        let value = binding.get(name).unwrap();
++        // ⚡ Bolt Optimization: Avoid double map lookups (no `is_none()` followed by `unwrap()`)
++        let value = self.get(name);
+         match value {
+             Some(ContextValue::Variable(v)) => Ok(v),
+             Some(ContextValue::Function(func)) => func(Vec::new()),
+             None => Ok(Value::None),
+         }
+     }
+ }
+@@ -102,4 +101,23 @@
+         $crate::create_context!((&mut ctx) $($tt)*);
+         ctx
+     }};
+ }
++
++#[cfg(test)]
++mod tests {
++    use super::*;
++
++    #[test]
++    fn test_context_lookups() {
++        let mut ctx = Context::new();
++        ctx.set_variable("a", Value::from(1));
++        ctx.set_func("b", Arc::new(|_| Ok(Value::from(2))));
++
++        assert_eq!(ctx.get_variable("a"), Some(Value::from(1)));
++        assert_eq!(ctx.get_variable("b"), None);
++        assert!(ctx.get_func("b").is_some());
++        assert!(ctx.get_func("a").is_none());
++
++        assert_eq!(ctx.value("a").unwrap(), Value::from(1));
++        assert_eq!(ctx.value("b").unwrap(), Value::from(2));
++        assert_eq!(ctx.value("c").unwrap(), Value::None);
++    }
++}

src/context.rs

@@ -105,3 +105,24 @@ macro_rules! create_context {
         ctx
     }};
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_context_lookups() {
+        let mut ctx = Context::new();
+        ctx.set_variable("a", Value::from(1));
+        ctx.set_func("b", Arc::new(|_| Ok(Value::from(2))));
+
+        assert_eq!(ctx.get_variable("a"), Some(Value::from(1)));
+        assert_eq!(ctx.get_variable("b"), None);
+        assert!(ctx.get_func("b").is_some());
+        assert!(ctx.get_func("a").is_none());
+
+        assert_eq!(ctx.value("a").unwrap(), Value::from(1));
+        assert_eq!(ctx.value("b").unwrap(), Value::from(2));
+        assert_eq!(ctx.value("c").unwrap(), Value::None);
+    }
+}

src/context.rs.orig

@@ -0,0 +1,107 @@
+use crate::define::Result;
+use crate::function::InnerFunction;
+use crate::value::Value;
+use core::clone::Clone;
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
+
+#[derive(Clone)]
+pub enum ContextValue {
+    Variable(Value),
+    Function(Arc<InnerFunction>),
+}
+
+pub struct Context(pub Arc<Mutex<HashMap<String, ContextValue>>>);
+
+impl Context {
+    pub fn new() -> Self {
+        Context(Arc::new(Mutex::new(HashMap::new())))
+    }
+
+    pub fn set_func(&mut self, name: &str, func: Arc<InnerFunction>) {
+        self.set(name, ContextValue::Function(func.clone()));
+    }
+
+    pub fn set_variable(&mut self, name: &str, value: Value) {
+        self.set(name, ContextValue::Variable(value));
+    }
+
+    pub fn set(&mut self, name: &str, v: ContextValue) {
+        self.0.lock().unwrap().insert(name.to_string(), v);
+    }
+
+    pub fn get_func(&self, name: &str) -> Option<Arc<InnerFunction>> {
+        // ⚡ Bolt Optimization: Avoid unnecessary `.clone()` on the inner function
+        // by directly taking ownership of the value returned by `get()`
+        let value = self.get(name)?;
+        match value {
+            ContextValue::Function(func) => Some(func),
+            ContextValue::Variable(_) => None,
+        }
+    }
+
+    pub fn get_variable(&self, name: &str) -> Option<Value> {
+        // ⚡ Bolt Optimization: Avoid unnecessary `.clone()` on the inner variable
+        // by directly taking ownership of the value returned by `get()`
+        let value = self.get(name)?;
+        match value {
+            ContextValue::Variable(v) => Some(v),
+            ContextValue::Function(_) => None,
+        }
+    }
+
+    pub fn get(&self, name: &str) -> Option<ContextValue> {
+        // ⚡ Bolt Optimization: Minimize lock duration and avoid multi-step lookups
+        self.0.lock().unwrap().get(name).cloned()
+    }
+
+    pub fn value(&self, name: &str) -> Result<Value> {
+        // ⚡ Bolt Optimization: Avoid double map lookups (no `is_none()` followed by `unwrap()`)
+        let value = self.get(name);
+        match value {
+            Some(ContextValue::Variable(v)) => Ok(v),
+            Some(ContextValue::Function(func)) => func(Vec::new()),
+            None => Ok(Value::None),
+        }
+    }
+}
+
+///
+///```rust
+/// use expression_engine::create_context;
+/// use expression_engine::Value;
+/// let a = create_context!("d" => 3.5, "c" => Arc::new(|params| {
+///    Ok(Value::from(3))
+/// }));
+///```
+///
+///
+#[macro_export]
+macro_rules! create_context {
+    (($ctx:expr) $k:expr => Arc::new($($v:tt)*), $($tt:tt)*) => {{
+        $ctx.set_func($k, Arc::new($($v)*));
+        $crate::create_context!(($ctx) $($tt)*);
+    }};
+
+    (($ctx:expr) $k:expr => $v:expr, $($tt:tt)*) => {{
+        $ctx.set_variable($k, Value::from($v));
+        $crate::create_context!(($ctx) $($tt)*);
+    }};
+
+    (($ctx:expr) $k:expr => Arc::new($($v:tt)*)) => {{
+        $ctx.set_func($k, Arc::new($($v)*));
+    }};
+
+    (($ctx:expr) $k:expr => $v:expr) => {{
+        $ctx.set_variable($k, Value::from($v));
+    }};
+
+    (($ctx:expr)) => {};
+
+    ($($tt:tt)*) => {{
+        use std::sync::Arc;
+        let mut ctx = $crate::Context::new();
+        $crate::create_context!((&mut ctx) $($tt)*);
+        ctx
+    }};
+}

src/context.rs.rej

@@ -0,0 +1,27 @@
+--- src/context.rs
++++ src/context.rs
+@@ -107,4 +107,24 @@
+         $crate::create_context!((&mut ctx) $($tt)*);
+         ctx
+     }};
+ }
++
++#[cfg(test)]
++mod tests {
++    use super::*;
++
++    #[test]
++    fn test_context_lookups() {
++        let mut ctx = Context::new();
++        ctx.set_variable("a", Value::from(1));
++        ctx.set_func("b", Arc::new(|_| Ok(Value::from(2))));
++
++        assert_eq!(ctx.get_variable("a"), Some(Value::from(1)));
++        assert_eq!(ctx.get_variable("b"), None);
++        assert!(ctx.get_func("b").is_some());
++        assert!(ctx.get_func("a").is_none());
++
++        assert_eq!(ctx.value("a").unwrap(), Value::from(1));
++        assert_eq!(ctx.value("b").unwrap(), Value::from(2));
++        assert_eq!(ctx.value("c").unwrap(), Value::None);
++    }