private IEnumerable EnumerateTest <T>(int level, int maxLevel)
{
// for non-leaf node, it could be a binary expression or one of the pre-defined node
if (level < maxLevel)
{
foreach (BinaryOperator op in _operators)
{
TestBinaryExpression binaryExpression = new TestBinaryExpression
{
ResultType = typeof(T),
Operator = op
};
foreach (TestExpression left in EnumerateTest <T>(level + 1, maxLevel))
{
left.ResultType = typeof(T);
binaryExpression.Left = left;
foreach (TestExpression right in EnumerateTest <T>(level + 1, maxLevel))
{
right.ResultType = typeof(T);
binaryExpression.Right = right;
yield return(binaryExpression);
}
}
}
}
// leaf node return const node only
if (level == maxLevel)
{
NodeExpressionPair leaf = LeafHelper.GetConstNode(typeof(T));
yield return(new TestExpression()
{
ExpectedNode = leaf.GetLeafNode(),
ExpressionTree = leaf.LeafExpression
});
}
// root can't be leaf node
else if (level != 0)
{
foreach (NodeExpressionPair leaf in _leafNode)
{
Exception expectedException = null;
object expectedNode = null;
try
{
expectedNode = leaf.GetLeafNode();
}
catch (Exception ex)
{
expectedException = ex;
}
TestExpression te = new TestExpression()
{
ExpectedConversionException = expectedException,
ExpectedNode = expectedNode,
ExpressionTree = leaf.LeafExpression
};
yield return(te);
}
}
}
// Comparison operator test
public void ComparisonOperatorTest()
{
_operators = new List <BinaryOperator>()
{
BinaryOperator.Add,
BinaryOperator.CheckedAdd,
BinaryOperator.Subtract,
BinaryOperator.CheckedSubtract,
BinaryOperator.Multiply,
BinaryOperator.CheckedMultiply,
BinaryOperator.Divide,
BinaryOperator.And,
BinaryOperator.Or
};
List <BinaryOperator> comparisonOperators = new List <BinaryOperator>()
{
BinaryOperator.Equal,
BinaryOperator.GreaterThan,
BinaryOperator.GreaterThanOrEqual,
BinaryOperator.LessThan,
BinaryOperator.LessThanOrEqual
};
_leafNode = new List <NodeExpressionPair>()
{
ExpressionLeafs.ConstIntValue,
ExpressionLeafs.StaticIntField,
ExpressionLeafs.StaticIntProperty,
ExpressionLeafs.VariableInWrapper
};
List <Variable> variables = new List <Variable>()
{
LeafHelper.GetVariable <int>()
};
int numberOfTests = 0;
foreach (BinaryOperator op in comparisonOperators)
{
TestBinaryExpression binExpr = new TestBinaryExpression()
{
Operator = op,
ResultType = typeof(Boolean),
};
foreach (TestExpression left in EnumerateTest <int>(0, 1))
{
numberOfTests++;
//Log.Info(numberOfTests.ToString());
binExpr.Left = left;
foreach (TestExpression right in EnumerateTest <int>(0, 1))
{
binExpr.Right = right;
}
ExpressionTestRuntime.ValidateExpressionXaml <bool>(binExpr);
if (binExpr.ExpectedConversionException == null)
{
ExpressionTestRuntime.ValidateExecutionResult(binExpr, variables);
}
}
}
}
