public void DifferentArguments()
{
//Testing Different argument types for While.Condition
// DelegateInArgument
// DelegateOutArgument
// Variable<T> , Activity<T> and Expression is already implemented.
DelegateInArgument <bool> delegateInArgument = new DelegateInArgument <bool>("Condition");
DelegateOutArgument <bool> delegateOutArgument = new DelegateOutArgument <bool>("Output");
TestCustomActivity <InvokeFunc <bool, bool> > invokeFunc = TestCustomActivity <InvokeFunc <bool, bool> > .CreateFromProduct(
new InvokeFunc <bool, bool>
{
Argument = true,
Func = new ActivityFunc <bool, bool>
{
Argument = delegateInArgument,
Result = delegateOutArgument,
Handler = new Microsoft.CoreWf.Statements.Sequence
{
DisplayName = "Sequence1",
Activities =
{
new Microsoft.CoreWf.Statements.While
{
DisplayName = "While1",
Condition = ExpressionServices.Convert <bool>(ctx => delegateInArgument.Get(ctx)),
Body = new Microsoft.CoreWf.Statements.Assign <bool>
{
DisplayName = "Assign1",
To = delegateInArgument,
Value = new Microsoft.CoreWf.Expressions.Not <bool, bool> {
Operand = delegateInArgument, DisplayName = "Not<Boolean,Boolean>"
}
},
},
new Microsoft.CoreWf.Statements.Assign <bool>
{
DisplayName = "Assign2",
To = delegateOutArgument,
Value = new Microsoft.CoreWf.Expressions.Not <bool, bool> {
Operand = delegateInArgument, DisplayName = "Not<Boolean,Boolean>"
},
},
new Microsoft.CoreWf.Statements.While
{
DisplayName = "While2",
Condition = ExpressionServices.Convert <bool>(ctx => delegateOutArgument.Get(ctx)),
Body = new Microsoft.CoreWf.Statements.Assign <bool>
{
DisplayName = "Assign3",
To = delegateOutArgument,
Value = new Microsoft.CoreWf.Expressions.Not <bool, bool> {
Operand = delegateOutArgument, DisplayName = "Not<Boolean,Boolean>"
}
},
},
},
}
}
}
);
TestSequence sequenceForTracing = new TestSequence
{
DisplayName = "Sequence1",
Activities =
{
new TestDoWhile
{
DisplayName = "While1",
ActivitySpecificTraces =
{
new OrderedTraces()
{
Steps =
{
new ActivityTrace("DelegateArgumentValue<Boolean>", ActivityInstanceState.Executing),
new ActivityTrace("DelegateArgumentValue<Boolean>", ActivityInstanceState.Closed),
new ActivityTrace("Assign1", ActivityInstanceState.Executing),
new ActivityTrace("Not<Boolean,Boolean>", ActivityInstanceState.Executing),
new ActivityTrace("Not<Boolean,Boolean>", ActivityInstanceState.Closed),
new ActivityTrace("Assign1", ActivityInstanceState.Closed),
new ActivityTrace("DelegateArgumentValue<Boolean>", ActivityInstanceState.Executing),
new ActivityTrace("DelegateArgumentValue<Boolean>", ActivityInstanceState.Closed),
}
},
}
},
new TestAssign <bool>
{
DisplayName = "Assign2",
ValueActivity = new Test.Common.TestObjects.Activities.Expressions.TestNot <bool, bool>{
DisplayName = "Not<Boolean,Boolean>"
}
},
new TestDoWhile
{
DisplayName = "While2",
ActivitySpecificTraces =
{
new OrderedTraces()
{
Steps =
{
new ActivityTrace("DelegateArgumentValue<Boolean>", ActivityInstanceState.Executing),
new ActivityTrace("DelegateArgumentValue<Boolean>", ActivityInstanceState.Closed),
new ActivityTrace("Assign3", ActivityInstanceState.Executing),
new ActivityTrace("Not<Boolean,Boolean>", ActivityInstanceState.Executing),
new ActivityTrace("Not<Boolean,Boolean>", ActivityInstanceState.Closed),
new ActivityTrace("Assign3", ActivityInstanceState.Closed),
new ActivityTrace("DelegateArgumentValue<Boolean>", ActivityInstanceState.Executing),
new ActivityTrace("DelegateArgumentValue<Boolean>", ActivityInstanceState.Closed),
}
},
}
},
}
};
invokeFunc.CustomActivityTraces.Add(sequenceForTracing.GetExpectedTrace().Trace);
TestIf root = new TestIf(HintThenOrElse.Else)
{
ConditionActivity = invokeFunc,
ThenActivity = new TestWriteLine {
Message = "True", HintMessage = "This is not expected"
},
ElseActivity = new TestWriteLine {
Message = "False", HintMessage = "False"
},
};
TestRuntime.RunAndValidateWorkflow(root);
}
public static Constraint SetReceiveRequestSendResponseScopeExecutionPropertyFactory()
{
DelegateInArgument <ReceiveRequestSendResponseScope> element = new DelegateInArgument <ReceiveRequestSendResponseScope>();
DelegateInArgument <ValidationContext> context = new DelegateInArgument <ValidationContext>();
DelegateInArgument <Activity> child = new DelegateInArgument <Activity>();
return(new Constraint <ReceiveRequestSendResponseScope>
{
Body = new ActivityAction <ReceiveRequestSendResponseScope, ValidationContext>
{
Argument1 = element,
Argument2 = context,
Handler = new ForEach <Activity>
{
Values = new GetChildSubtree
{
ValidationContext = context,
},
Body = new ActivityAction <Activity>
{
Argument = child,
Handler = new If
{
Condition = new InArgument <bool>((env) => child.Get(env) is ISendResponse),
Then = new ReceiveRequestSendResponseScope.ReceiveRequestSendResponseScopeExecutionPropertyFactorySetter
{
ISendResponse = new InArgument <ISendResponse>((env) => child.Get(env) as ISendResponse),
ReceiveRequestSendResponseScope = new InArgument <ReceiveRequestSendResponseScope>((env) => element.Get(env)),
},
},
},
},
},
});
}
public void SetDelegateArgument()
{
// for using delegate argument
TheStruct valueType = new TheStruct();
int indiceValue = 2;
DelegateInArgument <int> indice = new DelegateInArgument <int>();
Variable <TheStruct> var = VariableHelper.CreateInitialized <TheStruct>("var", valueType);
TestValueTypeIndexerReference <TheStruct, int> valueTypeIndexerReference = new TestValueTypeIndexerReference <TheStruct, int>()
{
OperandLocationVariable = var,
};
valueTypeIndexerReference.Indices.Add(new TestArgument <int>(Direction.In, null, (env) => indice.Get(env)));
int value = 321;
TestAssign <int> testAssign = new TestAssign <int>()
{
ToLocation = valueTypeIndexerReference, Value = value
};
TestSequence seq = new TestSequence()
{
Activities =
{
testAssign,
new TestWriteLine {
MessageExpression = ((ctx) => var.Get(ctx)[indiceValue].ToString())
}
}
};
System.Activities.Statements.Sequence outerSeq = new System.Activities.Statements.Sequence()
{
Variables =
{
var
},
Activities =
{
new InvokeAction <int>()
{
Argument = indiceValue,
Action = new ActivityAction <int>()
{
Argument = indice,
Handler = seq.ProductActivity
}
}
}
};
TestCustomActivity testActivity = TestCustomActivity <System.Activities.Statements.Sequence> .CreateFromProduct(outerSeq);
UnorderedTraces traces = new UnorderedTraces()
{
Steps =
{
new UserTrace(value.ToString())
}
};
testActivity.ActivitySpecificTraces.Add(traces);
ExpectedTrace expectedTrace = testActivity.GetExpectedTrace();
expectedTrace.AddIgnoreTypes(typeof(ActivityTrace));
TestRuntime.RunAndValidateWorkflow(testActivity, expectedTrace);
}
public static Constraint SetWorkflowInterfaceOperationNames()
{
DelegateInArgument <ReceiveRequestSendResponseScope> element = new DelegateInArgument <ReceiveRequestSendResponseScope>();
DelegateInArgument <ValidationContext> context = new DelegateInArgument <ValidationContext>();
DelegateInArgument <Activity> parent = new DelegateInArgument <Activity>();
DelegateInArgument <Activity> child = new DelegateInArgument <Activity>();
Variable <IOperationActivity> receiveRequest = new Variable <IOperationActivity>();
Variable <Type> workflowInterfaceType = new Variable <Type>();
Variable <Type> requestResultType = new Variable <Type>();
Variable <Type> responseParameterType = new Variable <Type>();
return(new Constraint <ReceiveRequestSendResponseScope>
{
Body = new ActivityAction <ReceiveRequestSendResponseScope, ValidationContext>
{
Argument1 = element,
Argument2 = context,
Handler = new Sequence
{
Variables =
{
receiveRequest,
workflowInterfaceType,
requestResultType,
responseParameterType,
},
Activities =
{
new ForEach <Activity>
{
Values = new GetParentChain
{
ValidationContext = context,
},
Body = new ActivityAction <Activity>
{
Argument = parent,
Handler = new If
{
Condition = new InArgument <bool>((env) => parent.Get(env).IsWorkflowActivity()),
Then = new Assign <Type>
{
Value = new InArgument <Type>((env) => parent.Get(env).GetWorkflowActivityType().GetGenericArguments()[(int)TypeParameterIndex.WorkflowInterface]),
To = workflowInterfaceType,
},
},
},
},
new ForEach <Activity>
{
Values = new GetChildSubtree
{
ValidationContext = context,
},
Body = new ActivityAction <Activity>
{
Argument = child,
Handler = new Sequence
{
Activities =
{
new If
{
Condition = new InArgument <bool>((env) => child.Get(env) is IReceiveRequest),
Then = new Sequence
{
Activities =
{
new Assign <IOperationActivity>
{
Value = new InArgument <IOperationActivity>((env) => child.Get(env) as IOperationActivity),
To = receiveRequest
},
new Assign <Type>
{
Value = new InArgument <Type>((env) => (child.Get(env) as IReceiveRequest).RequestResultType),
To = requestResultType
},
},
},
},
new If
{
Condition = new InArgument <bool>((env) => child.Get(env) is ISendResponse),
Then = new Assign <Type>
{
Value = new InArgument <Type>((env) => (child.Get(env) as ISendResponse).ResponseParameterType),
To = responseParameterType
},
},
},
},
},
},
new WorkflowInterfaceOperationNamesSetter
{
ReceiveRequest = new InArgument <IOperationActivity>((env) => receiveRequest.Get(env)),
WorkflowInterfaceType = new InArgument <Type>((env) => workflowInterfaceType.Get(env)),
RequestResultType = new InArgument <Type>((env) => requestResultType.Get(env)),
ResponseParameterType = new InArgument <Type>((env) => responseParameterType.Get(env)),
},
},
},
},
});
}
public static Constraint VerifyReceiveRequestSendResponseScopeChildren()
{
DelegateInArgument <ReceiveRequestSendResponseScope> element = new DelegateInArgument <ReceiveRequestSendResponseScope>();
DelegateInArgument <ValidationContext> context = new DelegateInArgument <ValidationContext>();
DelegateInArgument <Activity> child = new DelegateInArgument <Activity>();
Variable <int> receiveRequestCounter = new Variable <int>();
Variable <int> sendResponseCounter = new Variable <int>();
return(new Constraint <ReceiveRequestSendResponseScope>
{
Body = new ActivityAction <ReceiveRequestSendResponseScope, ValidationContext>
{
Argument1 = element,
Argument2 = context,
Handler = new Sequence
{
Variables =
{
receiveRequestCounter,
sendResponseCounter,
},
Activities =
{
new Assign <int>
{
Value = 0,
To = receiveRequestCounter,
},
new Assign <int>
{
Value = 0,
To = sendResponseCounter,
},
new ForEach <Activity>
{
Values = new GetChildSubtree
{
ValidationContext = context,
},
Body = new ActivityAction <Activity>
{
Argument = child,
Handler = new Sequence
{
Activities =
{
new If
{
Condition = new InArgument <bool>((env) => child.Get(env) is IReceiveRequest),
Then = new Assign <int>
{
Value = new InArgument <int>((env) => receiveRequestCounter.Get(env) + 1),
To = receiveRequestCounter
},
},
new If
{
Condition = new InArgument <bool>((env) => child.Get(env) is ISendResponse),
Then = new Assign <int>
{
Value = new InArgument <int>((env) => sendResponseCounter.Get(env) + 1),
To = sendResponseCounter
},
},
},
},
},
},
new AssertValidation
{
Assertion = new InArgument <bool>((env) => receiveRequestCounter.Get(env) == 1),
Message = new InArgument <string> ($"{nameof(ReceiveRequestSendResponseScope)} activity must contain one and only one {nameof(ReceiveRequest)} activity"),
PropertyName = new InArgument <string>((env) => element.Get(env).DisplayName)
},
new AssertValidation
{
Assertion = new InArgument <bool>((env) => sendResponseCounter.Get(env) == 1),
Message = new InArgument <string> ($"{nameof(ReceiveRequestSendResponseScope)} activity must contain one and only one {nameof(SendResponse)} activity"),
PropertyName = new InArgument <string>((env) => element.Get(env).DisplayName)
},
},
},
},
});
}
public void ParallelForEachWithWorkflowInvoker()
{
TestSequence innerSequence = new TestSequence("innerSeq");
DelegateInArgument <string> i = new DelegateInArgument <string>()
{
Name = "i"
};
string[] strArray = new string[] { "var1", "var2", "var3" };
TestParallelForEach <string> foreachAct = new TestParallelForEach <string>("foreach");
foreachAct.HintValues = strArray;
foreachAct.ValuesExpression = (context => new string[] { "var1", "var2", "var3" });
foreachAct.CurrentVariable = i;
foreachAct.HintIterationCount = 3;
TestWriteLine writeLine = new TestWriteLine("write hello");
writeLine.MessageExpression = ((env) => string.Format("WriteLine Argument: {0}", i.Get(env)));
for (int counter = strArray.Length - 1; counter > -1; counter--)
{
writeLine.HintMessageList.Add("WriteLine Argument: " + strArray[counter]);
}
foreachAct.Body = innerSequence;
innerSequence.Activities.Add(writeLine);
TestRuntime.RunAndValidateUsingWorkflowInvoker(foreachAct, null, null, null);
}
private Constraint ProcessParentChainConstraints()
{
DelegateInArgument <System.Activities.Statements.TransactionScope> element = new DelegateInArgument <System.Activities.Statements.TransactionScope> {
Name = "element"
};
DelegateInArgument <ValidationContext> argument = new DelegateInArgument <ValidationContext> {
Name = "validationContext"
};
DelegateInArgument <Activity> argument2 = new DelegateInArgument <Activity> {
Name = "parent"
};
Constraint <System.Activities.Statements.TransactionScope> constraint = new Constraint <System.Activities.Statements.TransactionScope>();
ActivityAction <System.Activities.Statements.TransactionScope, ValidationContext> action = new ActivityAction <System.Activities.Statements.TransactionScope, ValidationContext> {
Argument1 = element,
Argument2 = argument
};
Sequence sequence = new Sequence();
ForEach <Activity> item = new ForEach <Activity>();
GetParentChain chain = new GetParentChain {
ValidationContext = argument
};
item.Values = chain;
ActivityAction <Activity> action2 = new ActivityAction <Activity> {
Argument = argument2
};
Sequence sequence2 = new Sequence();
If @if = new If();
Equal <Type, Type, bool> equal = new Equal <Type, Type, bool>();
ObtainType type = new ObtainType {
Input = argument2
};
equal.Left = type;
equal.Right = new InArgument <Type>(context => typeof(System.Activities.Statements.TransactionScope));
@if.Condition = equal;
Sequence sequence3 = new Sequence();
AssertValidation validation = new AssertValidation {
IsWarning = 1
};
AbortInstanceFlagValidator validator = new AbortInstanceFlagValidator {
ParentActivity = argument2,
TransactionScope = new InArgument <System.Activities.Statements.TransactionScope>(context => element.Get(context))
};
validation.Assertion = validator;
validation.Message = new InArgument <string>(System.Activities.SR.AbortInstanceOnTransactionFailureDoesNotMatch);
validation.PropertyName = "AbortInstanceOnTransactionFailure";
sequence3.Activities.Add(validation);
AssertValidation validation2 = new AssertValidation();
IsolationLevelValidator validator2 = new IsolationLevelValidator {
ParentActivity = argument2,
CurrentIsolationLevel = new InArgument <System.Transactions.IsolationLevel>(context => element.Get(context).IsolationLevel)
};
validation2.Assertion = validator2;
validation2.Message = new InArgument <string>(System.Activities.SR.IsolationLevelValidation);
validation2.PropertyName = "IsolationLevel";
sequence3.Activities.Add(validation2);
@if.Then = sequence3;
sequence2.Activities.Add(@if);
action2.Handler = sequence2;
item.Body = action2;
sequence.Activities.Add(item);
action.Handler = sequence;
constraint.Body = action;
return(constraint);
}
public void ParallelForEachWithAChildThatOverridesCancelAndCompletionConditionIsTrue()
{
Variable <bool> cancelIt = new Variable <bool> {
Name = "cancelIt", Default = false
};
DelegateInArgument <bool> arg = new DelegateInArgument <bool>("arg");
TestParallelForEach <bool> pfeAct = new TestParallelForEach <bool>
{
DisplayName = "ParallelForEach1",
HintIterationCount = 2,
HintValues = new bool[] { true, false },
ValuesExpression = (e => new bool[] { true, false }),
CurrentVariable = arg,
CompletionConditionVariable = cancelIt,
Body = new TestIf(HintThenOrElse.Then, HintThenOrElse.Else)
{
DisplayName = "If1",
ConditionExpression = e => arg.Get(e),
ThenActivity = new TestBlockingActivityWithWriteLineInCancel("writeLineInCancel", OutcomeState.Completed)
{
ExpectedOutcome = new Outcome(OutcomeState.Completed, OutcomeState.Canceled),
},
ElseActivity = new TestSequence
{
DisplayName = "Sequence2",
Activities =
{
new TestDelay("d1", new TimeSpan(1)),
new TestAssign <bool> {
DisplayName = "Assign1",Value = true, ToVariable = cancelIt
}
}
}
},
};
TestSequence root = new TestSequence
{
DisplayName = "Sequence1",
Activities = { pfeAct },
Variables = { cancelIt },
};
OrderedTraces ordered = new OrderedTraces()
{
Steps =
{
new ActivityTrace("Sequence1", ActivityInstanceState.Executing),
new ActivityTrace("ParallelForEach1", ActivityInstanceState.Executing),
new UnorderedTraces
{
Steps =
{
new OrderedTraces()
{
Steps =
{
new ActivityTrace("If1", ActivityInstanceState.Executing),
new ActivityTrace("writeLineInCancel", ActivityInstanceState.Executing),
new ActivityTrace("w1", ActivityInstanceState.Executing),
new ActivityTrace("w1", ActivityInstanceState.Closed),
new ActivityTrace("writeLineInCancel", ActivityInstanceState.Closed),
new ActivityTrace("If1", ActivityInstanceState.Closed),
}
},
new OrderedTraces()
{
Steps =
{
new ActivityTrace("If1", ActivityInstanceState.Executing),
new ActivityTrace("Sequence2", ActivityInstanceState.Executing),
new ActivityTrace("d1", ActivityInstanceState.Executing),
new ActivityTrace("d1", ActivityInstanceState.Closed),
new ActivityTrace("Assign1", ActivityInstanceState.Executing),
new ActivityTrace("Assign1", ActivityInstanceState.Closed),
new ActivityTrace("Sequence2", ActivityInstanceState.Closed),
new ActivityTrace("If1", ActivityInstanceState.Closed),
new ActivityTrace("VariableValue<Boolean>", ActivityInstanceState.Executing),
new ActivityTrace("VariableValue<Boolean>", ActivityInstanceState.Closed),
}
}
}
},
new ActivityTrace("ParallelForEach1", ActivityInstanceState.Closed),
new ActivityTrace("Sequence1", ActivityInstanceState.Closed),
}
};
ExpectedTrace trace = new ExpectedTrace(ordered);
trace.AddIgnoreTypes(typeof(SynchronizeTrace));
trace.AddIgnoreTypes(typeof(BookmarkResumptionTrace));
TestRuntime.RunAndValidateWorkflow(root, trace);
}
static Activity CreateAverageCalculationWorkflow()
{
// Variables
var iterationVariable = new DelegateInArgument <int>()
{
Name = "iterationVariable"
};
var accumulator = new Variable <int>()
{
Default = 0, Name = "accumulator"
};
// Define the Input and Output arguments that the DynamicActivity binds to
var numbers = new InArgument <List <int> >();
var average = new OutArgument <double>();
var result = new Variable <double>()
{
Name = "result"
};
return(new DynamicActivity()
{
DisplayName = "Find average",
Properties =
{
// Input argument
new DynamicActivityProperty
{
Name = "Numbers",
Type = typeof(InArgument <List <int> >),
Value = numbers
},
// Output argument
new DynamicActivityProperty
{
Name = "Average",
Type = typeof(OutArgument <double>),
Value = average
}
},
Implementation = () =>
new Sequence
{
Variables = { result, accumulator },
Activities =
{
//<Snippet1>
new ForEach <int>
{
Values = new ArgumentValue <IEnumerable <int> >{
ArgumentName = "Numbers"
},
Body = new ActivityAction <int>
{
Argument = iterationVariable,
Handler = new Assign <int>
{
To = accumulator,
Value = new InArgument <int>(env => iterationVariable.Get(env) + accumulator.Get(env))
}
}
},
//</Snippet1>
// Calculate the average and assign to the output argument.
new Assign <double>
{
To = new ArgumentReference <double>{
ArgumentName = "Average"
},
Value = new InArgument <double>(env => accumulator.Get(env) / numbers.Get(env).Count <int>())
},
}
}
});
}
public void MultipleBranchesMultipleChildren()
{
TimeSpan time = new TimeSpan(0, 0, 2);
DelegateInArgument <string> currentVariable = new DelegateInArgument <string>()
{
Name = "currentVariable"
};
DelegateInArgument <string> currentVariable1 = new DelegateInArgument <string>()
{
Name = "currentVariable1"
};
DelegateInArgument <string> currentVariable2 = new DelegateInArgument <string>()
{
Name = "currentVariable2"
};
DelegateInArgument <string> currentVariable3 = new DelegateInArgument <string>()
{
Name = "currentVariable3"
};
#region Sequence
TestSequence sequence = new TestSequence()
{
Activities =
{
new TestWriteLine("WritelineAct1", "Hello"),
new TestIf("If act1", HintThenOrElse.Then)
{
Condition = true,
ThenActivity = new TestWriteLine("Writeline in then1")
{
Message = "I am writeline in if activity"
}
},
new TestDelay("Delay act1", time),
new TestParallelForEach <string>("Parallel For Each In sequence")
{
HintValues = new List <string>()
{
"Element1", "Element2"
},
ValuesExpression = (context => new List <string>()
{
"Element1", "Element2"
}),
CurrentVariable = currentVariable,
Body = new TestWriteLine()
{
MessageExpression = (env) => (string)currentVariable.Get(env),
HintMessageList = { "Element2", "Element1" }
},
HintIterationCount = 2
},
new TestTryCatch()
{
Try = new TestThrow <NullReferenceException>()
{
ExpectedOutcome = Outcome.CaughtException()
},
Catches =
{
new TestCatch <NullReferenceException>()
}
}
}
};
#endregion // Sequence
#region Sequence1
TestSequence sequence1 = new TestSequence()
{
Activities =
{
new TestWriteLine("WritelineAct2", "Hello"),
new TestIf("If act2", HintThenOrElse.Then)
{
Condition = true,
ThenActivity = new TestWriteLine("Writeline in then","I am writeline in if activity")
},
new TestDelay("Delay act2", time),
new TestParallelForEach <string>("Parallel For Each In sequence1")
{
HintValues = new List <string>()
{
"Element1", "Element2"
},
ValuesExpression = (context => new List <string>()
{
"Element1", "Element2"
}),
CurrentVariable = currentVariable1,
Body = new TestWriteLine("Writeline in PFE")
{
MessageExpression = (env) => (string)currentVariable1.Get(env),
HintMessageList = { "Element2", "Element1" }
},
HintIterationCount = 2
},
new TestTryCatch()
{
Try = new TestThrow <NullReferenceException>()
{
ExpectedOutcome = Outcome.CaughtException()
},
Catches =
{
new TestCatch <NullReferenceException>()
}
}
}
};
#endregion // Sequence1
#region Sequence2
TestSequence sequence2 = new TestSequence()
{
Activities =
{
new TestWriteLine("WritelineAct3", "Hello"),
new TestIf("If act3", HintThenOrElse.Then)
{
Condition = true,
ThenActivity = new TestWriteLine("Writeline in then","I am writeline in if activity")
},
new TestDelay("Delay act3", time),
new TestParallelForEach <string>("Parallel For Each In sequence2")
{
HintValues = new List <string>()
{
"Element1", "Element2"
},
ValuesExpression = (context => new List <string>()
{
"Element1", "Element2"
}),
CurrentVariable = currentVariable2,
Body = new TestWriteLine("Writeline in PFE")
{
MessageExpression = (env) => (string)currentVariable2.Get(env),
HintMessageList = { "Element2", "Element1" }
},
HintIterationCount = 2
},
new TestTryCatch()
{
Try = new TestThrow <NullReferenceException>()
{
ExpectedOutcome = Outcome.CaughtException()
},
Catches =
{
new TestCatch <NullReferenceException>()
}
}
}
};
#endregion // Sequence2
#region Sequence3
TestSequence sequence3 = new TestSequence()
{
Activities =
{
new TestWriteLine("WritelineAct4", "Hello"),
new TestIf("If act4", HintThenOrElse.Then)
{
Condition = true,
ThenActivity = new TestWriteLine("Writeline in then","I am writeline in if activity")
},
new TestDelay("Delay act4", time),
new TestParallelForEach <string>("Parallel For Each In sequence3")
{
HintValues = new List <string>()
{
"Element1", "Element2"
},
ValuesExpression = (context => new List <string>()
{
"Element1", "Element2"
}),
CurrentVariable = currentVariable3,
Body = new TestWriteLine("Writeline in PFE")
{
MessageExpression = (env) => (string)currentVariable3.Get(env),
HintMessageList = { "Element2", "Element1" }
},
HintIterationCount = 2
},
new TestTryCatch()
{
Try = new TestThrow <NullReferenceException>()
{
ExpectedOutcome = Outcome.CaughtException()
},
Catches =
{
new TestCatch <NullReferenceException>()
}
}
}
};
#endregion Sequence2
TestParallel parallelAct = new TestParallel("ParallelActivity")
{
Branches =
{
new TestSequence("First Sequence")
{
Activities ={ sequence }
},
// Second sequence
new TestSequence("Second sequence")
{
Activities ={ sequence1 }
},
// Third sequence
new TestSequence("Third sequence")
{
Activities ={ sequence2 }
},
// Fourth Sequence
new TestSequence("Fourth Sequence")
{
Activities ={ sequence3 }
}
},
HintNumberOfBranchesExecution = 4
};
ExpectedTrace trace = parallelAct.GetExpectedTrace();
TestRuntime.RunAndValidateWorkflow(parallelAct, trace);
}
public static Constraint HasParent <TActivity>(Func <Activity, bool> condition, string validationMessage)
where TActivity : Activity
{
var element = new DelegateInArgument <TActivity>();
DelegateInArgument <ValidationContext> context = new DelegateInArgument <ValidationContext>();
Variable <bool> result = new Variable <bool>();
DelegateInArgument <Activity> parent = new DelegateInArgument <Activity>();
return(new Constraint <TActivity>
{
Body = new ActivityAction <TActivity, ValidationContext>()
{
Argument1 = element,
Argument2 = context,
Handler = new Sequence()
{
Variables =
{
result
},
Activities =
{
new ForEach <Activity>()
{
Values = new GetParentChain
{
ValidationContext = context
},
Body = new ActivityAction <Activity>()
{
Argument = parent,
Handler = new If()
{
Condition = new InArgument <bool>(ctx => condition(parent.Get(ctx))),
Then = new Assign <bool>
{
Value = true,
To = result
}
}
}
},
new AssertValidation()
{
Assertion = new InArgument <bool>(result),
Message = new InArgument <string> (validationMessage),
}
}
}
}
});
}
public void BasicParallelForEachTest()
{
TestSequence outerSequence = new TestSequence("sequence1");
TestSequence innerSequence = new TestSequence("innerSeq");
DelegateInArgument <string> i = new DelegateInArgument <string>()
{
Name = "i"
};
string[] strArray = new string[] { "var1", "var2", "var3" };
TestParallelForEach <string> foreachAct = new TestParallelForEach <string>("foreach")
{
HintValues = new string[] { "var1", "var2", "var3" },
ValuesExpression = (context => new string[] { "var1", "var2", "var3" }),
CurrentVariable = i,
HintIterationCount = 3
};
TestWriteLine writeLine = new TestWriteLine("write hello")
{
MessageExpression = ((env) => string.Format("WriteLine Argument: {0}", i.Get(env)))
};
for (int counter = strArray.Length - 1; counter > -1; counter--)
{
writeLine.HintMessageList.Add("WriteLine Argument: " + strArray[counter]);
}
foreachAct.Body = innerSequence;
innerSequence.Activities.Add(writeLine);
outerSequence.Activities.Add(foreachAct);
ExpectedTrace tr = outerSequence.GetExpectedTrace();
TestRuntime.RunAndValidateWorkflow(outerSequence, tr);
}
public static Constraint GetConstraint()
{
List <Type> allowedTypes = new List <Type>
{
typeof(Sequence),
typeof(WriteLine),
typeof(Assign)
};
List <String> allowedNamespaces = new List <String>
{
"Microsoft.VisualBasic.Activities",
"System.Activities.Expressions"
};
Variable <Boolean> result =
new Variable <Boolean>("result", true);
DelegateInArgument <MySequenceWithConstraint> element =
new DelegateInArgument <MySequenceWithConstraint>();
DelegateInArgument <ValidationContext> vc =
new DelegateInArgument <ValidationContext>();
DelegateInArgument <Activity> child =
new DelegateInArgument <Activity>();
return(new Constraint <MySequenceWithConstraint>
{
Body = new ActivityAction
<MySequenceWithConstraint, ValidationContext>
{
Argument1 = element,
Argument2 = vc,
Handler = new Sequence
{
Variables = { result },
Activities =
{
new ForEach <Activity>
{
Values = new GetChildSubtree
{
ValidationContext = vc
},
Body = new ActivityAction <Activity>
{
Argument = child,
Handler = new If()
{
Condition = new InArgument <Boolean>(ac =>
allowedTypes.Contains(
child.Get(ac).GetType()) ||
allowedNamespaces.Contains(
child.Get(ac).GetType().Namespace)),
Else = new Assign <Boolean>
{
To = result,
Value = false
}
}
}
},
new AssertValidation
{
Assertion = new InArgument <Boolean>(result),
Message = new InArgument <String>(
"Only Sequence, WriteLine, Assign allowed"),
PropertyName = new InArgument <String>(
(env) => element.Get(env).DisplayName)
}
}
}
}
});
}
public void ThrowWithInnerException()
{
// Initializing variable which we will use to catch the exception object
DelegateInArgument <MemberAccessException> accExc = new DelegateInArgument <MemberAccessException>();
//TestParameters.DisableXamlRoundTrip = true;
TestSequence seq = new TestSequence("Outer Seq")
{
Activities =
{
new TestTryCatch("Try catch finally")
{
Try = new TestSequence("Try Activity")
{
Activities =
{
new TestThrow <MemberAccessException>("Throw Operation exception")
{
ExceptionExpression = (context => new MemberAccessException("Throw Exception", new IndexOutOfRangeException())),
//InnerException = new IndexOutOfRangeException(),
ExpectedOutcome = Outcome.CaughtException(),
}
}
},
Catches =
{
new TestCatch <MemberAccessException>()
{
ExceptionVariable = accExc,
Body = new TestSequence("Body of Catch")
{
Activities =
{
// Rethrowing inner exception so we can verify correct exception is thrown
new TestThrow <IndexOutOfRangeException>("Throw inner exception")
{
ExceptionExpression = (env) => (IndexOutOfRangeException)accExc.Get(env).InnerException,
ExpectedOutcome = Outcome.UncaughtException(typeof(IndexOutOfRangeException))
}
}
},
}
}
}
}
};
TestRuntime.RunAndValidateAbortedException(seq, typeof(IndexOutOfRangeException), new Dictionary <string, string>());
}
public void CancelChildOfParallelForEach()
{
DelegateInArgument <string> _currentVariable = new DelegateInArgument <string>()
{
Name = "_currentVariable"
};
TestParallelForEach <string> parallelForEach = new TestParallelForEach <string>("Parallel For Each Activity")
{
HintValues = new List <string>()
{
"Hi", "There"
},
ValuesExpression = (context => new List <string>()
{
"Hi", "There"
}),
CurrentVariable = _currentVariable,
Body = new TestSequence("Body of parallel for each")
{
Activities =
{
new TestWriteLine("Writeline in parallel for each")
{
MessageExpression = (env) => (string)_currentVariable.Get(env),
HintMessageList = { "There", "Hi" }
},
new TestIf("Test If", HintThenOrElse.Else, HintThenOrElse.Then)
{
ConditionExpression = (env) => (bool)(_currentVariable.Get(env).Equals("Hi")),
ThenActivity = new TestBlockingActivityUnique("BlockingActivity", "Bookmark")
{
ExpectedOutcome = Outcome.Canceled
},
ElseActivity = new TestWriteLine("Writeline in Else")
{
MessageExpression = (env) => (string)_currentVariable.Get(env),
HintMessage = "There"
}
},
new TestWriteLine()
{
Message = "Hello"
}
}
},
HintIterationCount = 2
};
using (TestWorkflowRuntime testWorkflowRuntime = TestRuntime.CreateTestWorkflowRuntime(parallelForEach))
{
testWorkflowRuntime.ExecuteWorkflow();
testWorkflowRuntime.WaitForActivityStatusChange("BlockingActivity", TestActivityInstanceState.Executing);
testWorkflowRuntime.CancelWorkflow();
testWorkflowRuntime.WaitForCanceled();
}
}
public static Constraint VerifyParentIsObjectContextScope(Activity activity)
{
DelegateInArgument <Activity> element = new DelegateInArgument <Activity>();
DelegateInArgument <ValidationContext> context = new DelegateInArgument <ValidationContext>();
DelegateInArgument <Activity> child = new DelegateInArgument <Activity>();
Variable <bool> result = new Variable <bool>();
return(new Constraint <Activity>
{
Body = new ActivityAction <Activity, ValidationContext>
{
Argument1 = element,
Argument2 = context,
Handler = new Sequence
{
Variables = { result },
Activities =
{
new ForEach <Activity>
{
Values = new GetParentChain
{
ValidationContext = context
},
Body = new ActivityAction <Activity>
{
Argument = child,
Handler = new If
{
Condition = new InArgument <bool>((env) => object.Equals(child.Get(env).GetType(), typeof(ObjectContextScope))),
Then = new Assign <bool>
{
Value = true,
To = result
}
}
}
},
new AssertValidation
{
Assertion = new InArgument <bool>(env => result.Get(env)),
Message = new InArgument <string> (string.Format("{0} can only be added inside an ObjectContextScope activity.", activity.GetType().Name)),
PropertyName = new InArgument <string>((env) => element.Get(env).DisplayName)
}
}
}
}
});
}
public void PersistParallelForEach()
{
DelegateInArgument <string> _currentVariable = new DelegateInArgument <string>()
{
Name = "_currentVariable"
};
TestParallelForEach <string> parallelForEach = new TestParallelForEach <string>("Parallel for each")
{
HintValues = new string[] { "Hi", "There" },
ValuesExpression = (context => new string[] { "Hi", "There" }),
CurrentVariable = _currentVariable,
Body = new TestSequence("Sequence")
{
Activities =
{
new TestWriteLine("Writeline")
{
Message = "Hi"
},
new TestSequence("inner seq")
{
Activities =
{
new TestIf(HintThenOrElse.Else, HintThenOrElse.Then)
{
DisplayName = "Test if",
ConditionExpression = (env) => (bool)(_currentVariable.Get(env).Equals("Hi")),
ThenActivity = new TestBlockingActivity("Block Hi"),
ElseActivity = new TestBlockingActivity("Block There")
}
}
},
new TestWriteLine("Writeline act")
{
Message = "After blocking activty"
},
}
}
};
JsonFileInstanceStore.FileInstanceStore jsonStore = new JsonFileInstanceStore.FileInstanceStore(".\\~");
using (TestWorkflowRuntime testWorkflowRuntime = TestRuntime.CreateTestWorkflowRuntime(parallelForEach, null, jsonStore, PersistableIdleAction.None))
{
testWorkflowRuntime.ExecuteWorkflow();
testWorkflowRuntime.WaitForActivityStatusChange("Block Hi", TestActivityInstanceState.Executing);
testWorkflowRuntime.PersistWorkflow();
System.Threading.Thread.Sleep(2000);
testWorkflowRuntime.ResumeBookMark("Block Hi", null);
testWorkflowRuntime.WaitForActivityStatusChange("Block There", TestActivityInstanceState.Executing);
testWorkflowRuntime.PersistWorkflow();
System.Threading.Thread.Sleep(2000);
testWorkflowRuntime.ResumeBookMark("Block There", null);
testWorkflowRuntime.WaitForCompletion();
}
}
private static Constraint ConfirmWithNoTarget()
{
DelegateInArgument <Confirm> element = new DelegateInArgument <Confirm> {
Name = "element"
};
DelegateInArgument <ValidationContext> validationContext = new DelegateInArgument <ValidationContext> {
Name = "validationContext"
};
Variable <bool> assertFlag = new Variable <bool> {
Name = "assertFlag"
};
Variable <IEnumerable <Activity> > elements = new Variable <IEnumerable <Activity> >()
{
Name = "elements"
};
Variable <int> index = new Variable <int>()
{
Name = "index"
};
return(new Constraint <Confirm>
{
Body = new ActivityAction <Confirm, ValidationContext>
{
Argument1 = element,
Argument2 = validationContext,
Handler = new Sequence
{
Variables =
{
assertFlag,
elements,
index
},
Activities =
{
new If
{
Condition = new InArgument <bool>((env) => element.Get(env).Target != null),
Then = new Assign <bool>
{
To = assertFlag,
Value = true
},
Else = new Sequence
{
Activities =
{
new Assign <IEnumerable <Activity> >
{
To = elements,
Value = new GetParentChain
{
ValidationContext = validationContext,
},
},
new While(env => (assertFlag.Get(env) != true) &&
index.Get(env) < elements.Get(env).Count())
{
Body = new Sequence
{
Activities =
{
new If(env => (elements.Get(env).ElementAt(index.Get(env))).GetType() == typeof(CompensationParticipant))
{
Then = new Assign <bool>
{
To = assertFlag,
Value = true
},
},
new Assign <int>
{
To = index,
Value = new InArgument <int>(env => index.Get(env) + 1)
},
}
}
}
}
}
},
new AssertValidation
{
Assertion = new InArgument <bool>(assertFlag),
Message = new InArgument <string>(SR.ConfirmWithNoTargetConstraint)
}
}
}
}
});
}
static Constraint CompensateWithNoTarget()
{
DelegateInArgument<Compensate> element = new DelegateInArgument<Compensate> { Name = "element" };
DelegateInArgument<ValidationContext> validationContext = new DelegateInArgument<ValidationContext> { Name = "validationContext" };
Variable<bool> assertFlag = new Variable<bool> { Name = "assertFlag" };
Variable<IEnumerable<Activity>> elements = new Variable<IEnumerable<Activity>>() { Name = "elements" };
Variable<int> index = new Variable<int>() { Name = "index" };
return new Constraint<Compensate>
{
Body = new ActivityAction<Compensate, ValidationContext>
{
Argument1 = element,
Argument2 = validationContext,
Handler = new Sequence
{
Variables =
{
assertFlag,
elements,
index
},
Activities =
{
new If
{
Condition = new InArgument<bool>((env) => element.Get(env).Target != null),
Then = new Assign<bool>
{
To = assertFlag,
Value = true
},
Else = new Sequence
{
Activities =
{
new Assign<IEnumerable<Activity>>
{
To = elements,
Value = new GetParentChain
{
ValidationContext = validationContext,
},
},
new While(env => (assertFlag.Get(env) != true) && index.Get(env) < elements.Get(env).Count())
{
Body = new Sequence
{
Activities =
{
new If(env => (elements.Get(env).ElementAt(index.Get(env))).GetType() == typeof(CompensationParticipant))
{
Then = new Assign<bool>
{
To = assertFlag,
Value = true
},
},
new Assign<int>
{
To = index,
Value = new InArgument<int>(env => index.Get(env) + 1)
},
}
}
}
}
}
},
new AssertValidation
{
Assertion = new InArgument<bool>(assertFlag),
Message = new InArgument<string>(SR.CompensateWithNoTargetConstraint)
}
}
}
}
};
}
public static Constraint CheckParent <ParentType>()
{
DelegateInArgument <Activity> element = new DelegateInArgument <Activity>();
DelegateInArgument <ValidationContext> context = new DelegateInArgument <ValidationContext>();
Variable <bool> result = new Variable <bool>();
DelegateInArgument <Activity> parent = new DelegateInArgument <Activity>();
return(new Constraint <Activity>
{
Body = new ActivityAction <Activity, ValidationContext>
{
Argument1 = element,
Argument2 = context,
Handler = new Sequence
{
Variables =
{
result
},
Activities =
{
new ForEach <Activity>
{
Values = new GetParentChain
{
ValidationContext = context
},
Body = new ActivityAction <Activity>
{
Argument = parent,
Handler = new If()
{
Condition = new InArgument <bool>((env) => object.Equals(parent.Get(env).GetType(), typeof(ParentType))),
Then = new Assign <bool>
{
Value = true,
To = result
}
}
}
},
new AssertValidation
{
Assertion = new InArgument <bool>(result),
Message = new InArgument <string> (string.Format("This activity has to be inside a {0} activity", typeof(ParentType).Name.ToString())),
}
}
}
}
});
}
