public void TestWhile1_Loop0_FaultedCondition()
{
WhileCondition whileCondition = new WhileCondition(0, DelegateBehavior.Faulted);
WhileBody whileBody = new WhileBody();
// declaring these makes it clear we are testing the correct overload
Func<bool> condition = whileCondition.Evaluate;
Func<Task> body = whileBody.ExecuteAsync;
Task whileTask = null;
try
{
whileTask = TaskBlocks.While(condition, body);
whileTask.Wait();
Assert.Fail("Expected an exception");
}
catch (AggregateException ex)
{
Assert.IsNotNull(whileTask);
Assert.AreEqual(TaskStatus.Faulted, whileTask.Status);
Assert.AreEqual(1, ex.InnerExceptions.Count);
Assert.AreSame(whileCondition.ExpectedException, ex.InnerExceptions[0]);
Assert.AreEqual(whileCondition.TotalIterations + 1, whileCondition.EvaluateCount);
Assert.AreEqual(whileCondition.TotalIterations, whileBody.SyncPartExecutionCount);
Assert.AreEqual(whileCondition.TotalIterations, whileBody.ExecutionCount);
}
}
public void TestWhile1_Loop3_NullTaskBody()
{
WhileCondition whileCondition = WhileCondition.True();
WhileBody whileBody = new WhileBody(3, DelegateBehavior.NullTask);
// declaring these makes it clear we are testing the correct overload
Func <bool> condition = whileCondition.Evaluate;
Func <Task> body = whileBody.ExecuteAsync;
Task whileTask = null;
try
{
whileTask = TaskBlocks.While(condition, body);
whileTask.Wait();
Assert.Fail("Expected an exception");
}
catch (AggregateException ex)
{
Assert.IsNotNull(whileTask);
Assert.AreEqual(TaskStatus.Faulted, whileTask.Status);
Assert.AreEqual(1, ex.InnerExceptions.Count);
Assert.IsInstanceOfType(ex.InnerExceptions[0], typeof(InvalidOperationException));
Assert.AreEqual(whileBody.MaxExecutions, whileCondition.EvaluateCount);
Assert.AreEqual(whileBody.MaxExecutions, whileBody.SyncPartExecutionCount);
Assert.AreEqual(whileBody.MaxExecutions - 1, whileBody.ExecutionCount);
}
}
public void TestWhile1_Loop3_FaultedCondition()
{
WhileCondition whileCondition = new WhileCondition(3, DelegateBehavior.Faulted);
WhileBody whileBody = new WhileBody();
// declaring these makes it clear we are testing the correct overload
Func <bool> condition = whileCondition.Evaluate;
Func <Task> body = whileBody.ExecuteAsync;
Task whileTask = null;
try
{
whileTask = TaskBlocks.While(condition, body);
whileTask.Wait();
Assert.Fail("Expected an exception");
}
catch (AggregateException ex)
{
Assert.IsNotNull(whileTask);
Assert.AreEqual(TaskStatus.Faulted, whileTask.Status);
Assert.AreEqual(1, ex.InnerExceptions.Count);
Assert.AreSame(whileCondition.ExpectedException, ex.InnerExceptions[0]);
Assert.AreEqual(whileCondition.TotalIterations + 1, whileCondition.EvaluateCount);
Assert.AreEqual(whileCondition.TotalIterations, whileBody.SyncPartExecutionCount);
Assert.AreEqual(whileCondition.TotalIterations, whileBody.ExecutionCount);
}
}
public new WhileCondition Create(AIMember aiMember)
{
_aiMember = aiMember;
WhileCondition instance = new WhileCondition(Comparison);
OnGetInstance(instance);
return(instance);
}
public override void Run()
{
whileCondition = stepSetting as WhileCondition;
while (ExecuteExpression() && statements != null)
{
foreach (var item in statements)
{
item.Run();
}
}
}
public void InvokeWhile(WhileCondition condition)
{
int index = Listeners.Count - 1;
while (index >= 0)
{
if (!condition.Invoke())
{
break;
}
Listeners[index].Value.Invoke();
index--;
}
}
public void TestWhile1_Loop3_Success()
{
WhileCondition whileCondition = new WhileCondition(3);
WhileBody whileBody = new WhileBody();
// declaring these makes it clear we are testing the correct overload
Func <bool> condition = whileCondition.Evaluate;
Func <Task> body = whileBody.ExecuteAsync;
Task whileTask = TaskBlocks.While(condition, body);
whileTask.Wait();
Assert.AreEqual(whileCondition.TotalIterations + 1, whileCondition.EvaluateCount);
Assert.AreEqual(whileCondition.TotalIterations, whileBody.SyncPartExecutionCount);
Assert.AreEqual(whileCondition.TotalIterations, whileBody.ExecutionCount);
}
public void TestWhile1_NullBodyFunction()
{
WhileCondition whileCondition = new WhileCondition(0);
// declaring these makes it clear we are testing the correct overload
Func <bool> condition = whileCondition.Evaluate;
Func <Task> body = null;
try
{
TaskBlocks.While(condition, body);
}
catch
{
Assert.AreEqual(0, whileCondition.EvaluateCount);
throw;
}
}
/// <summary>
/// Sets the <see cref="ICSharpOutputNode.WriteDown"/> flag.
/// </summary>
public override void SetWriteDown()
{
if (WriteDown)
{
return;
}
WriteDown = true;
foreach (ICSharpInstruction Instruction in InitInstructionList)
{
Instruction.SetWriteDown();
}
WhileCondition.SetWriteDown();
foreach (ICSharpScopeAttributeFeature Item in EntityDeclarationList)
{
Item.SetWriteDown();
}
foreach (ICSharpInstruction Instruction in LoopInstructionList)
{
Instruction.SetWriteDown();
}
foreach (ICSharpInstruction Instruction in IterationInstructionList)
{
Instruction.SetWriteDown();
}
foreach (ICSharpAssertion Assertion in InvariantList)
{
Assertion.SetWriteDown();
}
if (VariantExpression != null)
{
VariantExpression.SetWriteDown();
}
}
public void TestWhile1_Loop0_Success()
{
WhileCondition whileCondition = new WhileCondition(0);
WhileBody whileBody = new WhileBody();
// declaring these makes it clear we are testing the correct overload
Func<bool> condition = whileCondition.Evaluate;
Func<Task> body = whileBody.ExecuteAsync;
Task whileTask = TaskBlocks.While(condition, body);
whileTask.Wait();
Assert.AreEqual(whileCondition.TotalIterations + 1, whileCondition.EvaluateCount);
Assert.AreEqual(whileCondition.TotalIterations, whileBody.SyncPartExecutionCount);
Assert.AreEqual(whileCondition.TotalIterations, whileBody.ExecutionCount);
}
public void TestWhile1_NullBodyFunction()
{
WhileCondition whileCondition = new WhileCondition(0);
// declaring these makes it clear we are testing the correct overload
Func<bool> condition = whileCondition.Evaluate;
Func<Task> body = null;
try
{
TaskBlocks.While(condition, body);
}
catch
{
Assert.AreEqual(0, whileCondition.EvaluateCount);
throw;
}
}
/// <summary>
/// Writes down the C# instruction.
/// </summary>
/// <param name="writer">The stream on which to write.</param>
public override void WriteCSharp(ICSharpWriter writer)
{
Debug.Assert(WriteDown);
bool UseCurlyBrackets = false;
/*TODO
* List<AttachmentAlias> AttachmentVariableTable = new List<AttachmentAlias>();
* foreach (IInstruction Item in InitInstructionList)
* Item.AddAttachmentVariables(Context, AttachmentVariableTable);
* foreach (IInstruction Item in LoopInstructionList)
* Item.AddAttachmentVariables(Context, AttachmentVariableTable);
* foreach (IInstruction Item in IterationInstructionList)
* Item.AddAttachmentVariables(Context, AttachmentVariableTable);
*/
if (EntityDeclarationList.Count > 0 /* || AttachmentVariableTable.Count > 0*/ || InitInstructionList.Count > 1)
{
UseCurlyBrackets = true;
}
if (UseCurlyBrackets)
{
writer.WriteIndentedLine("{");
writer.IncreaseIndent();
}
foreach (ICSharpScopeAttributeFeature Item in EntityDeclarationList)
{
Item.WriteCSharp(writer);
}
if (Source.Variant.IsAssigned)
{
writer.WriteIndentedLine("double LoopVariant = double.NaN;");
}
/*
* foreach (AttachmentAlias AliasItem in AttachmentVariableTable)
* {
* string AttachedVariableName = AliasItem.EntityName;
* string AttachmentTypeString = CSharpTypes.Type2CSharpString(AliasItem.EntityType, Context, AliasItem.AttachmentFormat, CSharpNamespaceFormats.None);
*
* writer.WriteIndentedLine(AttachmentTypeString + " " + AttachedVariableName + ";");
* Context.AttachmentVariableTable.Add(AliasItem);
* }*/
if (EntityDeclarationList.Count > 0 /* || AttachmentVariableTable.Count > 0*/)
{
writer.WriteEmptyLine();
}
foreach (ICSharpInstruction Item in InitInstructionList)
{
Item.WriteCSharp(writer);
}
WriteCSharpInvariant(writer);
if (InvariantList.Count > 0)
{
writer.WriteEmptyLine();
}
ICSharpExpressionContext SourceExpressionContext = new CSharpExpressionContext();
WhileCondition.WriteCSharp(writer, SourceExpressionContext, -1);
string WhileString = SourceExpressionContext.ReturnValue;
writer.WriteIndentedLine($"while ({WhileString})");
writer.WriteIndentedLine("{");
writer.IncreaseIndent();
foreach (ICSharpInstruction Item in LoopInstructionList)
{
Item.WriteCSharp(writer);
}
if (LoopInstructionList.Count > 0 && IterationInstructionList.Count > 0)
{
writer.WriteEmptyLine();
}
foreach (ICSharpInstruction Item in IterationInstructionList)
{
Item.WriteCSharp(writer);
}
if (VariantExpression != null)
{
ICSharpExpressionContext VariantExpressionContext = new CSharpExpressionContext();
VariantExpression.WriteCSharp(writer, VariantExpressionContext, -1);
string ExpressionText = VariantExpressionContext.ReturnValue;
writer.WriteIndentedLine($"double NewVariantResult = {ExpressionText};");
writer.WriteIndentedLine("if (NewVariantResult >= LoopVariant)// Takes advantage of the fact that 'x >= NaN' is always false");
writer.IncreaseIndent();
writer.WriteIndentedLine("throw new InvalidOperationException();");
writer.DecreaseIndent();
writer.WriteIndentedLine("LoopVariant = NewVariantResult;");
}
WriteCSharpInvariant(writer);
writer.DecreaseIndent();
writer.WriteIndentedLine("}");
/*
* foreach (AttachmentAlias AliasItem in AttachmentVariableTable)
* Context.AttachmentVariableTable.Remove(AliasItem);
*/
if (UseCurlyBrackets)
{
writer.DecreaseIndent();
writer.WriteIndentedLine("}");
}
}
