text-document-common 1.4.0

// Generated by Qleany v1.5.1 from undo_redo_tests.tera
#![cfg(test)]
#![allow(dead_code)]
#![allow(unused_imports)]

use anyhow::Result;
use std::any::Any;
use std::sync::{Arc, Mutex};
use text_document_common::undo_redo::{CompositeCommand, UndoRedoCommand, UndoRedoManager};

// A simple test command that increments or decrements a counter
struct TestCommand {
    counter: Arc<Mutex<i32>>,
    value: i32,
}

impl TestCommand {
    fn new(counter: Arc<Mutex<i32>>, value: i32) -> Self {
        TestCommand { counter, value }
    }
}

impl UndoRedoCommand for TestCommand {
    fn undo(&mut self) -> Result<()> {
        let mut counter = self.counter.lock().unwrap();
        *counter -= self.value;
        Ok(())
    }

    fn redo(&mut self) -> Result<()> {
        let mut counter = self.counter.lock().unwrap();
        *counter += self.value;
        Ok(())
    }

    fn as_any(&self) -> &dyn Any {
        self
    }
}

// A mergeable test command that can be combined with other commands of the same type
struct MergeableCommand {
    counter: Arc<Mutex<i32>>,
    value: i32,
}

impl MergeableCommand {
    fn new(counter: Arc<Mutex<i32>>, value: i32) -> Self {
        MergeableCommand { counter, value }
    }
}

impl UndoRedoCommand for MergeableCommand {
    fn undo(&mut self) -> Result<()> {
        let mut counter = self.counter.lock().unwrap();
        *counter -= self.value;
        Ok(())
    }

    fn redo(&mut self) -> Result<()> {
        let mut counter = self.counter.lock().unwrap();
        *counter += self.value;
        Ok(())
    }

    fn can_merge(&self, other: &dyn UndoRedoCommand) -> bool {
        other.as_any().downcast_ref::<Self>().is_some()
    }

    fn merge(&mut self, other: &dyn UndoRedoCommand) -> bool {
        if let Some(other_cmd) = other.as_any().downcast_ref::<Self>() {
            self.value += other_cmd.value;
            return true;
        }
        false
    }

    fn as_any(&self) -> &dyn Any {
        self
    }
}

#[test]
fn test_new() {
    let manager = UndoRedoManager::new();
    assert!(!manager.can_undo(None));
    assert!(!manager.can_redo(None));
}

#[test]
fn test_add_command() {
    let counter = Arc::new(Mutex::new(0));
    let mut manager = UndoRedoManager::new();

    // Add a command
    manager.add_command(Box::new(TestCommand::new(counter.clone(), 5)));

    assert!(manager.can_undo(None));
    assert!(!manager.can_redo(None));
    assert_eq!(*counter.lock().unwrap(), 0); // Command should not be executed automatically
}

#[test]
fn test_undo() {
    let counter = Arc::new(Mutex::new(0));
    let mut manager = UndoRedoManager::new();

    // Add a command and execute it manually
    {
        let mut cmd = TestCommand::new(counter.clone(), 5);
        cmd.redo().unwrap();
        manager.add_command(Box::new(cmd));
    }

    assert_eq!(*counter.lock().unwrap(), 5);

    // Undo the command
    manager.undo(None).unwrap();

    assert_eq!(*counter.lock().unwrap(), 0);
    assert!(!manager.can_undo(None));
    assert!(manager.can_redo(None));
}

#[test]
fn test_redo() {
    let counter = Arc::new(Mutex::new(0));
    let mut manager = UndoRedoManager::new();

    // Add a command and execute it manually
    {
        let mut cmd = TestCommand::new(counter.clone(), 5);
        cmd.redo().unwrap();
        manager.add_command(Box::new(cmd));
    }

    // Undo and then redo
    manager.undo(None).unwrap();
    assert_eq!(*counter.lock().unwrap(), 0);

    manager.redo(None).unwrap();
    assert_eq!(*counter.lock().unwrap(), 5);

    assert!(manager.can_undo(None));
    assert!(!manager.can_redo(None));
}

#[test]
fn test_undo_redo_multiple() {
    let counter = Arc::new(Mutex::new(0));
    let mut manager = UndoRedoManager::new();

    // Add multiple commands
    {
        let mut cmd1 = TestCommand::new(counter.clone(), 5);
        cmd1.redo().unwrap();
        manager.add_command(Box::new(cmd1));

        let mut cmd2 = TestCommand::new(counter.clone(), 3);
        cmd2.redo().unwrap();
        manager.add_command(Box::new(cmd2));
    }

    assert_eq!(*counter.lock().unwrap(), 8);

    // Undo both commands
    manager.undo(None).unwrap(); // Undo cmd2
    assert_eq!(*counter.lock().unwrap(), 5);

    manager.undo(None).unwrap(); // Undo cmd1
    assert_eq!(*counter.lock().unwrap(), 0);

    // Redo both commands
    manager.redo(None).unwrap(); // Redo cmd1
    assert_eq!(*counter.lock().unwrap(), 5);

    manager.redo(None).unwrap(); // Redo cmd2
    assert_eq!(*counter.lock().unwrap(), 8);
}

#[test]
fn test_composite_command() {
    let counter = Arc::new(Mutex::new(0));
    let mut manager = UndoRedoManager::new();

    // Create a composite command
    manager.begin_composite(None);

    // Add commands to the composite
    {
        let mut cmd1 = TestCommand::new(counter.clone(), 5);
        cmd1.redo().unwrap();
        manager.add_command(Box::new(cmd1));

        let mut cmd2 = TestCommand::new(counter.clone(), 3);
        cmd2.redo().unwrap();
        manager.add_command(Box::new(cmd2));
    }

    manager.end_composite();

    assert_eq!(*counter.lock().unwrap(), 8);

    // Undo the composite (should undo both commands at once)
    manager.undo(None).unwrap();
    assert_eq!(*counter.lock().unwrap(), 0);

    // Redo the composite (should redo both commands at once)
    manager.redo(None).unwrap();
    assert_eq!(*counter.lock().unwrap(), 8);
}

#[test]
fn test_empty_composite() {
    let mut manager = UndoRedoManager::new();

    // Create an empty composite command
    manager.begin_composite(None);
    manager.end_composite();

    // Nothing should be added to the undo stack
    assert!(!manager.can_undo(None));
}

#[test]
fn test_nested_composite() {
    let counter = Arc::new(Mutex::new(0));
    let mut manager = UndoRedoManager::new();

    // Start outer composite
    manager.begin_composite(None);

    // Add a command
    {
        let mut cmd1 = TestCommand::new(counter.clone(), 5);
        cmd1.redo().unwrap();
        manager.add_command(Box::new(cmd1));
    }

    // Start inner composite (should be ignored and continue with outer composite)
    manager.begin_composite(None);

    // Add another command
    {
        let mut cmd2 = TestCommand::new(counter.clone(), 3);
        cmd2.redo().unwrap();
        manager.add_command(Box::new(cmd2));
    }

    // End inner composite (should have no effect)
    manager.end_composite();

    // Add a third command
    {
        let mut cmd3 = TestCommand::new(counter.clone(), 2);
        cmd3.redo().unwrap();
        manager.add_command(Box::new(cmd3));
    }

    // End outer composite
    manager.end_composite();

    assert_eq!(*counter.lock().unwrap(), 10);

    // Undo the composite (should undo all three commands)
    manager.undo(None).unwrap();
    assert_eq!(*counter.lock().unwrap(), 0);
}

#[test]
fn test_command_merging() {
    let counter = Arc::new(Mutex::new(0));
    let mut manager = UndoRedoManager::new();

    // Add a mergeable command
    {
        let mut cmd1 = MergeableCommand::new(counter.clone(), 5);
        cmd1.redo().unwrap();
        manager.add_command(Box::new(cmd1));
    }

    // Add another mergeable command that should be merged with the first
    {
        let mut cmd2 = MergeableCommand::new(counter.clone(), 3);
        cmd2.redo().unwrap();
        manager.add_command(Box::new(cmd2));
    }

    assert_eq!(*counter.lock().unwrap(), 8);

    // Undo should undo both commands at once since they were merged
    manager.undo(None).unwrap();
    assert_eq!(*counter.lock().unwrap(), 0);

    // Redo should redo both commands at once
    manager.redo(None).unwrap();
    assert_eq!(*counter.lock().unwrap(), 8);
}

#[test]
fn test_redo_stack_cleared_on_new_command() {
    let counter = Arc::new(Mutex::new(0));
    let mut manager = UndoRedoManager::new();

    // Add and execute a command
    {
        let mut cmd1 = TestCommand::new(counter.clone(), 5);
        cmd1.redo().unwrap();
        manager.add_command(Box::new(cmd1));
    }

    // Undo the command
    manager.undo(None).unwrap();
    assert!(manager.can_redo(None));

    // Add a new command
    {
        let mut cmd2 = TestCommand::new(counter.clone(), 3);
        cmd2.redo().unwrap();
        manager.add_command(Box::new(cmd2));
    }

    // Redo stack should be cleared
    assert!(!manager.can_redo(None));
    assert_eq!(*counter.lock().unwrap(), 3);
}

#[test]
fn test_undo_with_empty_stack() {
    let mut manager = UndoRedoManager::new();

    // Undo with empty stack should not fail
    let result = manager.undo(None);
    assert!(result.is_ok());
}

#[test]
fn test_redo_with_empty_stack() {
    let mut manager = UndoRedoManager::new();

    // Redo with empty stack should not fail
    let result = manager.redo(None);
    assert!(result.is_ok());
}

#[test]
fn test_clear() {
    let counter = Arc::new(Mutex::new(0));
    let mut manager = UndoRedoManager::new();

    // Add and execute commands
    {
        let mut cmd1 = TestCommand::new(counter.clone(), 5);
        cmd1.redo().unwrap();
        manager.add_command(Box::new(cmd1));

        let mut cmd2 = TestCommand::new(counter.clone(), 3);
        cmd2.redo().unwrap();
        manager.add_command(Box::new(cmd2));
    }

    assert_eq!(*counter.lock().unwrap(), 8);
    assert!(manager.can_undo(None));
    assert!(!manager.can_redo(None));

    // Undo one command to populate the redo stack
    manager.undo(None).unwrap();
    assert_eq!(*counter.lock().unwrap(), 5);
    assert!(manager.can_undo(None));
    assert!(manager.can_redo(None));

    // Clear the manager
    manager.clear_all_stacks();

    // Verify both stacks are empty
    assert!(!manager.can_undo(None));
    assert!(!manager.can_redo(None));

    // Verify we can add new commands after clearing
    {
        let mut cmd = TestCommand::new(counter.clone(), 10);
        cmd.redo().unwrap();
        manager.add_command(Box::new(cmd));
    }

    assert!(manager.can_undo(None));
    assert!(!manager.can_redo(None));

    // Verify undo works after clearing
    manager.undo(None).unwrap();
    assert_eq!(*counter.lock().unwrap(), 5); // Back to the value before the new command
    assert!(!manager.can_undo(None));
    assert!(manager.can_redo(None));
}

#[test]
fn test_clear_with_in_progress_composite() {
    let counter = Arc::new(Mutex::new(0));
    let mut manager = UndoRedoManager::new();

    // Begin a composite command
    manager.begin_composite(None);

    // Add commands to the composite
    {
        let mut cmd1 = TestCommand::new(counter.clone(), 5);
        cmd1.redo().unwrap();
        manager.add_command(Box::new(cmd1));

        let mut cmd2 = TestCommand::new(counter.clone(), 3);
        cmd2.redo().unwrap();
        manager.add_command(Box::new(cmd2));
    }

    assert_eq!(*counter.lock().unwrap(), 8);

    // Clear the manager without ending the composite
    manager.clear_all_stacks();

    // Verify both stacks are empty
    assert!(!manager.can_undo(None));
    assert!(!manager.can_redo(None));

    // Verify the composite state is reset by adding a command normally
    {
        let mut cmd = TestCommand::new(counter.clone(), 10);
        cmd.redo().unwrap();
        manager.add_command(Box::new(cmd));
    }

    // Command should be added directly to the undo stack, not to a composite
    assert!(manager.can_undo(None));

    // Verify undo works normally after clearing
    manager.undo(None).unwrap();
    assert_eq!(*counter.lock().unwrap(), 8); // Back to the value before the new command
    assert!(!manager.can_undo(None));
    assert!(manager.can_redo(None));
}