Refactor Display mod tests

Refactor the Display module tests to not depend on the virtual curses
tracing.

5 files changed, 272 insertions, 507 deletions

diff --git a/src/display/mod.rs b/src/display/mod.rs
index 8ee0c47..3b26b5e 100644
--- a/src/display/mod.rs
+++ b/src/display/mod.rs
@@ -294,366 +294,219 @@ impl<'d> Display<'d> {
 #[cfg(all(windows, test))]
 mod tests {
 	use super::*;
-	use crate::build_trace;
-	use crate::display_module_test;
-
-	display_module_test!(
-		set_style_underline_disabled,
-		[
-			build_trace!("attron", "64"),
-			build_trace!("attroff", "256"),
-			build_trace!("attron", "128")
-		],
-		|display: &mut Display<'_>| display.set_style(true, true, true)
-	);
+	use crate::display::testutil::{display_module_test, TestContext};
+
+	#[test]
+	#[serial_test::serial()]
+	fn windows_set_style_underline_disabled() {
+		display_module_test(|mut test_context: TestContext| {
+			let display = Display::new(&mut test_context.curses, &test_context.config.theme);
+			display.set_style(true, true, true);
+			assert!(test_context.curses.is_dimmed());
+			assert!(test_context.curses.is_reverse());
+			assert!(!test_context.curses.is_underline());
+		});
+	}
 }
 
 #[cfg(all(unix, test))]
 mod tests {
 	use super::*;
-	use crate::build_trace;
-	use crate::display_module_test;
-
-	display_module_test!(
-		draw_str,
-		[build_trace!("addstr", "Test string")],
-		|display: &mut Display<'_>| display.draw_str("Test string")
-	);
-
-	display_module_test!(
-		clear,
-		[
-			build_trace!("attrset", "16"),
-			build_trace!("attroff", "64"),
-			build_trace!("attroff", "256"),
-			build_trace!("attroff", "128"),
-			build_trace!("erase")
-		],
-		|display: &mut Display<'_>| display.clear()
-	);
-
-	display_module_test!(refresh, [build_trace!("refresh")], |display: &mut Display<'_>| {
-		display.refresh()
-	});
-
-	display_module_test!(
-		color_action_break_not_selected,
-		[build_trace!("attrset", "20")],
-		|display: &mut Display<'_>| display.color(DisplayColor::ActionBreak, false)
-	);
-
-	display_module_test!(
-		color_action_break_selected,
-		[build_trace!("attrset", "21")],
-		|display: &mut Display<'_>| display.color(DisplayColor::ActionBreak, true)
-	);
-
-	display_module_test!(
-		color_action_drop_not_selected,
-		[build_trace!("attrset", "22")],
-		|display: &mut Display<'_>| display.color(DisplayColor::ActionDrop, false)
-	);
-
-	display_module_test!(
-		color_action_drop_selected,
-		[build_trace!("attrset", "23")],
-		|display: &mut Display<'_>| display.color(DisplayColor::ActionDrop, true)
-	);
-
-	display_module_test!(
-		color_action_edit_not_selected,
-		[build_trace!("attrset", "24")],
-		|display: &mut Display<'_>| display.color(DisplayColor::ActionEdit, false)
-	);
-
-	display_module_test!(
-		color_action_edit_selected,
-		[build_trace!("attrset", "25")],
-		|display: &mut Display<'_>| display.color(DisplayColor::ActionEdit, true)
-	);
-
-	display_module_test!(
-		color_action_exec_not_selected,
-		[build_trace!("attrset", "26")],
-		|display: &mut Display<'_>| display.color(DisplayColor::ActionExec, false)
-	);
-
-	display_module_test!(
-		color_action_exec_selected,
-		[build_trace!("attrset", "27")],
-		|display: &mut Display<'_>| display.color(DisplayColor::ActionExec, true)
-	);
-
-	display_module_test!(
-		color_action_fixup_not_selected,
-		[build_trace!("attrset", "28")],
-		|display: &mut Display<'_>| display.color(DisplayColor::ActionFixup, false)
-	);
-
-	display_module_test!(
-		color_action_fixup_selected,
-		[build_trace!("attrset", "29")],
-		|display: &mut Display<'_>| display.color(DisplayColor::ActionFixup, true)
-	);
-
-	display_module_test!(
-		color_action_pick_not_selected,
-		[build_trace!("attrset", "30")],
-		|display: &mut Display<'_>| display.color(DisplayColor::ActionPick, false)
-	);
-
-	display_module_test!(
-		color_action_pick_selected,
-		[build_trace!("attrset", "31")],
-		|display: &mut Display<'_>| display.color(DisplayColor::ActionPick, true)
-	);
-
-	display_module_test!(
-		color_action_reword_not_selected,
-		[build_trace!("attrset", "32")],
-		|display: &mut Display<'_>| display.color(DisplayColor::ActionReword, false)
-	);
-
-	display_module_test!(
-		color_action_reword_selected,
-		[build_trace!("attrset", "33")],
-		|display: &mut Display<'_>| display.color(DisplayColor::ActionReword, true)
-	);
-
-	display_module_test!(
-		color_action_squash_not_selected,
-		[build_trace!("attrset", "34")],
-		|display: &mut Display<'_>| display.color(DisplayColor::ActionSquash, false)
-	);
-
-	display_module_test!(
-		color_action_squash_selected,
-		[build_trace!("attrset", "35")],
-		|display: &mut Display<'_>| display.color(DisplayColor::ActionSquash, true)
-	);
-
-	display_module_test!(
-		color_normal_not_selected,
-		[build_trace!("attrset", "16")],
-		|display: &mut Display<'_>| display.color(DisplayColor::Normal, false)
-	);
-
-	display_module_test!(
-		color_normal_selected,
-		[build_trace!("attrset", "17")],
-		|display: &mut Display<'_>| display.color(DisplayColor::Normal, true)
-	);
-
-	display_module_test!(
-		color_indicator_color_not_selected,
-		[build_trace!("attrset", "18")],
-		|display: &mut Display<'_>| display.color(DisplayColor::IndicatorColor, false)
-	);
-
-	display_module_test!(
-		color_indiciator_color_selected,
-		[build_trace!("attrset", "19")],
-		|display: &mut Display<'_>| display.color(DisplayColor::IndicatorColor, true)
-	);
-
-	display_module_test!(
-		color_diff_add_color_not_selected,
-		[build_trace!("attrset", "36")],
-		|display: &mut Display<'_>| display.color(DisplayColor::DiffAddColor, false)
-	);
-
-	display_module_test!(
-		color_diff_add_color_selected,
-		[build_trace!("attrset", "37")],
-		|display: &mut Display<'_>| display.color(DisplayColor::DiffAddColor, true)
-	);
-
-	display_module_test!(
-		color_diff_remove_color_not_selected,
-		[build_trace!("attrset", "40")],
-		|display: &mut Display<'_>| display.color(DisplayColor::DiffRemoveColor, false)
-	);
-
-	display_module_test!(
-		color_diff_remove_color_selected,
-		[build_trace!("attrset", "41")],
-		|display: &mut Display<'_>| display.color(DisplayColor::DiffRemoveColor, true)
-	);
-
-	display_module_test!(
-		color_diff_change_color_not_selected,
-		[build_trace!("attrset", "38")],
-		|display: &mut Display<'_>| display.color(DisplayColor::DiffChangeColor, false)
-	);
-
-	display_module_test!(
-		color_diff_change_color_selected,
-		[build_trace!("attrset", "39")],
-		|display: &mut Display<'_>| display.color(DisplayColor::DiffChangeColor, true)
-	);
-
-	display_module_test!(
-		color_diff_context_color_not_selected,
-		[build_trace!("attrset", "42")],
-		|display: &mut Display<'_>| display.color(DisplayColor::DiffContextColor, false)
-	);
-
-	display_module_test!(
-		color_diff_context_color_selected,
-		[build_trace!("attrset", "43")],
-		|display: &mut Display<'_>| display.color(DisplayColor::DiffContextColor, true)
-	);
-
-	display_module_test!(
-		color_diff_whitespace_color_not_selected,
-		[build_trace!("attrset", "44")],
-		|display: &mut Display<'_>| display.color(DisplayColor::DiffWhitespaceColor, false)
-	);
-
-	display_module_test!(
-		color_diff_whitespace_color_selected,
-		[build_trace!("attrset", "45")],
-		|display: &mut Display<'_>| display.color(DisplayColor::DiffWhitespaceColor, true)
-	);
-
-	display_module_test!(
-		set_style_dim_off_underline_off_reverse_off,
-		[
-			build_trace!("attroff", "64"),
-			build_trace!("attroff", "256"),
-			build_trace!("attroff", "128")
-		],
-		|display: &mut Display<'_>| display.set_style(false, false, false)
-	);
-
-	display_module_test!(
-		set_style_dim_on_underline_off_reverse_off,
-		[
-			build_trace!("attron", "64"),
-			build_trace!("attroff", "256"),
-			build_trace!("attroff", "128")
-		],
-		|display: &mut Display<'_>| display.set_style(true, false, false)
-	);
-
-	display_module_test!(
-		set_style_dim_on_underline_off_reverse_on,
-		[
-			build_trace!("attron", "64"),
-			build_trace!("attroff", "256"),
-			build_trace!("attron", "128")
-		],
-		|display: &mut Display<'_>| display.set_style(true, false, true)
-	);
-
-	display_module_test!(
-		set_style_dim_on_underline_on_reverse_off,
-		[
-			build_trace!("attron", "64"),
-			build_trace!("attron", "256"),
-			build_trace!("attroff", "128")
-		],
-		|display: &mut Display<'_>| display.set_style(true, true, false)
-	);
-
-	display_module_test!(
-		set_style_dim_on_underline_on_reverse_on,
-		[
-			build_trace!("attron", "64"),
-			build_trace!("attron", "256"),
-			build_trace!("attron", "128")
-		],
-		|display: &mut Display<'_>| display.set_style(true, true, true)
-	);
-
-	display_module_test!(
-		set_style_dim_off_underline_on_reverse_off,
-		[
-			build_trace!("attroff", "64"),
-			build_trace!("attron", "256"),
-			build_trace!("attroff", "128")
-		],
-		|display: &mut Display<'_>| display.set_style(false, true, false)
-	);
-
-	display_module_test!(
-		set_style_dim_off_underline_on_reverse_on,
-		[
-			build_trace!("attroff", "64"),
-			build_trace!("attron", "256"),
-			build_trace!("attron", "128")
-		],
-		|display: &mut Display<'_>| display.set_style(false, true, true)
-	);
-
-	display_module_test!(
-		set_style_dim_off_underline_off_reverse_on,
-		[
-			build_trace!("attroff", "64"),
-			build_trace!("attroff", "256"),
-			build_trace!("attron", "128")
-		],
-		|display: &mut Display<'_>| display.set_style(false, false, true)
-	);
-
-	display_module_test!(
-		getch_normal_input,
-		Input::Character('z'),
-		[],
-		|display: &mut Display<'_>| assert_eq!(display.getch().unwrap(), Input::Character('z'))
-	);
-
-	display_module_test!(
-		getch_resize,
-		Input::KeyResize,
-		[
-			build_trace!("resize_term", "0", "0"),
-			build_trace!("get_max_y"),
-			build_trace!("get_max_x")
-		],
-		|display: &mut Display<'_>| { assert_eq!(display.getch().unwrap(), Input::KeyResize) }
-	);
-
-	display_module_test!(get_window_size, [], |display: &mut Display<'_>| {
-		assert_eq!(display.get_window_size(), (77, 66));
-	});
-
-	display_module_test!(
-		fill_end_of_line,
-		[build_trace!("hline", " ", "77")],
-		|display: &mut Display<'_>| display.fill_end_of_line()
-	);
-
-	display_module_test!(
-		ensure_at_line_start,
-		[build_trace!("mv", "32", "0")],
-		|display: &mut Display<'_>| display.ensure_at_line_start(32)
-	);
-
-	display_module_test!(
-		move_from_end_of_line,
-		[
-			build_trace!("get_cur_y"),
-			build_trace!("get_max_x"),
-			build_trace!("mv", "13", "65")
-		],
-		|display: &mut Display<'_>| display.move_from_end_of_line(12)
-	);
-
-	display_module_test!(
-		leave_temporarily,
-		[
-			build_trace!("def_prog_mode"),
-			build_trace!("endwin"),
-			build_trace!("reset_prog_mode")
-		],
-		|display: &mut Display<'_>| {
-			let result = display.leave_temporarily(|| "Done");
-			assert_eq!(result, "Done");
-		}
-	);
+	use crate::display::testutil::{display_module_test, TestContext};
+	use crate::display::virtual_curses::State;
+	use rstest::rstest;
+
+	#[test]
+	#[serial_test::serial]
+	fn draw_str() {
+		display_module_test(|mut test_context: TestContext| {
+			let display = Display::new(&mut test_context.curses, &test_context.config.theme);
+			display.draw_str("Test String");
+			let output = test_context.curses.get_output();
+			assert_eq!(output, vec!["Test String"]);
+		});
+	}
+
+	#[test]
+	#[serial_test::serial]
+	fn clear() {
+		display_module_test(|mut test_context: TestContext| {
+			test_context.curses.addstr("Test String");
+			test_context.curses.attron(curses::A_DIM);
+			test_context.curses.attron(curses::A_REVERSE);
+			test_context.curses.attron(curses::A_UNDERLINE);
+
+			let display = Display::new(&mut test_context.curses, &test_context.config.theme);
+			display.clear();
+			assert!(test_context.curses.get_output().is_empty());
+			assert!(!test_context.curses.is_dimmed());
+			assert!(!test_context.curses.is_reverse());
+			assert!(!test_context.curses.is_underline());
+		});
+	}
+
+	#[test]
+	#[serial_test::serial]
+	fn reset() {
+		display_module_test(|mut test_context: TestContext| {
+			let display = Display::new(&mut test_context.curses, &test_context.config.theme);
+			display.refresh();
+			assert_eq!(test_context.curses.get_state(), State::Refreshed);
+		});
+	}
+
+	#[rstest(
+		display_color,
+		selected,
+		expected,
+		case::action_break(DisplayColor::ActionBreak, false, 20),
+		case::action_break_selected(DisplayColor::ActionBreak, true, 21),
+		case::action_drop(DisplayColor::ActionDrop, false, 22),
+		case::action_drop_selected(DisplayColor::ActionDrop, true, 23),
+		case::action_edit(DisplayColor::ActionEdit, false, 24),
+		case::action_edit_selected(DisplayColor::ActionEdit, true, 25),
+		case::action_exec(DisplayColor::ActionExec, false, 26),
+		case::action_exec_selected(DisplayColor::ActionExec, true, 27),
+		case::action_fixup(DisplayColor::ActionFixup, false, 28),
+		case::action_fixup_selected(DisplayColor::ActionFixup, true, 29),
+		case::action_pick(DisplayColor::ActionPick, false, 30),
+		case::action_pick_selected(DisplayColor::ActionPick, true, 31),
+		case::action_reword(DisplayColor::ActionReword, false, 32),
+		case::action_reword_selected(DisplayColor::ActionReword, true, 33),
+		case::action_squash(DisplayColor::ActionSquash, false, 34),
+		case::action_squash_selected(DisplayColor::ActionSquash, true, 35),
+		case::normal(DisplayColor::Normal, false, 16),
+		case::normal_selected(DisplayColor::Normal, true, 17),
+		case::indicator(DisplayColor::IndicatorColor, false, 18),
+		case::indicator_selected(DisplayColor::IndicatorColor, true, 19),
+		case::diff_add(DisplayColor::DiffAddColor, false, 36),
+		case::diff_add_selected(DisplayColor::DiffAddColor, true, 37),
+		case::diff_remove(DisplayColor::DiffRemoveColor, false, 40),
+		case::diff_remove_selected(DisplayColor::DiffRemoveColor, true, 41),
+		case::diff_change(DisplayColor::DiffChangeColor, false, 38),
+		case::diff_change_selected(DisplayColor::DiffChangeColor, true, 39),
+		case::diff_context(DisplayColor::DiffContextColor, false, 42),
+		case::diff_context_selected(DisplayColor::DiffContextColor, true, 43),
+		case::diff_whitespace(DisplayColor::DiffWhitespaceColor, false, 44),
+		case::diff_whitespace_selected(DisplayColor::DiffWhitespaceColor, true, 45)
+	)]
+	#[serial_test::serial()]
+	fn color(display_color: DisplayColor, selected: bool, expected: chtype) {
+		display_module_test(|mut test_context: TestContext| {
+			let display = Display::new(&mut test_context.curses, &test_context.config.theme);
+			display.color(display_color, selected);
+			assert!(test_context.curses.is_color_enabled(expected));
+		});
+	}
+
+	#[rstest(
+		dim,
+		underline,
+		reverse,
+		case::all_off(false, false, false),
+		case::reverse(false, false, true),
+		case::underline(false, true, false),
+		case::underline_reverse(false, true, true),
+		case::dim(true, false, false),
+		case::dim_reverse(true, false, true),
+		case::dim_underline(true, true, false),
+		case::all_on(true, true, true)
+	)]
+	#[serial_test::serial()]
+	fn style(dim: bool, underline: bool, reverse: bool) {
+		display_module_test(|mut test_context: TestContext| {
+			let display = Display::new(&mut test_context.curses, &test_context.config.theme);
+			display.set_style(dim, underline, reverse);
+			assert_eq!(test_context.curses.is_dimmed(), dim);
+			assert_eq!(test_context.curses.is_underline(), underline);
+			assert_eq!(test_context.curses.is_reverse(), reverse);
+		});
+	}
+
+	#[test]
+	#[serial_test::serial]
+	fn getch_normal_input() {
+		display_module_test(|mut test_context: TestContext| {
+			test_context.curses.push_input(Input::Character('z'));
+			let display = Display::new(&mut test_context.curses, &test_context.config.theme);
+			assert_eq!(display.getch().unwrap(), Input::Character('z'));
+		});
+	}
 
-	display_module_test!(end, [build_trace!("endwin")], |display: &mut Display<'_>| {
-		display.end()
-	});
+	#[test]
+	#[serial_test::serial]
+	fn getch_resize() {
+		display_module_test(|mut test_context: TestContext| {
+			test_context.curses.push_input(Input::KeyResize);
+			let display = Display::new(&mut test_context.curses, &test_context.config.theme);
+			assert_eq!(display.getch().unwrap(), Input::KeyResize);
+			assert_eq!(test_context.curses.get_state(), State::Resized);
+		});
+	}
+
+	#[test]
+	#[serial_test::serial]
+	fn get_window_size() {
+		display_module_test(|mut test_context: TestContext| {
+			test_context.curses.resize_term(10, 12);
+			let display = Display::new(&mut test_context.curses, &test_context.config.theme);
+			assert_eq!(display.get_window_size(), (12, 10));
+		});
+	}
+
+	#[test]
+	#[serial_test::serial]
+	fn fill_end_of_line() {
+		display_module_test(|mut test_context: TestContext| {
+			test_context.curses.resize_term(10, 23);
+			let display = Display::new(&mut test_context.curses, &test_context.config.theme);
+			display.fill_end_of_line();
+			assert_eq!(test_context.curses.get_output()[0], "{HLINE| |23}");
+		});
+	}
+
+	#[test]
+	#[serial_test::serial]
+	fn ensure_at_line_start() {
+		display_module_test(|mut test_context: TestContext| {
+			test_context.curses.resize_term(5, 25);
+			test_context.curses.mv(10, 12);
+			let display = Display::new(&mut test_context.curses, &test_context.config.theme);
+			display.ensure_at_line_start(5);
+			assert_eq!(test_context.curses.get_cur_y(), 5);
+			assert_eq!(test_context.curses.get_cur_x(), 0);
+		});
+	}
+
+	#[test]
+	#[serial_test::serial]
+	fn move_from_end_of_line() {
+		display_module_test(|mut test_context: TestContext| {
+			test_context.curses.resize_term(5, 25);
+			test_context.curses.mv(5, 20);
+			let display = Display::new(&mut test_context.curses, &test_context.config.theme);
+			display.move_from_end_of_line(5);
+			assert_eq!(test_context.curses.get_cur_x(), 20);
+		});
+	}
+
+	#[test]
+	#[serial_test::serial]
+	fn leave_temporarily() {
+		display_module_test(|mut test_context: TestContext| {
+			let display = Display::new(&mut test_context.curses, &test_context.config.theme);
+			assert_eq!(display.leave_temporarily(|| "Done"), "Done");
+			assert_eq!(test_context.curses.get_state(), State::Normal);
+		});
+	}
+
+	#[test]
+	#[serial_test::serial]
+	fn end() {
+		display_module_test(|mut test_context: TestContext| {
+			let display = Display::new(&mut test_context.curses, &test_context.config.theme);
+			display.end();
+			assert_eq!(test_context.curses.get_state(), State::Ended);
+		});
+	}
 }
diff --git a/src/display/testutil.rs b/src/display/testutil.rs
index 2b5f8db..3b1ddfe 100644
--- a/src/display/testutil.rs
+++ b/src/display/testutil.rs
@@ -1,14 +1,15 @@
 use crate::config::Config;
-use crate::display::color_mode::ColorMode;
 use crate::display::curses::Curses;
-use crate::display::curses::Input;
-use crate::display::Display;
-use crate::testutil::compare_trace;
 use std::env::set_var;
 use std::path::Path;
 
-pub fn _display_module_test<F>(expected_trace: &[(String, Vec<String>)], input: Option<Input>, callback: F)
-where F: FnOnce(&mut Display<'_>) {
+pub struct TestContext {
+	pub config: Config,
+	pub curses: Curses,
+}
+
+pub fn display_module_test<F>(callback: F)
+where F: FnOnce(TestContext) {
 	set_var(
 		"GIT_DIR",
 		Path::new(env!("CARGO_MANIFEST_DIR"))
@@ -19,38 +20,6 @@ where F: FnOnce(&mut Display<'_>) {
 			.unwrap(),
 	);
 	let config = Config::new().unwrap();
-	let mut curses = Curses::new();
-	if let Some(input) = input {
-		curses.push_input(input);
-	}
-	curses.resize_term(66, 77);
-	curses.mv(13, 17);
-	curses.set_color_mode(ColorMode::TrueColor);
-	let mut display = Display::new(&mut curses, &config.theme);
-	callback(&mut display);
-	let trace = curses.get_function_trace();
-	compare_trace(&trace, &expected_trace.to_vec());
+	let curses = Curses::new();
+	callback(TestContext { config, curses });
 }
-
-// a lot of the testing here is just ensuring that the correct curses function are called
-#[macro_export]
-macro_rules! display_module_test {
-		($name:ident, $expected_trace:expr, $fun:expr) => {
-			concat_idents::concat_idents!(test_name = display_module_, $name {
-				#[test]
-				#[serial_test::serial]
-				fn test_name() {
-					crate::display::testutil::_display_module_test(&$expected_trace, None, $fun);
-				}
-			});
-		};
-		($name:ident, $input:expr, $expected_trace:expr, $fun:expr) => {
-			concat_idents::concat_idents!(test_name = display_module_, $name {
-				#[test]
-				#[serial_test::serial]
-				fn test_name() {
-					crate::display::testutil::_display_module_test(&$expected_trace, Some($input), $fun);
-				}
-			});
-		};
-	}
diff --git a/src/display/virtual_curses.rs b/src/display/virtual_curses.rs
index fe50798..1683267 100644
--- a/src/display/virtual_curses.rs
+++ b/src/display/virtual_curses.rs
@@ -1,6 +1,3 @@
-#![allow(non_camel_case_types)]
-
-use crate::build_trace;
 use crate::display::color_mode::ColorMode;
 use crate::display::utils::detect_color_mode;
 pub use pancurses::{chtype, Input};
@@ -18,16 +15,25 @@ pub const COLOR_MAGENTA: i16 = 5;
 pub const COLOR_CYAN: i16 = 6;
 pub const COLOR_WHITE: i16 = 7;
 
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub enum State {
+	Normal,
+	Saved,
+	Ended,
+	Refreshed,
+	Resized,
+}
+
 pub struct Curses {
 	attributes: RefCell<chtype>,
 	color_mode: ColorMode,
 	color_pairs: [(i16, i16); 255],
 	colors: [(i16, i16, i16); 255],
-	function_call_trace: RefCell<Vec<(String, Vec<String>)>>,
-	output: RefCell<Vec<String>>,
 	input: RefCell<Vec<Input>>,
+	output: RefCell<Vec<String>>,
 	position: RefCell<(i32, i32)>,
 	size: RefCell<(i32, i32)>,
+	state: RefCell<State>,
 }
 
 impl Curses {
@@ -37,26 +43,48 @@ impl Curses {
 			color_mode: detect_color_mode(16),
 			color_pairs: [(0, 0); 255],
 			colors: [(0, 0, 0); 255],
-			function_call_trace: RefCell::new(vec![build_trace!("new")]),
-			output: RefCell::new(vec![]),
 			input: RefCell::new(vec![]),
+			output: RefCell::new(vec![]),
 			position: RefCell::new((0, 0)),
 			size: RefCell::new((10, 10)),
+			state: RefCell::new(State::Normal),
 		}
 	}
 
-	pub(crate) fn get_function_trace(&self) -> Vec<(String, Vec<String>)> {
-		self.function_call_trace.borrow().clone()
-	}
+	// Start mock access functions
 
 	pub(crate) const fn get_colors(&self) -> &[(i16, i16, i16); 255] {
 		&self.colors
 	}
 
+	pub(crate) fn get_output(&self) -> Vec<String> {
+		self.output.borrow().clone()
+	}
+
 	pub(crate) const fn get_color_pairs(&self) -> &[(i16, i16); 255] {
 		&self.color_pairs
 	}
 
+	pub(crate) fn get_state(&self) -> State {
+		*self.state.borrow()
+	}
+
+	pub(crate) fn is_color_enabled(&self, color_index: chtype) -> bool {
+		(*self.attributes.borrow() & color_index) == color_index
+	}
+
+	pub(crate) fn is_dimmed(&self) -> bool {
+		(*self.attributes.borrow() & A_DIM) == A_DIM
+	}
+
+	pub(crate) fn is_reverse(&self) -> bool {
+		(*self.attributes.borrow() & A_REVERSE) == A_REVERSE
+	}
+
+	pub(crate) fn is_underline(&self) -> bool {
+		(*self.attributes.borrow() & A_UNDERLINE) == A_UNDERLINE
+	}
+
 	pub(crate) fn push_input(&self, input: Input) {
 		self.input.borrow_mut().insert(0, input);
 	}
@@ -65,6 +93,8 @@ impl Curses {
 		self.color_mode = color_mode;
 	}
 
+	// End mock access functions
+
 	pub(super) fn init_color(&mut self, index: i16, red: i16, green: i16, blue: i16) {
 		self.colors[index as usize] = (red, green, blue);
 	}
@@ -74,104 +104,85 @@ impl Curses {
 		index as chtype
 	}
 
-	pub(super) fn get_color_mode(&self) -> &ColorMode {
-		self.function_call_trace
-			.borrow_mut()
-			.push(build_trace!("get_color_mode"));
+	pub(super) const fn get_color_mode(&self) -> &ColorMode {
 		&self.color_mode
 	}
 
 	pub(super) fn erase(&self) {
-		self.function_call_trace.borrow_mut().push(build_trace!("erase"));
 		self.output.borrow_mut().clear();
 	}
 
 	pub(super) fn refresh(&self) {
-		self.function_call_trace.borrow_mut().push(build_trace!("refresh"));
+		self.state.replace(State::Refreshed);
 	}
 
 	pub(super) fn addstr(&self, s: &str) {
-		self.function_call_trace.borrow_mut().push(build_trace!("addstr", s));
 		self.output.borrow_mut().push(String::from(s));
 	}
 
 	pub(super) fn attrset<T: Into<chtype>>(&self, attributes: T) {
 		let attrs = attributes.into();
-		self.function_call_trace
-			.borrow_mut()
-			.push(build_trace!("attrset", attrs));
 		self.attributes.replace(attrs);
 	}
 
 	pub(super) fn attron<T: Into<chtype>>(&self, attribute: T) {
 		let attr = attribute.into();
 		let old_attr = *self.attributes.borrow();
-		self.function_call_trace.borrow_mut().push(build_trace!("attron", attr));
 		self.attributes.replace(old_attr | attr);
 	}
 
 	pub(super) fn attroff<T: Into<chtype>>(&self, attribute: T) {
 		let attr = attribute.into();
 		let old_attr = *self.attributes.borrow();
-		self.function_call_trace
-			.borrow_mut()
-			.push(build_trace!("attroff", attr));
 		self.attributes.replace(old_attr & !attr);
 	}
 
 	pub(super) fn getch(&self) -> Option<Input> {
-		self.function_call_trace.borrow_mut().push(build_trace!("getch"));
 		self.input.borrow_mut().pop()
 	}
 
 	pub(crate) fn get_cur_y(&self) -> i32 {
-		self.function_call_trace.borrow_mut().push(build_trace!("get_cur_y"));
 		(*self.position.borrow()).1
 	}
 
+	pub(crate) fn get_cur_x(&self) -> i32 {
+		(*self.position.borrow()).0
+	}
+
 	pub(super) fn get_max_x(&self) -> i32 {
-		self.function_call_trace.borrow_mut().push(build_trace!("get_max_x"));
 		(*self.size.borrow()).0
 	}
 
 	pub(super) fn get_max_y(&self) -> i32 {
-		self.function_call_trace.borrow_mut().push(build_trace!("get_max_y"));
 		(*self.size.borrow()).1
 	}
 
 	pub(crate) fn hline(&self, ch: char, width: i32) {
-		self.function_call_trace
-			.borrow_mut()
-			.push(build_trace!("hline", ch, width));
+		self.output.borrow_mut().push(format!("{{HLINE|{}|{}}}", ch, width));
 	}
 
 	pub(crate) fn mv(&self, y: i32, x: i32) {
-		self.function_call_trace.borrow_mut().push(build_trace!("mv", y, x));
 		self.position.replace((x, y));
 	}
 
 	pub(crate) fn resize_term(&self, nlines: i32, ncols: i32) {
-		self.function_call_trace
-			.borrow_mut()
-			.push(build_trace!("resize_term", nlines, ncols));
-		if nlines != 0 && ncols != 0 {
+		if nlines == 0 && ncols == 0 {
+			self.state.replace(State::Resized);
+		}
+		else {
 			self.size.replace((ncols, nlines));
 		}
 	}
 
 	pub(super) fn def_prog_mode(&self) {
-		self.function_call_trace
-			.borrow_mut()
-			.push(build_trace!("def_prog_mode"));
+		self.state.replace(State::Saved);
 	}
 
 	pub(super) fn reset_prog_mode(&self) {
-		self.function_call_trace
-			.borrow_mut()
-			.push(build_trace!("reset_prog_mode"));
+		self.state.replace(State::Normal);
 	}
 
 	pub(super) fn endwin(&self) {
-		self.function_call_trace.borrow_mut().push(build_trace!("endwin"));
+		self.state.replace(State::Ended);
 	}
 }
diff --git a/src/main.rs b/src/main.rs
index f602ac1..97a14ab 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -43,10 +43,6 @@ mod show_commit;
 mod todo_file;
 mod view;
 
-#[cfg(test)]
-#[macro_use]
-mod testutil;
-
 use crate::config::Config;
 use crate::constants::{NAME, VERSION};
 use crate::display::curses::Curses;
diff --git a/src/testutil.rs b/src/testutil.rs
deleted file mode 100644
index 7a2a6be..0000000
--- a/src/testutil.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-#[macro_export]
-macro_rules! build_trace {
-	($name:expr) => {{
-		let args: Vec<String> = vec![];
-		(String::from($name), args)
-	}};
-	($name:expr, $($arg:expr),*) => {{
-		let mut args = vec![];
-		$( args.push(format!("{}", $arg)); )*
-		(String::from($name), args)
-	}};
-}
-
-pub fn panic_trace_error(e: &(String, Vec<String>), trace: &[(String, Vec<String>)]) {
-	panic!(vec![
-		"\n==========",
-		"Missing function call in trace",
-		format!("Call: {}({})", e.0, e.1.join(", ")).as_str(),
-		"Trace:",
-		trace
-			.iter()
-			.map(|t| {
-				let (ref func, ref args) = *t;
-				format!(
-					"\t{}({})",
-					func,
-					args.iter()
-						.map(|v| v.replace("\n", "\\n"))
-						.collect::<Vec<String>>()
-						.join(", ")
-				)
-			})
-			.collect::<Vec<String>>()
-			.join("\n")
-			.as_str(),
-		"==========\n"
-	]
-	.join("\n"));
-}
-
-pub fn compare_trace(actual: &[(String, Vec<String>)], expected: &[(String, Vec<String>)]) {
-	let mut e_iter = expected.iter();
-	let mut a_iter = actual.iter();
-	'trace: while let Some(e) = e_iter.next() {
-		loop {
-			if let Some(a) = a_iter.next() {
-				// function name and argument length must match
-				if !a.0.eq(&e.0) || a.1.len() != e.1.len() {
-					continue;
-				}
-				if a.1.iter().zip(&e.1).all(|(a, e)| e.eq("*") || a.eq(e)) {
-					continue 'trace;
-				}
-			}
-			else {
-				panic_trace_error(e, actual);
-			}
-		}
-	}
-
-	if let Some(e) = e_iter.next() {
-		panic_trace_error(e, actual);
-	}
-}