public static void AssertST0Id(
SupportListener listener,
string property,
string expectedList)
{
AssertST0Id(listener.AssertOneGetNew().Get(property), expectedList);
}
public RegressionEnvironment AddListener(
string statementName,
SupportListener listener)
{
GetAssertStatement(statementName).AddListener(listener);
return this;
}
public ReadRunnable(
RegressionEnvironment env,
SupportListener listener)
{
this.env = env;
this.listener = listener;
}
public static void AssertRectanglesManyRow(
RegressionEnvironment env,
SupportListener listener,
IList<BoundingBox> rectangles,
params string[] matches)
{
for (var i = 0; i < rectangles.Count; i++) {
var box = rectangles[i];
SendRectangle(env, "R" + box, box.MinX, box.MinY, box.MaxX - box.MinX, box.MaxY - box.MinY);
if (matches[i] == null) {
if (listener.IsInvoked) {
Assert.Fail(
"Unexpected output for box " +
i +
": " +
SortJoinProperty(listener.GetAndResetLastNewData(), "c0"));
}
}
else {
if (!listener.IsInvoked) {
Assert.Fail("No output for box " + i);
}
Assert.AreEqual(matches[i], SortJoinProperty(listener.GetAndResetLastNewData(), "c0"));
}
}
}
private static void TryOptimizableEquals(
RegressionEnvironment env,
RegressionPath path,
string epl,
int numStatements)
{
// test function returns lookup value and "Equals"
for (int i = 0; i < numStatements; i++) {
string text = "@Name('s" + i + "') " + epl.Replace("!NUM!", i.ToString());
env.CompileDeploy(text, path).AddListener("s" + i);
}
env.Milestone(0);
var loops = 1000;
var delta = PerformanceObserver.TimeMillis(
() => {
SupportStaticMethodLib.ResetCountInvoked();
for (int i = 0; i < loops; i++) {
env.SendEventBean(new SupportBean("E_" + i % numStatements, 0));
SupportListener listener = env.Listener("s" + i % numStatements);
Assert.IsTrue(listener.GetAndClearIsInvoked());
}
});
Assert.AreEqual(loops, SupportStaticMethodLib.CountInvoked);
Assert.IsTrue(delta < 1000, "Delta is " + delta);
env.UndeployAll();
}
private static void AssertList(
SupportListener listener,
params SupportBean[] events)
{
var @out = listener.AssertOneGetNewAndReset().Get("c0").UnwrapIntoArray <object>();
EPAssertionUtil.AssertEqualsExactOrder(@out, events);
}
public static void AssertValuesArrayScalar(
SupportListener listener,
string field,
params object[] expected)
{
var result = listener.AssertOneGetNew().Get(field);
AssertValuesArrayScalar(result, expected);
}
public ReadRunnable(
RegressionEnvironment env,
SupportListener listenerZero,
SupportListener listenerOne)
{
this.env = env;
this.listenerZero = listenerZero;
this.listenerOne = listenerOne;
}
private static SupportListener[] GetListeners(RegressionEnvironment env)
{
var listeners = new SupportListener[10];
for (var i = 0; i < listeners.Length; i++) {
listeners[i] = env.ListenerNew();
}
return listeners;
}
public void Run(RegressionEnvironment env)
{
env.AdvanceTime(0);
string epl = "@Name('s0') select irstream * from SupportBean#time(10)";
env.CompileDeploy(epl).AddListener("s0");
string deploymentId = env.DeploymentId("s0");
env.SendEventBean(new SupportBean("E1", 1));
env.AdvanceTime(2000);
env.SendEventBean(new SupportBean("E2", 2));
env.AdvanceTime(4000);
env.SendEventBean(new SupportBean("E3", 3));
env.Listener("s0").Reset();
env.Milestone(0);
env.StageService.GetStage("P1");
StageIt(env, "P1", deploymentId);
env.Milestone(1);
env.AdvanceTimeStage("P1", 9999);
Assert.IsFalse(env.ListenerStage("P1", "s0").GetAndClearIsInvoked());
env.AdvanceTimeStage("P1", 10000);
Assert.AreEqual("E1", env.ListenerStage("P1", "s0").AssertOneGetOldAndReset().Get("TheString"));
env.Milestone(2);
env.AdvanceTimeStage("P1", 11999);
Assert.IsFalse(env.ListenerStage("P1", "s0").GetAndClearIsInvoked());
env.AdvanceTimeStage("P1", 12000);
Assert.AreEqual("E2", env.ListenerStage("P1", "s0").AssertOneGetOldAndReset().Get("TheString"));
env.AdvanceTime(12000);
Assert.IsFalse(env.ListenerStage("P1", "s0").GetAndClearIsInvoked());
UnstageIt(env, "P1", deploymentId);
env.Milestone(3);
env.AdvanceTime(13999);
env.AdvanceTimeStage("P1", 14000);
SupportListener listener = env.Listener("s0");
Assert.IsFalse(listener.GetAndClearIsInvoked());
env.AdvanceTime(14000);
Assert.AreEqual("E3", env.Listener("s0").AssertOneGetOldAndReset().Get("TheString"));
env.UndeployAll();
}
internal static void SendAssertEventRectangle(
RegressionEnvironment env,
SupportListener listener,
double x,
double y,
double width,
double height,
bool expected)
{
env.SendEventBean(new SupportSpatialEventRectangle(null, x, y, width, height));
Assert.AreEqual(expected, env.Listener("s0").IsInvokedAndReset());
}
public static void SendAssert(
RegressionEnvironment env,
SupportListener listener,
double px,
double py,
double x,
double y,
double width,
double height,
bool expected)
{
SendAssertWNull(env, listener, px, py, x, y, width, height, expected);
}
private static void AssertReceived(
SupportListener listener,
object[][] values)
{
var @event = listener.AssertOneGetNewAndReset();
var events = (EventBean[]) @event.GetFragment("detail");
if (values == null) {
Assert.IsNull(events);
return;
}
EPAssertionUtil.AssertPropsPerRowAnyOrder(events, new [] { "c0", "c1" }, values);
}
private static void AssertEventsReceived(
SupportListener updateListener,
int[] expectedIds)
{
Assert.AreEqual(1, updateListener.LastNewData.Length);
Assert.IsNull(updateListener.LastOldData);
var theEvent = updateListener.LastNewData[0];
Assert.AreEqual(expectedIds[0], ((SupportBean_S0) theEvent.Get("S0")).Id);
Assert.AreEqual(expectedIds[1], ((SupportBean_S1) theEvent.Get("S1")).Id);
Assert.AreEqual(expectedIds[2], ((SupportBean_S2) theEvent.Get("S2")).Id);
Assert.AreEqual(expectedIds[3], ((SupportBean_S3) theEvent.Get("S3")).Id);
Assert.AreEqual(expectedIds[4], ((SupportBean_S4) theEvent.Get("S4")).Id);
}
public static void AssertRectanglesSingleValue(
RegressionEnvironment env,
SupportListener listener,
IList<BoundingBox> rectangles,
params string[] matches)
{
for (var i = 0; i < rectangles.Count; i++) {
var box = rectangles[i];
SendRectangle(env, "R" + box, box.MinX, box.MinY, box.MaxX - box.MinX, box.MaxY - box.MinY);
var c0 = listener.AssertOneGetNewAndReset().Get("c0").ToString();
Assert.AreEqual(matches[i], c0, "for box " + i);
}
}
public static void SendAssertWNull(
RegressionEnvironment env,
SupportListener listener,
double? px,
double? py,
double? x,
double? y,
double? width,
double? height,
bool? expected)
{
env.SendEventBean(new SupportEventRectangleWithOffset("E", px, py, x, y, width, height));
Assert.AreEqual(expected, listener.AssertOneGetNewAndReset().Get("c0"));
}
private static void TryAssertionSnapshotColumn(
RegressionEnvironment env,
SupportListener listener,
EPStatement stmt,
string[] fields)
{
env.SendEventBean(new SupportBean("E1", 1));
env.SendEventBean(new SupportBean("E1", 1));
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.Statement("s0").GetEnumerator(),
fields,
new[] {new object[] {"E1", 1}});
Assert.IsFalse(env.Listener("s0").IsInvoked);
env.SendEventBean(new SupportBean("E2", 2));
EPAssertionUtil.AssertPropsPerRow(
env.Listener("s0").LastNewData,
fields,
new[] {new object[] {"E1", 1}, new object[] {"E2", 2}});
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.Statement("s0").GetEnumerator(),
fields,
new[] {new object[] {"E1", 1}, new object[] {"E2", 2}});
env.SendEventBean(new SupportBean("E2", 2));
env.SendEventBean(new SupportBean("E1", 1));
env.SendEventBean(new SupportBean("E2", 2));
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.Statement("s0").GetEnumerator(),
fields,
new[] {new object[] {"E1", 1}, new object[] {"E2", 2}});
EPAssertionUtil.AssertPropsPerRow(
env.Listener("s0").LastNewData,
fields,
new[] {new object[] {"E1", 1}, new object[] {"E2", 2}});
env.Listener("s0").Reset();
env.SendEventBean(new SupportBean("E3", 3));
env.SendEventBean(new SupportBean("E1", 1));
env.SendEventBean(new SupportBean("E2", 2));
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.Statement("s0").GetEnumerator(),
fields,
new[] {new object[] {"E1", 1}, new object[] {"E2", 2}, new object[] {"E3", 3}});
EPAssertionUtil.AssertPropsPerRow(
env.Listener("s0").LastNewData,
fields,
new[] {new object[] {"E1", 1}, new object[] {"E2", 2}, new object[] {"E3", 3}});
env.Listener("s0").Reset();
}
private static void AssertPrio(
SupportListener listener,
string theString,
int[] prioValues)
{
var events = listener.NewDataListFlattened;
Assert.AreEqual(prioValues.Length, events.Length);
for (var i = 0; i < prioValues.Length; i++) {
Assert.AreEqual(prioValues[i], events[i].Get("prio"));
if (theString != null) {
Assert.AreEqual(theString, events[i].Get("TheString"));
}
}
listener.Reset();
}
public void Run(RegressionEnvironment env)
{
RegressionPath path = new RegressionPath();
string epl = "select * from SupportBean(TheString regexp '.*,.*,.*,.*,.*,13,.*,.*,.*,.*,.*,.*')";
int count = 5;
DeployMultiple(count, path, epl, env);
env.Milestone(0);
SupportListener[] listeners = new SupportListener[count];
for (int i = 0; i < count; i++) {
listeners[i] = env.Listener("s" + i);
}
long delta = PerformanceObserver.TimeMillis(
() => {
int loops = 1000;
for (int i = 0; i < loops; i++) {
bool match = i % 100 == 0;
string value = match
? "42,12,13,12,32,13,14,43,56,31,78,10"
: // match
"42,12,13,12,32,14,13,43,56,31,78,10"; // no-match
env.SendEventBean(new SupportBean(value, 0));
if (match) {
foreach (SupportListener listener in listeners) {
listener.AssertOneGetNewAndReset();
}
}
else {
foreach (SupportListener listener in listeners) {
Assert.IsFalse(listener.IsInvoked);
}
}
}
});
#if DEBUG
Assert.That(delta, Is.LessThan(2000), "Delta is " + delta); // ~7 seconds without optimization
#else
Assert.That(delta, Is.LessThan(1000), "Delta is " + delta); // ~7 seconds without optimization
#endif
env.UndeployAll();
}
private static void AssertReceived(
SupportListener listenerStmtOne,
SupportBean[] beans,
int[] indexesAll,
int[] indexesWhere,
string[] mapKeys,
object[] mapValues)
{
var received = listenerStmtOne.AssertOneGetNewAndReset();
EPAssertionUtil.AssertEqualsExactOrder(
SupportBean.GetBeansPerIndex(beans, indexesAll),
(object[]) received.Get("c0"));
EPAssertionUtil.AssertEqualsExactOrder(
SupportBean.GetBeansPerIndex(beans, indexesWhere),
(ICollection<object>) received.Get("c1"));
EPAssertionUtil.AssertPropsMap((IDictionary<object, object>) received.Get("c2"), mapKeys, mapValues);
}
public static void SendAssertSpatialAABB(
RegressionEnvironment env,
SupportListener listener,
int numX,
int numY,
long deltaMSec)
{
var start = PerformanceObserver.MilliTime;
for (var x = 0; x < numX; x++) {
for (var y = 0; y < numY; y++) {
env.SendEventBean(new SupportSpatialAABB("", x, y, 0.1, 0.1));
listener.AssertOneGetNewAndReset();
}
}
var delta = PerformanceObserver.MilliTime - start;
Assert.That(delta, Is.LessThan(deltaMSec), "Delta: " + delta);
}
private static void TryReuse(
RegressionEnvironment env,
string[] statements,
AtomicLong milestone)
{
// create all statements
for (var i = 0; i < statements.Length; i++) {
env.CompileDeploy("@Name('s" + i + "')" + statements[i]).AddListener("s" + i);
}
env.Milestone(milestone.GetAndIncrement());
var listeners = new SupportListener[statements.Length];
for (var i = 0; i < statements.Length; i++) {
listeners[i] = env.Listener("s" + i);
}
// send event, all should receive the event
SendBean(env, "IntBoxed", 3);
for (var i = 0; i < statements.Length; i++) {
Assert.IsTrue(listeners[i].IsInvokedAndReset());
}
// stop first, then second, then third etc statement
for (var toStop = 0; toStop < statements.Length; toStop++) {
env.UndeployModuleContaining("s" + toStop);
// send event, all remaining statement received it
SendBean(env, "IntBoxed", 3);
for (var i = 0; i <= toStop; i++) {
Assert.IsFalse(listeners[i].IsInvoked);
}
for (var i = toStop + 1; i < statements.Length; i++) {
Assert.IsTrue(listeners[i].IsInvokedAndReset());
}
}
// now all statements are stopped, send event and verify no listener received
SendBean(env, "IntBoxed", 3);
for (var i = 0; i < statements.Length; i++) {
Assert.IsFalse(listeners[i].IsInvoked);
}
}
private static void RunAssertionSimple(
RegressionEnvironment env,
string epl)
{
env.CompileDeploy(epl).AddListener("s0");
string deploymentId = env.DeploymentId("s0");
SendEvent(env, null, "E1", 10);
AssertTotal(env, null, 10);
env.Milestone(0);
env.StageService.GetStage("P1");
StageIt(env, "P1", deploymentId);
env.Milestone(1);
Assert.IsNull(env.Deployment.GetDeployment(deploymentId));
Assert.IsNotNull(env.StageService.GetExistingStage("P1").DeploymentService.GetDeployment(deploymentId));
AssertEqualsAnyOrder(new string[] { deploymentId }, env.StageService.GetExistingStage("P1").DeploymentService.Deployments);
SendEvent(env, null, "E3", 21);
SendEvent(env, "P1", "E4", 22);
AssertTotal(env, "P1", 10 + 22);
env.Milestone(2);
UnstageIt(env, "P1", deploymentId);
env.Milestone(3);
Assert.IsNotNull(env.Deployment.GetDeployment(deploymentId));
Assert.IsNull(env.StageService.GetExistingStage("P1").DeploymentService.GetDeployment(deploymentId));
SendEvent(env, null, "E5", 31);
SendEvent(env, "P1", "E6", 32);
AssertTotal(env, null, 10 + 22 + 31);
SupportListener listener = env.Listener("s0");
env.UndeployAll();
SendEvent(env, null, "end", 99);
Assert.IsFalse(listener.GetAndClearIsInvoked());
}
private static void TryAssertionSimpleColumn(
RegressionEnvironment env,
SupportListener listener,
EPStatement stmt,
string[] fields)
{
env.SendEventBean(new SupportBean("E1", 1));
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.Statement("s0").GetEnumerator(),
fields,
new[] {new object[] {"E1", 1}});
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {"E1", 1});
env.SendEventBean(new SupportBean("E1", 1));
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.Statement("s0").GetEnumerator(),
fields,
new[] {new object[] {"E1", 1}});
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {"E1", 1});
env.SendEventBean(new SupportBean("E2", 1));
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.Statement("s0").GetEnumerator(),
fields,
new[] {new object[] {"E1", 1}, new object[] {"E2", 1}});
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {"E2", 1});
env.SendEventBean(new SupportBean("E1", 2));
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.Statement("s0").GetEnumerator(),
fields,
new[] {new object[] {"E1", 1}, new object[] {"E2", 1}, new object[] {"E1", 2}});
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {"E1", 2});
env.SendEventBean(new SupportBean("E2", 2));
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.Statement("s0").GetEnumerator(),
fields,
new[] {new object[] {"E1", 1}, new object[] {"E2", 1}, new object[] {"E1", 2}, new object[] {"E2", 2}});
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {"E2", 2});
env.SendEventBean(new SupportBean("E2", 2));
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.Statement("s0").GetEnumerator(),
fields,
new[] {new object[] {"E1", 1}, new object[] {"E2", 1}, new object[] {"E1", 2}, new object[] {"E2", 2}});
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {"E2", 2});
env.SendEventBean(new SupportBean("E1", 1));
EPAssertionUtil.AssertPropsPerRowAnyOrder(
env.Statement("s0").GetEnumerator(),
fields,
new[] {new object[] {"E1", 1}, new object[] {"E2", 1}, new object[] {"E1", 2}, new object[] {"E2", 2}});
EPAssertionUtil.AssertProps(
env.Listener("s0").AssertOneGetNewAndReset(),
fields,
new object[] {"E1", 1});
}
public ReadRunnable(RegressionEnvironment env)
{
this.env = env;
env.AddListener("out");
listener = env.Listener("out");
}
public void Run(RegressionEnvironment env)
{
var milestone = new AtomicLong();
var existingStatements = new bool[_theCase.Filters.Length];
var startedStatements = new bool[_theCase.Filters.Length];
var initialListeners = new SupportListener[_theCase.Filters.Length];
// create statements
for (var i = 0; i < _theCase.Filters.Length; i++) {
var filter = _theCase.Filters[i];
var stmtName = "s" + i;
var epl = "@Name('" + stmtName + "') select * from SupportBean(" + filter + ")";
env.CompileDeploy(epl).AddListener(stmtName);
existingStatements[i] = true;
startedStatements[i] = true;
initialListeners[i] = env.Listener(stmtName);
try {
AssertSendEvents(existingStatements, startedStatements, initialListeners, env, _theCase.Items);
}
catch (AssertionException ex) {
var message = "Failed after create stmt " + i + " and before milestone P" + milestone.Get();
log.Error(message, ex);
Assert.Fail(message, ex);
}
env.Milestone(milestone.GetAndIncrement());
try {
AssertSendEvents(existingStatements, startedStatements, initialListeners, env, _theCase.Items);
}
catch (AssertionException ex) {
Assert.Fail("Failed after create stmt " + i + " and after milestone P" + milestone.Get(), ex);
}
}
// stop statements
for (var i = 0; i < _theCase.Filters.Length; i++) {
var stmtName = "s" + i;
env.UndeployModuleContaining(stmtName);
startedStatements[i] = false;
try {
AssertSendEvents(existingStatements, startedStatements, initialListeners, env, _theCase.Items);
}
catch (AssertionException ex) {
throw new AssertionException(
"Failed after stop stmt " + i + " and before milestone P" + milestone.Get(),
ex);
}
env.Milestone(milestone.Get());
try {
AssertSendEvents(existingStatements, startedStatements, initialListeners, env, _theCase.Items);
}
catch (AssertionException ex) {
throw new EPException(
"Failed after stop stmt " + i + " and after milestone P" + milestone.Get(),
ex);
}
catch (Exception ex) {
throw new EPException(
"Failed after stop stmt " + i + " and after milestone P" + milestone.Get(),
ex);
}
milestone.GetAndIncrement();
}
// destroy statements
env.UndeployAll();
}
