public void DecomposeDebugMTRFails_ExpectedBehavior()
{
var ctx = new MyDebugContext();
ctx.Init();
var task = new Selector <byte>()
{
Name = "Test"
};
task.AddSubtask(new PrimitiveTask <byte>()
{
Name = "Sub-task1"
}.AddCondition(new FuncCondition <MyContext, byte>("Done == true", context => context.Done == true)));
task.AddSubtask(new PrimitiveTask <byte>()
{
Name = "Sub-task2"
});
ctx.LastMTR.Add(0);
var status = task.Decompose(ctx, 0, out var plan);
Assert.IsTrue(status == DecompositionStatus.Rejected);
Assert.IsTrue(plan == null);
Assert.IsTrue(ctx.MTRDebug.Count == 1);
Assert.IsTrue(ctx.MTRDebug[0].Contains("REPLAN FAIL"));
Assert.IsTrue(ctx.MTRDebug[0].Contains("Sub-task2"));
}
public void DecomposeCompoundSubtaskLoseToLastMTR_ExpectedBehavior()
{
var ctx = new MyContext();
var task = new Selector <byte>()
{
Name = "Test"
};
var task2 = new Selector <byte>()
{
Name = "Test2"
};
task2.AddSubtask(new PrimitiveTask <byte>()
{
Name = "Sub-task1"
}.AddCondition(new FuncCondition <MyContext, byte>("Done == true", context => context.Done == true)));
task2.AddSubtask(new PrimitiveTask <byte>()
{
Name = "Sub-task2"
});
task.AddSubtask(new PrimitiveTask <byte>()
{
Name = "Sub-task1"
}.AddCondition(new FuncCondition <MyContext, byte>("Done == true", context => context.Done == true)));
task.AddSubtask(task2);
ctx.LastMTR.Add(0);
var status = task.Decompose(ctx, 0, out var plan);
Assert.IsTrue(status == DecompositionStatus.Rejected);
Assert.IsTrue(plan == null);
Assert.IsTrue(ctx.MethodTraversalRecord.Count == 1);
Assert.IsTrue(ctx.MethodTraversalRecord[0] == -1);
}
public void DecomposeCompoundSubtaskFails_ExpectedBehavior()
{
var ctx = new MyContext();
var task = new Selector <byte>()
{
Name = "Test"
};
var task2 = new Selector <byte>()
{
Name = "Test2"
};
task2.AddSubtask(new PrimitiveTask <byte>()
{
Name = "Sub-task1"
}.AddCondition(new FuncCondition <MyContext, byte>("Done == true", context => context.Done == true)));
task2.AddSubtask(new PrimitiveTask <byte>()
{
Name = "Sub-task2"
}.AddCondition(new FuncCondition <MyContext, byte>("Done == true", context => context.Done == true)));
task.AddSubtask(task2);
task.AddSubtask(new PrimitiveTask <byte>()
{
Name = "Sub-task3"
});
var status = task.Decompose(ctx, 0, out var plan);
Assert.IsTrue(status == DecompositionStatus.Succeeded);
Assert.IsTrue(plan != null);
Assert.IsTrue(plan.Count == 1);
Assert.AreEqual("Sub-task3", plan.Peek().Name);
Assert.IsTrue(ctx.MethodTraversalRecord.Count == 0);
}
public void DecomposeNestedSubtasks_ExpectedBehavior()
{
var ctx = new MyContext();
ctx.Init();
var task = new Sequence() { Name = "Test" };
var task2 = new Selector() { Name = "Test2" };
var task3 = new Selector() { Name = "Test3" };
task3.AddSubtask(new PrimitiveTask() { Name = "Sub-task1" }.AddCondition(new FuncCondition<MyContext>("Done == true", context => context.Done == true)));
task3.AddSubtask(new PrimitiveTask() { Name = "Sub-task2" });
task2.AddSubtask(task3);
task2.AddSubtask(new PrimitiveTask() { Name = "Sub-task3" });
task.AddSubtask(task2);
task.AddSubtask(new PrimitiveTask() { Name = "Sub-task4" });
var status = task.Decompose(ctx, 0, out var plan);
Assert.IsTrue(status == DecompositionStatus.Succeeded);
Assert.IsTrue(plan != null);
Assert.IsTrue(plan.Count == 2);
Assert.AreEqual("Sub-task2", plan.Dequeue().Name);
Assert.AreEqual("Sub-task4", plan.Dequeue().Name);
}
public void NestedPausePlan_ExpectedBehavior()
{
var ctx = new MyContext();
ctx.Init();
var task = new Sequence() { Name = "Test" };
var task2 = new Selector() { Name = "Test2" };
var task3 = new Sequence() { Name = "Test3" };
task3.AddSubtask(new PrimitiveTask() { Name = "Sub-task1" });
task3.AddSubtask(new PausePlanTask());
task3.AddSubtask(new PrimitiveTask() { Name = "Sub-task2" });
task2.AddSubtask(task3);
task2.AddSubtask(new PrimitiveTask() { Name = "Sub-task3" });
task.AddSubtask(task2);
task.AddSubtask(new PrimitiveTask() { Name = "Sub-task4" });
var status = task.Decompose(ctx, 0, out var plan);
Assert.IsTrue(status == DecompositionStatus.Partial);
Assert.IsTrue(plan != null);
Assert.IsTrue(plan.Count == 1);
Assert.AreEqual("Sub-task1", plan.Peek().Name);
Assert.IsTrue(ctx.HasPausedPartialPlan);
Assert.IsTrue(ctx.PartialPlanQueue.Count == 2);
var queueAsArray = ctx.PartialPlanQueue.ToArray();
Assert.AreEqual(task3, queueAsArray[0].Task);
Assert.AreEqual(2, queueAsArray[0].TaskIndex);
Assert.AreEqual(task, queueAsArray[1].Task);
Assert.AreEqual(1, queueAsArray[1].TaskIndex);
}
public void DecomposeNestedCompoundSubtaskLoseToMTR2_ExpectedBehavior()
{
var ctx = new MyContext();
ctx.Init();
ctx.ContextState = ContextState.Planning;
var task = new Sequence() { Name = "Test" };
var task2 = new Selector() { Name = "Test2" };
var task3 = new Selector() { Name = "Test3" };
task3.AddSubtask(new PrimitiveTask() { Name = "Sub-task1" }.AddCondition(new FuncCondition<MyContext>("Done == true", context => context.Done == true)));
task3.AddSubtask(new PrimitiveTask() { Name = "Sub-task2" });
task2.AddSubtask(new PrimitiveTask() { Name = "Sub-task3" }.AddCondition(new FuncCondition<MyContext>("Done == true", context => context.Done == true)));
task2.AddSubtask(task3);
task.AddSubtask(task2);
task.AddSubtask(new PrimitiveTask() { Name = "Sub-task4" });
ctx.LastMTR.Add(1);
ctx.LastMTR.Add(0);
var status = task.Decompose(ctx, 0, out var plan);
Assert.IsTrue(status == DecompositionStatus.Rejected);
Assert.IsTrue(plan == null);
Assert.IsTrue(ctx.MethodTraversalRecord.Count == 2);
Assert.IsTrue(ctx.MethodTraversalRecord[0] == 1);
Assert.IsTrue(ctx.MethodTraversalRecord[1] == -1);
}
public void ContinueNestedPausePlan_ExpectedBehavior()
{
var ctx = new MyContext();
ctx.Init();
var task = new Sequence() { Name = "Test" };
var task2 = new Selector() { Name = "Test2" };
var task3 = new Sequence() { Name = "Test3" };
task3.AddSubtask(new PrimitiveTask() { Name = "Sub-task1" });
task3.AddSubtask(new PausePlanTask());
task3.AddSubtask(new PrimitiveTask() { Name = "Sub-task2" });
task2.AddSubtask(task3);
task2.AddSubtask(new PrimitiveTask() { Name = "Sub-task3" });
task.AddSubtask(task2);
task.AddSubtask(new PrimitiveTask() { Name = "Sub-task4" });
var status = task.Decompose(ctx, 0, out var plan);
Assert.IsTrue(status == DecompositionStatus.Partial);
Assert.IsTrue(plan != null);
Assert.IsTrue(plan.Count == 1);
Assert.AreEqual("Sub-task1", plan.Dequeue().Name);
Assert.IsTrue(ctx.HasPausedPartialPlan);
Assert.IsTrue(ctx.PartialPlanQueue.Count == 2);
var queueAsArray = ctx.PartialPlanQueue.ToArray();
Assert.AreEqual(task3, queueAsArray[0].Task);
Assert.AreEqual(2, queueAsArray[0].TaskIndex);
Assert.AreEqual(task, queueAsArray[1].Task);
Assert.AreEqual(1, queueAsArray[1].TaskIndex);
ctx.HasPausedPartialPlan = false;
plan = new Queue<ITask>();
while (ctx.PartialPlanQueue.Count > 0)
{
var kvp = ctx.PartialPlanQueue.Dequeue();
var s = kvp.Task.Decompose(ctx, kvp.TaskIndex, out var p);
if (s == DecompositionStatus.Succeeded || s == DecompositionStatus.Partial)
{
while (p.Count > 0)
{
plan.Enqueue(p.Dequeue());
}
}
if (ctx.HasPausedPartialPlan)
break;
}
Assert.IsTrue(plan != null);
Assert.IsTrue(plan.Count == 2);
Assert.AreEqual("Sub-task2", plan.Dequeue().Name);
Assert.AreEqual("Sub-task4", plan.Dequeue().Name);
}
public void DecomposeCompoundSubtaskWinOverLastMTR_ExpectedBehavior()
{
var ctx = new MyContext();
var rootTask = new Selector()
{
Name = "Root"
};
var task = new Selector()
{
Name = "Test1"
};
var task2 = new Selector()
{
Name = "Test2"
};
var task3 = new Selector()
{
Name = "Test3"
};
task3.AddSubtask(new PrimitiveTask()
{
Name = "Sub-task3-1"
}.AddCondition(new FuncCondition <MyContext>("Done == true", context => context.Done == true)));
task3.AddSubtask(new PrimitiveTask()
{
Name = "Sub-task3-2"
});
task2.AddSubtask(new PrimitiveTask()
{
Name = "Sub-task2-1"
}.AddCondition(new FuncCondition <MyContext>("Done == true", context => context.Done == true)));
task2.AddSubtask(new PrimitiveTask()
{
Name = "Sub-task2-2"
});
task.AddSubtask(task2);
task.AddSubtask(task3);
task.AddSubtask(new PrimitiveTask()
{
Name = "Sub-task1-1"
}.AddCondition(new FuncCondition <MyContext>("Done == false", context => context.Done == false)));
rootTask.AddSubtask(task);
ctx.LastMTR.Add(0);
ctx.LastMTR.Add(1);
ctx.LastMTR.Add(0);
// In this test, we prove that [0, 0, 1] beats [0, 1, 0]
var status = rootTask.Decompose(ctx, 0, out var plan);
Assert.IsTrue(status == DecompositionStatus.Succeeded);
}
public void DecomposeCompoundSubtaskLoseToLastMTR2_ExpectedBehavior()
{
var ctx = new MyContext();
var rootTask = new Selector()
{
Name = "Root"
};
var task = new Selector()
{
Name = "Test1"
};
var task2 = new Selector()
{
Name = "Test2"
};
var task3 = new Selector()
{
Name = "Test3"
};
task2.AddSubtask(new PrimitiveTask()
{
Name = "Sub-task2-1"
}.AddCondition(new FuncCondition <MyContext>("Done == true", context => context.Done == true)));
task2.AddSubtask(new PrimitiveTask()
{
Name = "Sub-task2-1"
});
task.AddSubtask(new PrimitiveTask()
{
Name = "Sub-task1-1"
}.AddCondition(new FuncCondition <MyContext>("Done == true", context => context.Done == true)));
task.AddSubtask(task2);
rootTask.AddSubtask(task);
ctx.LastMTR.Add(0);
ctx.LastMTR.Add(1);
ctx.LastMTR.Add(0);
// We expect this test to be rejected, because [0,1,1] shouldn't beat [0,1,0]
var status = rootTask.Decompose(ctx, 0, out var plan);
Assert.IsTrue(status == DecompositionStatus.Rejected);
Assert.IsTrue(plan == null);
Assert.IsTrue(ctx.MethodTraversalRecord.Count == 3);
Assert.IsTrue(ctx.MethodTraversalRecord[0] == 0);
Assert.IsTrue(ctx.MethodTraversalRecord[1] == 1);
Assert.IsTrue(ctx.MethodTraversalRecord[2] == -1);
}
public void DecomposeNestedCompoundSubtaskEqualToMTR_ExpectedBehavior()
{
var ctx = new MyContext();
ctx.Init();
var task = new Sequence()
{
Name = "Test"
};
var task2 = new Selector()
{
Name = "Test2"
};
var task3 = new Selector()
{
Name = "Test3"
};
task3.AddSubtask(new PrimitiveTask()
{
Name = "Sub-task2"
}.AddCondition(new FuncCondition <MyContext>("Done == true", context => context.Done == true)));
task3.AddSubtask(new PrimitiveTask()
{
Name = "Sub-task3"
});
task2.AddSubtask(new PrimitiveTask()
{
Name = "Sub-task1"
}.AddCondition(new FuncCondition <MyContext>("Done == true", context => context.Done == true)));
task2.AddSubtask(task3);
task.AddSubtask(task2);
task.AddSubtask(new PrimitiveTask()
{
Name = "Sub-task4"
});
ctx.LastMTR.Add(1);
ctx.LastMTR.Add(1);
var plan = task.Decompose(ctx, 0);
Assert.IsTrue(plan != null);
Assert.IsTrue(plan.Count == 2);
Assert.IsTrue(ctx.MethodTraversalRecord.Count == 1);
Assert.IsTrue(ctx.MethodTraversalRecord[0] == 1);
Assert.AreEqual("Sub-task3", plan.Dequeue().Name);
Assert.AreEqual("Sub-task4", plan.Dequeue().Name);
}
public void DecomposeWithSubtasks3_ExpectedBehavior()
{
var ctx = new MyContext();
var task = new Selector()
{
Name = "Test"
};
task.AddSubtask(new PrimitiveTask()
{
Name = "Sub-task1"
}.AddCondition(new FuncCondition <MyContext>("Done == true", context => context.Done == true)));
task.AddSubtask(new PrimitiveTask()
{
Name = "Sub-task2"
});
var plan = task.Decompose(ctx, 0);
Assert.IsTrue(plan != null);
Assert.IsTrue(plan.Count == 1);
Assert.AreEqual("Sub-task2", plan.Peek().Name);
}
public void DecomposeWithSubtasks_ExpectedBehavior()
{
var ctx = new MyContext();
var task = new Selector()
{
Name = "Test"
};
task.AddSubtask(new PrimitiveTask()
{
Name = "Sub-task1"
});
task.AddSubtask(new PrimitiveTask()
{
Name = "Sub-task2"
});
var plan = task.Decompose(ctx, 0);
Assert.IsTrue(plan != null);
Assert.IsTrue(plan.Count == 1);
Assert.AreEqual("Sub-task1", plan.Peek().Name);
}
public void DecomposeNestedCompoundSubtaskLoseToMTRReturnToPreviousWorldState_ExpectedBehavior()
{
var ctx = new MyContext();
ctx.Init();
ctx.ContextState = ContextState.Planning;
ctx.SetState(MyWorldState.HasA, true, EffectType.PlanAndExecute);
ctx.SetState(MyWorldState.HasB, true, EffectType.Permanent);
ctx.SetState(MyWorldState.HasC, true, EffectType.PlanOnly);
var task = new Sequence() { Name = "Test" };
var task2 = new Selector() { Name = "Test2" };
var task3 = new Selector() { Name = "Test3" };
task3.AddSubtask(new PrimitiveTask() { Name = "Sub-task2" }.AddCondition(new FuncCondition<MyContext>("Done == true", context => context.Done == true)));
task3.AddSubtask(new PrimitiveTask() { Name = "Sub-task3" }.AddEffect(new ActionEffect<MyContext>("TestEffect", EffectType.Permanent, (context, type) => context.SetState(MyWorldState.HasA, false, EffectType.PlanOnly))));
task2.AddSubtask(task3);
task2.AddSubtask(new PrimitiveTask() { Name = "Sub-task4" }.AddEffect(new ActionEffect<MyContext>("TestEffect", EffectType.Permanent, (context, type) => context.SetState(MyWorldState.HasB, false, EffectType.PlanOnly))));
task.AddSubtask(new PrimitiveTask() { Name = "Sub-task1" }
.AddEffect(new ActionEffect<MyContext>("TestEffect", EffectType.Permanent, (context, type) => context.SetState(MyWorldState.HasA, false, EffectType.PlanOnly))));
task.AddSubtask(task2);
task.AddSubtask(new PrimitiveTask() { Name = "Sub-task5" }.AddEffect(new ActionEffect<MyContext>("TestEffect", EffectType.Permanent, (context, type) => context.SetState(MyWorldState.HasC, false, EffectType.PlanOnly))));
ctx.LastMTR.Add(0);
ctx.LastMTR.Add(0);
var status = task.Decompose(ctx, 0, out var plan);
Assert.IsTrue(status == DecompositionStatus.Rejected);
Assert.IsTrue(plan == null);
Assert.IsTrue(ctx.MethodTraversalRecord.Count == 2);
Assert.IsTrue(ctx.MethodTraversalRecord[0] == 0);
Assert.IsTrue(ctx.MethodTraversalRecord[1] == -1);
Assert.IsTrue(ctx.WorldStateChangeStack[(int) MyWorldState.HasA].Count == 1);
Assert.IsTrue(ctx.WorldStateChangeStack[(int) MyWorldState.HasB].Count == 1);
Assert.IsTrue(ctx.WorldStateChangeStack[(int) MyWorldState.HasC].Count == 1);
Assert.AreEqual(1, ctx.GetState(MyWorldState.HasA));
Assert.AreEqual(1, ctx.GetState(MyWorldState.HasB));
Assert.AreEqual(1, ctx.GetState(MyWorldState.HasC));
}
public void DecomposeWithSubtasks_ExpectedBehavior()
{
var ctx = new MyContext();
var task = new Selector <byte>()
{
Name = "Test"
};
task.AddSubtask(new PrimitiveTask <byte>()
{
Name = "Sub-task1"
});
task.AddSubtask(new PrimitiveTask <byte>()
{
Name = "Sub-task2"
});
var status = task.Decompose(ctx, 0, out var plan);
Assert.IsTrue(status == DecompositionStatus.Succeeded);
Assert.IsTrue(plan != null);
Assert.IsTrue(plan.Count == 1);
Assert.AreEqual("Sub-task1", plan.Peek().Name);
}
public void DecomposeMTRSucceedsWhenEqual_ExpectedBehavior()
{
var ctx = new MyContext();
var task = new Selector()
{
Name = "Test"
};
task.AddSubtask(new PrimitiveTask()
{
Name = "Sub-task1"
}.AddCondition(new FuncCondition <MyContext>("Done == true", context => context.Done == true)));
task.AddSubtask(new PrimitiveTask()
{
Name = "Sub-task2"
});
ctx.LastMTR.Add(1);
var plan = task.Decompose(ctx, 0);
Assert.IsTrue(plan != null);
Assert.IsTrue(ctx.MethodTraversalRecord.Count == 0);
Assert.IsTrue(plan.Count == 1);
}
public void AddSubtask_ExpectedBehavior()
{
var task = new Selector <byte>()
{
Name = "Test"
};
var t = task.AddSubtask(new PrimitiveTask <byte>()
{
Name = "Sub-task"
});
Assert.IsTrue(t == task);
Assert.IsTrue(task.Subtasks.Count == 1);
}
public void IsValid_ExpectedBehavior()
{
var ctx = new MyContext();
var task = new Selector <byte>()
{
Name = "Test"
};
task.AddSubtask(new PrimitiveTask <byte>()
{
Name = "Sub-task"
});
Assert.IsTrue(task.IsValid(ctx));
}
public void ContinueMultipleNestedPausePlan_ExpectedBehavior()
{
var ctx = new MyContext();
ctx.Init();
var task = new Sequence()
{
Name = "Test"
};
var task2 = new Selector()
{
Name = "Test2"
};
var task3 = new Sequence()
{
Name = "Test3"
};
var task4 = new Sequence()
{
Name = "Test4"
};
task3.AddSubtask(new PrimitiveTask()
{
Name = "Sub-task1"
});
task3.AddSubtask(new PausePlanTask());
task3.AddSubtask(new PrimitiveTask()
{
Name = "Sub-task2"
});
task2.AddSubtask(task3);
task2.AddSubtask(new PrimitiveTask()
{
Name = "Sub-task3"
});
task4.AddSubtask(new PrimitiveTask()
{
Name = "Sub-task5"
});
task4.AddSubtask(new PausePlanTask());
task4.AddSubtask(new PrimitiveTask()
{
Name = "Sub-task6"
});
task.AddSubtask(task2);
task.AddSubtask(new PrimitiveTask()
{
Name = "Sub-task4"
});
task.AddSubtask(task4);
task.AddSubtask(new PrimitiveTask()
{
Name = "Sub-task7"
});
var plan = task.Decompose(ctx, 0);
Assert.IsTrue(plan != null);
Assert.IsTrue(plan.Count == 1);
Assert.AreEqual("Sub-task1", plan.Dequeue().Name);
Assert.IsTrue(ctx.HasPausedPartialPlan);
Assert.IsTrue(ctx.PartialPlanQueue.Count == 2);
var queueAsArray = ctx.PartialPlanQueue.ToArray();
Assert.AreEqual(task3, queueAsArray[0].Task);
Assert.AreEqual(2, queueAsArray[0].TaskIndex);
Assert.AreEqual(task, queueAsArray[1].Task);
Assert.AreEqual(1, queueAsArray[1].TaskIndex);
ctx.HasPausedPartialPlan = false;
plan = new Queue <ITask>();
while (ctx.PartialPlanQueue.Count > 0)
{
var kvp = ctx.PartialPlanQueue.Dequeue();
var p = kvp.Task.Decompose(ctx, kvp.TaskIndex);
while (p.Count > 0)
{
plan.Enqueue(p.Dequeue());
}
if (ctx.HasPausedPartialPlan)
{
break;
}
}
Assert.IsTrue(plan != null);
Assert.IsTrue(plan.Count == 3);
Assert.AreEqual("Sub-task2", plan.Dequeue().Name);
Assert.AreEqual("Sub-task4", plan.Dequeue().Name);
Assert.AreEqual("Sub-task5", plan.Dequeue().Name);
ctx.HasPausedPartialPlan = false;
plan = new Queue <ITask>();
while (ctx.PartialPlanQueue.Count > 0)
{
var kvp = ctx.PartialPlanQueue.Dequeue();
var p = kvp.Task.Decompose(ctx, kvp.TaskIndex);
while (p.Count > 0)
{
plan.Enqueue(p.Dequeue());
}
if (ctx.HasPausedPartialPlan)
{
break;
}
}
Assert.IsTrue(plan != null);
Assert.IsTrue(plan.Count == 2);
Assert.AreEqual("Sub-task6", plan.Dequeue().Name);
Assert.AreEqual("Sub-task7", plan.Dequeue().Name);
}
