public void InitialTokenCancellation_WhileRunning()
{
var tokenSource = new CancellationTokenSource();
var sequence = new TestSequence(tokenSource.Token);
sequence.ExpectConnect(null, StreamInitializationCause.WatchStarting);
sequence.ProvideResponse(WatchResponseResult.Continue);
sequence.WaitForCancellation();
Task task = sequence.RunToStability();
tokenSource.Cancel();
// If it doesn't finish quickly, Task.Wait will time out and the assertion will fail.
Assert.Throws <AggregateException>(() => task.Wait(s_timeout));
Assert.Equal(TaskStatus.Canceled, task.Status);
}
public void StopTokenCancellation()
{
var sequence = new TestSequence();
sequence.ExpectConnect(null, StreamInitializationCause.WatchStarting);
sequence.ProvideResponse(WatchResponseResult.Continue);
sequence.ProvideResponseHangingInStateMachine();
Task task = sequence.RunToStability();
var tokenSource = new CancellationTokenSource();
sequence.WatchStream.Stop(tokenSource.Token);
tokenSource.Cancel();
AssertTaskIsCancelledSoon(task);
sequence.Verify();
}
public void ThrowFromOverloadedOperator()
{
TestSubtract <OverLoadOperatorThrowingType, OverLoadOperatorThrowingType, OverLoadOperatorThrowingType> sub = new TestSubtract <OverLoadOperatorThrowingType, OverLoadOperatorThrowingType, OverLoadOperatorThrowingType>
{
LeftExpression = context => new OverLoadOperatorThrowingType(13),
RightExpression = context => new OverLoadOperatorThrowingType(14),
};
OverLoadOperatorThrowingType.ThrowException = true;
sub.ExpectedOutcome = Outcome.UncaughtException();
TestSequence seq = TestExpressionTracer.GetTraceableBinaryExpressionActivity <OverLoadOperatorThrowingType, OverLoadOperatorThrowingType, OverLoadOperatorThrowingType>(sub, "12");
TestRuntime.RunAndValidateAbortedException(seq, typeof(ArithmeticException), null);
}
public void SetUninitializedIndices()
{
//
// Test case description:
// Try executing ValueTypeIndexerReference activity without initializing indices. Validation exception
// expected.
TheStruct valueType = new TheStruct();
Variable <TheStruct> var = new Variable <TheStruct>()
{
Default = valueType, Name = "var"
};
TestValueTypeIndexerReference <TheStruct, int> valueTypeIndexerReference = new TestValueTypeIndexerReference <TheStruct, int>()
{
OperandLocationVariable = var,
};
int value = 321;
TestAssign <int> testAssign = new TestAssign <int>()
{
ToLocation = valueTypeIndexerReference, Value = value
};
TestSequence seq = new TestSequence()
{
Variables = { var },
Activities =
{
testAssign,
new TestWriteLine {
MessageExpression = ((ctx) => var.Get(ctx)[1].ToString()),HintMessage = value.ToString()
}
}
};
string error = string.Format(ErrorStrings.IndicesAreNeeded, valueTypeIndexerReference.ProductActivity.GetType().Name, valueTypeIndexerReference.DisplayName);
List <TestConstraintViolation> constraints = new List <TestConstraintViolation>
{
new TestConstraintViolation(
error,
valueTypeIndexerReference.ProductActivity)
};
TestRuntime.ValidateWorkflowErrors(seq, constraints, error);
}
public void TrySetItemNullOperand()
{
//
// Test case description:
// Try executing ValueTypeIndexerReference activity without initializing indices. Validation exception
// expected.
TheStruct valueType = new TheStruct();
Variable <TheStruct> var = new Variable <TheStruct>()
{
Default = valueType, Name = "var"
};
TestValueTypeIndexerReference <TheStruct, int> valueTypeIndexerReference = new TestValueTypeIndexerReference <TheStruct, int>()
{
Indices =
{
new TestArgument <int>(Direction.In, null, 2)
}
};
int value = 321;
TestAssign <int> testAssign = new TestAssign <int>()
{
ToLocation = valueTypeIndexerReference, Value = value
};
TestSequence seq = new TestSequence()
{
Variables = { var },
Activities =
{
testAssign,
}
};
string error = string.Format(ErrorStrings.RequiredArgumentValueNotSupplied, "OperandLocation", valueTypeIndexerReference.ProductActivity.GetType().Name, valueTypeIndexerReference.DisplayName);
List <TestConstraintViolation> constraints = new List <TestConstraintViolation>
{
new TestConstraintViolation(
error,
valueTypeIndexerReference.ProductActivity)
};
TestRuntime.ValidateWorkflowErrors(seq, constraints, error);
}
public void ChangePropertyNameAfterOpened()
{
Variable <TheStruct> var = new Variable <TheStruct>()
{
Name = "var",
Default = new TheStruct()
};
TestValueTypePropertyReference <TheStruct, int> valueTypePropertyReference = new TestValueTypePropertyReference <TheStruct, int>()
{
PropertyName = "PublicProperty",
OperandLocationVariable = var
};
int value = 321;
TestAssign <int> testAssign = new TestAssign <int>()
{
ToLocation = valueTypePropertyReference,
Value = value,
};
TestSequence sequence = new TestSequence()
{
Variables =
{
var
},
Activities =
{
new TestWriteLine("Start", "Start"),
new TestBlockingActivity("Blocking"),
testAssign,
},
};
using (TestWorkflowRuntime runtime = TestRuntime.CreateTestWorkflowRuntime(sequence))
{
runtime.ExecuteWorkflow();
runtime.WaitForActivityStatusChange("Blocking", TestActivityInstanceState.Executing);
valueTypePropertyReference.PropertyName = "PublicProperty1";
runtime.ResumeBookMark("Blocking", null);
runtime.WaitForCompletion(true);
}
}
public void DoWhileVariblesHaveSameName()
{
const string activityName = "activity";
const string varibleName = "counter";
Variable <int> counter1 = VariableHelper.CreateInitialized <int>(varibleName, 0);
Variable <int> counter2 = VariableHelper.CreateInitialized <int>(varibleName, 0);
TestSequence outerSequence = new TestSequence(activityName)
{
Variables = { counter1 },
Activities =
{
new TestDoWhile(activityName)
{
ConditionExpression = ((env) => ((int)counter1.Get(env)) < 3),
HintIterationCount = 3,
Body = new TestSequence(activityName)
{
Activities =
{
new TestSequence(activityName)
{
Variables = { counter2 },
Activities =
{
new TestWriteLine("Trace Counter 2", (env => counter2.Get(env).ToString()), "0"),
}
},
new TestAssign <int>("Add One")
{
ToVariable = counter1,
ValueExpression = ((env) => (((int)counter1.Get(env))) + 1),
},
}
}
},
new TestWriteLine("Trace Counter")
{
MessageExpression = (env => counter1.Get(env).ToString()),
HintMessage = "3",
}
}
};
TestRuntime.RunAndValidateWorkflow(outerSequence);
}
//[HostWorkflowAsWebService]
public void IfInWhileSometimesIfThenTrueSometimesElseTrue()
{
Variable <int> counter = VariableHelper.CreateInitialized <int>("counter", 0);
TestWriteLine writeTrue = new TestWriteLine("writeTrue");
writeTrue.Message = "I say you are RIGHT!";
TestWriteLine writeFalse = new TestWriteLine("writeFalse");
writeFalse.Message = "I say you are WRONG!";
TestIf ifAct = new TestIf("if act",
HintThenOrElse.Then,
HintThenOrElse.Else,
HintThenOrElse.Then,
HintThenOrElse.Else)
{
ConditionExpression = ((env) => ((int)counter.Get(env)) % 2 == 0),
ThenActivity = writeTrue,
ElseActivity = writeFalse,
};
TestAssign <int> increment = new TestAssign <int>("Add One");
increment.ToVariable = counter;
increment.ValueExpression = (env) => (((int)counter.Get(env))) + 1;
TestSequence sequence = new TestSequence("innerSequence");
sequence.Activities.Add(ifAct);
sequence.Activities.Add(increment);
TestWhile whileAct = new TestWhile("while act")
{
ConditionExpression = (env) => ((int)counter.Get(env)) < 4,
Body = sequence,
HintIterationCount = 4,
};
TestSequence rootSequence = new TestSequence("rootSequence");
rootSequence.Activities.Add(whileAct);
rootSequence.Variables.Add(counter);
TestRuntime.RunAndValidateWorkflow(rootSequence);
}
public void TrySettingReadOnlyField()
{
//
// Test case description:
// Try setting a read only field. Exception expected.
TheStruct valueType = new TheStruct();
Variable <TheStruct> var = new Variable <TheStruct>()
{
Default = valueType, Name = "var"
};
TestValueTypeFieldReference <TheStruct, int> valueTypeFieldReference = new TestValueTypeFieldReference <TheStruct, int>()
{
FieldName = "readonlyField",
OperandLocationVariable = var,
};
int value = 321;
TestAssign <int> testAssign = new TestAssign <int>()
{
ToLocation = valueTypeFieldReference, Value = value
};
TestSequence seq = new TestSequence()
{
Variables = { var },
Activities =
{
testAssign,
new TestWriteLine {
MessageExpression = ((ctx) => var.Get(ctx).readonlyField.ToString()),HintMessage = value.ToString()
}
}
};
string error = string.Format(ErrorStrings.MemberIsReadOnly, "readonlyField", typeof(TheStruct).Name);
List <TestConstraintViolation> constraints = new List <TestConstraintViolation>
{
new TestConstraintViolation(
error,
valueTypeFieldReference.ProductActivity)
};
TestRuntime.ValidateWorkflowErrors(seq, constraints, error);
}
public void TrySetTypeWithoutIndexer()
{
//
// Test case description:
// Try setting indexer on type that does not support ‘this’ property. Validation exception is expected.
int valueType = 0;
Variable <int> var = new Variable <int>()
{
Default = valueType, Name = "var"
};
TestValueTypeIndexerReference <int, int> valueTypeIndexerReference = new TestValueTypeIndexerReference <int, int>()
{
OperandLocationVariable = var,
};
valueTypeIndexerReference.Indices.Add(new TestArgument <int>(Direction.In, null, 2));
int value = 321;
TestAssign <int> testAssign = new TestAssign <int>()
{
ToLocation = valueTypeIndexerReference,
Value = value,
};
TestSequence seq = new TestSequence()
{
Variables = { var },
Activities =
{
testAssign
}
};
string error = string.Format(ErrorStrings.SpecialMethodNotFound, "set_Item", typeof(int).Name);
List <TestConstraintViolation> constraints = new List <TestConstraintViolation>
{
new TestConstraintViolation(
error,
valueTypeIndexerReference.ProductActivity)
};
TestRuntime.ValidateWorkflowErrors(seq, constraints, error);
}
public void ThrowInSeq()
{
TestSequence seq = new TestSequence()
{
Activities =
{
new TestWriteLine()
{
Message = "Hi"
},
new TestThrow <InvalidCastException>()
},
};
TestRuntime.RunAndValidateAbortedException(seq, typeof(InvalidCastException), new Dictionary <string, string>());
}
public void UnreachableActivityAfterThrow()
{
TestSequence seq = new TestSequence()
{
Activities =
{
new TestThrow <MissingMemberException>(),
new TestWriteLine("WriteLine")
{
Message = "Unreachable activity"
},
}
};
TestRuntime.RunAndValidateAbortedException(seq, typeof(MissingMemberException), new Dictionary <string, string>());
}
public void ThrowExceptionWithMessage()
{
// Initializing variable which we will use to catch the exception object
DelegateInArgument <OperationCanceledException> op = new DelegateInArgument <OperationCanceledException>();
//TestParameters.DisableXamlRoundTrip = true;
TestSequence seq = new TestSequence("Outer Seq")
{
Activities =
{
new TestTryCatch("Try catch finally")
{
Try = new TestSequence("Try Activity")
{
Activities =
{
new TestThrow <OperationCanceledException>("Throw Operation exception")
{
ExceptionExpression = (context => new OperationCanceledException("We have set the message to overwrite exception message")),
ExpectedOutcome = Outcome.CaughtException(),
}
}
},
Catches =
{
new TestCatch <OperationCanceledException>()
{
ExceptionVariable = op,
Body = new TestSequence("Body of Catch")
{
Activities =
{
new TestWriteLine("Writeline for exception message")
{
MessageExpression = (env) => op.Get(env).Message,
HintMessage = "We have set the message to overwrite exception message"
}
}
},
}
}
}
}
};
TestRuntime.RunAndValidateWorkflow(seq);
}
public void TrySettingNullFieldName()
{
//
// Test case description:
// Try setting a null OperandLocation. Validation exception expected.
TheStruct valueType = new TheStruct();
Variable <TheStruct> var = new Variable <TheStruct>()
{
Default = valueType, Name = "var"
};
TestValueTypeFieldReference <TheStruct, int> valueTypeFieldReference = new TestValueTypeFieldReference <TheStruct, int>()
{
OperandLocationVariable = var
};
int value = 321;
TestAssign <int> testAssign = new TestAssign <int>()
{
ToLocation = valueTypeFieldReference, Value = value
};
TestSequence seq = new TestSequence()
{
Variables = { var },
Activities =
{
testAssign,
new TestWriteLine {
MessageExpression = ((ctx) => var.Get(ctx).publicField.ToString()),HintMessage = value.ToString()
}
}
};
string error = string.Format(ErrorStrings.ActivityPropertyMustBeSet, "FieldName", valueTypeFieldReference.DisplayName);
List <TestConstraintViolation> constraints = new List <TestConstraintViolation>
{
new TestConstraintViolation(
error,
valueTypeFieldReference.ProductActivity)
};
TestRuntime.ValidateWorkflowErrors(seq, constraints, error);
}
public void EmptyTry()
{
// catch
TestCatch <Exception> testcatch1 = new TestCatch <Exception>();
TestCatch <MemberAccessException> testcatch2 = new TestCatch <MemberAccessException>();
TestCatch[] catches = new TestCatch[] { testcatch1, testcatch2 };
// finally
TestSequence finalSeq = new TestSequence();
finalSeq.Activities.Add(new TestWriteLine("Final", "Final"));
// Run test
TestRuntime.RunAndValidateWorkflow(
CreateTryCatchFinally(null, catches, finalSeq, WFType.SEQ, false));
}
public void BasicIfTest()
{
TestSequence outerSequence = new TestSequence("sequence1");
TestSequence innerSequence = new TestSequence("innerseq");
TestAssign <int> increment = new TestAssign <int>("Increment Counter");
Variable <int> counter = VariableHelper.CreateInitialized <int>("counter", 0);
TestSequence ifSequence = new TestSequence("ifSequence");
TestDoWhile whileAct = new TestDoWhile("dowhile")
{
ConditionExpression = ((env) => ((int)counter.Get(env)) < 10),
Body = ifSequence,
HintIterationCount = 10,
};
TestWriteLine writeLine = new TestWriteLine("write hello")
{
Message = "Its a small world after all"
};
increment.ToVariable = counter;
increment.ValueExpression = ((env) => ((int)counter.Get(env)) + 1);
TestIf ifAct = new TestIf("if act", HintThenOrElse.Else)
{
ConditionExpression = ((env) => ((int)counter.Get(env)) > 10),
ThenActivity = new TestWriteLine("NotExecuting Writeline", "Shouldnt appear on screen"),
ElseActivity = writeLine
};
TestIf ifAct2 = new TestIf("if act2", HintThenOrElse.Then)
{
ConditionExpression = ((env) => ((int)counter.Get(env)) < 10),
ThenActivity = innerSequence,
};
ifSequence.Activities.Add(ifAct);
ifSequence.Activities.Add(ifAct2);
innerSequence.Activities.Add(increment);
outerSequence.Variables.Add(counter);
outerSequence.Activities.Add(whileAct);
TestRuntime.RunAndValidateWorkflow(outerSequence);
}
public void TrySettingPropertyWithoutSetter()
{
//
// Test case description:
// Try setting a property which does not have a setter. Exception expected.
TheStruct valueType = new TheStruct();
Variable <TheStruct> var = new Variable <TheStruct>()
{
Default = valueType, Name = "var"
};
TestValueTypePropertyReference <TheStruct, int> valueTypePropertyReference = new TestValueTypePropertyReference <TheStruct, int>()
{
PropertyName = "PropertyWithoutSetter",
OperandLocationVariable = var,
};
int value = 321;
TestAssign <int> testAssign = new TestAssign <int>()
{
ToLocation = valueTypePropertyReference,
Value = value,
ExpectedOutcome = Outcome.UncaughtException(typeof(InvalidOperationException)),
};
TestSequence seq = new TestSequence()
{
Variables = { var },
Activities =
{
testAssign,
}
};
string error = string.Format(ErrorStrings.MemberIsReadOnly, "PropertyWithoutSetter", typeof(TheStruct));
List <TestConstraintViolation> constraints = new List <TestConstraintViolation>
{
new TestConstraintViolation(
error,
valueTypePropertyReference.ProductActivity)
};
TestRuntime.ValidateWorkflowErrors(seq, constraints, error);
}
public void TestAbortLoad()
{
Variable <int> value = VariableHelper.Create <int>("value");
TestSequence sequence = new TestSequence()
{
Variables = { value },
Activities =
{
new TestAssign <int>()
{
ToVariable = value,
Value = 100
},
new TestPersist(),
new TestReadLine <int>("Read", "Read")
{
BookmarkValue = value
},
new TestWriteLine("AfterAbort")
{
MessageExpression = (env) => value.Get(env).ToString(),
HintMessage = "9999"
}
}
};
JsonFileInstanceStore.FileInstanceStore jsonStore = new JsonFileInstanceStore.FileInstanceStore(".\\~");
TestWorkflowRuntime runtime = TestRuntime.CreateTestWorkflowRuntime(sequence, null, jsonStore, PersistableIdleAction.Persist);
runtime.ExecuteWorkflow();
runtime.WaitForActivityStatusChange("Read", TestActivityInstanceState.Executing);
runtime.PersistWorkflow();
runtime.AbortWorkflow("Abort Workflow");
//Wait Sometime to Handle to free
Thread.CurrentThread.Join((int)TimeSpan.FromSeconds(4).TotalMilliseconds);
//Load Workflow from Last Persistence Point
runtime.LoadWorkflow();
runtime.ResumeBookMark("Read", 9999);
runtime.WaitForActivityStatusChange("AfterAbort", TestActivityInstanceState.Closed);
//Wait for the second completion trace
TestTraceManager.Instance.WaitForTrace(runtime.CurrentWorkflowInstanceId, new SynchronizeTrace(RemoteWorkflowRuntime.CompletedOrAbortedHandlerCalled), 1);
//Call Abort on Completed Workflow, this should not throw exception
runtime.AbortWorkflow("Abort on Completed Workflow");
}
public void SetIndexNegative()
{
Variable <string[]> array = new Variable <string[]>("array", context => new string[] { "Ola" });
TestArrayItemValue <string> itemValue = new TestArrayItemValue <string>
{
ArrayVariable = array,
Index = -1,
ExpectedOutcome = Outcome.UncaughtException()
};
TestSequence testSequence = new TestSequence
{
Variables = { array },
Activities = { itemValue }
};
TestRuntime.RunAndValidateAbortedException(testSequence, typeof(IndexOutOfRangeException), null);
}
/// <summary>
/// Exception is thrown in try and caught.
/// Exception is thrown in try and caught. Catch contains a base of thrown child exception.
/// </summary>
/// Disabled and failed in desktop
//[Fact]
public void InheritedExceptions2()
{
// try
TestSequence trySeq = new TestSequence();
trySeq.Activities.Add(new TestWriteLine("Try", "Try"));
trySeq.Activities.Add(new TestThrow <ArgumentException>("TestThrow1"));
// catch
TestCatch[] catches = new TestCatch[] { new TestCatch <Exception>() };
catches[0].HintHandleException = true;
// create and run
TestActivity act = CreateTryCatchFinally(trySeq, catches, null, WFType.SEQ, true);
TestRuntime.RunAndValidateWorkflow(act);
}
public void SwitchWithEnums()
{
TestSwitch <OrderStatus> order = new TestSwitch <OrderStatus>();
order.AddCase(OrderStatus.NewOrder, new TestWriteLine("We have received a new order")
{
Message = "New Order"
});
order.AddCase(OrderStatus.Processing, new TestWriteLine("Order is in processing state")
{
Message = "Processing"
});
order.AddCase(OrderStatus.Shipped, new TestSequence {
Activities = { new TestWriteLine("Order is shipped to you")
{
Message = "Order shipped"
} }
});
order.Hints.Add(0);
order.Hints.Add(1);
order.Hints.Add(2);
List <OrderStatus> values = new List <OrderStatus>()
{
OrderStatus.NewOrder, OrderStatus.Processing, OrderStatus.Shipped
};
DelegateInArgument <OrderStatus> var = new DelegateInArgument <OrderStatus> {
Name = "var"
};
TestForEach <OrderStatus> forEachAct = new TestForEach <OrderStatus>("ForEachAct")
{
Values = values,
CurrentVariable = var
};
TestSequence seq = new TestSequence("Seq in For Each");
seq.Activities.Add(order);
forEachAct.Body = seq;
order.ExpressionExpression = (env) => (OrderStatus)var.Get(env);
forEachAct.HintIterationCount = 3;
TestRuntime.RunAndValidateWorkflow(forEachAct);
}
public void TrySettingFieldOfNonExistentField()
{
//
// Test case description:
// Try setting value of a field in a type which does not exist. Validation exception expected.
TheStruct valueType = new TheStruct();
Variable <TheStruct> var = new Variable <TheStruct>()
{
Default = valueType, Name = "var"
};
TestValueTypeFieldReference <TheStruct, int> valueTypeFieldReference = new TestValueTypeFieldReference <TheStruct, int>()
{
FieldName = "NonExistField",
OperandLocationVariable = var,
};
int value = 321;
TestAssign <int> testAssign = new TestAssign <int>()
{
ToLocation = valueTypeFieldReference, Value = value
};
TestSequence seq = new TestSequence()
{
Variables = { var },
Activities =
{
testAssign,
}
};
string error = string.Format(ErrorStrings.MemberNotFound, "NonExistField", typeof(TheStruct).Name);
List <TestConstraintViolation> constraints = new List <TestConstraintViolation>
{
new TestConstraintViolation(
error,
valueTypeFieldReference.ProductActivity)
};
TestRuntime.ValidateWorkflowErrors(seq, constraints, error);
}
public void CompletionConditionCancelsRestOfBranches()
{
Variable <bool> cancelIt = new Variable <bool> {
Name = "cancelIt", Default = false
};
DelegateInArgument <int> i = new DelegateInArgument <int>()
{
Name = "i"
};
TestWriteLine w1 = new TestWriteLine("w1", "write1")
{
HintMessageList = { "write1", "write1", "write1" }
};
TestAssign <bool> a1 = new TestAssign <bool>
{
Value = true,
ToVariable = cancelIt,
};
TestIf decide = new TestIf(HintThenOrElse.Else, HintThenOrElse.Else, HintThenOrElse.Then)
{
ConditionExpression = ((ctx) => i.Get(ctx) < 5),
ThenActivity = a1,
ElseActivity = w1,
};
TestParallelForEach <int> foreachAct = new TestParallelForEach <int>("foreach")
{
HintValues = new int[] { 1, 2, 3, 4, 5, 6 },
ValuesExpression = (context => new int[] { 1, 2, 3, 4, 5, 6 }),
CurrentVariable = i,
HintIterationCount = 3,
Body = decide,
CompletionConditionVariable = cancelIt,
};
TestSequence sequence = new TestSequence
{
Activities = { foreachAct },
Variables = { cancelIt },
};
TestRuntime.RunAndValidateWorkflow(sequence);
}
public void BasicSequenceNoVariables()
{
// Test case description:
// Sequence activity without any variables
TestSequence sequence = new TestSequence("Sequence1");
TestSequence sequence2 = new TestSequence("InnerSequence1");
TestSequence sequence3 = new TestSequence("InnerSequence2");
TestSequence sequence4 = new TestSequence("InnerSequence3");
TestSequence sequence5 = new TestSequence("InnerSequence4");
TestSequence sequence6 = new TestSequence("seq5");
TestSequence sequence7 = new TestSequence("seq6");
TestSequence sequence8 = new TestSequence("seq7");
TestSequence sequence9 = new TestSequence("seq8");
TestWriteLine writeLine1 = new TestWriteLine("Hello One");
writeLine1.Message = string.Format("Hello world in {0} , {1} , {2}!", sequence.DisplayName, sequence2.DisplayName, sequence6.DisplayName);
TestWriteLine writeLine2 = new TestWriteLine("Hello Two");
writeLine2.Message = string.Format("Hello world in {0} , {1} , {2}!", sequence.DisplayName, sequence3.DisplayName, sequence7.DisplayName);
TestWriteLine writeLine3 = new TestWriteLine("Hello Three");
writeLine3.Message = string.Format("Hello world in {0} , {1} , {2}!", sequence.DisplayName, sequence4.DisplayName, sequence8.DisplayName);
TestWriteLine writeLine4 = new TestWriteLine("Hello Four");
writeLine4.Message = string.Format("Hello world in {0} , {1} , {2}!", sequence.DisplayName, sequence5.DisplayName, sequence9.DisplayName);
sequence6.Activities.Add(writeLine1);
sequence7.Activities.Add(writeLine2);
sequence8.Activities.Add(writeLine3);
sequence9.Activities.Add(writeLine4);
sequence2.Activities.Add(sequence6);
sequence3.Activities.Add(sequence7);
sequence4.Activities.Add(sequence8);
sequence5.Activities.Add(sequence9);
sequence.Activities.Add(sequence2);
sequence.Activities.Add(sequence3);
sequence.Activities.Add(sequence4);
sequence.Activities.Add(sequence5);
TestRuntime.RunAndValidateWorkflow(sequence);
}
public void TrySettingValueOfFieldNameNull()
{
//
// Test case description:
// Try executing ValueTypeFieldReference activity by setting FieldName to null. Validation exception
// expected.
TheStruct valueType = new TheStruct();
Variable <TheStruct> var = new Variable <TheStruct>()
{
Default = valueType, Name = "var"
};
TestValueTypeFieldReference <TheStruct, int> valueTypeFieldReference = new TestValueTypeFieldReference <TheStruct, int>()
{
FieldName = null,
OperandLocationVariable = var,
};
int value = 321;
TestAssign <int> testAssign = new TestAssign <int>()
{
ToLocation = valueTypeFieldReference, Value = value
};
TestSequence seq = new TestSequence()
{
Variables = { var },
Activities =
{
testAssign,
}
};
string error = string.Format(ErrorStrings.ActivityPropertyMustBeSet, "FieldName", valueTypeFieldReference.DisplayName);
List <TestConstraintViolation> constraints = new List <TestConstraintViolation>
{
new TestConstraintViolation(
error,
valueTypeFieldReference.ProductActivity)
};
TestRuntime.ValidateWorkflowErrors(seq, constraints, error);
}
public void AddLogDetail(TestBlock testBlock, int sequenceIndex)
{
if (isTest)
{
return;
}
TestSequence testSequence = testBlock.Sequences[sequenceIndex];
logDataDetail += "\n" + string.Join(", ", new string[] { testBlock.ParticipantCode, testBlock.BlockCode, StudyNumber.ToString(),
testBlock.ConditionCode, testSequence.SequenceNumber.ToString(),
testSequence.IndexOfDifficulty.ToString(), testSequence.TargetWidth.ToString(), testSequence.TargetAmplitude.ToString(),
testSequence.EffecttiveIndexOfDifficulty.ToString(), testSequence.EffectiveTargetWidth.ToString(), testSequence.EffectiveAmplitude.ToString(),
testSequence.StartTime.ToString("MM/dd/yyyy hh:mm:ss.fff tt"), "Cardboard", testBlock.ErrorThreshold.ToString(),
testBlock.SelectedControlMethod.ToString(), testBlock.SelectedConfirmationMethod.ToString(),
testBlock.DwellTime.ToString(), testBlock.Timeout.ToString(), testBlock.MouseSensivity.ToString(),
testSequence.MovementTime.ToString(), testSequence.ErrorRate.ToString(), testSequence.Throughput.ToString(), testSequence.RotationSumDegree.ToString() });
}
public void FlowStepActionToNestedActivityInSequence()
{
TestFlowchart flowchart = new TestFlowchart();
TestWriteLine w1 = new TestWriteLine("w1", "w1");
TestWriteLine w2 = new TestWriteLine("w2", "w2");
TestWriteLine w3 = new TestWriteLine("w3", "w3");
TestSequence seq = new TestSequence();
seq.Activities.Add(w2);
flowchart.AddLink(w1, seq);
flowchart.AddLink(seq, w3);
flowchart.AddLink(w3, w2);
TestRuntime.ValidateInstantiationException(flowchart, string.Format(ErrorStrings.ActivityCannotBeReferencedWithoutTarget, w2.DisplayName, seq.DisplayName, flowchart.DisplayName));
}
public void AddLogTrial(TestBlock testBlock, int sequenceIndex, int trialNumber)
{
if (isTest)
{
return;
}
TestSequence testSequence = testBlock.Sequences[sequenceIndex];
TestTrial trial = testSequence.Trials[trialNumber];
logDataTrials += "\n" + string.Join(", ", new string[] { testBlock.ParticipantCode, testBlock.BlockCode, StudyNumber.ToString(),
testBlock.ConditionCode, testBlock.MouseSensivity.ToString(), testSequence.SequenceNumber.ToString(),
trial.TrialNumber.ToString(), trial.TargetAngle.ToString(),
trial.StartTime.ToString("MM/dd/yyyy hh:mm:ss.fff tt"),
trial.TotalCursorMovement.ToString(), trial.TimeToActivate.ToString(),
trial.TimeToFixate.ToString(), trial.TargetCenterError.x.ToString(), trial.TargetCenterError.y.ToString(),
trial.TimedOut.ToString(), trial.Error.ToString() });
}
public void CatchBothUnhandledExceptionHandlerAndInCatch()
{
// try
// Throws a handled exception, then a caught exception
TestSequence trySeq = new TestSequence("Try")
{
Activities =
{
new TestThrow <FormatException>("ThrowFormat")
{
ExceptionExpression = (context => new FormatException(CustomUtility.CustomMessage)),
ExpectedOutcome = Outcome.HandledException(),
},
},
ExpectedOutcome = Outcome.Canceled
};
// catch
// Should not catch anything
TestCatch[] catches = new TestCatch[]
{
new TestCatch <ArgumentException>()
{
}
};
// finally
// Just confirm it executed
TestWriteLine finalSeq = new TestWriteLine("Final", "Final");
// Run test
TestActivity act = CreateTryCatchFinally(trySeq, catches, finalSeq, WFType.SEQ, false);
// Run and validate trace
using (TestWorkflowRuntime runtime = TestRuntime.CreateTestWorkflowRuntime(act))
{
// Add the unhandled handler
runtime.WorkflowRuntimeAdapterType = typeof(AddHandleExceptionRuntimeAdapter);
runtime.ExecuteWorkflow();
runtime.GetWatcher().WaitForWorkflowCanceled();
}
}
public void CompositeProcedurals()
{
Variable <bool> cond = new Variable <bool> {
Default = true
};
Variable <string> value = new Variable <string> {
Default = "Apple"
};
DelegateInArgument <string> arg = new DelegateInArgument <string> {
Name = "Apple"
};
string[] values = { "a", "b" };
TestSwitch <string> switchAct = new TestSwitch <string>();
switchAct.ExpressionVariable = value;
switchAct.AddCase("Apple", new TestWriteLine("Apple", "this is an apple"));
switchAct.AddCase("Orange", new TestWriteLine("Orange", "this is an orange"));
switchAct.Hints.Add(0);
TestIf ifAct = new TestIf(HintThenOrElse.Then);
ifAct.ConditionVariable = cond;
ifAct.ThenActivity = new TestWriteLine("W", "Yes thats true");
ifAct.ElseActivity = new TestWriteLine("W", "No thats not true");
TestForEach <string> forEachAct = new TestForEach <string>();
forEachAct.Values = values;
forEachAct.CurrentVariable = arg;
forEachAct.HintIterationCount = 2;
forEachAct.Body = new TestWriteLine {
DisplayName = "w1", MessageExpression = context => arg.Get(context), HintMessageList = { "a", "b" }
};
TestSequence seq = new TestSequence
{
Variables = { cond, value },
Activities = { switchAct, ifAct, forEachAct }
};
TestRuntime.RunAndValidateWorkflow(seq);
}
/// <summary>
/// Reads a sequence set from a textual file.
/// </summary>
/// <param name="p"></param>
/// <returns></returns>
private List<TestSequence> ReadSequencesFromFile(string p)
{
List<TestSequence> sequences = new List<TestSequence>();
//reads file contents
string line;
TextReader reader = new StreamReader(p);
//iterates through lines
while((line = reader.ReadLine()) != null){
//turn sequence into a list
TestSequence seq = new TestSequence();
seq.Path = line.Split(',').ToList();
if(seq.Path.Count > 1)
sequences.Add(seq);
}
reader.Dispose();
return sequences;
}
