Finished selector base tests, new base composite

Author: ashblue

Assets/FluidBehaviorTree/Editor/Testing/ParentTasks/CompositeBaseTest.cs

@@ -0,0 +1,66 @@
+using Adnc.FluidBT.TaskParents;
+using NSubstitute;
+using NUnit.Framework;
+
+namespace Adnc.FluidBT.Testing {
+    public class CompositeBaseTest {
+        private CompositeExample _composite;
+        
+        public class CompositeExample : CompositeBase {
+            public void SetChildIndex (int index) {
+                ChildIndex = index;
+            }
+        }
+
+        [SetUp]
+        public void Set_composite () {
+            _composite = new CompositeExample();
+        }
+        
+        public class EndMethod : CompositeBaseTest {
+            [Test]
+            public void Does_not_fail_if_children_empty () {                
+                _composite.End();
+            }
+
+            [Test]
+            public void Calls_end_on_current_child () {
+                var child = A.TaskStub().Build();
+                _composite.AddChild(child);
+                
+                _composite.End();
+                child.Received(1).End();
+            }
+        }
+        
+        public class ResetMethod : CompositeBaseTest {
+            [Test]
+            public void Resets_child_node_pointer () {
+                _composite.SetChildIndex(2);
+                
+                _composite.Reset();
+
+                Assert.AreEqual(0, _composite.ChildIndex);
+            }
+
+            [Test]
+            public void Clears_all_lower_priorities () {
+                _composite.AddChild(A.TaskStub().Build());
+                
+                _composite.Reset();
+                
+                Assert.AreEqual(0, _composite.AbortLowerPriorities.Count);
+            }
+
+            [Test]
+            public void Clears_self_abort_task () {
+                var condition = A.TaskStub().WithAbortConditionSelf(true).Build();
+                _composite.AddChild(condition);
+
+                _composite.Reset();
+                
+                Assert.AreEqual(null, _composite.SelfAbortTask);
+            }
+        }
+    }
+}

Assets/FluidBehaviorTree/Editor/Testing/ParentTasks/CompositeBaseTest.cs.meta

@@ -1,6 +1,7 @@
 using Adnc.FluidBT.TaskParents;
 using Adnc.FluidBT.Tasks;
 using NSubstitute;
+using System.Collections.Generic;
 using NUnit.Framework;
 
 namespace Adnc.FluidBT.Testing {
@@ -38,57 +39,76 @@ public void Returns_continue_if_a_child_task_returns_continue () {
                 }
             }
 
-            public class TwoNodes : UpdateMethod {
-                // @TODO Break off into a stops on continue test
+            public class MultipleNodes : UpdateMethod {
                 [Test]
-                public void Reruns_the_same_node_if_it_returns_continue () {
-                    var selector = new Selector();
-
-                    var childSuccess = A.TaskStub().WithUpdateStatus(TaskStatus.Failure).Build();
-                    selector.AddChild(childSuccess);
+                public void Stops_on_continue () {
+                    var childFailure = A.TaskStub().WithUpdateStatus(TaskStatus.Failure).Build();
+                    _selector.AddChild(childFailure);
 
                     var childContinue = A.TaskStub().WithUpdateStatus(TaskStatus.Continue).Build();
-                    selector.AddChild(childContinue);
-
-                    selector.Update();
-
-                    // @TODO Check child index instead
-                    childSuccess.Received(1).Update();
-                    childContinue.Received(1).Update();
-
-                    selector.Update();
-
-                    childSuccess.Received(1).Update();
-                    childContinue.Received(2).Update();
+                    _selector.AddChild(childContinue);
+                    
+                    var childSuccess = A.TaskStub().Build();
+                    _selector.AddChild(childSuccess);
+
+                    _selector.Update();
+
+                    var updateCalls = new List<int> {1, 1, 0};
+                    for (var i = 0; i < updateCalls.Count; i++) {
+                        var child = _selector.children[i];
+                        child.Received(updateCalls[i]).Update();
+                    }
                 }
+                
+                [Test]
+                public void Reruns_the_same_node_if_it_returns_continue () {
+                    var childFailure = A.TaskStub().WithUpdateStatus(TaskStatus.Failure).Build();
+                    _selector.AddChild(childFailure);
 
-                public void Stops_on_continue () {
-
-                }
+                    var childContinue = A.TaskStub().WithUpdateStatus(TaskStatus.Continue).Build();
+                    _selector.AddChild(childContinue);
 
-                public void Returns_failure_if_all_return_failure () {
+                    _selector.Update();
+                    _selector.Update();
 
+                    var updateCalls = new List<int> {1, 2};
+                    for (var i = 0; i < updateCalls.Count; i++) {
+                        var child = _selector.children[i];
+                        child.Received(updateCalls[i]).Update();
+                    }
                 }
 
-                public void Only_runs_first_node_if_success () {
+                [Test]
+                public void Returns_failure_if_all_return_failure () {
+                    var childA = A.TaskStub().WithUpdateStatus(TaskStatus.Failure).Build();
+                    _selector.AddChild(childA);
+                    
+                    var childB = A.TaskStub().WithUpdateStatus(TaskStatus.Failure).Build();
+                    _selector.AddChild(childB);
 
+                    Assert.AreEqual(TaskStatus.Failure, _selector.Update());
                 }
 
-                public void Runs_all_nodes_on_success () {
+                [Test]
+                public void Stops_on_first_success_node () {
+                    var childFailure = A.TaskStub().WithUpdateStatus(TaskStatus.Failure).Build();
+                    _selector.AddChild(childFailure);
+
+                    var childSuccessA = A.TaskStub().Build();
+                    _selector.AddChild(childSuccessA);
+                    
+                    var childSuccessB = A.TaskStub().Build();
+                    _selector.AddChild(childSuccessB);
+
+                    _selector.Update();
+
+                    var updateCalls = new List<int> {1, 1, 0};
+                    for (var i = 0; i < updateCalls.Count; i++) {
+                        var child = _selector.children[i];
+                        child.Received(updateCalls[i]).Update();
+                    }
                 }
             }
         }
-
-        public class EndMethod {
-            public void Calls_end_on_current_child_node () {
-
-            }
-        }
-
-        public class ResetMethod {
-            public void Sets_child_index_to_zero () {
-
-            }
-        }
     }
 }

Assets/FluidBehaviorTree/Editor/Testing/ParentTasks/SelectorTest.cs

@@ -427,19 +427,6 @@ public void Triggers_lower_priority_when_valid () {
                 }
             }
         }
-
-        public class ResetMethod : TaskSequenceTest {
-            [Test]
-            public void Resets_ticking_of_child_nodes () {
-                _childB.Update().Returns(TaskStatus.Continue);
-
-                _sequence.Update();
-                _sequence.Reset();
-                _sequence.Update();
-
-                _sequence.children.ForEach((c) => c.Received(2).Update());
-            }
-        }
     }
 }
 

Assets/FluidBehaviorTree/Editor/Testing/ParentTasks/TaskSequenceTest.cs

@@ -0,0 +1,32 @@
+using System.Collections.Generic;
+using Adnc.FluidBT.Tasks;
+
+namespace Adnc.FluidBT.TaskParents {
+    public abstract class CompositeBase : TaskParentBase {
+        public ITask SelfAbortTask { get; protected set; }
+        public int ChildIndex { get; protected set; }
+        public List<ITask> AbortLowerPriorities { get; } = new List<ITask>();
+
+        public override ITaskParent AddChild (ITask child) {
+            if (children.Count == 0) {
+                SelfAbortTask = child.GetAbortCondition();
+            }
+            
+            return base.AddChild(child);
+        }
+
+        public override void End () {
+            if (ChildIndex < children.Count) {
+                children[ChildIndex].End();
+            }
+        }
+        
+        public override void Reset (bool hardReset = false) {
+            ChildIndex = 0;
+            AbortLowerPriorities.Clear();
+            SelfAbortTask = null;
+
+            base.Reset(hardReset);
+        }
+    }
+}

Assets/FluidBehaviorTree/Scripts/TaskParents/Composites/CompositeBase.cs

@@ -1,9 +1,7 @@
 using Adnc.FluidBT.Tasks;
 
 namespace Adnc.FluidBT.TaskParents {
-    public class Selector : TaskParentBase {
-        public int ChildIndex { get; private set; }
-
+    public class Selector : CompositeBase {
         protected override TaskStatus OnUpdate () {
             for (var i = ChildIndex; i < children.Count; i++) {
                 var child = children[ChildIndex];

Assets/FluidBehaviorTree/Scripts/TaskParents/Composites/CompositeBase.cs.meta

@@ -2,30 +2,26 @@
 using Adnc.FluidBT.Tasks;
 
 namespace Adnc.FluidBT.TaskParents {
-    public class Sequence : TaskParentBase {
-        private ITask _selfAbortTask;
-        private int _childIndex;
-        private readonly List<ITask> _abortLowerPriorities = new List<ITask>();
-
+    public class Sequence : CompositeBase {
         protected override TaskStatus OnUpdate () {
             if (AbortType.HasFlag(AbortType.Self)
-                && _childIndex > 0
-                && _selfAbortTask != null
-                && _selfAbortTask.Update() == TaskStatus.Failure) {
-                children[_childIndex].End();
+                && ChildIndex > 0
+                && SelfAbortTask != null
+                && SelfAbortTask.Update() == TaskStatus.Failure) {
+                children[ChildIndex].End();
                 Reset();
                 return TaskStatus.Failure;
             }
 
-            foreach (var abort in _abortLowerPriorities) {
+            foreach (var abort in AbortLowerPriorities) {
                 if (abort.Update() != TaskStatus.Failure) continue;
-                children[_childIndex].End();
+                children[ChildIndex].End();
                 Reset();
                 return TaskStatus.Failure;
             }
 
-            for (var i = _childIndex; i < children.Count; i++) {
-                var child = children[_childIndex];
+            for (var i = ChildIndex; i < children.Count; i++) {
+                var child = children[ChildIndex];
 
                 if (child.Enabled) {
                     var status = child.Update();
@@ -36,34 +32,15 @@ protected override TaskStatus OnUpdate () {
                     if (child.IsLowerPriority) {
                         var abortCondition = child.GetAbortCondition();
                         if (abortCondition != null) {
-                            _abortLowerPriorities.Add(abortCondition);
+                            AbortLowerPriorities.Add(abortCondition);
                         }
                     }
                 }
 
-                _childIndex++;
+                ChildIndex++;
             }
 
             return TaskStatus.Success;
         }
-        
-        public override ITaskParent AddChild (ITask child) {
-            if (children.Count == 0) {
-                _selfAbortTask = child.GetAbortCondition();
-            }
-            
-            return base.AddChild(child);
-        }
-
-        public override void End () {
-            children[_childIndex].End();
-        }
-
-        public override void Reset (bool hardReset = false) {
-            _childIndex = 0;
-            _abortLowerPriorities.Clear();
-
-            base.Reset(hardReset);
-        }
     }
 }