rpn_cli/

engine.rs

use crate::calc::context::{Context, Format};
use crate::calc::undo::Undo;
use crate::calc::value::{Value, ValueRef};
use crate::config::Config;
use crate::core::action;
use crate::core::action::{Action, Actions};
use crate::core::count::Count;
use crate::core::helper::CommandEditor;
use crate::core::interface::{Directive, Interface, Operation};
use crate::core::stack::{BracketChars, StackItem, ValueStack};
use crate::error::{EngineError, MyError, MyResult};
use crate::util::text::create_padding;
use fileinput::FileInput;
use itertools::Itertools;
use std::cell::RefCell;
use std::fs::File;
use std::io::{BufRead, BufReader, Write};
use std::rc::Rc;
use std::slice::Iter;

const PAGE_LIMIT: usize = 10;

pub struct Engine<W: Write> {
    config: Config,
    editor: CommandEditor,
    interface: Rc<RefCell<Interface<W>>>,
    context: Rc<RefCell<Context>>,
    undos: Vec<Undo>,
    redos: Vec<Undo>,
    clip: Option<ValueRef>,
    dirty: bool,
    interact: bool,
    chars: BracketChars,
}

// noinspection RsLift
impl<W: Write> Engine<W> {
    pub fn new(config: Config, chars: BracketChars) -> MyResult<Self> {
        let interface = Rc::new(RefCell::new(Interface::build()));
        let editor = interface.borrow().create_editor()?;
        let context = Rc::new(RefCell::new(Context::new()));
        let undos = Vec::new();
        let redos = Vec::new();
        let engine = Self {
            config,
            editor,
            interface,
            context,
            undos,
            redos,
            clip: None,
            dirty: false,
            interact: false,
            chars,
        };
        Ok(engine)
    }

    pub fn parse_input(&mut self, writer: &mut W) -> MyResult<()> {
        let mut stack = ValueStack::new(Vec::new());
        if let Some(import) = &self.config.import {
            let import = vec![String::from(import)];
            self.import_file(writer, &mut stack, import)?;
        }
        if !self.config.values.is_empty() {
            self.parse_values(writer, &mut stack)?;
            if !self.config.mock {
                self.show_simple(writer, &mut stack)?;
            }
        } else if !self.config.paths.is_empty() || atty::isnt(atty::Stream::Stdin) || atty::isnt(atty::Stream::Stdout) {
            let reader = FileInput::new(&self.config.paths);
            self.parse_files(writer, &mut stack, reader)?;
            self.show_simple(writer, &mut stack)?;
        } else {
            self.parse_loop(writer, &mut stack)?;
        }
        Ok(())
    }

    fn parse_values(
        &mut self,
        writer: &mut W,
        stack: &mut ValueStack,
    ) -> MyResult<()> {
        let values = self.config.values.drain(..).collect::<Vec<String>>();
        if self.config.mock {
            for (index, value) in values.iter().enumerate() {
                self.interact = index + 1 == values.len();
                self.interact_line(writer, stack, &value)?;
            }
        } else {
            for value in values {
                self.parse_line(writer, stack, &value)?;
            }
        }
        Ok(())
    }

    fn parse_files(
        &mut self,
        writer: &mut W,
        stack: &mut ValueStack,
        reader: FileInput,
    ) -> MyResult<()> {
        let mut undo = Undo::default();
        let mut redo = Undo::default();
        let reader = BufReader::new(reader);
        for line in reader.lines() {
            let line = line?;
            self.parse_inner(writer, stack, &mut undo, &mut redo, &line)?;
        }
        self.commit_undo(undo, redo);
        Ok(())
    }

    fn parse_loop(
        &mut self,
        writer: &mut W,
        stack: &mut ValueStack,
    ) -> MyResult<()> {
        self.interact = true;
        loop {
            let line = self.editor.readline("rpn> ")?;
            self.editor.add_history_entry(&line)?;
            self.interact_line(writer, stack, &line)?;
        }
    }

    fn interact_line(
        &mut self,
        writer: &mut W,
        stack: &mut ValueStack,
        line: &str,
    ) -> MyResult<()> {
        let result = match self.parse_line(writer, stack, line) {
            Ok(()) => {
                if self.interact && self.dirty {
                    self.limit_stack(writer, stack, Some(PAGE_LIMIT))?;
                }
                Ok(())
            }
            Err(MyError::Engine(error)) => {
                if self.interact {
                    writeln!(writer, "  {}", error)?;
                }
                Ok(())
            }
            Err(error) => {
                Err(error)
            }
        };
        self.dirty = false;
        result
    }

    fn parse_line(
        &mut self,
        writer: &mut W,
        stack: &mut ValueStack,
        line: &str,
    ) -> MyResult<()> {
        let mut undo = Undo::default();
        let mut redo = Undo::default();
        self.parse_inner(writer, stack, &mut undo, &mut redo, line)?;
        self.commit_undo(undo, redo);
        Ok(())
    }

    fn parse_inner(
        &mut self,
        writer: &mut W,
        stack: &mut ValueStack,
        undo: &mut Undo,
        redo: &mut Undo,
        line: &str,
    ) -> MyResult<()> {
        let mut empty = true;
        let (line, comment) = Self::split_comment(line);
        let actions = Actions::new(&self.interface, line.split_ascii_whitespace());
        for action in actions {
            let action = match action {
                Ok((action, keyword)) => self.apply_action(
                    writer,
                    stack,
                    undo,
                    redo,
                    action,
                    Some(keyword),
                ),
                Err(error) => Err(error),
            };
            if let Err(error) = action {
                undo.apply_to(stack);
                return Err(error);
            }
            empty = false;
        }
        if let Some(comment) = comment {
            if let Err(error) = self.apply_comment(stack, comment) {
                undo.apply_to(stack);
                return Err(error);
            }
            empty = false;
        }
        self.dirty |= empty;
        Ok(())
    }

    fn split_comment(line: &str) -> (&str, Option<&str>) {
        if let Some(stop) = line.find('#') {
            let start = stop + 1;
            let values = line[..stop].trim();
            let comment = line[start..].trim();
            let comment = if comment.is_empty() { None } else { Some(comment) };
            (values, comment)
        } else {
            let values = line.trim();
            (values, None)
        }
    }

    fn apply_action(
        &mut self,
        writer: &mut W,
        stack: &mut ValueStack,
        undo: &mut Undo,
        redo: &mut Undo,
        action: Action<W>,
        keyword: Option<&str>,
    ) -> MyResult<()> {
        match action {
            Action::Operation(operation) => {
                match operation.as_ref() {
                    Operation::ValueNone(function) => {
                        let result = function()?;
                        stack.push_single(undo, result, keyword);
                        self.dirty = true;
                    }
                    Operation::ValueOne(function) => {
                        let value = stack.pop_single(undo, None)?;
                        let result = function(value)?;
                        stack.push_single(undo, result, keyword);
                        self.dirty = true;
                    }
                    Operation::ValueTwo(function) => {
                        let (value1, value2) = stack.pop_double(undo, None)?;
                        let result = function(value1, value2)?;
                        stack.push_single(undo, result, keyword);
                        self.dirty = true;
                    }
                    Operation::ValueAll(function) => {
                        let (values, _) = stack.pop_series(undo, None);
                        let result = function(values)?;
                        stack.push_single(undo, result, keyword);
                        self.dirty = true;
                    }
                    Operation::SeriesTwo(function) => {
                        let (value1, value2) = stack.pop_double(undo, None)?;
                        let results = function(value1, value2)?;
                        self.dirty |= stack.push_series(undo, results, keyword);
                    }
                    Operation::SeriesThree(function) => {
                        let (value1, value2, value3) = stack.pop_triple(undo, None)?;
                        let results = function(value1, value2, value3)?;
                        self.dirty |= stack.push_series(undo, results, keyword);
                    }
                    Operation::SeriesAll(function) => {
                        let (values, as_series) = stack.pop_series(undo, None);
                        let results = function(values)?;
                        if as_series {
                            self.dirty |= stack.push_series(undo, results, keyword);
                        } else {
                            self.dirty |= stack.push_singles(undo, results, keyword);
                        }
                    }
                    Operation::TimeNow(function) => {
                        let result = function(&self.config.now)?;
                        stack.push_single(undo, result, keyword);
                        self.dirty = true;
                    }
                    Operation::TimeCast(function) => {
                        let value = stack.pop_single(undo, None)?;
                        let result = function(value)?;
                        stack.push_single(undo, result, keyword);
                        self.dirty = true;
                    }
                    Operation::ContextNone(function) => {
                        function(&mut self.context.borrow_mut());
                        self.dirty = true;
                    }
                    Operation::ContextOne(function) => {
                        let value = stack.pop_single(undo, keyword)?;
                        function(&mut self.context.borrow_mut(), value);
                        self.dirty = true;
                    }
                    Operation::EngineNone(function) => {
                        if let Some(dirty) = function(self, writer, stack)? {
                            self.dirty = dirty;
                        }
                    }
                    Operation::EngineUndo(function, _, _) => {
                        if let Some(dirty) = function(self, stack, undo, redo, keyword)? {
                            self.dirty = dirty;
                        }
                    }
                }
            }
            Action::Directive(directive, tokens) => {
                match directive.as_ref() {
                    Directive::EngineOne(function, _) => {
                        let token = tokens.into_iter().next();
                        self.dirty |= function(self, writer, stack, token)?;
                    }
                    Directive::EngineAll(function, _) => {
                        self.dirty |= function(self, writer, stack, tokens)?;
                    }
                    Directive::EngineApply(function, _) => {
                        self.dirty |= function(self, writer, keyword, stack, undo, redo, tokens)?;
                    }
                }
            }
            Action::Definition(actions) => {
                for action in actions {
                    self.apply_action(writer, stack, undo, redo, action, None)?;
                }
                undo.merge(0, vec![], keyword);
            }
            Action::Value(value, dirty) => {
                stack.push_single(undo, value, keyword);
                self.dirty |= dirty;
            }
        }
        Ok(())
    }

    fn apply_comment(
        &mut self,
        stack: &ValueStack,
        comment: &str,
    ) -> MyResult<()> {
        let value = stack.peek_single()?;
        value.borrow_mut().set_comment(comment);
        self.dirty = true;
        Ok(())
    }

    fn commit_undo(
        &mut self,
        undo: Undo,
        redo: Undo,
    ) {
        if !undo.is_empty() {
            self.undos.push(undo);
            self.redos.clear();
        } else if !redo.is_empty() {
            self.redos.push(redo);
        }
    }

    pub fn flat_values(
        &mut self,
        stack: &mut ValueStack,
        undo: &mut Undo,
        redo: &mut Undo,
        keyword: Option<&str>,
    ) -> MyResult<Option<bool>> {
        if stack.items.iter().any(|item| matches!(item, StackItem::Series(_))) {
            let items = stack.pop_stack(undo, None);
            redo.clear();
            stack.push_singles(undo, items, keyword);
            Ok(Some(true))
        } else {
            Ok(None)
        }
    }

    pub fn clear_values(
        &mut self,
        stack: &mut ValueStack,
        undo: &mut Undo,
        redo: &mut Undo,
        keyword: Option<&str>,
    ) -> MyResult<Option<bool>> {
        let items = stack.wrapped_drain(..).collect();
        undo.merge(0, items, keyword);
        redo.clear();
        Ok(Some(true))
    }

    pub fn pop_value(
        &mut self,
        stack: &mut ValueStack,
        undo: &mut Undo,
        redo: &mut Undo,
        keyword: Option<&str>,
    ) -> MyResult<Option<bool>> {
        stack.pop_single(undo, keyword)?;
        redo.clear();
        Ok(Some(true))
    }

    pub fn dup_value(
        &mut self,
        stack: &mut ValueStack,
        undo: &mut Undo,
        redo: &mut Undo,
        keyword: Option<&str>,
    ) -> MyResult<Option<bool>> {
        let value = stack.peek_single()?;
        let value = Rc::new(RefCell::new(value.borrow().clone()));
        stack.push_single(undo, value, keyword);
        redo.clear();
        Ok(Some(true))
    }

    pub fn swap_values(
        &mut self,
        stack: &mut ValueStack,
        undo: &mut Undo,
        redo: &mut Undo,
        keyword: Option<&str>,
    ) -> MyResult<Option<bool>> {
        let (value1, value2) = stack.pop_double(undo, None)?;
        stack.push_single(undo, value2, None);
        stack.push_single(undo, value1, keyword);
        redo.clear();
        Ok(Some(true))
    }

    pub fn cut_value(
        &mut self,
        stack: &mut ValueStack,
        undo: &mut Undo,
        redo: &mut Undo,
        keyword: Option<&str>,
    ) -> MyResult<Option<bool>> {
        let value = stack.pop_single(undo, keyword)?;
        self.clip = Some(value);
        redo.clear();
        Ok(Some(true))
    }

    pub fn copy_value(
        &mut self,
        stack: &mut ValueStack,
        _undo: &mut Undo,
        _redo: &mut Undo,
        _keyword: Option<&str>,
    ) -> MyResult<Option<bool>> {
        let value = stack.peek_single()?;
        let value = Rc::new(RefCell::new(value.borrow().clone()));
        self.clip = Some(value);
        Ok(None)
    }

    pub fn paste_value(
        &mut self,
        stack: &mut ValueStack,
        undo: &mut Undo,
        redo: &mut Undo,
        keyword: Option<&str>,
    ) -> MyResult<Option<bool>> {
        if let Some(clip) = &self.clip {
            stack.push_single(undo, Rc::clone(clip), keyword);
            redo.clear();
            Ok(Some(true))
        } else {
            Err(MyError::from(EngineError::MissingClip))
        }
    }

    pub fn import_file(
        &mut self,
        writer: &mut W,
        stack: &mut ValueStack,
        tokens: Vec<String>,
    ) -> MyResult<bool> {
        let reader = FileInput::new(&tokens);
        self.parse_files(writer, stack, reader)?;
        Ok(true)
    }

    pub fn export_file(
        &mut self,
        _writer: &mut W,
        stack: &mut ValueStack,
        tokens: Vec<String>,
    ) -> MyResult<bool> {
        if let Some(path) = tokens.first() {
            let mut writer = File::create(path)?;
            let sep = self.context.borrow_mut().swap_sep(false);
            let result = self.write_simple(&mut writer, stack);
            self.context.borrow_mut().swap_sep(sep);
            result?;
        }
        Ok(false)
    }

    pub fn set_variable(
        &mut self,
        writer: &mut W,
        stack: &mut ValueStack,
        token: Option<String>,
    ) -> MyResult<bool> {
        if let Some(token) = token {
            let value = stack.peek_single()?;
            if self.interface.borrow_mut().insert_variable(token.clone(), Rc::clone(&value)) {
                for (value, _) in stack.iter_stack() {
                    Self::unassign_variable(value, &token);
                }
            }
            self.reassign_variable(value, token);
            self.interface.borrow().adjust_editor(&mut self.editor);
            Ok(true)
        } else {
            let items = self.interface.borrow()
                .get_variables()
                .iter()
                .sorted_by(|(lhs, _), (rhs, _)| String::cmp(lhs, rhs))
                .map(|(_, value)| Rc::clone(value))
                .map(|value| StackItem::Single(value))
                .collect::<Vec<_>>();
            let mut stack = ValueStack::new(items);
            self.show_stack(writer, &mut stack)?;
            Ok(false)
        }
    }

    fn unassign_variable(value: ValueRef, token: &str) {
        let mut inner = value.borrow_mut();
        if let Some(previous) = &inner.variable {
            if previous == token {
                inner.variable = None;
            }
        }
    }

    fn reassign_variable(&mut self, value: ValueRef, token: String) {
        let mut inner = value.borrow_mut();
        if let Some(previous) = &inner.variable {
            if previous != &token {
                self.interface.borrow_mut().remove_variable(previous);
            }
        }
        inner.variable = Some(token);
    }

    pub fn define_function(
        &mut self,
        writer: &mut W,
        _stack: &mut ValueStack,
        tokens: Vec<String>,
    ) -> MyResult<bool> {
        let mut tokens = tokens.iter();
        if let Some(keyword) = tokens.next() {
            let description = tokens.clone().join(" ");
            let actions = self.parse_actions(tokens)?;
            if !actions.is_empty() {
                let (input, output) = action::fold_actions(&actions);
                self.interface.borrow_mut().insert_definition(
                    keyword,
                    actions,
                    input,
                    output,
                    description,
                );
            } else {
                self.interface.borrow_mut().remove_definition(keyword);
            }
            self.interface.borrow().adjust_editor(&mut self.editor);
        } else {
            self.interface.borrow().show_definitions(writer, self.interact)?;
        }
        Ok(false)
    }

    pub fn apply_all(
        &mut self,
        writer: &mut W,
        keyword: Option<&str>,
        stack: &mut ValueStack,
        undo: &mut Undo,
        _redo: &mut Undo,
        tokens: Vec<String>,
    ) -> MyResult<bool> {
        let actions = self.parse_actions(tokens.iter())?;
        if let (Count::N(1), Count::N(1)) = action::fold_actions(&actions) {
            let (input_values, as_series) = stack.pop_series(undo, None);
            let mut output_values = Vec::new();
            let mut temp_undo = Undo::new(0, vec![], vec![]);
            let mut temp_redo = Undo::new(0, vec![], vec![]);
            for value in input_values {
                let mut temp_stack = ValueStack::new(Vec::new());
                temp_stack.push_single(&mut temp_undo, value, None);
                for action in &actions {
                    self.apply_action(
                        writer,
                        &mut temp_stack,
                        &mut temp_undo,
                        &mut temp_redo,
                        action.clone(),
                        None,
                    )?;
                }
                let (mut temp_values, _) = temp_stack.pop_series(&mut temp_undo, None);
                output_values.append(&mut temp_values);
            }
            if !output_values.is_empty() {
                if as_series {
                    stack.push_series(undo, output_values, None);
                } else {
                    stack.push_singles(undo, output_values, None);
                }
                undo.add_tokens(keyword, tokens);
                Ok(true)
            } else {
                Ok(false)
            }
        } else {
            Err(MyError::Engine(EngineError::BadApplyOp))
        }
    }

    fn parse_actions(
        &mut self,
        tokens: Iter<String>,
    ) -> MyResult<Vec<Action<W>>> {
        let tokens = tokens.map(String::as_ref);
        let actions = Actions::new(&self.interface, tokens);
        actions
            .map(|result| result.map(|(x, _)| x))
            .collect::<MyResult<Vec<Action<W>>>>()
    }

    pub fn undo_stack(
        &mut self,
        stack: &mut ValueStack,
        undo: &mut Undo,
        redo: &mut Undo,
        _keyword: Option<&str>,
    ) -> MyResult<Option<bool>> {
        if !undo.is_empty() {
            self.redos.push(undo.apply_to(stack));
            redo.clear();
            Ok(Some(true))
        } else if let Some(mut undo) = self.undos.pop() {
            self.redos.push(undo.apply_to(stack));
            redo.clear();
            Ok(Some(true))
        } else {
            Err(MyError::from(EngineError::MissingUndo))
        }
    }

    pub fn redo_stack(
        &mut self,
        stack: &mut ValueStack,
        undo: &mut Undo,
        redo: &mut Undo,
        _keyword: Option<&str>,
    ) -> MyResult<Option<bool>> {
        if undo.is_empty() {
            if !redo.is_empty() {
                self.undos.push(redo.apply_to(stack));
                return Ok(Some(true));
            } else if let Some(mut redo) = self.redos.pop() {
                self.undos.push(redo.apply_to(stack));
                return Ok(Some(true));
            }
        }
        Err(MyError::from(EngineError::MissingRedo))
    }

    pub fn show_history(
        &mut self,
        writer: &mut W,
        _stack: &mut ValueStack,
    ) -> MyResult<Option<bool>> {
        if self.interact {
            self.limit_history(writer, PAGE_LIMIT)?;
        }
        Ok(Some(false))
    }

    fn limit_history(&mut self, writer: &mut W, limit: usize) -> MyResult<()> {
        if self.undos.is_empty() {
            writeln!(writer, "  <==")?;
        } else {
            if self.undos.len() > limit {
                writeln!(writer, "  ...")?;
            }
            for (index, undo) in self.undos.iter().rev().enumerate().take(limit).rev() {
                if index == 0 {
                    writeln!(writer, "  {} <==", undo)?;
                } else {
                    writeln!(writer, "  {}", undo)?;
                }
            }
        }
        for redo in self.redos.iter().rev().take(limit) {
            writeln!(writer, "  {}", redo)?;
        }
        if self.redos.len() > limit {
            writeln!(writer, "  ...")?;
        }
        Ok(())
    }

    fn show_simple(
        &mut self,
        writer: &mut W,
        stack: &mut ValueStack,
    ) -> Result<(), MyError> {
        if self.config.sum {
            let mut undo = Undo::new(0, vec![], vec![]);
            let (values, _) = stack.pop_series(&mut undo, None);
            let result = Value::calc_sum(values)?;
            stack.push_single(&mut undo, result, None);
        }
        if self.config.hex {
            self.context.borrow_mut().set_hex();
        }
        if self.config.sep {
            self.context.borrow_mut().set_sep();
        }
        if let Some(dp) = self.config.dp {
            self.context.borrow_mut().set_dp_u8(dp);
        }
        self.write_simple(writer, stack)?;
        Ok(())
    }

    fn write_simple<V: Write>(
        &mut self,
        writer: &mut V,
        stack: &mut ValueStack,
    ) -> MyResult<()> {
        self.measure_hexadecimal(stack);
        let context = self.context.borrow();
        for (value, _) in stack.iter_stack() {
            let (integer, fraction, _, _) = value.borrow().to_strings(&context);
            writeln!(writer, "{}{}", integer, fraction)?;
        }
        Ok(())
    }

    pub fn show_stack(
        &mut self,
        writer: &mut W,
        stack: &mut ValueStack,
    ) -> MyResult<Option<bool>> {
        self.limit_stack(writer, stack, None)?;
        Ok(Some(false))
    }

    fn limit_stack(
        &mut self,
        writer: &mut W,
        stack: &mut ValueStack,
        limit: Option<usize>,
    ) -> MyResult<()> {
        if self.interact {
            self.measure_hexadecimal(stack);
            let context = self.context.borrow();
            let table = match limit {
                Some(limit) if limit < stack.total_len() => {
                    // It is necessary to collect intermediate results
                    // into a vector, or the double ended iterator is
                    // not called.
                    writeln!(writer, "  ...")?;
                    stack.iter_stack()
                        .rev()
                        .take(limit)
                        .collect::<Vec<_>>()
                        .into_iter()
                        .rev()
                        .map(|(value, style)| (value.borrow().to_strings(&context), style))
                        .collect::<Vec<_>>()
                }
                _ => {
                    stack.iter_stack()
                        .map(|(value, style)| (value.borrow().to_strings(&context), style))
                        .collect::<Vec<_>>()
                }
            };
            let integer_width = table.iter()
                .map(|((x, _, _, _), _)| x.len())
                .max()
                .unwrap_or_default();
            let fraction_width = table.iter()
                .map(|((_, x, _, _), _)| x.len())
                .max()
                .unwrap_or_default();
            for ((integer, fraction, variable, comment), style) in table {
                let padding = create_padding(' ', integer_width + 1, integer.len(), 0);
                let prefix = self.chars.get_prefix(style).unwrap_or(' ');
                let suffix = self.chars.get_suffix(style);
                write!(writer, "{}{}{}{}", prefix, padding, integer, fraction)?;
                if suffix.is_some() || variable.is_some() || comment.is_some() {
                    let padding = create_padding(' ', fraction_width, fraction.len(), 0);
                    write!(writer, "{}", padding)?;
                }
                if let Some(suffix) = suffix {
                    write!(writer, " {}", suffix)?;
                }
                if let Some(variable) = variable {
                    write!(writer, " = {}", variable)?;
                }
                if let Some(comment) = comment {
                    write!(writer, " # {}", comment)?;
                }
                writeln!(writer)?;
            }
        }
        Ok(())
    }

    fn measure_hexadecimal(&mut self, stack: &ValueStack) {
        let mut context = self.context.borrow_mut();
        if let Format::Base16(_) = context.format {
            let chunks = stack.iter_stack()
                .map(|(value, _)| value.borrow().measure_hexadecimal())
                .max()
                .unwrap_or_default();
            context.format = Format::Base16(chunks);
        }
    }

    pub fn show_help(
        &mut self,
        writer: &mut W,
        _stack: &mut ValueStack,
    ) -> MyResult<Option<bool>> {
        self.interface.borrow().show_help(writer, self.interact)?;
        Ok(Some(false))
    }
}

// noinspection DuplicatedCode
#[cfg(test)]
pub mod tests {
    use crate::calc::context::Format;
    use crate::calc::undo::tests::create_undo;
    use crate::calc::value::tests::parse_value;
    use crate::config::Config;
    use crate::core::stack::tests::{parse_item, parse_items, parse_series};
    use crate::core::stack::{BracketChars, ValueStack};
    use crate::engine::Engine;
    use crate::error::MyResult;
    use crate::util::text::tests::BufferWriter;
    use pretty_assertions::assert_eq;
    use std::collections::HashMap;
    use std::io::Write;

    #[test]
    fn test_split_comment_finds_first_hash() {
        assert_eq!(Engine::<BufferWriter>::split_comment("\tone two three\t"), ("one two three", None));
        assert_eq!(Engine::<BufferWriter>::split_comment("\tone two three #\t"), ("one two three", None));
        assert_eq!(Engine::<BufferWriter>::split_comment("\tone # two # three\t"), ("one", Some("two # three")));
    }

    // VALUE CREATION

    #[test]
    fn test_create_values_modifies_stack() {
        let expected_items = parse_items(vec!["1", "2", "3", "4", "5", "6"]);
        let expected_undos = vec![
            create_undo(3, vec![], vec!["1", "2", "3"]),
            create_undo(3, vec![], vec!["4", "5", "6"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2 3").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "4 5 6").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_comment_modifies_current_line() {
        let expected_items = vec![
            parse_item("1"),
            parse_item("2"),
            parse_item("3"),
            parse_item("42 # the answer"),
        ];
        let expected_undos = vec![
            create_undo(2, vec![], vec!["1", "2"]),
            create_undo(2, vec![], vec!["3", "42"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "3 42 # the answer").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_comment_modifies_previous_line() {
        let expected_items = vec![
            parse_item("1"),
            parse_item("2"),
            parse_item("3"),
            parse_item("42 # the answer"),
        ];
        let expected_undos = vec![
            create_undo(4, vec![], vec!["1", "2", "3", "42"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2 3 42").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "# the answer").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_comment_fails_cleanly() {
        let expected_items = vec![];
        let expected_undos = vec![];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "# the answer").is_err());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "Not enough values on stack\n");
    }

    // UNKNOWN OPERATIONS

    #[test]
    fn test_unknown_operation_fails_cleanly() {
        let expected_items = parse_items(vec!["1", "2", "3"]);
        let expected_undos = vec![
            create_undo(3, vec![], vec!["1", "2", "3"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2 3").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "4 5 xyz 999").is_err());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "Invalid number or keyword: xyz\n");
    }

    // NULLARY OPERATIONS

    #[test]
    fn test_nullary_operation_modifies_stack() {
        let expected_undos = vec![
            create_undo(1, vec![], vec!["now"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "now").is_ok());
        assert_eq!(stack.wrapped_len(), 1);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    // UNARY OPERATIONS

    #[test]
    fn test_unary_operation_modifies_stack() {
        let expected_items = parse_items(vec!["1", "-2"]);
        let expected_undos = vec![
            create_undo(3, vec![], vec!["1", "2", "3"]),
            create_undo(1, vec!["2", "3"], vec!["pop", "neg"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2 3").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "pop neg").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_unary_operation_fails_cleanly() {
        let expected_items = parse_items(vec!["1", "2", "3"]);
        let expected_undos = vec![
            create_undo(3, vec![], vec!["1", "2", "3"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2 3").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "pop pop pop neg 999").is_err());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "Not enough values on stack\n");
    }

    // BINARY OPERATIONS

    #[test]
    fn test_binary_operation_modifies_stack() {
        let expected_items = parse_items(vec!["1", "5"]);
        let expected_undos = vec![
            create_undo(3, vec![], vec!["1", "2", "3"]),
            create_undo(1, vec!["2", "3"], vec!["add"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2 3").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "add").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_binary_operation_fails_cleanly() {
        let expected_items = parse_items(vec!["1", "2", "3"]);
        let expected_undos = vec![
            create_undo(3, vec![], vec!["1", "2", "3"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2 3").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "pop pop add 999").is_err());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "Not enough values on stack\n");
    }

    // SERIES OPERATIONS

    #[test]
    fn test_series_to_value_operation_modifies_stack() {
        let expected_items = parse_items(vec!["6"]);
        let expected_undos = vec![
            create_undo(3, vec![], vec!["1", "2", "3"]),
            create_undo(1, vec!["1", "2", "3"], vec!["sum"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2 3").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "sum").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_binary_to_series_operation_modifies_stack() {
        let expected_items = parse_items(vec!["[1 2 3 4 5]"]);
        let expected_undos = vec![
            create_undo(2, vec![], vec!["1", "5"]),
            create_undo(1, vec!["1", "5"], vec!["seq"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 5").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "seq").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_binary_to_series_operation_fails_cleanly() {
        let expected_items = parse_items(vec!["1", "5"]);
        let expected_undos = vec![
            create_undo(2, vec![], vec!["1", "5"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 5").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "pop seq 999").is_err());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "Not enough values on stack\n");
    }

    #[test]
    fn test_series_to_series_operation_modifies_stack() {
        let expected_items = parse_items(vec!["5", "4", "3", "2", "1"]);
        let expected_undos = vec![
            create_undo(5, vec![], vec!["1", "2", "3", "4", "5"]),
            create_undo(5, vec!["1", "2", "3", "4", "5"], vec!["rev"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2 3 4 5").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "rev").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_series_to_series_operation_modifies_series() {
        let expected_items = parse_items(vec!["1", "2", "[5 4 3]"]);
        let expected_undos = vec![
            create_undo(3, vec![], vec!["1", "2", "3", "5", "seq"]),
            create_undo(1, vec!["[3 4 5]"], vec!["rev"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2 3 5 seq").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "rev").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    // APPLY OPERATIONS

    #[test]
    fn test_apply_unary_operation_modifies_empty() {
        let expected_items = vec![];
        let expected_undos = vec![];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "apply 2 pow").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_apply_unary_operation_modifies_stack() {
        let expected_items = parse_items(vec!["1", "4", "9", "16", "25", "36"]);
        let expected_undos = vec![
            create_undo(3, vec![], vec!["1", "2", "5", "seq", "6"]),
            create_undo(6, vec!["1", "[2 3 4 5]", "6"], vec!["apply", "2", "pow"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2 5 seq 6").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "apply 2 pow").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_apply_unary_operation_modifies_series() {
        let expected_items = parse_items(vec!["1", "2", "3", "[16 25 36]"]);
        let expected_undos = vec![
            create_undo(4, vec![], vec!["1", "2", "3", "4", "6", "seq"]),
            create_undo(1, vec!["[4 5 6]"], vec!["apply", "2", "pow"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2 3 4 6 seq").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "apply 2 pow").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_apply_nullary_operation_fails_cleanly() {
        let expected_items = vec![];
        let expected_undos = vec![];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "apply now").is_err());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "Unsupported apply operation (must be unary)\n");
    }

    #[test]
    fn test_apply_binary_operation_fails_cleanly() {
        let expected_items = vec![];
        let expected_undos = vec![];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "apply add").is_err());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "Unsupported apply operation (must be unary)\n");
    }

    #[test]
    fn test_apply_series_operation_fails_cleanly() {
        let expected_items = vec![];
        let expected_undos = vec![];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "apply sum").is_err());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "Unsupported apply operation (must be unary)\n");
    }

    // CAST OPERATIONS

    #[test]
    fn test_cast_modifies_current_line() {
        let expected_items = vec![
            parse_item("1"),
            parse_item("2"),
            parse_item("3"),
            parse_item("5025.678 [delta]"),
        ];
        let expected_undos = vec![
            create_undo(2, vec![], vec!["1", "2"]),
            create_undo(2, vec![], vec!["3", "5025.678", "delta"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "3 5025.678 delta").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_cast_modifies_previous_line() {
        let expected_items = vec![
            parse_item("1"),
            parse_item("2"),
            parse_item("3"),
            parse_item("5025.678 [delta]"),
        ];
        let expected_undos = vec![
            create_undo(4, vec![], vec!["1", "2", "3", "5025.678"]),
            create_undo(1, vec!["5025.678"], vec!["delta"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2 3 5025.678").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "delta").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_cast_fails_cleanly() {
        let expected_items = vec![];
        let expected_undos = vec![];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "delta").is_err());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "Not enough values on stack\n");
    }

    // FLAT OPERATIONS

    #[test]
    fn test_flat_operation_leaves_stack_no_series() {
        let expected_items = parse_items(vec!["1", "2", "3", "4", "5"]);
        let expected_undos = vec![
            create_undo(5, vec![], vec!["1", "2", "3", "4", "5"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2 3 4 5").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "flat").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_flat_operation_modifies_stack_with_series() {
        let expected_items = parse_items(vec!["1", "2", "3", "4", "5", "6", "7", "8"]);
        let expected_undos = vec![
            create_undo(5, vec![], vec!["1", "2", "3", "seq", "4", "5", "7", "seq", "8"]),
            create_undo(8, vec!["1", "[2 3]", "4", "[5 6 7]", "8"], vec!["flat"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2 3 seq 4 5 7 seq 8").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "flat").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    // CLEAR OPERATIONS

    #[test]
    fn test_clear_operation_modifies_stack() {
        let expected_items = vec![];
        let expected_undos = vec![
            create_undo(3, vec![], vec!["1", "2", "3"]),
            create_undo(0, vec!["1", "2", "3"], vec!["clear"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2 3").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "clear").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    // POP OPERATIONS

    #[test]
    fn test_pop_operation_modifies_stack() {
        let expected_items = parse_items(vec!["1", "2"]);
        let expected_undos = vec![
            create_undo(3, vec![], vec!["1", "2", "3"]),
            create_undo(0, vec!["3"], vec!["pop"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2 3").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "pop").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_pop_operation_fails_cleanly() {
        let expected_items = parse_items(vec!["1", "2", "3"]);
        let expected_undos = vec![
            create_undo(3, vec![], vec!["1", "2", "3"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2 3").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "pop pop pop pop 999").is_err());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "Not enough values on stack\n");
    }

    // DUP OPERATIONS

    #[test]
    fn test_dup_operation_modifies_stack() {
        let expected_items = vec![
            parse_item("1"),
            parse_item("2"),
            parse_item("3 = x # comment"),
            parse_item("3 # comment"),
        ];
        let expected_undos = vec![
            create_undo(3, vec![], vec!["1", "2", "3"]),
            create_undo(1, vec![], vec!["dup"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2 3 = x # comment").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "dup").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_dup_operation_fails_cleanly() {
        let expected_items = vec![
            parse_item("1"),
            parse_item("2"),
            parse_item("3 = x # comment"),
        ];
        let expected_undos = vec![
            create_undo(3, vec![], vec!["1", "2", "3"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2 3 = x # comment").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "pop pop pop dup 999").is_err());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "Not enough values on stack\n");
    }

    // SWAP OPERATIONS

    #[test]
    fn test_swap_operation_modifies_stack() {
        let expected_items = parse_items(vec!["1", "3", "2"]);
        let expected_undos = vec![
            create_undo(3, vec![], vec!["1", "2", "3"]),
            create_undo(2, vec!["2", "3"], vec!["swap"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2 3").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "swap").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_swap_operation_fails_cleanly() {
        let expected_items = parse_items(vec!["1", "2", "3"]);
        let expected_undos = vec![
            create_undo(3, vec![], vec!["1", "2", "3"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2 3").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "pop pop swap 999").is_err());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "Not enough values on stack\n");
    }

    // CUT OPERATIONS

    #[test]
    fn test_cut_operation_copies_value() {
        let expected_items = vec![];
        let expected_undos = vec![
            create_undo(1, vec![], vec!["42"]),
            create_undo(0, vec!["42"], vec!["cut"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "42").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "cut").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(engine.clip, Some(parse_value("42")));
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_cut_operation_fails_cleanly() {
        let expected_items = vec![];
        let expected_undos = vec![];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "cut").is_err());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(engine.clip, None);
        assert_eq!(writer.buffer, "Not enough values on stack\n");
    }

    // COPY OPERATIONS

    #[test]
    fn test_copy_operation_copies_value() {
        let expected_items = parse_items(vec!["42 = x # comment"]);
        let expected_undos = vec![
            create_undo(1, vec![], vec!["42"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "42 = x # comment").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "copy").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(engine.clip, Some(parse_value("42 # comment")));
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_copy_operation_fails_cleanly() {
        let expected_items = vec![];
        let expected_undos = vec![];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "copy").is_err());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(engine.clip, None);
        assert_eq!(writer.buffer, "Not enough values on stack\n");
    }

    // PASTE OPERATIONS

    #[test]
    fn test_paste_operation_copies_value() {
        let expected_items = parse_items(vec!["42", "42"]);
        let expected_undos = vec![
            create_undo(1, vec![], vec!["42"]),
            create_undo(1, vec![], vec!["paste"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "42").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "copy").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "paste").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(engine.clip, Some(parse_value("42")));
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_paste_operation_fails_cleanly() {
        let expected_items = parse_items(vec!["42"]);
        let expected_undos = vec![
            create_undo(1, vec![], vec!["42"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "42").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "paste").is_err());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(engine.clip, None);
        assert_eq!(writer.buffer, "No value on clipboard\n");
    }

    // UNDO OPERATIONS

    #[test]
    fn test_single_undo_resets_previous_line() {
        let expected_items = parse_items(vec!["4", "5", "6"]);
        let expected_undos = vec![
            create_undo(3, vec![], vec!["4", "5", "6"]),
        ];
        let expected_redos = vec![
            create_undo(2, vec!["11"], vec!["add"]),
        ];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "4 5 6").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "add").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "undo").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_double_undo_resets_previous_lines() {
        let expected_items = vec![];
        let expected_undos = vec![];
        let expected_redos = vec![
            create_undo(2, vec!["11"], vec!["add"]),
            create_undo(0, vec!["4", "5", "6"], vec!["4", "5", "6"]),
        ];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "4 5 6").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "add").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "undo undo").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_single_undo_with_suffix_resets_previous_line() {
        let expected_items = parse_items(vec!["4", "30"]);
        let expected_undos = vec![
            create_undo(3, vec![], vec!["4", "5", "6"]),
            create_undo(1, vec!["5", "6"], vec!["mul"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "4 5 6").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "add").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "undo mul").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_double_undo_with_suffix_resets_previous_lines() {
        let expected_items = parse_items(vec!["1", "6"]);
        let expected_undos = vec![
            create_undo(3, vec![], vec!["1", "2", "3"]),
            create_undo(1, vec!["2", "3"], vec!["mul"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2 3").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "4 5 6").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "add").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "undo undo mul").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_single_undo_with_prefix_resets_current_line() {
        let expected_items = parse_items(vec!["4", "11"]);
        let expected_undos = vec![
            create_undo(3, vec![], vec!["4", "5", "6"]),
            create_undo(1, vec!["5", "6"], vec!["add"]),
        ];
        let expected_redos = vec![
            create_undo(2, vec!["15"], vec!["add"]),
        ];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "4 5 6").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "add").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "add undo").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_double_undo_with_prefix_resets_current_and_previous_lines() {
        let expected_items = parse_items(vec!["4", "5", "6"]);
        let expected_undos = vec![
            create_undo(3, vec![], vec!["4", "5", "6"]),
        ];
        let expected_redos = vec![
            create_undo(2, vec!["15"], vec!["add"]),
            create_undo(2, vec!["11"], vec!["add"]),
        ];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "4 5 6").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "add").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "add undo undo").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_single_undo_with_prefix_and_suffix_resets_current_line() {
        let expected_items = parse_items(vec!["44"]);
        let expected_undos = vec![
            create_undo(3, vec![], vec!["4", "5", "6"]),
            create_undo(1, vec!["5", "6"], vec!["add"]),
            create_undo(1, vec!["4", "11"], vec!["mul"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "4 5 6").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "add").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "add undo mul").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_double_undo_with_prefix_and_suffix_resets_current_and_previous_lines() {
        let expected_items = parse_items(vec!["4", "30"]);
        let expected_undos = vec![
            create_undo(3, vec![], vec!["4", "5", "6"]),
            create_undo(1, vec!["5", "6"], vec!["mul"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "4 5 6").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "add").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "add undo undo mul").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_triple_undo_operation_fails_cleanly() {
        let expected_items = vec![];
        let expected_undos = vec![];
        let expected_redos = vec![
            create_undo(2, vec!["11"], vec!["add"]),
            create_undo(0, vec!["4", "5", "6"], vec!["4", "5", "6"]),
        ];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "4 5 6").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "add").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "undo undo undo").is_err());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "Start of undo history\n");
    }

    // REDO OPERATIONS

    #[test]
    fn test_single_redo_operation_modifies_stack() {
        let expected_items = parse_items(vec!["4", "11"]);
        let expected_undos = vec![
            create_undo(3, vec![], vec!["4", "5", "6"]),
            create_undo(1, vec!["5", "6"], vec!["add"]),
        ];
        let expected_redos = vec![
            create_undo(2, vec!["15"], vec!["add"]),
        ];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "4 5 6").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "add").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "add").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "undo undo").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "redo").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_double_redo_operation_modifies_stack() {
        let expected_items = parse_items(vec!["15"]);
        let expected_undos = vec![
            create_undo(3, vec![], vec!["4", "5", "6"]),
            create_undo(1, vec!["5", "6"], vec!["add"]),
            create_undo(1, vec!["4", "11"], vec!["add"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "4 5 6").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "add").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "add").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "undo undo").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "redo redo").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_single_redo_operation_with_prefix_fails_cleanly() {
        let expected_items = parse_items(vec!["4", "5", "6"]);
        let expected_undos = vec![
            create_undo(3, vec![], vec!["4", "5", "6"]),
        ];
        let expected_redos = vec![
            create_undo(2, vec!["15"], vec!["add"]),
            create_undo(2, vec!["11"], vec!["add"]),
        ];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "4 5 6").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "add").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "add").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "undo undo").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "mul redo 999").is_err());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "End of undo history\n");
    }

    #[test]
    fn test_triple_redo_operation_fails_cleanly() {
        let expected_items = parse_items(vec!["15"]);
        let expected_undos = vec![
            create_undo(3, vec![], vec!["4", "5", "6"]),
            create_undo(1, vec!["5", "6"], vec!["add"]),
            create_undo(1, vec!["4", "11"], vec!["add"]),
        ];
        let expected_redos = vec![];
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "4 5 6").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "add").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "add").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "undo undo").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "redo redo redo 999").is_err());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.undos, expected_undos);
        assert_eq!(engine.redos, expected_redos);
        assert_eq!(writer.buffer, "End of undo history\n");
    }

    // VARIABLE ASSIGNMENT

    #[test]
    fn test_variable_not_assigned_by_default() {
        let expected_items = vec![
            parse_item("1"),
            parse_item("2"),
            parse_item("3"),
        ];
        let expected_variables = HashMap::new();
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2 3").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.interface.borrow().get_variables(), &expected_variables);
    }

    #[test]
    fn test_variable_is_assigned_to_new_entry() {
        let expected_items = vec![
            parse_item("1"),
            parse_item("2 = foo"),
            parse_item("3"),
        ];
        let expected_variables = HashMap::from([
            (String::from("foo"), parse_value("2 = foo")),
        ]);
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "set foo").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "3").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.interface.borrow().get_variables(), &expected_variables);
    }

    #[test]
    fn test_variable_is_reassigned_to_new_entry() {
        let expected_items = vec![
            parse_item("1"),
            parse_item("2"),
            parse_item("3 = foo"),
        ];
        let expected_variables = HashMap::from([
            (String::from("foo"), parse_value("3 = foo")),
        ]);
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "set foo").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "3").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "set foo").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.interface.borrow().get_variables(), &expected_variables);
    }

    #[test]
    fn test_variable_is_replaced_with_same_name() {
        let expected_items = vec![
            parse_item("1"),
            parse_item("2"),
            parse_item("3 = foo"),
        ];
        let expected_variables = HashMap::from([
            (String::from("foo"), parse_value("3 = foo")),
        ]);
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2 3").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "set foo").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "set foo").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.interface.borrow().get_variables(), &expected_variables);
    }

    #[test]
    fn test_variable_is_replaced_with_new_name() {
        let expected_items = vec![
            parse_item("1"),
            parse_item("2"),
            parse_item("3 = bar"),
        ];
        let expected_variables = HashMap::from([
            (String::from("bar"), parse_value("3 = bar")),
        ]);
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 2 3").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "set foo").is_ok());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "set bar").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.interface.borrow().get_variables(), &expected_variables);
    }

    #[test]
    fn test_variable_assignment_fails_cleanly() {
        let expected_variables = HashMap::new();
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "set foo").is_err());
        assert_eq!(engine.interface.borrow().get_variables(), &expected_variables);
        assert_eq!(writer.buffer, "Not enough values on stack\n");
    }

    #[test]
    fn test_variables_are_assigned_on_same_line() {
        let expected_items = vec![
            parse_item("1 = foo"),
            parse_item("2 = bar"),
            parse_item("3 = baz"),
        ];
        let expected_variables = HashMap::from([
            (String::from("foo"), parse_value("1 = foo")),
            (String::from("bar"), parse_value("2 = bar")),
            (String::from("baz"), parse_value("3 = baz")),
        ]);
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "1 = foo 2 = bar 3 = baz").is_ok());
        assert_eq!(stack.items, expected_items);
        assert_eq!(engine.interface.borrow().get_variables(), &expected_variables);
    }

    // TEXT OUTPUT

    #[test]
    fn test_prints_error_on_invalid_decimal() {
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "xyz").is_err());
        assert_eq!(writer.buffer, "Invalid number or keyword: xyz\n");
    }

    #[test]
    fn test_prints_error_on_invalid_hexadecimal() {
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        engine.context.borrow_mut().set_hex();
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "xyz").is_err());
        assert_eq!(writer.buffer, "Invalid number or keyword: xyz\n");
    }

    #[test]
    fn test_shows_history_from_start() {
        let expected = "\
<==
111
222
333 444 555
666 777
...
";
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        engine.redos.insert(0, create_undo(0, vec![], vec!["111"]));
        engine.redos.insert(0, create_undo(0, vec![], vec!["222"]));
        engine.redos.insert(0, create_undo(0, vec![], vec!["333", "444", "555"]));
        engine.redos.insert(0, create_undo(0, vec![], vec!["666", "777"]));
        engine.redos.insert(0, create_undo(0, vec![], vec!["888"]));
        engine.redos.insert(0, create_undo(0, vec![], vec!["999"]));
        assert!(engine.limit_history(&mut writer, 4).is_ok());
        assert_eq!(writer.buffer, indent_multiline(expected));
    }

    #[test]
    fn test_shows_history_with_lower_limit() {
        let expected = "\
...
222
333 444 555 <==
666 777
888
...
";
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        engine.undos.push(create_undo(0, vec![], vec!["111"]));
        engine.undos.push(create_undo(0, vec![], vec!["222"]));
        engine.undos.push(create_undo(0, vec![], vec!["333", "444", "555"]));
        engine.redos.insert(0, create_undo(0, vec![], vec!["666", "777"]));
        engine.redos.insert(0, create_undo(0, vec![], vec!["888"]));
        engine.redos.insert(0, create_undo(0, vec![], vec!["999"]));
        assert!(engine.limit_history(&mut writer, 2).is_ok());
        assert_eq!(writer.buffer, indent_multiline(expected));
    }

    #[test]
    fn test_shows_history_with_equal_limit() {
        let expected = "\
111
222
333 444 555 <==
666 777
888
999
";
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        engine.undos.push(create_undo(0, vec![], vec!["111"]));
        engine.undos.push(create_undo(0, vec![], vec!["222"]));
        engine.undos.push(create_undo(0, vec![], vec!["333", "444", "555"]));
        engine.redos.insert(0, create_undo(0, vec![], vec!["666", "777"]));
        engine.redos.insert(0, create_undo(0, vec![], vec!["888"]));
        engine.redos.insert(0, create_undo(0, vec![], vec!["999"]));
        assert!(engine.limit_history(&mut writer, 3).is_ok());
        assert_eq!(writer.buffer, indent_multiline(expected));
    }

    #[test]
    fn test_shows_history_with_higher_limit() {
        let expected = "\
111
222
333 444 555 <==
666 777
888
999
";
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        engine.undos.push(create_undo(0, vec![], vec!["111"]));
        engine.undos.push(create_undo(0, vec![], vec!["222"]));
        engine.undos.push(create_undo(0, vec![], vec!["333", "444", "555"]));
        engine.redos.insert(0, create_undo(0, vec![], vec!["666", "777"]));
        engine.redos.insert(0, create_undo(0, vec![], vec!["888"]));
        engine.redos.insert(0, create_undo(0, vec![], vec!["999"]));
        assert!(engine.limit_history(&mut writer, 4).is_ok());
        assert_eq!(writer.buffer, indent_multiline(expected));
    }

    #[test]
    fn test_shows_history_to_end() {
        let expected = "\
...
333 444 555
666 777
888
999 <==
";
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        engine.undos.push(create_undo(0, vec![], vec!["111"]));
        engine.undos.push(create_undo(0, vec![], vec!["222"]));
        engine.undos.push(create_undo(0, vec![], vec!["333", "444", "555"]));
        engine.undos.push(create_undo(0, vec![], vec!["666", "777"]));
        engine.undos.push(create_undo(0, vec![], vec!["888"]));
        engine.undos.push(create_undo(0, vec![], vec!["999"]));
        assert!(engine.limit_history(&mut writer, 4).is_ok());
        assert_eq!(writer.buffer, indent_multiline(expected));
    }

    #[test]
    fn test_shows_stack_with_no_values() {
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        assert!(engine.show_stack(&mut writer, &mut stack).is_ok());
        assert_eq!(writer.buffer, "");
    }

    #[test]
    fn test_shows_stack_as_decimal() {
        let expected = "\
99999
99999     # integer value
99999     = foo
99999     = bar # integer value
  123.45
  123.45  # decimal value
  123.45  = baz
  123.45  = qux # decimal value
    3.142
    3.142 # decimal value
    3.142 = quux
    3.142 = quuux # decimal value
";
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        stack.wrapped_push(parse_item("99999"));
        stack.wrapped_push(parse_item("99999 # integer value"));
        stack.wrapped_push(parse_item("99999 = foo"));
        stack.wrapped_push(parse_item("99999 = bar # integer value"));
        stack.wrapped_push(parse_item("123.45"));
        stack.wrapped_push(parse_item("123.45 # decimal value"));
        stack.wrapped_push(parse_item("123.45 = baz"));
        stack.wrapped_push(parse_item("123.45 = qux # decimal value"));
        stack.wrapped_push(parse_item("3.142"));
        stack.wrapped_push(parse_item("3.142 # decimal value"));
        stack.wrapped_push(parse_item("3.142 = quux"));
        stack.wrapped_push(parse_item("3.142 = quuux # decimal value"));
        assert!(engine.show_stack(&mut writer, &mut stack).is_ok());
        assert_eq!(writer.buffer, indent_multiline(expected));
    }

    #[test]
    fn test_shows_stack_as_single_hexadecimal_no_sep() {
        let expected = "\
0x7fffffff
0x7fffffff # large value
0x7fffffff = foo
0x7fffffff = bar # large value
0x00000001
0x00000001 # small value
0x00000001 = baz
0x00000001 = qux # small value
";
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        engine.context.borrow_mut().format = Format::Base16(0);
        engine.context.borrow_mut().sep = false;
        stack.wrapped_push(parse_item("2147483647"));
        stack.wrapped_push(parse_item("2147483647 # large value"));
        stack.wrapped_push(parse_item("2147483647 = foo"));
        stack.wrapped_push(parse_item("2147483647 = bar # large value"));
        stack.wrapped_push(parse_item("1"));
        stack.wrapped_push(parse_item("1 # small value"));
        stack.wrapped_push(parse_item("1 = baz"));
        stack.wrapped_push(parse_item("1 = qux # small value"));
        assert!(engine.show_stack(&mut writer, &mut stack).is_ok());
        assert_eq!(writer.buffer, indent_multiline(expected));
    }

    #[test]
    fn test_shows_stack_as_double_hexadecimal_with_sep() {
        let expected = "\
0x,00000001,00000000
0x,00000001,00000000 # large value
0x,00000001,00000000 = foo
0x,00000001,00000000 = bar # large value
0x,00000000,00000001
0x,00000000,00000001 # small value
0x,00000000,00000001 = baz
0x,00000000,00000001 = qux # small value
";
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        engine.context.borrow_mut().format = Format::Base16(0);
        engine.context.borrow_mut().sep = true;
        stack.wrapped_push(parse_item("4294967296"));
        stack.wrapped_push(parse_item("4294967296 # large value"));
        stack.wrapped_push(parse_item("4294967296 = foo"));
        stack.wrapped_push(parse_item("4294967296 = bar # large value"));
        stack.wrapped_push(parse_item("1"));
        stack.wrapped_push(parse_item("1 # small value"));
        stack.wrapped_push(parse_item("1 = baz"));
        stack.wrapped_push(parse_item("1 = qux # small value"));
        assert!(engine.show_stack(&mut writer, &mut stack).is_ok());
        assert_eq!(writer.buffer, indent_multiline(expected));
    }

    #[test]
    fn test_shows_stack_with_lower_limit() {
        let expected = "\
_ ...
| 0.25  |
[ 0.375 ]
( 0.5   )
[ 0.625 ]
_ 0.75
_ 0.875
";
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        stack.wrapped_push(parse_item("-0.25"));
        stack.wrapped_push(parse_item("-0.125"));
        stack.wrapped_push(parse_series(vec![
            "0",
            "0.125",
            "0.25",
            "0.375",
        ]));
        stack.wrapped_push(parse_series(vec![
            "0.5",
            "0.625",
        ]));
        stack.wrapped_push(parse_item("0.75"));
        stack.wrapped_push(parse_item("0.875"));
        assert!(engine.limit_stack(&mut writer, &mut stack, Some(6)).is_ok());
        assert_eq!(writer.buffer, replace_multiline(expected));
    }

    #[test]
    fn test_shows_stack_with_equal_limit() {
        let expected = "\
_ -0.25
_ -0.125
(  0     )
|  0.125 |
|  0.25  |
[  0.375 ]
(  0.5   )
[  0.625 ]
_  0.75
_  0.875
";
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        stack.wrapped_push(parse_item("-0.25"));
        stack.wrapped_push(parse_item("-0.125"));
        stack.wrapped_push(parse_series(vec![
            "0",
            "0.125",
            "0.25",
            "0.375",
        ]));
        stack.wrapped_push(parse_series(vec![
            "0.5",
            "0.625",
        ]));
        stack.wrapped_push(parse_item("0.75"));
        stack.wrapped_push(parse_item("0.875"));
        assert!(engine.limit_stack(&mut writer, &mut stack, Some(10)).is_ok());
        assert_eq!(writer.buffer, replace_multiline(expected));
    }

    #[test]
    fn test_shows_stack_with_higher_limit() {
        let expected = "\
_ -0.25
_ -0.125
(  0     )
|  0.125 |
|  0.25  |
[  0.375 ]
(  0.5   )
[  0.625 ]
_  0.75
_  0.875
";
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        stack.wrapped_push(parse_item("-0.25"));
        stack.wrapped_push(parse_item("-0.125"));
        stack.wrapped_push(parse_series(vec![
            "0",
            "0.125",
            "0.25",
            "0.375",
        ]));
        stack.wrapped_push(parse_series(vec![
            "0.5",
            "0.625",
        ]));
        stack.wrapped_push(parse_item("0.75"));
        stack.wrapped_push(parse_item("0.875"));
        assert!(engine.limit_stack(&mut writer, &mut stack, Some(12)).is_ok());
        assert_eq!(writer.buffer, replace_multiline(expected));
    }

    #[test]
    fn test_shows_stack_with_no_limit() {
        let expected = "\
_ -0.25
_ -0.125
(  0     )
|  0.125 |
|  0.25  |
[  0.375 ]
(  0.5   )
[  0.625 ]
_  0.75
_  0.875
";
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        stack.wrapped_push(parse_item("-0.25"));
        stack.wrapped_push(parse_item("-0.125"));
        stack.wrapped_push(parse_series(vec![
            "0",
            "0.125",
            "0.25",
            "0.375",
        ]));
        stack.wrapped_push(parse_series(vec![
            "0.5",
            "0.625",
        ]));
        stack.wrapped_push(parse_item("0.75"));
        stack.wrapped_push(parse_item("0.875"));
        assert!(engine.limit_stack(&mut writer, &mut stack, None).is_ok());
        assert_eq!(writer.buffer, replace_multiline(expected));
    }

    #[test]
    fn test_shows_variables_sorted_by_name() {
        let expected = "\
5 = five
4 = four
1 = one
3 = three
2 = two
";
        let mut engine = create_engine();
        let mut writer = BufferWriter::new();
        let mut stack = ValueStack::new(Vec::new());
        engine.interface.borrow_mut().insert_variable(String::from("one"), parse_value("1 = one"));
        engine.interface.borrow_mut().insert_variable(String::from("two"), parse_value("2 = two"));
        engine.interface.borrow_mut().insert_variable(String::from("three"), parse_value("3 = three"));
        engine.interface.borrow_mut().insert_variable(String::from("four"), parse_value("4 = four"));
        engine.interface.borrow_mut().insert_variable(String::from("five"), parse_value("5 = five"));
        assert!(parse_line(&mut engine, &mut writer, &mut stack, "set").is_ok());
        assert_eq!(writer.buffer, indent_multiline(expected));
    }

    fn indent_multiline(lines: &str) -> String {
        lines.lines()
            .map(|x| format!("  {}\n", x))
            .collect::<Vec<String>>()
            .join("")
    }

    fn replace_multiline(lines: &str) -> String {
        lines.lines()
            .map(|x| x.replace("_", " "))
            .map(|x| format!("{}\n", x))
            .collect::<Vec<String>>()
            .join("")
    }

    fn create_engine() -> Engine<BufferWriter> {
        let config = Config::default();
        let chars = BracketChars {
            open: ('(', ')'),
            middle: ('|', '|'),
            close: ('[', ']'),
        };
        Engine::new(config, chars).unwrap().with_interact(true)
    }

    fn parse_line(
        engine: &mut Engine<BufferWriter>,
        writer: &mut BufferWriter,
        stack: &mut ValueStack,
        line: &str,
    ) -> MyResult<()> {
        let result = engine.parse_line(writer, stack, line);
        if let Err(error) = &result {
            writeln!(writer, "{}", error)?;
        }
        result
    }

    impl<W: Write> Engine<W> {
        pub fn with_interact(mut self, interact: bool) -> Self {
            self.interact = interact;
            self
        }
    }
}