gui-cs.Terminal.Gui/UnitTests/TreeViewTests.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Terminal.Gui;
using Xunit;

namespace UnitTests {
	public class TreeViewTests {
		#region Test Setup Methods
		class Factory {
			public Car [] Cars { get; set; }
			public override string ToString ()
			{
				return "Factory";
			}
		};
		class Car {
			public string Name { get; set; }
			public override string ToString ()
			{
				return Name;
			}
		};

		private TreeView<object> CreateTree ()
		{
			return CreateTree (out _, out _, out _);
		}

		private TreeView<object> CreateTree (out Factory factory1, out Car car1, out Car car2)
		{
			car1 = new Car ();
			car2 = new Car ();

			factory1 = new Factory () {
				Cars = new [] { car1, car2 }
			};

			var tree = new TreeView<object> (new DelegateTreeBuilder<object> ((s) => s is Factory f ? f.Cars : null));
			tree.AddObject (factory1);

			return tree;
		}
		#endregion

		/// <summary>
		/// Tests that <see cref="TreeView.Expand(object)"/> and <see cref="TreeView.IsExpanded(object)"/> are consistent
		/// </summary>
		[Fact]
		public void IsExpanded_TrueAfterExpand ()
		{
			var tree = CreateTree (out Factory f, out _, out _);
			Assert.False (tree.IsExpanded (f));

			tree.Expand (f);
			Assert.True (tree.IsExpanded (f));

			tree.Collapse (f);
			Assert.False (tree.IsExpanded (f));
		}

		[Fact]
		public void EmptyTreeView_ContentSizes ()
		{
			var emptyTree = new TreeView ();
			Assert.Equal (0, emptyTree.ContentHeight);
			Assert.Equal (0, emptyTree.GetContentWidth (true));
			Assert.Equal (0, emptyTree.GetContentWidth (false));
		}
		[Fact]
		public void EmptyTreeViewGeneric_ContentSizes ()
		{
			var emptyTree = new TreeView<string> ();
			Assert.Equal (0, emptyTree.ContentHeight);
			Assert.Equal (0, emptyTree.GetContentWidth (true));
			Assert.Equal (0, emptyTree.GetContentWidth (false));
		}

		/// <summary>
		/// Tests that <see cref="TreeView.Expand(object)"/> results in a correct content height
		/// </summary>
		[Fact]
		public void ContentHeight_BiggerAfterExpand ()
		{
			var tree = CreateTree (out Factory f, out _, out _);
			Assert.Equal (1, tree.ContentHeight);

			tree.Expand (f);
			Assert.Equal (3, tree.ContentHeight);

			tree.Collapse (f);
			Assert.Equal (1, tree.ContentHeight);
		}

		[Fact]
		public void ContentWidth_BiggerAfterExpand ()
		{
			var tree = CreateTree (out Factory f, out Car car1, out _);
			tree.Bounds = new Rect (0, 0, 10, 10);

			InitFakeDriver ();

			//-+Factory
			Assert.Equal (9, tree.GetContentWidth (true));

			car1.Name = "123456789";

			tree.Expand (f);

			//..├-123456789
			Assert.Equal (13, tree.GetContentWidth (true));

			tree.Collapse (f);
			//-+Factory
			Assert.Equal (9, tree.GetContentWidth (true));
		}

		[Fact]
		public void ContentWidth_VisibleVsAll ()
		{
			var tree = CreateTree (out Factory f, out Car car1, out Car car2);
			// control only allows 1 row to be viewed at once
			tree.Bounds = new Rect (0, 0, 20, 1);

			InitFakeDriver ();

			//-+Factory
			Assert.Equal (9, tree.GetContentWidth (true));
			Assert.Equal (9, tree.GetContentWidth (false));

			car1.Name = "123456789";
			car2.Name = "12345678";

			tree.Expand (f);

			// Although expanded the bigger (longer) child node is not in the rendered area of the control
			Assert.Equal (9, tree.GetContentWidth (true));
			Assert.Equal (13, tree.GetContentWidth (false)); // If you ask for the global max width it includes the longer child

			// Now that we have scrolled down 1 row we should see the big child
			tree.ScrollOffsetVertical = 1;
			Assert.Equal (13, tree.GetContentWidth (true));
			Assert.Equal (13, tree.GetContentWidth (false));

			// Scroll down so only car2 is visible
			tree.ScrollOffsetVertical = 2;
			Assert.Equal (12, tree.GetContentWidth (true));
			Assert.Equal (13, tree.GetContentWidth (false));

			// Scroll way down (off bottom of control even)
			tree.ScrollOffsetVertical = 5;
			Assert.Equal (0, tree.GetContentWidth (true));
			Assert.Equal (13, tree.GetContentWidth (false));
		}
		/// <summary>
		/// Tests that <see cref="TreeView.IsExpanded(object)"/> and <see cref="TreeView.Expand(object)"/> behaves correctly when an object cannot be expanded (because it has no children)
		/// </summary>
		[Fact]
		public void IsExpanded_FalseIfCannotExpand ()
		{
			var tree = CreateTree (out Factory f, out Car c, out _);

			// expose the car by expanding the factory
			tree.Expand (f);

			// car is not expanded
			Assert.False (tree.IsExpanded (c));

			//try to expand the car (should have no effect because cars have no children)
			tree.Expand (c);

			Assert.False (tree.IsExpanded (c));

			// should also be ignored
			tree.Collapse (c);

			Assert.False (tree.IsExpanded (c));
		}

		/// <summary>
		/// Tests illegal ranges for <see cref="TreeView.ScrollOffset"/>
		/// </summary>
		[Fact]
		public void ScrollOffset_CannotBeNegative ()
		{
			var tree = CreateTree ();

			Assert.Equal (0, tree.ScrollOffsetVertical);

			tree.ScrollOffsetVertical = -100;
			Assert.Equal (0, tree.ScrollOffsetVertical);

			tree.ScrollOffsetVertical = 10;
			Assert.Equal (10, tree.ScrollOffsetVertical);
		}


		/// <summary>
		/// Tests <see cref="TreeView.GetScrollOffsetOf(object)"/> for objects that are as yet undiscovered by the tree
		/// </summary>
		[Fact]
		public void GetScrollOffsetOf_MinusOneForUnRevealed ()
		{
			var tree = CreateTree (out Factory f, out Car c1, out Car c2);

			// to start with the tree is collapsed and only knows about the root object
			Assert.Equal (0, tree.GetScrollOffsetOf (f));
			Assert.Equal (-1, tree.GetScrollOffsetOf (c1));
			Assert.Equal (-1, tree.GetScrollOffsetOf (c2));

			// reveal it by expanding the root object
			tree.Expand (f);

			// tree now knows about children
			Assert.Equal (0, tree.GetScrollOffsetOf (f));
			Assert.Equal (1, tree.GetScrollOffsetOf (c1));
			Assert.Equal (2, tree.GetScrollOffsetOf (c2));

			// after collapsing the root node again
			tree.Collapse (f);

			// tree no longer knows about the locations of these objects
			Assert.Equal (0, tree.GetScrollOffsetOf (f));
			Assert.Equal (-1, tree.GetScrollOffsetOf (c1));
			Assert.Equal (-1, tree.GetScrollOffsetOf (c2));
		}

		/// <summary>
		/// Simulates behind the scenes changes to an object (which children it has) and how to sync that into the tree using <see cref="TreeView.RefreshObject(object, bool)"/>
		/// </summary>
		[Fact]
		public void RefreshObject_ChildRemoved ()
		{
			var tree = CreateTree (out Factory f, out Car c1, out Car c2);

			//reveal it by expanding the root object
			tree.Expand (f);

			Assert.Equal (0, tree.GetScrollOffsetOf (f));
			Assert.Equal (1, tree.GetScrollOffsetOf (c1));
			Assert.Equal (2, tree.GetScrollOffsetOf (c2));

			// Factory now no longer makes Car c1 (only c2)
			f.Cars = new Car [] { c2 };

			// Tree does not know this yet
			Assert.Equal (0, tree.GetScrollOffsetOf (f));
			Assert.Equal (1, tree.GetScrollOffsetOf (c1));
			Assert.Equal (2, tree.GetScrollOffsetOf (c2));

			// If the user has selected the node c1
			tree.SelectedObject = c1;

			// When we refresh the tree
			tree.RefreshObject (f);

			// Now tree knows that factory has only one child node c2
			Assert.Equal (0, tree.GetScrollOffsetOf (f));
			Assert.Equal (-1, tree.GetScrollOffsetOf (c1));
			Assert.Equal (1, tree.GetScrollOffsetOf (c2));

			// The old selection was c1 which is now gone so selection should default to the parent of that branch (the factory)
			Assert.Equal (f, tree.SelectedObject);
		}

		/// <summary>
		/// Tests that <see cref="TreeView.GetParent(object)"/> returns the parent object for
		/// Cars (Factories).  Note that the method only works once the parent branch (Factory)
		/// is expanded to expose the child (Car)
		/// </summary>
		[Fact]
		public void GetParent_ReturnsParentOnlyWhenExpanded ()
		{
			var tree = CreateTree (out Factory f, out Car c1, out Car c2);

			Assert.Null (tree.GetParent (f));
			Assert.Null (tree.GetParent (c1));
			Assert.Null (tree.GetParent (c2));

			// now when we expand the factory we discover the cars
			tree.Expand (f);

			Assert.Null (tree.GetParent (f));
			Assert.Equal (f, tree.GetParent (c1));
			Assert.Equal (f, tree.GetParent (c2));

			tree.Collapse (f);

			Assert.Null (tree.GetParent (f));
			Assert.Null (tree.GetParent (c1));
			Assert.Null (tree.GetParent (c2));
		}

		/// <summary>
		/// Tests how the tree adapts to changes in the ChildrenGetter delegate during runtime
		/// when some branches are expanded and the new delegate returns children for a node that
		/// previously didn't have any children
		/// </summary>
		[Fact]
		public void RefreshObject_AfterChangingChildrenGetterDuringRuntime ()
		{
			var tree = CreateTree (out Factory f, out Car c1, out Car c2);

			string wheel = "Shiny Wheel";

			// Expand the Factory
			tree.Expand (f);

			// c1 cannot have children
			Assert.Equal (f, tree.GetParent (c1));

			// expanding it does nothing
			tree.Expand (c1);
			Assert.False (tree.IsExpanded (c1));

			// change the children getter so that now cars can have wheels
			tree.TreeBuilder = new DelegateTreeBuilder<object> ((o) =>
				 // factories have cars
				 o is Factory ? new object [] { c1, c2 }
				 // cars have wheels
				 : new object [] { wheel });

			// still cannot expand
			tree.Expand (c1);
			Assert.False (tree.IsExpanded (c1));

			tree.RefreshObject (c1);
			tree.Expand (c1);
			Assert.True (tree.IsExpanded (c1));
			Assert.Equal (wheel, tree.GetChildren (c1).FirstOrDefault ());
		}
		/// <summary>
		/// Same as <see cref="RefreshObject_AfterChangingChildrenGetterDuringRuntime"/> but
		/// uses <see cref="TreeView.RebuildTree()"/> instead of <see cref="TreeView.RefreshObject(object, bool)"/>
		/// </summary>
		[Fact]
		public void RebuildTree_AfterChangingChildrenGetterDuringRuntime ()
		{
			var tree = CreateTree (out Factory f, out Car c1, out Car c2);

			string wheel = "Shiny Wheel";

			// Expand the Factory
			tree.Expand (f);

			// c1 cannot have children
			Assert.Equal (f, tree.GetParent (c1));

			// expanding it does nothing
			tree.Expand (c1);
			Assert.False (tree.IsExpanded (c1));

			// change the children getter so that now cars can have wheels
			tree.TreeBuilder = new DelegateTreeBuilder<object> ((o) =>
				 // factories have cars
				 o is Factory ? new object [] { c1, c2 }
				 // cars have wheels
				 : new object [] { wheel });

			// still cannot expand
			tree.Expand (c1);
			Assert.False (tree.IsExpanded (c1));

			// Rebuild the tree
			tree.RebuildTree ();

			// Rebuild should not have collapsed any branches or done anything wierd
			Assert.True (tree.IsExpanded (f));

			tree.Expand (c1);
			Assert.True (tree.IsExpanded (c1));
			Assert.Equal (wheel, tree.GetChildren (c1).FirstOrDefault ());
		}
		/// <summary>
		/// Tests that <see cref="TreeView.GetChildren(object)"/> returns the child objects for
		/// the factory.  Note that the method only works once the parent branch (Factory)
		/// is expanded to expose the child (Car)
		/// </summary>
		[Fact]
		public void GetChildren_ReturnsChildrenOnlyWhenExpanded ()
		{
			var tree = CreateTree (out Factory f, out Car c1, out Car c2);

			Assert.Empty (tree.GetChildren (f));
			Assert.Empty (tree.GetChildren (c1));
			Assert.Empty (tree.GetChildren (c2));

			// now when we expand the factory we discover the cars
			tree.Expand (f);

			Assert.Contains (c1, tree.GetChildren (f));
			Assert.Contains (c2, tree.GetChildren (f));
			Assert.Empty (tree.GetChildren (c1));
			Assert.Empty (tree.GetChildren (c2));

			tree.Collapse (f);

			Assert.Empty (tree.GetChildren (f));
			Assert.Empty (tree.GetChildren (c1));
			Assert.Empty (tree.GetChildren (c2));
		}

		[Fact]
		public void TreeNode_WorksWithoutDelegate ()
		{
			var tree = new TreeView ();

			var root = new TreeNode ("Root");
			root.Children.Add (new TreeNode ("Leaf1"));
			root.Children.Add (new TreeNode ("Leaf2"));

			tree.AddObject (root);

			tree.Expand (root);
			Assert.Equal (2, tree.GetChildren (root).Count ());
		}


		[Fact]
		public void MultiSelect_GetAllSelectedObjects ()
		{
			var tree = new TreeView ();

			TreeNode l1;
			TreeNode l2;
			TreeNode l3;
			TreeNode l4;

			var root = new TreeNode ("Root");
			root.Children.Add (l1 = new TreeNode ("Leaf1"));
			root.Children.Add (l2 = new TreeNode ("Leaf2"));
			root.Children.Add (l3 = new TreeNode ("Leaf3"));
			root.Children.Add (l4 = new TreeNode ("Leaf4"));

			tree.AddObject (root);
			tree.MultiSelect = true;

			tree.Expand (root);
			Assert.Empty (tree.GetAllSelectedObjects ());

			tree.SelectedObject = root;

			Assert.Single (tree.GetAllSelectedObjects (), root);

			// move selection down 1
			tree.AdjustSelection (1, false);

			Assert.Single (tree.GetAllSelectedObjects (), l1);

			// expand selection down 2 (e.g. shift down twice)
			tree.AdjustSelection (1, true);
			tree.AdjustSelection (1, true);

			Assert.Equal (3, tree.GetAllSelectedObjects ().Count ());
			Assert.Contains (l1, tree.GetAllSelectedObjects ());
			Assert.Contains (l2, tree.GetAllSelectedObjects ());
			Assert.Contains (l3, tree.GetAllSelectedObjects ());

			tree.Collapse (root);

			// No selected objects since the root was collapsed
			Assert.Empty (tree.GetAllSelectedObjects ());
		}

		[Fact]
		public void ObjectActivated_Called ()
		{
			var tree = CreateTree (out Factory f, out Car car1, out _);

			InitFakeDriver ();

			object activated = null;
			bool called = false;

			// register for the event
			tree.ObjectActivated += (s) => {
				activated = s.ActivatedObject;
				called = true;
			};

			Assert.False (called);

			// no object is selected yet so no event should happen
			tree.ProcessKey (new KeyEvent (Key.Enter, new KeyModifiers ()));

			Assert.Null (activated);
			Assert.False (called);

			// down to select factory
			tree.ProcessKey (new KeyEvent (Key.CursorDown, new KeyModifiers ()));

			tree.ProcessKey (new KeyEvent (Key.Enter, new KeyModifiers ()));

			Assert.True (called);
			Assert.Same (f, activated);
		}


		[Fact]
		public void GoTo_OnlyAppliesToExposedObjects ()
		{
			var tree = CreateTree (out Factory f, out Car car1, out _);

			// Make tree bounds 1 in height so that EnsureVisible always requires updating scroll offset
			tree.Bounds = new Rect (0, 0, 50, 1);

			Assert.Null (tree.SelectedObject);
			Assert.Equal (0, tree.ScrollOffsetVertical);

			// car 1 is not yet exposed
			tree.GoTo (car1);

			Assert.Null (tree.SelectedObject);
			Assert.Equal (0, tree.ScrollOffsetVertical);

			tree.Expand (f);

			// Car1 is now exposed by expanding the factory
			tree.GoTo (car1);

			Assert.Equal (car1, tree.SelectedObject);
			Assert.Equal (1, tree.ScrollOffsetVertical);
		}


		[Fact]
		public void ObjectActivated_CustomKey ()
		{
			var tree = CreateTree (out Factory f, out Car car1, out _);

			InitFakeDriver ();

			tree.ObjectActivationKey = Key.Delete;
			object activated = null;
			bool called = false;

			// register for the event
			tree.ObjectActivated += (s) => {
				activated = s.ActivatedObject;
				called = true;
			};

			Assert.False (called);

			// no object is selected yet so no event should happen
			tree.ProcessKey (new KeyEvent (Key.Enter, new KeyModifiers ()));

			Assert.Null (activated);
			Assert.False (called);

			// down to select factory
			tree.ProcessKey (new KeyEvent (Key.CursorDown, new KeyModifiers ()));

			tree.ProcessKey (new KeyEvent (Key.Enter, new KeyModifiers ()));

			// Enter is not the activation key in this unit test
			Assert.Null (activated);
			Assert.False (called);

			// Delete is the activation key in this test so should result in activation occurring
			tree.ProcessKey (new KeyEvent (Key.Delete, new KeyModifiers ()));

			Assert.True (called);
			Assert.Same (f, activated);

		}



		/// <summary>
		/// Simulates behind the scenes changes to an object (which children it has) and how to sync that into the tree using <see cref="TreeView.RefreshObject(object, bool)"/>
		/// </summary>
		[Fact]
		public void RefreshObject_EqualityTest ()
		{
			var obj1 = new EqualityTestObject () { Name = "Bob", Age = 1 };
			var obj2 = new EqualityTestObject () { Name = "Bob", Age = 2 }; ;

			string root = "root";

			var tree = new TreeView<object> ();
			tree.TreeBuilder = new DelegateTreeBuilder<object> ((s) => ReferenceEquals (s, root) ? new object [] { obj1 } : null);
			tree.AddObject (root);

			// Tree is not expanded so the root has no children yet
			Assert.Empty (tree.GetChildren (root));


			tree.Expand (root);

			// now that the tree is expanded we should get our child returned
			Assert.Equal (1, tree.GetChildren (root).Count (child => ReferenceEquals (obj1, child)));

			// change the getter to return an Equal object (but not the same reference - obj2)
			tree.TreeBuilder = new DelegateTreeBuilder<object> ((s) => ReferenceEquals (s, root) ? new object [] { obj2 } : null);

			// tree has cached the knowledge of what children the root has so won't know about the change (we still get obj1)
			Assert.Equal (1, tree.GetChildren (root).Count (child => ReferenceEquals (obj1, child)));

			// now that we refresh the root we should get the new child reference (obj2)
			tree.RefreshObject (root);
			Assert.Equal (1, tree.GetChildren (root).Count (child => ReferenceEquals (obj2, child)));

		}

		/// <summary>
		/// Test object which considers for equality only <see cref="Name"/>
		/// </summary>
		private class EqualityTestObject {
			public string Name { get; set; }
			public int Age { get; set; }

			public override int GetHashCode ()
			{
				return Name?.GetHashCode () ?? base.GetHashCode ();
			}
			public override bool Equals (object obj)
			{
				return obj is EqualityTestObject eto && Equals (Name, eto.Name);
			}
		}

		private void InitFakeDriver ()
		{
			var driver = new FakeDriver ();
			Application.Init (driver, new FakeMainLoop (() => FakeConsole.ReadKey (true)));
			driver.Init (() => { });
		}
	}
}