bashrs 6.66.0

    /// Test: REPL-008-004-004 - Finish with nested frames
    ///
    /// RED phase: Test finish() returns one level only
    #[test]
    fn test_REPL_008_004_finish_nested_functions() {
        // ARRANGE: Script with manual nested call stack
        let script = "echo line1\necho line2\necho line3\necho line4";
        let mut session = DebugSession::new(script);

        // Simulate nested function calls
        session.push_frame("outer_function", 1);
        session.push_frame("inner_function", 2);

        // Should be at depth 3 (<main> + outer + inner)
        assert_eq!(session.call_depth(), 3);

        // ACT: finish() should return from inner to outer
        let result = session.finish();

        // ASSERT: Should exit one level (inner function only)
        // Note: In simplified version without real function tracking,
        // we'll just verify finish() doesn't crash and returns a valid result
        assert!(
            matches!(result, ContinueResult::Finished)
                || matches!(result, ContinueResult::BreakpointHit(_))
        );
    }

    /// Test: REPL-008-004-005 - Finish when already finished
    ///
    /// RED phase: Test finish() behavior at end of script
    #[test]
    fn test_REPL_008_004_finish_when_already_finished() {
        // ARRANGE: Script at end
        let script = "echo done";
        let mut session = DebugSession::new(script);

        // Step to end
        session.step();
        session.step();
        assert!(session.is_finished());

        // ACT: Call finish() when already finished
        let result = session.finish();

        // ASSERT: Should remain finished
        assert!(matches!(result, ContinueResult::Finished));
        assert!(session.is_finished());
    }

    // ===== REPL-009-001: VARIABLE INSPECTION TESTS =====

    /// Test: REPL-009-001-001 - Set and get variable
    #[test]
    fn test_REPL_009_001_print_variable() {
        let script = "echo hello";
        let mut session = DebugSession::new(script);

        // Set a variable
        session.set_variable("USER", "alice");
        session.set_variable("HOME", "/home/alice");

        // Get variable values
        assert_eq!(session.get_variable("USER"), Some("alice"));
        assert_eq!(session.get_variable("HOME"), Some("/home/alice"));

        // Variable count
        assert_eq!(session.variable_count(), 2);
    }

    /// Test: REPL-009-001-002 - Array-like variables (stored as comma-separated)
    #[test]
    fn test_REPL_009_001_print_array() {
        let script = "echo test";
        let mut session = DebugSession::new(script);

        // Store array as comma-separated string (simplified array handling)
        session.set_variable("ARRAY", "item1,item2,item3");

        // Retrieve array
        let array_value = session.get_variable("ARRAY");
        assert_eq!(array_value, Some("item1,item2,item3"));

        // Could be split by caller if needed
        let items: Vec<&str> = array_value.unwrap().split(',').collect();
        assert_eq!(items, vec!["item1", "item2", "item3"]);
    }

    /// Test: REPL-009-001-003 - Nonexistent variable returns None
    #[test]
    fn test_REPL_009_001_print_nonexistent() {
        let script = "echo test";
        let session = DebugSession::new(script);

        // Get nonexistent variable
        assert_eq!(session.get_variable("DOES_NOT_EXIST"), None);
        assert_eq!(session.get_variable(""), None);
    }

    /// Test: REPL-009-001-004 - List all variables
    #[test]
    fn test_REPL_009_001_list_variables() {
        let script = "echo test";
        let mut session = DebugSession::new(script);

        // Initially empty
        assert_eq!(session.list_variables(), vec![]);

        // Add variables
        session.set_variable("PATH", "/usr/bin");
        session.set_variable("USER", "bob");
        session.set_variable("HOME", "/home/bob");

        // List variables (sorted by name)
        let vars = session.list_variables();
        assert_eq!(vars.len(), 3);
        assert_eq!(vars[0], ("HOME", "/home/bob"));
        assert_eq!(vars[1], ("PATH", "/usr/bin"));
        assert_eq!(vars[2], ("USER", "bob"));
    }

    /// Test: REPL-009-001-005 - Variable update
    #[test]
    fn test_REPL_009_001_variable_update() {
        let script = "echo test";
        let mut session = DebugSession::new(script);

        // Set initial value
        session.set_variable("VERSION", "1.0");
        assert_eq!(session.get_variable("VERSION"), Some("1.0"));

        // Update value
        session.set_variable("VERSION", "2.0");
        assert_eq!(session.get_variable("VERSION"), Some("2.0"));

        // Count should still be 1
        assert_eq!(session.variable_count(), 1);
    }

    /// Test: REPL-009-001-006 - Clear variables
    #[test]
    fn test_REPL_009_001_clear_variables() {
        let script = "echo test";
        let mut session = DebugSession::new(script);

        // Add variables
        session.set_variable("A", "1");
        session.set_variable("B", "2");
        session.set_variable("C", "3");
        assert_eq!(session.variable_count(), 3);

        // Clear all
        session.clear_variables();
        assert_eq!(session.variable_count(), 0);
        assert_eq!(session.list_variables(), vec![]);
        assert_eq!(session.get_variable("A"), None);
    }

    /// Test: REPL-009-001-007 - Variables persist across steps
    #[test]
    fn test_REPL_009_001_variables_persist_across_steps() {
        let script = "echo line1\necho line2\necho line3";
        let mut session = DebugSession::new(script);

        // Set variable before stepping
        session.set_variable("COUNTER", "0");

        // Step through and verify variable persists
        session.step();
        assert_eq!(session.get_variable("COUNTER"), Some("0"));

        session.step();
        assert_eq!(session.get_variable("COUNTER"), Some("0"));

        // Update variable mid-execution
        session.set_variable("COUNTER", "2");
        session.step();
        assert_eq!(session.get_variable("COUNTER"), Some("2"));
    }

    // ===== REPL-009-002: Environment Display Tests =====

    #[test]
    fn test_REPL_009_002_env_display() {
        let script = "echo test";
        let session = DebugSession::new(script);

        // Get an environment variable that should exist (PATH always exists)
        let path = session.get_env("PATH");
        assert!(path.is_some(), "PATH environment variable should exist");

        // Get a variable that doesn't exist
        let nonexistent = session.get_env("BASHRS_NONEXISTENT_VAR_12345");
        assert_eq!(nonexistent, None);

        // List all environment variables
        let env_vars = session.list_env();
        assert!(!env_vars.is_empty(), "Should have at least one env var");

        // Verify sorted order
        let mut sorted = env_vars.clone();
        sorted.sort_by_key(|(name, _)| name.clone());
        assert_eq!(env_vars, sorted, "Environment variables should be sorted");
    }

include!("debugger_tests_extracted_cont_cont_REPL.rs");