public void ForEachMapGroupReduce()
        {
            string xml = @"
                <Map>
                    <Rule Type = 'IninValueOnT1' />
                    <MapRule Type = 'MapRuleOnT1IfTrue' />
                    <ForEach>
                        <MapReduce>
                            <Map>
                                <MapRule Type = 'MapRuleOnT2Test' />
                                <MapRule Type = 'MapRuleOnT2Add' />
                            </Map>
                            <Reduce>
                                <ReduceRule Type = 'ReduceRuleOnT2' />
                                <ReduceRule Type = 'AssignRuleOnT2' />
                            </Reduce>
                        </MapReduce>
                    </ForEach>
                </Map>";
            Parser parser = xml.CreateParser("Map");
            parser.AddContext("IninValueOnT1", "ClassLibrary1.IninValueOnT1, ClassLibrary1");
            parser.AddContext("MapRuleOnT1IfTrue", "ClassLibrary1.MapRuleOnT1IfTrue, ClassLibrary1");
            parser.AddContext("MapRuleOnT2Test", "MapReduce.Parser.UnitTest.MapRuleOnT2Test, MapReduce.Parser.UnitTest");
            parser.AddContext("MapRuleOnT2Add", "MapReduce.Parser.UnitTest.MapRuleOnT2Add, MapReduce.Parser.UnitTest");
            parser.AddContext("ReduceRuleOnT2", "ClassLibrary1.ReduceRuleOnT2, ClassLibrary1");
            parser.AddContext("AssignRuleOnT2", "ClassLibrary1.AssignRuleOnT2, ClassLibrary1");

            Assert.IsTrue(parser.MapBlock());
            var parserResult = parser.Result.Expression;
            var resultFunc = (Expression<Func<Test1, IEnumerable<Test2>>>)parserResult;

            Func<Test1, IEnumerable<Test2>> func = resultFunc.Compile();

            var t1 = new Test1() { A = 10 };
            List<Test2> result = func(t1).ToList();
            Assert.AreEqual(10, result.Count);
            Assert.AreEqual(103, result[9].Details.Count());
            Assert.AreEqual(103, result[0].Details.Count());
        }
        public void CondtionTest()
        {
            string xml = @"
                    <Reduce>
            <ReduceRule Type = 'ReduceRuleOnT1' />
            <ReduceRule Type = 'AssignRuleOnT1' Condition='ConditionOnRuleTest1' />
            </Reduce>";
            Parser parser = xml.CreateParser("Reduce");
            parser.AddContext("ReduceRuleOnT1", "ClassLibrary1.ReduceRuleOnT1, ClassLibrary1");
            parser.AddContext("AssignRuleOnT1", "ClassLibrary1.AssignRuleOnT1, ClassLibrary1");
            parser.AddContext("ConditionOnRuleTest1", "MapReduce.Parser.UnitTest.ConditionOnRuleTest1, MapReduce.Parser.UnitTest");
            Assert.IsTrue(parser.ReduceBlock());
            PrivateObject po = new PrivateObject(parser);
            ParserResult parserResult = (ParserResult)po.GetField("currentReduceResult");
            var resultFunc = (Expression<Func<IEnumerable<Test2>, Test1, Test1>>)parserResult.Expression;

            Func<IEnumerable<Test2>, Test1, Test1> func = resultFunc.Compile();

            var t2List = new List<Test2>() { new Test2() { Result = 1 }, new Test2() { Result = 2 }, };
            var t1 = new Test1();
            Test1 result = func(t2List, t1);
            Assert.AreEqual(3, result.Result);
            Assert.IsNull(result.Details);
        }
        public void ForEachMapRule()
        {
            string xml = @"
                <Map>
                    <Rule Type = 'IninValueOnT1' />
                    <MapRule Type = 'MapRuleOnT1IfTrue' />
                    <ForEach>
                      <MapRule Type = 'MapRuleOnT2' />
                    </ForEach>
                </Map>";
            Parser parser = xml.CreateParser("Map");
            parser.AddContext("IninValueOnT1", "ClassLibrary1.IninValueOnT1, ClassLibrary1");
            parser.AddContext("MapRuleOnT1IfTrue", "ClassLibrary1.MapRuleOnT1IfTrue, ClassLibrary1");
            parser.AddContext("MapRuleOnT2", "ClassLibrary1.MapRuleOnT2, ClassLibrary1");

            Assert.IsTrue(parser.MapBlock());
            var parserResult = parser.Result.Expression;
            var resultFunc = (Expression<Func<Test1, IEnumerable<IEnumerable<Test3>>>>)parserResult;

            Func<Test1, IEnumerable<IEnumerable<Test3>>> func = resultFunc.Compile();

            var t1 = new Test1() { A = 2 };
            IEnumerable<IEnumerable<Test3>> result1 = func(t1);
            IEnumerable<Test3> result2 = result1.SelectMany(r => r.Select(l => l));
            Assert.AreEqual(2, result1.Count());
            Assert.AreEqual(3, result2.Count());
        }
        public void NestedForEachMapReduce()
        {
            string xml = @"
            <MapReduce>
                <Map>
                    <Rule Type = 'IninValueOnT1' />
                    <MapRule Type = 'MapRuleOnT1IfTrue' />
                    <ForEach>
                        <MapReduce>
                            <Map>
                                <Rule Type = 'IninValueOnT2' />
                                <MapRule Type = 'MapRuleOnT2' />
                                <ForEach>
                                    <Rule Type = 'IninValueOnT3' />
                                </ForEach>
                            </Map>
                            <Reduce>
                                <ReduceRule Type = 'ReduceRuleOnT2' />
                                <ReduceRule Type = 'AssignRuleOnT2' />
                            </Reduce>
                        </MapReduce>
                    </ForEach>
                </Map>
                <Reduce>
                    <ReduceRule Type = 'ReduceRuleOnT1' />
                    <ReduceRule Type = 'AssignRuleOnT1' />
                </Reduce>
            </MapReduce>";
            Parser parser = xml.CreateParser("MapReduce");
            parser.AddContext("IninValueOnT1", "ClassLibrary1.IninValueOnT1, ClassLibrary1");
            parser.AddContext("MapRuleOnT1IfTrue", "ClassLibrary1.MapRuleOnT1IfTrue, ClassLibrary1");
            parser.AddContext("IninValueOnT2", "ClassLibrary1.IninValueOnT2, ClassLibrary1");
            parser.AddContext("MapRuleOnT2", "ClassLibrary1.MapRuleOnT2, ClassLibrary1");
            parser.AddContext("IninValueOnT3", "ClassLibrary1.IninValueOnT3, ClassLibrary1");
            parser.AddContext("ReduceRuleOnT2", "ClassLibrary1.ReduceRuleOnT2, ClassLibrary1");
            parser.AddContext("AssignRuleOnT2", "ClassLibrary1.AssignRuleOnT2, ClassLibrary1");
            parser.AddContext("ReduceRuleOnT1", "ClassLibrary1.ReduceRuleOnT1, ClassLibrary1");
            parser.AddContext("AssignRuleOnT1", "ClassLibrary1.AssignRuleOnT1, ClassLibrary1");

            Assert.IsTrue(parser.Build());
            var parserResult = parser.Result.Expression;
            var resultFunc = (Expression<Func<Test1, Test1>>)parserResult;

            Func<Test1, Test1> func = resultFunc.Compile();

            var t1 = new Test1() { A = 10 };
            Test1 result = func(t1);
            Assert.AreEqual(10, result.Details.Count());
            Assert.AreEqual(220, result.Result);
        }
 private void doTest(Test1 t1, Func<Test1, Test1> func)
 {
     var result = func(t1);
     Assert.AreEqual(100, result.Details.Count());
     Assert.AreEqual(505000, result.Result);
 }
 private void doTest(Test1 t1, Delegate func)
 {
     var result = (Test1)func.DynamicInvoke(t1);
     Assert.AreEqual(100, result.Details.Count());
     Assert.AreEqual(505000, result.Result);
 }
 public TestInstance(Test1 t1, int seed)
 {
     T1 = t1;
     Seed = seed;
 }