ruchy 4.1.2

/// State management for notebook testing sessions
#[derive(Clone, Default)]
pub struct TestState {
    variables: Vec<(String, String)>,
}
impl TestState {
    /// # Examples
    ///
    /// ```
    /// use ruchy::notebook::testing::state::TestState;
    ///
    /// let instance = TestState::new();
    /// // Verify behavior
    /// ```
    pub fn new() -> Self {
        Self::default()
    }
    /// # Examples
    ///
    /// ```
    /// use ruchy::notebook::testing::state::TestState;
    ///
    /// let mut instance = TestState::new();
    /// let result = instance.is_empty();
    /// // Verify behavior
    /// ```
    pub fn is_empty(&self) -> bool {
        self.variables.is_empty()
    }
    /// # Examples
    ///
    /// ```ignore
    /// use ruchy::notebook::testing::state::set_variable;
    ///
    /// let result = set_variable(());
    /// assert_eq!(result, Ok(()));
    /// ```
    pub fn set_variable(&mut self, name: String, value: String) {
        if let Some(var) = self.variables.iter_mut().find(|(n, _)| n == &name) {
            var.1 = value;
        } else {
            self.variables.push((name, value));
        }
    }
    /// # Examples
    ///
    /// ```
    /// use ruchy::notebook::testing::state::TestState;
    ///
    /// let mut instance = TestState::new();
    /// let result = instance.get_variable();
    /// // Verify behavior
    /// ```
    pub fn get_variable(&self, name: &str) -> Option<&String> {
        self.variables
            .iter()
            .find(|(n, _)| n == name)
            .map(|(_, v)| v)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    // EXTREME TDD: Comprehensive test coverage for state management system

    #[test]
    fn test_test_state_new() {
        let state = TestState::new();
        assert!(state.is_empty());
        assert!(state.variables.is_empty());
    }

    #[test]
    fn test_test_state_default() {
        let state = TestState::default();
        assert!(state.is_empty());
        assert!(state.variables.is_empty());
    }

    #[test]
    fn test_test_state_clone() {
        let mut state = TestState::new();
        state.set_variable("test".to_string(), "value".to_string());

        let cloned = state.clone();
        assert_eq!(cloned.get_variable("test"), Some(&"value".to_string()));
        assert!(!cloned.is_empty());
    }

    #[test]
    fn test_is_empty_initially() {
        let state = TestState::new();
        assert!(state.is_empty());
    }

    #[test]
    fn test_is_empty_after_adding_variable() {
        let mut state = TestState::new();
        state.set_variable("key".to_string(), "value".to_string());
        assert!(!state.is_empty());
    }

    #[test]
    fn test_set_variable_new() {
        let mut state = TestState::new();
        state.set_variable("name".to_string(), "value".to_string());

        assert!(!state.is_empty());
        assert_eq!(state.variables.len(), 1);
        assert_eq!(state.variables[0].0, "name");
        assert_eq!(state.variables[0].1, "value");
    }

    #[test]
    fn test_set_variable_update_existing() {
        let mut state = TestState::new();
        state.set_variable("name".to_string(), "initial".to_string());
        state.set_variable("name".to_string(), "updated".to_string());

        assert_eq!(state.variables.len(), 1);
        assert_eq!(state.variables[0].0, "name");
        assert_eq!(state.variables[0].1, "updated");
    }

    #[test]
    fn test_set_multiple_variables() {
        let mut state = TestState::new();
        state.set_variable("var1".to_string(), "value1".to_string());
        state.set_variable("var2".to_string(), "value2".to_string());
        state.set_variable("var3".to_string(), "value3".to_string());

        assert_eq!(state.variables.len(), 3);
        assert!(!state.is_empty());
    }

    #[test]
    fn test_get_variable_existing() {
        let mut state = TestState::new();
        state.set_variable("test_var".to_string(), "test_value".to_string());

        let result = state.get_variable("test_var");
        assert_eq!(result, Some(&"test_value".to_string()));
    }

    #[test]
    fn test_get_variable_nonexistent() {
        let state = TestState::new();
        let result = state.get_variable("nonexistent");
        assert_eq!(result, None);
    }

    #[test]
    fn test_get_variable_after_update() {
        let mut state = TestState::new();
        state.set_variable("key".to_string(), "old_value".to_string());
        state.set_variable("key".to_string(), "new_value".to_string());

        let result = state.get_variable("key");
        assert_eq!(result, Some(&"new_value".to_string()));
    }

    #[test]
    fn test_variable_name_case_sensitivity() {
        let mut state = TestState::new();
        state.set_variable("Variable".to_string(), "value1".to_string());
        state.set_variable("variable".to_string(), "value2".to_string());

        assert_eq!(state.variables.len(), 2);
        assert_eq!(state.get_variable("Variable"), Some(&"value1".to_string()));
        assert_eq!(state.get_variable("variable"), Some(&"value2".to_string()));
    }

    #[test]
    fn test_empty_variable_name() {
        let mut state = TestState::new();
        state.set_variable(String::new(), "empty_name".to_string());

        assert_eq!(state.get_variable(""), Some(&"empty_name".to_string()));
        assert!(!state.is_empty());
    }

    #[test]
    fn test_empty_variable_value() {
        let mut state = TestState::new();
        state.set_variable("empty_value".to_string(), String::new());

        assert_eq!(state.get_variable("empty_value"), Some(&String::new()));
        assert!(!state.is_empty());
    }

    #[test]
    fn test_unicode_variable_names_and_values() {
        let mut state = TestState::new();
        state.set_variable("变量".to_string(), "值".to_string());
        state.set_variable("🦀".to_string(), "rust".to_string());

        assert_eq!(state.get_variable("变量"), Some(&"值".to_string()));
        assert_eq!(state.get_variable("🦀"), Some(&"rust".to_string()));
    }

    #[test]
    fn test_very_long_variable_name() {
        let mut state = TestState::new();
        let long_name = "a".repeat(1000);
        let value = "long_name_value".to_string();

        state.set_variable(long_name.clone(), value.clone());
        assert_eq!(state.get_variable(&long_name), Some(&value));
    }

    #[test]
    fn test_very_long_variable_value() {
        let mut state = TestState::new();
        let name = "long_value_var".to_string();
        let long_value = "x".repeat(10000);

        state.set_variable(name.clone(), long_value.clone());
        assert_eq!(state.get_variable(&name), Some(&long_value));
    }

    #[test]
    fn test_special_character_variable_names() {
        let mut state = TestState::new();
        state.set_variable("var-with-dash".to_string(), "dash".to_string());
        state.set_variable("var_with_underscore".to_string(), "underscore".to_string());
        state.set_variable("var.with.dot".to_string(), "dot".to_string());
        state.set_variable("var@with@at".to_string(), "at".to_string());

        assert_eq!(
            state.get_variable("var-with-dash"),
            Some(&"dash".to_string())
        );
        assert_eq!(
            state.get_variable("var_with_underscore"),
            Some(&"underscore".to_string())
        );
        assert_eq!(state.get_variable("var.with.dot"), Some(&"dot".to_string()));
        assert_eq!(state.get_variable("var@with@at"), Some(&"at".to_string()));
    }

    #[test]
    fn test_multiple_updates_same_variable() {
        let mut state = TestState::new();
        let var_name = "counter".to_string();

        for i in 0..100 {
            state.set_variable(var_name.clone(), i.to_string());
        }

        assert_eq!(state.variables.len(), 1);
        assert_eq!(state.get_variable("counter"), Some(&"99".to_string()));
    }

    #[test]
    fn test_state_persistence_through_operations() {
        let mut state = TestState::new();

        // Add multiple variables
        state.set_variable("var1".to_string(), "value1".to_string());
        state.set_variable("var2".to_string(), "value2".to_string());

        // Update one variable
        state.set_variable("var1".to_string(), "updated1".to_string());

        // Add another variable
        state.set_variable("var3".to_string(), "value3".to_string());

        // Verify all variables are in expected state
        assert_eq!(state.variables.len(), 3);
        assert_eq!(state.get_variable("var1"), Some(&"updated1".to_string()));
        assert_eq!(state.get_variable("var2"), Some(&"value2".to_string()));
        assert_eq!(state.get_variable("var3"), Some(&"value3".to_string()));
    }
}