public void TestFlowRequired()
        {
            _rootCartNodeOneReq.Init(null);

            EventBean[] stream2Events = SupportJoinResultNodeFactory.MakeEvents(2); // for identifying rows in cartesian product
            EventBean[] stream3Events = SupportJoinResultNodeFactory.MakeEvents(2); // for identifying rows in cartesian product
            EventBean[] stream4Events = SupportJoinResultNodeFactory.MakeEvents(2); // for identifying rows in cartesian product

            // Post result from 3, send 2 rows
            List <EventBean[]> resultFinalRows = new List <EventBean[]>();

            EventBean[] childRow = new EventBean[5];
            childRow[3] = stream3Events[0];
            _rootCartNodeOneReq.Result(childRow, 3, null, null, resultFinalRows, null);
            childRow    = new EventBean[5];
            childRow[3] = stream3Events[1];
            _rootCartNodeOneReq.Result(childRow, 3, null, null, resultFinalRows, null);

            // Post result from 2, send 2 rows
            childRow    = new EventBean[5];
            childRow[2] = stream2Events[0];
            _rootCartNodeOneReq.Result(childRow, 2, null, null, resultFinalRows, null);
            childRow    = new EventBean[5];
            childRow[2] = stream2Events[1];
            _rootCartNodeOneReq.Result(childRow, 2, null, null, resultFinalRows, null);

            // Post result from 4
            childRow    = new EventBean[5];
            childRow[4] = stream4Events[0];
            _rootCartNodeOneReq.Result(childRow, 4, null, null, resultFinalRows, null);
            childRow    = new EventBean[5];
            childRow[4] = stream4Events[1];
            _rootCartNodeOneReq.Result(childRow, 4, null, null, resultFinalRows, null);

            // process posted rows (child rows were stored and are compared to find other rows to generate)
            _rootCartNodeOneReq.Process(null, resultFinalRows, null);

            // 5 generated rows: 2 (stream 2) + 2 (stream 3) + 1 (self, Node 2)
            Assert.AreEqual(8, _parentNode.RowsList.Count);

            EventBean[][] rowArr = SupportJoinResultNodeFactory.ConvertTo2DimArr(_parentNode.RowsList);
            EPAssertionUtil.AssertEqualsAnyOrder(
                new[]
            {
                new[] { null, null, stream2Events[0], stream3Events[0], stream4Events[0] },
                new[] { null, null, stream2Events[0], stream3Events[1], stream4Events[0] },
                new[] { null, null, stream2Events[1], stream3Events[0], stream4Events[0] },
                new[] { null, null, stream2Events[1], stream3Events[1], stream4Events[0] },
                new[] { null, null, stream2Events[0], stream3Events[0], stream4Events[1] },
                new[] { null, null, stream2Events[0], stream3Events[1], stream4Events[1] },
                new[] { null, null, stream2Events[1], stream3Events[0], stream4Events[1] },
                new[] { null, null, stream2Events[1], stream3Events[1], stream4Events[1] },
            }, rowArr);
        }
        public void TestFlow()
        {
            _optCartNode.Init(_resultMultipleEvents);

            EventBean[] stream2Events = SupportJoinResultNodeFactory.MakeEvents(2); // for identifying rows in cartesian product
            EventBean[] stream3Events = SupportJoinResultNodeFactory.MakeEvents(2); // for identifying rows in cartesian product

            Node      nodeOne           = _resultMultipleEvents[1][0];
            EventBean eventOneStreamOne = nodeOne.Events.First();
            Node      nodeTwo           = _resultMultipleEvents[1][1];
            EventBean eventTwoStreamOne = nodeTwo.Events.First();

            // generate an event row originating from child 1
            List <EventBean[]> resultFinalRows = new List <EventBean[]>();

            EventBean[] childRow = new EventBean[4];                                             // new rows for each result
            childRow[2] = stream2Events[0];
            _optCartNode.Result(childRow, 2, eventOneStreamOne, nodeOne, resultFinalRows, null); // child is stream 2
            childRow    = new EventBean[4];
            childRow[2] = stream2Events[1];
            _optCartNode.Result(childRow, 2, eventOneStreamOne, nodeOne, resultFinalRows, null); // child is stream 2

            // generate an event row originating from child 2
            childRow    = new EventBean[4];
            childRow[3] = stream3Events[0];
            _optCartNode.Result(childRow, 3, eventOneStreamOne, nodeOne, resultFinalRows, null); // child is stream 3
            childRow    = new EventBean[4];
            childRow[3] = stream3Events[1];
            _optCartNode.Result(childRow, 3, eventOneStreamOne, nodeOne, resultFinalRows, null); // child is stream 3

            // process posted rows (child rows were stored and are compared to find other rows to generate)
            _optCartNode.Process(_resultMultipleEvents, resultFinalRows, null);

            // 5 generated rows: 2 (stream 2) + 2 (stream 3) + 1 (self, Node 2)
            Assert.AreEqual(5, _parentNode.RowsList.Count);

            EventBean[][] rowArr = SupportJoinResultNodeFactory.ConvertTo2DimArr(_parentNode.RowsList);
            EPAssertionUtil.AssertEqualsAnyOrder(
                new[]
            {
                new[] { null, eventOneStreamOne, stream2Events[0], stream3Events[0] },
                new[] { null, eventOneStreamOne, stream2Events[0], stream3Events[1] },
                new[] { null, eventOneStreamOne, stream2Events[1], stream3Events[0] },
                new[] { null, eventOneStreamOne, stream2Events[1], stream3Events[1] },
                new[] { null, eventTwoStreamOne, null, null },
            }, rowArr);
        }
        public void TestFlowOptional()
        {
            RootCartProdAssemblyNode rootCartNodeAllOpt = (RootCartProdAssemblyNode) new RootCartProdAssemblyNodeFactory(1, 5, true).MakeAssemblerUnassociated();

            rootCartNodeAllOpt.AddChild(new SupportJoinProcNode(2, 5));
            rootCartNodeAllOpt.AddChild(new SupportJoinProcNode(3, 5));
            rootCartNodeAllOpt.AddChild(new SupportJoinProcNode(4, 5));

            _parentNode.AddChild(rootCartNodeAllOpt);

            rootCartNodeAllOpt.Init(null);
            List <EventBean[]> resultFinalRows = new List <EventBean[]>();

            rootCartNodeAllOpt.Process(null, resultFinalRows, null);

            // 5 generated rows: 2 (stream 2) + 2 (stream 3) + 1 (self, Node 2)
            Assert.AreEqual(1, _parentNode.RowsList.Count);

            EventBean[][] rowArr = SupportJoinResultNodeFactory.ConvertTo2DimArr(_parentNode.RowsList);
            EPAssertionUtil.AssertEqualsAnyOrder(
                new[] { new EventBean[] { null, null, null, null, null } }, rowArr);
        }
Example #4
0
        public void TestCompute()
        {
            // test null
            IList <EventBean[]> rowsA = null;
            IList <EventBean[]> rowsB = null;

            TryCompute(rowsA, rowsB);
            Assert.IsTrue(_results.IsEmpty());

            // test no rows A
            rowsA = new List <EventBean[]>();
            TryCompute(rowsA, rowsB);
            Assert.IsTrue(_results.IsEmpty());

            // test no rows B
            rowsA = null;
            rowsB = new List <EventBean[]>();
            TryCompute(rowsA, rowsB);
            Assert.IsTrue(_results.IsEmpty());

            // test side A one row, B empty
            rowsA = MakeRowsA(1);
            rowsB = null;
            TryCompute(rowsA, rowsB);
            Assert.AreEqual(1, _results.Count);
            EPAssertionUtil.AssertEqualsExactOrder(rowsA[0], _results[0]);

            // test side B one row, A empty
            rowsA = null;
            rowsB = MakeRowsB(1);
            TryCompute(rowsA, rowsB);
            Assert.AreEqual(1, _results.Count);
            EPAssertionUtil.AssertEqualsExactOrder(rowsB[0], _results[0]);

            // test A and B one row
            rowsA = MakeRowsA(1);
            rowsB = MakeRowsB(1);
            TryCompute(rowsA, rowsB);
            Assert.AreEqual(1, _results.Count);
            EPAssertionUtil.AssertEqualsExactOrder(
                new[] { rowsA[0][0], rowsB[0][1], null, rowsA[0][3] }, _results[0]);

            // test A=2 rows and B=1 row
            rowsA = MakeRowsA(2);
            rowsB = MakeRowsB(1);
            TryCompute(rowsA, rowsB);
            Assert.AreEqual(2, _results.Count);
            EPAssertionUtil.AssertEqualsAnyOrder(
                new[]
            {
                new[] { rowsA[0][0], rowsB[0][1], null, rowsA[0][3] },
                new[] { rowsA[1][0], rowsB[0][1], null, rowsA[1][3] }
            }, SupportJoinResultNodeFactory.ConvertTo2DimArr(_results));

            // test A=1 rows and B=2 row
            rowsA = MakeRowsA(1);
            rowsB = MakeRowsB(2);
            TryCompute(rowsA, rowsB);
            Assert.AreEqual(2, _results.Count);
            EPAssertionUtil.AssertEqualsAnyOrder(
                new[]
            {
                new[] { rowsA[0][0], rowsB[0][1], null, rowsA[0][3] },
                new[] { rowsA[0][0], rowsB[1][1], null, rowsA[0][3] }
            }, SupportJoinResultNodeFactory.ConvertTo2DimArr(_results));

            // test A=2 rows and B=2 row
            rowsA = MakeRowsA(2);
            rowsB = MakeRowsB(2);
            TryCompute(rowsA, rowsB);
            Assert.AreEqual(4, _results.Count);
            EPAssertionUtil.AssertEqualsAnyOrder(
                new[]
            {
                new[] { rowsA[0][0], rowsB[0][1], null, rowsA[0][3] },
                new[] { rowsA[0][0], rowsB[1][1], null, rowsA[0][3] },
                new[] { rowsA[1][0], rowsB[0][1], null, rowsA[1][3] },
                new[] { rowsA[1][0], rowsB[1][1], null, rowsA[1][3] }
            }, SupportJoinResultNodeFactory.ConvertTo2DimArr(_results));

            // test A=2 rows and B=3 row
            rowsA = MakeRowsA(2);
            rowsB = MakeRowsB(3);
            TryCompute(rowsA, rowsB);
            Assert.AreEqual(6, _results.Count);
            EPAssertionUtil.AssertEqualsAnyOrder(
                new[]
            {
                new[] { rowsA[0][0], rowsB[0][1], null, rowsA[0][3] },
                new[] { rowsA[0][0], rowsB[1][1], null, rowsA[0][3] },
                new[] { rowsA[0][0], rowsB[2][1], null, rowsA[0][3] },
                new[] { rowsA[1][0], rowsB[0][1], null, rowsA[1][3] },
                new[] { rowsA[1][0], rowsB[1][1], null, rowsA[1][3] },
                new[] { rowsA[1][0], rowsB[2][1], null, rowsA[1][3] }
            },
                SupportJoinResultNodeFactory.ConvertTo2DimArr(_results));
        }