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()
{
_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 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()
{
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 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(ExprIdentNode identNode)
{
try
{
identNode.Validate(ExprValidationContextFactory.Make(_streamTypeService));
Assert.Fail();
}
catch (ExprValidationException ex)
{
// expected
}
}
public void TestEvaluatePerformance()
{
// test performance of evaluate for indexed events
// fails if the getter is not in place
EventBean[] events = SupportStreamTypeSvc3Stream.SampleEvents;
_identNodes[2].Validate(ExprValidationContextFactory.Make(_streamTypeService));
long startTime = PerformanceObserver.MilliTime;
for (int i = 0; i < 100000; i++)
{
_identNodes[2].ExprEvaluator.Evaluate(new EvaluateParams(events, false, null));
}
long endTime = PerformanceObserver.MilliTime;
long delta = endTime - startTime;
log.Info(".testEvaluate delta=" + delta);
Assert.IsTrue(delta < 500);
}
public void TestGetType()
{
// test success
_identNodes[0].Validate(ExprValidationContextFactory.Make(_streamTypeService));
Assert.AreEqual(typeof(string), _identNodes[0].ExprEvaluator.ReturnType);
}
public void TestEqualsNode()
{
_node.Validate(ExprValidationContextFactory.Make(_streamTypeService));
Assert.IsTrue(_node.EqualsNode(new ExprStreamUnderlyingNodeImpl("s0", false)));
Assert.IsFalse(_node.EqualsNode(new ExprStreamUnderlyingNodeImpl("xxx", false)));
}
