public void Children_OnMovedChild_Passes()
{
var node = new TreeNodeHelper <int>();
node.Children.Add(
node.CreateNode(0)
, node.CreateNode(1)
, node.CreateNode(2));
int callCounter = 0;
(TreeNodeHelper <int> self, TreeNodeHelper <int> child, int fromIndex, int toIndex)recievedValues = default;
node.OnMovedChild.Add((_s, _c, _from, _to) => {
callCounter++;
recievedValues = (_s, _c, _from, _to);
});
node.OnMovedChild.Add((_, __, ___, ____) => throw new System.Exception());
Debug.Log($"test -- childCount={node.ChildCount}");
var moveFromIndex = 1;
var moveToIndex = 2;
var fromChild = node[moveFromIndex];
Assert.DoesNotThrow(() => node.Children.MoveTo(moveFromIndex, moveToIndex));
Assert.AreEqual(1, callCounter);
Assert.AreSame(node, recievedValues.self);
Assert.AreEqual(moveFromIndex, recievedValues.fromIndex);
Assert.AreEqual(moveToIndex, recievedValues.toIndex);
Assert.AreSame(node[moveToIndex], recievedValues.child);
Assert.AreSame(fromChild, recievedValues.child);
}
public void Children_OnRemovedChild_Passes()
{
var node = new TreeNodeHelper <int>();
node.Children.Add(node.CreateNode(0), node.CreateNode(1));
int callCounter = 0;
(TreeNodeHelper <int> self, TreeNodeHelper <int> child, int index)recievedValues = default;
node.OnRemovedChild.Add((_s, _c, _i) => {
callCounter++;
recievedValues = (_s, _c, _i);
});
node.OnRemovedChild.Add((_, __, ___) => throw new System.Exception());
var removeIndex = node.ChildCount - 1;
var removeChild = node[removeIndex];
Assert.DoesNotThrow(() => node.Children.RemoveAt(removeIndex));
Assert.AreEqual(1, callCounter);
Assert.AreSame(node, recievedValues.self);
Assert.AreEqual(removeIndex, recievedValues.index);
Assert.AreSame(removeChild, recievedValues.child);
}
public void SiblingIndex_Passes()
{
var parent = new TreeNodeHelper <int>();
parent.Children.Add(
parent.CreateNode(100),
parent.CreateNode(200),
parent.CreateNode(300)
);
for (var i = 0; i < parent.ChildCount; ++i)
{
Assert.AreEqual(i, parent[i].SiblingIndex);
}
}
public void Parent_OnChangedParent_Passes()
{
{
var callbacks = new SmartDelegate <Callback>();
var c = 0;
callbacks.Add((_) => c++);
callbacks.Add((_) => { });
callbacks.SafeDynamicInvoke(0, () => "test fail...");
}
var node = new TreeNodeHelper <int>();
int callCounter = 0;
(TreeNodeHelper <int> self, TreeNodeHelper <int> parent, TreeNodeHelper <int> prevParent)recievedValue = default;
node.OnChangedParent.Add((_s, _p, _prev) => {
callCounter++;
recievedValue = (_s, _p, _prev);
});
node.OnChangedParent.Add((_, __, ___) => throw new System.Exception());
var parent = node.CreateNode(100);
Assert.DoesNotThrow(() => {
node.Parent = parent;
});
Assert.AreEqual(1, callCounter);
Assert.AreSame(node, recievedValue.self);
Assert.AreSame(parent, recievedValue.parent);
Assert.IsNull(recievedValue.prevParent);
}
public void Children_OnClearedChildren_Passes()
{
var node = new TreeNodeHelper <int>();
int callCounter = 0;
TreeNodeHelper <int> recievedValues = default;
node.OnClearedChildren.Add((_s) => {
callCounter++;
recievedValues = _s;
});
node.OnClearedChildren.Add((_) => throw new System.Exception());
node.Children.Add(node.CreateNode(0), node.CreateNode(1));
Assert.DoesNotThrow(() => node.Children.Clear());
Assert.AreEqual(1, callCounter);
Assert.AreSame(node, recievedValues);
}
public void IEnumerable_GetValueEnueramble_Passes()
{
var node = new TreeNodeHelper <int>();
node.Children.Add(
node.CreateNode(10
, node.CreateNode(100)
, node.CreateNode(200)
)
, node.CreateNode(20)
, node.CreateNode(30
, node.CreateNode(100)
)
);
AssertionUtils.AssertEnumerable(
new TreeNodeHelper <int>[] {
node,
node.Children[0], node.Children[0][0], node.Children[0][1],
node.Children[1],
node.Children[2], node.Children[2][0]
}.Select(_n => _n.Value)
, node.GetValueEnumerable()
, ""
);
}
public void IEnumerable_Passes()
{
var node = new TreeNodeHelper <int>();
node.Children.Add(
node.CreateNode(10)
, node.CreateNode(20)
, node.CreateNode(30));
node[0].Children.Add(
node.CreateNode(100)
, node.CreateNode(200));
node[2].Children.Add(
node.CreateNode(100));
AssertionUtils.AssertEnumerable(
new TreeNodeHelper <int>[] {
node,
node.Children[0], node.Children[0][0], node.Children[0][1],
node.Children[1],
node.Children[2], node.Children[2][0]
}
, node
, ""
);
}
public void Parent_Property_Passes()
{
var node = new TreeNodeHelper <int>();
Assert.IsNull(node.Parent);
var parent = node.CreateNode(100);
node.Parent = parent;
Assert.AreSame(parent, node.Parent);
node.Parent = null;
Assert.IsNull(node.Parent);
}
public void Children_OnChangedChildCount_Passes()
{
var node = new TreeNodeHelper <int>();
int callCounter = 0;
(TreeNodeHelper <int> self, IReadOnlyListHelper <TreeNodeHelper <int> > children, int count)recievedValues = default;
node.OnChangedChildCount.Add((_s, _children, _c) => {
callCounter++;
recievedValues = (_s, _children, _c);
});
node.OnChangedChildCount.Add((_, __, ___) => throw new System.Exception());
for (var i = 0; i < 5; ++i)
{
callCounter = 0;
recievedValues = default;
Assert.DoesNotThrow(() => node.Children.Add(node.CreateNode(0)));
Assert.AreEqual(1, callCounter);
Assert.AreSame(node, recievedValues.self);
Assert.AreSame(node.Children, recievedValues.children);
Assert.AreEqual(i + 1, recievedValues.count);
}
for (var i = 0; node.ChildCount > 0; ++i)
{
callCounter = 0;
recievedValues = default;
Assert.DoesNotThrow(() => node.Children.RemoveAt(0));
Assert.AreEqual(1, callCounter);
Assert.AreSame(node, recievedValues.self);
Assert.AreSame(node.Children, recievedValues.children);
Assert.AreEqual(node.Children.Count, recievedValues.count);
}
}
