public static InArgument <T> GetInArgumentFromExpectedNode <T>(TestExpression te)
{
InArgument <T> retInArg = null;
// leaf node:
if (te.GetType() == typeof(TestExpression))
{
if (te.ExpectedNode is Activity <T> )
{
retInArg = (Activity <T>)te.ExpectedNode;
}
else if (te.ExpectedNode is Variable <T> )
{
retInArg = (Variable <T>)te.ExpectedNode;
}
else
{
//Log.TraceInternal("Expect a generic type with type parameter: {0}", typeof(T).ToString());
//Log.TraceInternal("Expected node type is: {0}", te.ExpectedNode.GetType().ToString());
throw new NotSupportedException("Not supported expected node type");
}
}
// non-leaf node:
else if (te is TestBinaryExpression || te is TestUnaryExpression)
{
retInArg = (Activity <T>)te.CreateExpectedActivity();
}
return(retInArg);
}
// variablesActual is set when variable comparison makes the difference. Example: memberExpression.NoneGenericVariableGet
public static void ValidateExecutionResult(TestExpression te, List <Variable> variablesExpected, List <Variable> variablesActual, params Type[] refTypes)
{
//MethodInfo createExpectedWorkflowMethodInfo = te.GetType().GetMethod("CreateExpectedWorkflow", BindingFlags.Public | BindingFlags.Instance);
//Sequence expectedSequence = (Sequence)createExpectedWorkflowMethodInfo.MakeGenericMethod(te.ResultType).Invoke(te, BindingFlags.Instance | BindingFlags.InvokeMethod, null, null, null);
//if (variablesExpected != null)
//{
// foreach (Variable v in variablesExpected)
// {
// expectedSequence.Variables.Add(v);
// }
//}
//string xaml = PartialTrustXamlServices.Save(expectedSequence);
////Log.TraceInternal("Expected workflow:\n{0}", xaml);
//Activity clonedWorkflowElement = (Activity)PartialTrustXamlServices.Load(new StringReader(xaml));
//var namespaces = from t in refTypes
// select t.Namespace;
//var assemblies = from t in refTypes
// select new AssemblyReference() { Assembly = t.Assembly };
//// TextExpression.SetNamespaces(clonedWorkflowElement, namespaces.ToArray());
//// TextExpression.SetReferences(clonedWorkflowElement, assemblies.ToArray());
//Exception expectedException = null;
//string expectedResult = ExecuteWorkflowAndGetResult(clonedWorkflowElement, out expectedException);
////Log.TraceInternal("Expected result: {0}\n", expectedResult);
//MethodInfo createActualWorkflowMethodInfo = te.GetType().GetMethod("CreateActualWorkflow", BindingFlags.Public | BindingFlags.Instance);
//Sequence actualSequence = (Sequence)createActualWorkflowMethodInfo.MakeGenericMethod(te.ResultType).Invoke(te, BindingFlags.Instance | BindingFlags.InvokeMethod, null, null, null);
//// TextExpression.SetNamespaces(actualSequence, namespaces.ToArray());
//// TextExpression.SetReferences(actualSequence, assemblies.ToArray());
//List<Variable> varList = variablesActual ?? variablesExpected;
//if (varList != null)
//{
// foreach (Variable v in varList)
// {
// actualSequence.Variables.Add(v);
// }
//}
//// xaml = PartialTrustXamlServices.Save(actualSequence);
////Log.TraceInternal("Actual workflow:\n{0}", xaml);
//// clonedWorkflowElement = (Sequence)XamlServices.Load(new StringReader(xaml));
//Exception actualException = null;
//string actualResult = ExecuteWorkflowAndGetResult(actualSequence, out actualException);
////Log.TraceInternal("Actual result: {0}\n", actualResult);
//ExpressionTestRuntime.ValidateException(expectedException, actualException);
//if (expectedResult != actualResult)
//{
// throw new Exception("Inconsistent execution result!");
//}
}
public static void ValidateReferenceExpressionXaml <T>(TestExpression te)
{
Expression <Func <ActivityContext, T> > lambdaExpression = (Expression <Func <ActivityContext, T> >)te.CreateLambdaExpresson <T>();
//Log.TraceInternal("Expression: {0}", lambdaExpression.ToString());
Activity expectedActivity = te.CreateExpectedActivity() as Activity;
Activity actualActivity = ExpressionServices.ConvertReference(lambdaExpression);
ValidateActivity(expectedActivity, actualActivity);
}
private static Activity <TResult> HandleUnaryExpression <TOperand, TResult>(UnaryOperator op, TestExpression operand)
{
Activity <TResult> we = null;
switch (op)
{
case UnaryOperator.Cast:
we = new Cast <TOperand, TResult>()
{
Checked = false,
Operand = TestExpression.GetInArgumentFromExpectedNode <TOperand>(operand),
};
break;
case UnaryOperator.CheckedCast:
we = new Cast <TOperand, TResult>()
{
Checked = true,
Operand = TestExpression.GetInArgumentFromExpectedNode <TOperand>(operand),
};
break;
case UnaryOperator.Not:
we = new Not <TOperand, TResult>()
{
Operand = TestExpression.GetInArgumentFromExpectedNode <TOperand>(operand),
};
break;
case UnaryOperator.TypeAs:
we = new As <TOperand, TResult>()
{
Operand = TestExpression.GetInArgumentFromExpectedNode <TOperand>(operand),
};
break;
default:
throw new NotSupportedException(string.Format("Operator: {0} is unsupported", op.ToString()));
}
return(we);
}
private static readonly string s_path = string.Empty; //DirectoryAssistance.GetTestBinsDirectory("TempFile.txt");
public static void ValidateExpressionXaml <T>(TestExpression te)
{
Activity expectedActivity = null, actualActivity = null;
Expression <Func <ActivityContext, T> > lambdaExpression = null;
lambdaExpression = (Expression <Func <ActivityContext, T> >)te.CreateLambdaExpresson <T>();
//Log.TraceInternal("Expression: {0}", lambdaExpression.ToString());
expectedActivity = te.CreateExpectedActivity() as Activity;
if (te.ExpectedConversionException != null)
{
ExceptionHelpers.CheckForException(
te.ExpectedConversionException.GetType(), te.ExpectedConversionException.Message,
() => { actualActivity = ExpressionServices.Convert(lambdaExpression); }, true);
}
else
{
actualActivity = ExpressionServices.Convert(lambdaExpression);
ValidateActivity(expectedActivity, actualActivity);
}
}
static protected Activity <T> GetWorkflowElementFromExpectedNode <T>(TestExpression te)
{
Activity <T> we = null;
if (te.ExpectedConversionException != null)
{
return(null);
}
// leaf node:
if (te.GetType() == typeof(TestExpression))
{
if (te.ExpectedNode is Activity <T> )
{
we = (Activity <T>)te.ExpectedNode;
}
else if (te.ExpectedNode is Variable <T> )
{
we = new VariableValue <T>()
{
Variable = (Variable <T>)te.ExpectedNode
};
}
else
{
throw new NotSupportedException("Not supported expected node type");
}
}
// non-leaf node:
else if (te is TestBinaryExpression || te is TestUnaryExpression)
{
we = (Activity <T>)te.CreateExpectedActivity();
}
return(we);
}
public static void ValidateExecutionResult(TestExpression te, List <Variable> variables, params Type[] refTypes)
{
ValidateExecutionResult(te, variables, null, refTypes);
}
private static Activity HandleBinaryExpression <TLeft, TRight, TResult>(BinaryOperator op, TestExpression left, TestExpression right)
{
Activity we = null;
InArgument <TLeft> leftArgument = (InArgument <TLeft>)TestExpression.GetInArgumentFromExpectedNode <TLeft>(left);
leftArgument.EvaluationOrder = 0;
InArgument <TRight> rightArgument = (InArgument <TRight>)TestExpression.GetInArgumentFromExpectedNode <TRight>(right);
rightArgument.EvaluationOrder = 1;
switch (op)
{
case BinaryOperator.Add:
we = new Add <TLeft, TRight, TResult>()
{
Checked = false,
Left = leftArgument,
Right = rightArgument
};
break;
case BinaryOperator.And:
we = new And <TLeft, TRight, TResult>()
{
Left = leftArgument,
Right = rightArgument
};
break;
case BinaryOperator.AndAlso:
we = new AndAlso()
{
Left = TestExpression.GetWorkflowElementFromExpectedNode <bool>(left),
Right = TestExpression.GetWorkflowElementFromExpectedNode <bool>(right)
};
break;
case BinaryOperator.CheckedAdd:
we = new Add <TLeft, TRight, TResult>()
{
Checked = true,
Left = leftArgument,
Right = rightArgument
};
break;
case BinaryOperator.CheckedMultiply:
we = new Multiply <TLeft, TRight, TResult>()
{
Checked = true,
Left = leftArgument,
Right = rightArgument
};
break;
case BinaryOperator.CheckedSubtract:
we = new Subtract <TLeft, TRight, TResult>()
{
Checked = true,
Left = leftArgument,
Right = rightArgument
};
break;
case BinaryOperator.Divide:
we = new Divide <TLeft, TRight, TResult>()
{
Left = leftArgument,
Right = rightArgument
};
break;
case BinaryOperator.Equal:
we = new Equal <TLeft, TRight, TResult>()
{
Left = leftArgument,
Right = rightArgument
};
break;
case BinaryOperator.GreaterThan:
we = new GreaterThan <TLeft, TRight, TResult>()
{
Left = leftArgument,
Right = rightArgument
};
break;
case BinaryOperator.GreaterThanOrEqual:
we = new GreaterThanOrEqual <TLeft, TRight, TResult>()
{
Left = leftArgument,
Right = rightArgument
};
break;
case BinaryOperator.LessThan:
we = new LessThan <TLeft, TRight, TResult>()
{
Left = leftArgument,
Right = rightArgument
};
break;
case BinaryOperator.LessThanOrEqual:
we = new LessThanOrEqual <TLeft, TRight, TResult>()
{
Left = leftArgument,
Right = rightArgument
};
break;
case BinaryOperator.Or:
we = new Or <TLeft, TRight, TResult>()
{
Left = leftArgument,
Right = rightArgument
};
break;
case BinaryOperator.Multiply:
we = new Multiply <TLeft, TRight, TResult>()
{
Checked = false,
Left = leftArgument,
Right = rightArgument
};
break;
case BinaryOperator.NotEqual:
we = new NotEqual <TLeft, TRight, TResult>()
{
Left = leftArgument,
Right = rightArgument
};
break;
case BinaryOperator.OrElse:
we = new OrElse()
{
Left = TestExpression.GetWorkflowElementFromExpectedNode <bool>(left),
Right = TestExpression.GetWorkflowElementFromExpectedNode <bool>(right)
};
break;
case BinaryOperator.Subtract:
we = new Subtract <TLeft, TRight, TResult>()
{
Checked = false,
Left = leftArgument,
Right = rightArgument
};
break;
default:
throw new NotSupportedException(string.Format("Operator: {0} is unsupported", op.ToString()));
}
return(we);
}
