public void TestValidate()
{
// Must have exactly 2 subnodes
try
{
_bitWiseNode.Validate(ExprValidationContextFactory.MakeEmpty());
Assert.Fail();
}
catch (ExprValidationException)
{
// Expected
Log.Debug("No nodes in the expression");
}
// Must have only number or boolean-type subnodes
_bitWiseNode.AddChildNode(new SupportExprNode(typeof(string)));
_bitWiseNode.AddChildNode(new SupportExprNode(typeof(int)));
try
{
_bitWiseNode.Validate(ExprValidationContextFactory.MakeEmpty());
Assert.Fail();
}
catch (ExprValidationException)
{
// Expected
}
}
public void TestValidate()
{
ExprCoalesceNode coalesceNode = new ExprCoalesceNode();
coalesceNode.AddChildNode(new SupportExprNode(1));
// Test too few nodes under this node
try
{
coalesceNode.Validate(ExprValidationContextFactory.MakeEmpty());
Assert.Fail();
}
catch (ExprValidationException ex)
{
// Expected
}
// Test node result type not fitting
coalesceNode.AddChildNode(new SupportExprNode("s"));
try
{
coalesceNode.Validate(ExprValidationContextFactory.MakeEmpty());
Assert.Fail();
}
catch (ExprValidationException ex)
{
// Expected
}
}
private void runAssertionThreading(ConfigurationEngineDefaults.ThreadingProfile threadingProfile)
{
_concatNode = new ExprConcatNode();
var textA = "This is the first text";
var textB = "Second text";
var textC = "Third text, some more";
foreach (var text in new[] { textA, textB, textC })
{
_concatNode.AddChildNode(new ExprConstantNodeImpl(text));
}
_concatNode.Validate(ExprValidationContextFactory.MakeEmpty(threadingProfile));
var numThreads = 4;
var numLoop = 10000;
var threads = new List <SupportConcatThread>(numThreads);
for (var i = 0; i < numThreads; i++)
{
var thread = new SupportConcatThread(_concatNode, numLoop, textA + textB + textC);
threads.Add(thread);
thread.Start();
}
foreach (var thread in threads)
{
thread.Join();
Assert.IsFalse(thread.IsFail);
}
}
public void TestGetValidatedSubtree()
{
SupportExprNode.SetValidateCount(0);
// Confirms all child nodes validated
// Confirms depth-first validation
SupportExprNode topNode = new SupportExprNode(typeof(Boolean));
SupportExprNode parent_1 = new SupportExprNode(typeof(Boolean));
SupportExprNode parent_2 = new SupportExprNode(typeof(Boolean));
topNode.AddChildNode(parent_1);
topNode.AddChildNode(parent_2);
SupportExprNode supportNode1_1 = new SupportExprNode(typeof(Boolean));
SupportExprNode supportNode1_2 = new SupportExprNode(typeof(Boolean));
SupportExprNode supportNode2_1 = new SupportExprNode(typeof(Boolean));
SupportExprNode supportNode2_2 = new SupportExprNode(typeof(Boolean));
parent_1.AddChildNode(supportNode1_1);
parent_1.AddChildNode(supportNode1_2);
parent_2.AddChildNode(supportNode2_1);
parent_2.AddChildNode(supportNode2_2);
ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.SELECT, topNode, ExprValidationContextFactory.MakeEmpty());
Assert.AreEqual(1, supportNode1_1.ValidateCountSnapshot);
Assert.AreEqual(2, supportNode1_2.ValidateCountSnapshot);
Assert.AreEqual(3, parent_1.ValidateCountSnapshot);
Assert.AreEqual(4, supportNode2_1.ValidateCountSnapshot);
Assert.AreEqual(5, supportNode2_2.ValidateCountSnapshot);
Assert.AreEqual(6, parent_2.ValidateCountSnapshot);
Assert.AreEqual(7, topNode.ValidateCountSnapshot);
}
public void TestValidate()
{
_identNodes[0].Validate(ExprValidationContextFactory.Make(_streamTypeService));
Assert.AreEqual(2, _identNodes[0].StreamId);
Assert.AreEqual(typeof(string), _identNodes[0].ExprEvaluator.ReturnType);
Assert.AreEqual("Mapped('a')", _identNodes[0].ResolvedPropertyName);
_identNodes[1].Validate(ExprValidationContextFactory.Make(_streamTypeService));
Assert.AreEqual(2, _identNodes[1].StreamId);
Assert.AreEqual(typeof(string), _identNodes[1].ExprEvaluator.ReturnType);
Assert.AreEqual("Nested.NestedValue", _identNodes[1].ResolvedPropertyName);
_identNodes[2].Validate(ExprValidationContextFactory.Make(_streamTypeService));
Assert.AreEqual(2, _identNodes[2].StreamId);
Assert.AreEqual(typeof(int?), _identNodes[2].ExprEvaluator.ReturnType);
Assert.AreEqual("Indexed[1]", _identNodes[2].ResolvedPropertyName);
_identNodes[3].Validate(ExprValidationContextFactory.Make(_streamTypeService));
Assert.AreEqual(0, _identNodes[3].StreamId);
Assert.AreEqual(typeof(int?), _identNodes[3].ExprEvaluator.ReturnType);
Assert.AreEqual("IntPrimitive", _identNodes[3].ResolvedPropertyName);
TryInvalidValidate(new ExprIdentNodeImpl(""));
TryInvalidValidate(new ExprIdentNodeImpl("dummy"));
TryInvalidValidate(new ExprIdentNodeImpl("Nested", "s0"));
TryInvalidValidate(new ExprIdentNodeImpl("dummy", "s2"));
TryInvalidValidate(new ExprIdentNodeImpl("IntPrimitive", "s2"));
TryInvalidValidate(new ExprIdentNodeImpl("IntPrimitive", "s3"));
}
public void TestValidate()
{
// Must have 2 or more subnodes
try
{
_minMaxNode.Validate(ExprValidationContextFactory.MakeEmpty());
Assert.Fail();
}
catch (ExprValidationException ex)
{
// Expected
}
// Must have only number-type subnodes
_minMaxNode.AddChildNode(new SupportExprNode(typeof(String)));
_minMaxNode.AddChildNode(new SupportExprNode(typeof(int)));
try
{
_minMaxNode.Validate(ExprValidationContextFactory.MakeEmpty());
Assert.Fail();
}
catch (ExprValidationException ex)
{
// Expected
}
}
public void SetUp()
{
_arrayNodes = new ExprArrayNode[4];
_arrayNodes[0] = new ExprArrayNode();
// no coercion array
_arrayNodes[1] = new ExprArrayNode();
_arrayNodes[1].AddChildNode(new SupportExprNode(2));
_arrayNodes[1].AddChildNode(new SupportExprNode(3));
// coercion
_arrayNodes[2] = new ExprArrayNode();
_arrayNodes[2].AddChildNode(new SupportExprNode(1.5D));
_arrayNodes[2].AddChildNode(new SupportExprNode(1));
// mixed types
_arrayNodes[3] = new ExprArrayNode();
_arrayNodes[3].AddChildNode(new SupportExprNode("a"));
_arrayNodes[3].AddChildNode(new SupportExprNode(1));
for (int i = 0; i < _arrayNodes.Length; i++)
{
_arrayNodes[i].Validate(ExprValidationContextFactory.MakeEmpty());
}
}
public void TestValidate()
{
// Must have exactly 1 subnodes
try
{
_minNode.Validate(ExprValidationContextFactory.MakeEmpty());
Assert.Fail();
}
catch (ExprValidationException ex)
{
// Expected
}
// Must have only number-type subnodes
_minNode = new ExprMinMaxAggrNode(false, MinMaxTypeEnum.MIN, true, false);
_minNode.AddChildNode(new SupportExprNode(typeof(string)));
_minNode.AddChildNode(new SupportExprNode(typeof(int)));
try
{
_minNode.Validate(ExprValidationContextFactory.Make(new SupportStreamTypeSvc3Stream()));
Assert.Fail();
}
catch (ExprValidationException ex)
{
// Expected
}
}
public void TestValidate()
{
// test success
_orNode.AddChildNode(new SupportExprNode(typeof(Boolean)));
_orNode.AddChildNode(new SupportExprNode(typeof(Boolean)));
_orNode.Validate(ExprValidationContextFactory.MakeEmpty());
// test failure, type mismatch
_orNode.AddChildNode(new SupportExprNode(typeof(string)));
try
{
_orNode.Validate(ExprValidationContextFactory.MakeEmpty());
Assert.Fail();
}
catch (ExprValidationException ex)
{
// Expected
}
// test failed - with just one child
_orNode = new ExprOrNode();
_orNode.AddChildNode(new SupportExprNode(typeof(Boolean)));
try
{
_orNode.Validate(ExprValidationContextFactory.MakeEmpty());
Assert.Fail();
}
catch (ExprValidationException ex)
{
// Expected
}
}
public void TestValidate()
{
// Must have exactly 2 subnodes
try
{
_arithNode.Validate(ExprValidationContextFactory.MakeEmpty());
Assert.Fail();
}
catch (ExprValidationException)
{
// Expected
}
// Must have only number-type subnodes
_arithNode.AddChildNode(new SupportExprNode(typeof(string)));
_arithNode.AddChildNode(new SupportExprNode(typeof(int)));
try
{
_arithNode.Validate(ExprValidationContextFactory.MakeEmpty());
Assert.Fail();
}
catch (ExprValidationException)
{
// Expected
}
}
public void TestValidate()
{
ExprCaseNode caseNode = SupportExprNodeFactory.MakeCaseSyntax1Node();
caseNode.Validate(ExprValidationContextFactory.MakeEmpty());
caseNode = SupportExprNodeFactory.MakeCaseSyntax2Node();
caseNode.Validate(ExprValidationContextFactory.MakeEmpty());
// No subnodes: Exception is thrown.
TryInvalidValidate(new ExprCaseNode(false));
TryInvalidValidate(new ExprCaseNode(true));
// singe child node not possible, must be 2 at least
caseNode = new ExprCaseNode(false);
caseNode.AddChildNode(new SupportExprNode(4));
TryInvalidValidate(caseNode);
// in a case 1 expression (e.g. case when a=b then 1 else 2) the when child nodes must return boolean
caseNode.AddChildNode(new SupportExprNode(2));
TryInvalidValidate(caseNode);
// in a case 2 expression (e.g. case a when b then 1 else 2) then a and b types must be comparable
caseNode = new ExprCaseNode(true);
caseNode.AddChildNode(new SupportExprNode("a"));
caseNode.AddChildNode(new SupportExprNode(1));
caseNode.AddChildNode(new SupportExprNode(2));
TryInvalidValidate(caseNode);
}
public void TestGetType()
{
_arithNode.AddChildNode(new SupportExprNode(typeof(double?)));
_arithNode.AddChildNode(new SupportExprNode(typeof(int)));
_arithNode.Validate(ExprValidationContextFactory.MakeEmpty());
Assert.AreEqual(typeof(double?), _arithNode.ReturnType);
}
public void TestEvaluateEquals()
{
var eparams = new EvaluateParams(null, false, null);
_equalsNodes[0] = MakeNode(true, false, false);
Assert.IsFalse(_equalsNodes[0].ExprEvaluator.Evaluate(eparams).AsBoolean());
_equalsNodes[0] = MakeNode(false, false, false);
Assert.IsTrue(_equalsNodes[0].ExprEvaluator.Evaluate(eparams).AsBoolean());
_equalsNodes[0] = MakeNode(true, true, false);
Assert.IsTrue(_equalsNodes[0].ExprEvaluator.Evaluate(eparams).AsBoolean());
_equalsNodes[0] = MakeNode(true, typeof(bool), null, typeof(bool), false);
Assert.IsNull(_equalsNodes[0].ExprEvaluator.Evaluate(eparams));
_equalsNodes[0] = MakeNode(null, typeof(String), "ss", typeof(String), false);
Assert.IsNull(_equalsNodes[0].ExprEvaluator.Evaluate(eparams));
_equalsNodes[0] = MakeNode(null, typeof(String), null, typeof(String), false);
Assert.IsNull(_equalsNodes[0].ExprEvaluator.Evaluate(eparams));
// try a long and int
_equalsNodes[1].Validate(ExprValidationContextFactory.MakeEmpty());
Assert.IsTrue(_equalsNodes[1].ExprEvaluator.Evaluate(eparams).AsBoolean());
// try a double and int
_equalsNodes[2].Validate(ExprValidationContextFactory.MakeEmpty());
Assert.IsTrue(_equalsNodes[2].ExprEvaluator.Evaluate(eparams).AsBoolean());
_equalsNodes[3].Validate(ExprValidationContextFactory.MakeEmpty());
Assert.IsTrue(_equalsNodes[3].ExprEvaluator.Evaluate(eparams).AsBoolean());
}
public void TestEvaluate()
{
SupportExprNode childOne = new SupportExprNode("d");
SupportExprNode childTwo = new SupportExprNode("c");
_opNode.AddChildNode(childOne);
_opNode.AddChildNode(childTwo);
_opNode.Validate(ExprValidationContextFactory.MakeEmpty()); // Type initialization
var eparams = new EvaluateParams(null, false, null);
Assert.AreEqual(true, _opNode.Evaluate(eparams));
childOne.Value = "c";
Assert.AreEqual(true, _opNode.Evaluate(eparams));
childOne.Value = "b";
Assert.AreEqual(false, _opNode.Evaluate(eparams));
_opNode = MakeNode(null, typeof(int), 2, typeof(int));
Assert.AreEqual(null, _opNode.Evaluate(eparams));
_opNode = MakeNode(1, typeof(int), null, typeof(int));
Assert.AreEqual(null, _opNode.Evaluate(eparams));
_opNode = MakeNode(null, typeof(int), null, typeof(int));
Assert.AreEqual(null, _opNode.Evaluate(eparams));
}
public void TestValidate()
{
ExprPropertyExistsNode castNode = new ExprPropertyExistsNode();
// Test too few nodes under this node
try
{
castNode.Validate(ExprValidationContextFactory.MakeEmpty());
Assert.Fail();
}
catch (ExprValidationException ex)
{
// Expected
}
castNode.AddChildNode(new SupportExprNode(1));
try
{
castNode.Validate(ExprValidationContextFactory.MakeEmpty());
Assert.Fail();
}
catch (ExprValidationException ex)
{
// Expected
}
}
public void TestGetType()
{
for (int i = 0; i < _isNodes.Length; i++)
{
_isNodes[i].Validate(ExprValidationContextFactory.MakeEmpty());
Assert.AreEqual(typeof(bool?), _isNodes[i].ReturnType);
}
}
public void TestEqualsNode()
{
_identNodes[0].Validate(ExprValidationContextFactory.Make(_streamTypeService));
_identNodes[2].Validate(ExprValidationContextFactory.Make(_streamTypeService));
_identNodes[3].Validate(ExprValidationContextFactory.Make(_streamTypeService));
Assert.IsTrue(_identNodes[3].EqualsNode(_identNodes[3]));
Assert.IsFalse(_identNodes[0].EqualsNode(_identNodes[2]));
}
public void TestEvaluate()
{
Log.Debug(".testEvaluate");
_bitWiseNode.AddChildNode(new SupportExprNode(10));
_bitWiseNode.AddChildNode(new SupportExprNode(12));
ExprNodeUtility.GetValidatedSubtree(ExprNodeOrigin.SELECT, _bitWiseNode, ExprValidationContextFactory.MakeEmpty());
Assert.AreEqual(8, _bitWiseNode.Evaluate(new EvaluateParams(null, false, null)));
}
public void TestEvaluate()
{
EventBean[] events = new EventBean[] { MakeEvent(10) };
_identNodes[3].Validate(ExprValidationContextFactory.Make(_streamTypeService));
Assert.AreEqual(10, _identNodes[3].ExprEvaluator.Evaluate(new EvaluateParams(events, false, null)));
Assert.IsNull(_identNodes[3].ExprEvaluator.Evaluate(new EvaluateParams(new EventBean[2], false, null)));
}
public void TestEvaluate()
{
EventBean theEvent = MakeEvent(10);
EventBean[] events = new EventBean[] { theEvent };
_node.Validate(ExprValidationContextFactory.Make(_streamTypeService));
Assert.AreEqual(theEvent.Underlying, _node.Evaluate(new EvaluateParams(events, false, null)));
}
public void TestValidate()
{
_node.Validate(ExprValidationContextFactory.Make(_streamTypeService));
Assert.AreEqual(0, _node.StreamId);
Assert.AreEqual(typeof(SupportBean), _node.ReturnType);
TryInvalidValidate(new ExprStreamUnderlyingNodeImpl("", false));
TryInvalidValidate(new ExprStreamUnderlyingNodeImpl("dummy", false));
}
public void TestGetType()
{
for (int i = 0; i < _castNodes.Length; i++)
{
_castNodes[i].Validate(ExprValidationContextFactory.MakeEmpty());
}
Assert.AreEqual(typeof(long?), _castNodes[0].TargetType);
Assert.AreEqual(typeof(int?), _castNodes[1].TargetType);
}
public void TestEvaluate()
{
for (int i = 0; i < _castNodes.Length; i++)
{
_castNodes[i].Validate(ExprValidationContextFactory.MakeEmpty());
}
Assert.AreEqual(10L, _castNodes[0].ExprEvaluator.Evaluate(new EvaluateParams(null, false, null)));
Assert.AreEqual(16, _castNodes[1].ExprEvaluator.Evaluate(new EvaluateParams(null, false, null)));
}
private static void SetupNode(ExprMinMaxRowNode nodeMin, int intValue, double doubleValue, float?floatValue)
{
nodeMin.AddChildNode(new SupportExprNode(intValue));
nodeMin.AddChildNode(new SupportExprNode(doubleValue));
if (floatValue != null)
{
nodeMin.AddChildNode(new SupportExprNode(floatValue));
}
nodeMin.Validate(ExprValidationContextFactory.MakeEmpty());
}
public void TestToExpressionString()
{
for (int i = 0; i < _identNodes.Length; i++)
{
_identNodes[i].Validate(ExprValidationContextFactory.Make(_streamTypeService));
}
Assert.AreEqual("Mapped('a')", _identNodes[0].ToExpressionStringMinPrecedenceSafe());
Assert.AreEqual("Nested.NestedValue", _identNodes[1].ToExpressionStringMinPrecedenceSafe());
Assert.AreEqual("s2.Indexed[1]", _identNodes[2].ToExpressionStringMinPrecedenceSafe());
Assert.AreEqual("s0.IntPrimitive", _identNodes[3].ToExpressionStringMinPrecedenceSafe());
}
private void TryInvalidValidate(ExprLikeNode exprLikeRegexpNode)
{
try {
exprLikeRegexpNode.Validate(ExprValidationContextFactory.MakeEmpty());
Assert.Fail();
}
catch (ExprValidationException ex)
{
// expected
}
}
private void TryInvalidValidate(ExprPreviousNode exprPrevNode)
{
try {
exprPrevNode.Validate(ExprValidationContextFactory.MakeEmpty());
Assert.Fail();
}
catch (ExprValidationException)
{
// expected
}
}
private ExprMinMaxRowNode MakeNode(Object valueOne, Type typeOne,
Object valueTwo, Type typeTwo,
Object valueThree, Type typeThree)
{
var maxNode = new ExprMinMaxRowNode(MinMaxTypeEnum.MAX);
maxNode.AddChildNode(new SupportExprNode(valueOne, typeOne));
maxNode.AddChildNode(new SupportExprNode(valueTwo, typeTwo));
maxNode.AddChildNode(new SupportExprNode(valueThree, typeThree));
maxNode.Validate(ExprValidationContextFactory.MakeEmpty());
return(maxNode);
}
private void TryInvalidValidate(ExprIdentNode identNode)
{
try
{
identNode.Validate(ExprValidationContextFactory.Make(_streamTypeService));
Assert.Fail();
}
catch (ExprValidationException ex)
{
// expected
}
}
public void TestGetType()
{
for (int i = 0; i < _coalesceNodes.Length; i++)
{
_coalesceNodes[i].Validate(ExprValidationContextFactory.MakeEmpty());
}
Assert.AreEqual(typeof(long?), _coalesceNodes[0].ReturnType);
Assert.AreEqual(typeof(string), _coalesceNodes[1].ReturnType);
Assert.AreEqual(typeof(bool?), _coalesceNodes[2].ReturnType);
Assert.AreEqual(typeof(char?), _coalesceNodes[3].ReturnType);
Assert.AreEqual(typeof(double?), _coalesceNodes[4].ReturnType);
}