public void TestAnonymousObjectSingleResult()
        {
            var q = new QueriableDummyNoExe<dummyntup>();
            var a = from evt in q
                    select new
                    {
                        Jets = evt.valC1D,
                        Tracks = evt.valC1D
                    };

            var b = from evt in a
                    select new
                    {
                        MatchedJets = from j in evt.Jets
                                      where evt.Tracks.Where(t => Math.Abs(t - j) < 0.1).Any()
                                      select new
                                      {
                                          Jet = j,
                                          Track = (from t in evt.Tracks orderby Math.Abs(j - t) ascending select t).First()
                                      }
                    };

            var c = from evt in b
                    select (from j in evt.MatchedJets orderby j.Track - j.Jet select j).First();

            var d = from evt in c
                    select evt.Jet;

            var r1 = d.Sum();
            var qm = DummyQueryExectuor.LastQueryModel;

            var sf = QMFuncFinder.FindQMFunctions(qm);
            Assert.IsNotNull(sf);
            Assert.AreEqual(2, sf.Count(), "# of qm functions");
        }
        public void NoObjectFunctionReturns()
        {
            var q = new QueriableDummyNoExe <LINQToTTreeLib.ResultOperators.ROFirstLastTest.ntupWithObjects>();

            // Create a dual object. Avoid anonymous objects just for the sake of it.
            var matched = from evt in q
                          select new LINQToTTreeLib.ResultOperators.ROFirstLastTest.TestTranslatedNestedCompareAndSortHolderEvent()
            {
                matches = from j in evt.jets
                          orderby j.v3 ascending
                          select new LINQToTTreeLib.ResultOperators.ROFirstLastTest.TestTranslatedNestedCompareAndSortHolder()
                {
                    jet = j
                }
            };

            // Filter on the first jet in the sequence.
            var goodmatched = from evt in matched
                              where evt.matches.First().jet.v3 > 0
                              select evt;

            var r = goodmatched.Count();

            var qm = DummyQueryExectuor.LastQueryModel;
            var sf = QMFuncFinder.FindQMFunctions(qm);

            Assert.AreEqual(0, sf.Where(f => !f.IsSequence).Count(), "# of functions");
            Assert.AreEqual(0, sf.Where(f => f.IsSequence).Count(), "# of functions"); // it returns an object...
        }
        public void TestAdditonalFromClause()
        {
            var q = new QueriableDummyNoExe <dummyntup>();
            var a = from evt in q
                    select new
            {
                Jets   = evt.valC1D,
                Tracks = evt.valC1D
            };

            var b = from evt in a
                    select new
            {
                MatchedJets = from j in evt.Jets
                              where evt.Tracks.Where(t => Math.Abs(t - j) < 0.1).Any()
                              select new
                {
                    Jet   = j,
                    Track = (from t in evt.Tracks orderby Math.Abs(j - t) ascending select t).First()
                }
            };

            var c = from evt in b
                    from j in evt.MatchedJets
                    where j.Jet > 30
                    select j.Jet + j.Track;
            var r1 = c.Count();
            var qm = DummyQueryExectuor.LastQueryModel;

            var sf = QMFuncFinder.FindQMFunctions(qm);

            Assert.IsNotNull(sf);
            Assert.AreEqual(2, sf.Count(), "# of qm functions");
        }
        public void TestBogus()
        {
            var q = new QueriableDummyNoExe <dummyntup>();
            var a = from evt in q
                    select new
            {
                Jets   = evt.valC1D,
                Tracks = evt.valC1D
            };

            var b = from evt in a
                    select new
            {
                MatchedJets = from j in evt.Jets
                              where evt.Tracks.Where(t => Math.Abs(t - j) < 0.1).Any()
                              select new
                {
                    Jet   = j,
                    Track = (from t in evt.Tracks orderby Math.Abs(j - t) ascending select t).First()
                }
            };

            var r1 = b.Where(evt => evt.MatchedJets.Count() > 1).Count();
            var qm = DummyQueryExectuor.LastQueryModel;

            var sf = QMFuncFinder.FindQMFunctions(qm);

            Assert.IsNotNull(sf);
            Assert.AreEqual(3, sf.Count(), "# of qm functions");
            var f = sf.First();

            Assert.AreEqual(1, f.Arguments.Count(), "# of arguments");
        }
        public void CatchArgsInOrderBy()
        {
            // This test produces somethign caught in the wild (caused a compile error).
            // The bug has to do with a combination of the First predicate and the CPPCode statement conspiring
            // to cause the problem, unfortunately. So, the test is here.
            var q = new QueriableDummyNoExe <LINQToTTreeLib.ResultOperators.ROFirstLastTest.ntup3>();

            var resultA = from evt in q
                          select new
            {
                r1 = evt.run1.Where(r => r > 3).Select(r => LINQToTTreeLib.ResultOperators.ROFirstLastTest.DoItClass.DoIt(r)),
                r2 = evt.run2.Where(r => r > 4).Select(r => LINQToTTreeLib.ResultOperators.ROFirstLastTest.DoItClass.DoIt(r))
            };
            var resultB = from e in resultA
                          select new
            {
                joinedR = from r1 in e.r1
                          select(from r2 in e.r2
                                 orderby r1 - r2 ascending
                                 select r2).First()
            };
            var result = from e in resultB
                         from r in e.joinedR
                         select r;
            var c = result.Sum();

            var qm = DummyQueryExectuor.LastQueryModel;
            var sf = QMFuncFinder.FindQMFunctions(qm);

            Assert.AreEqual(1, sf.Where(f => !f.IsSequence).Count(), "# of non-functions");
            Assert.AreEqual(3, sf.Where(f => f.IsSequence).Count(), "# of sequence functions");
        }
        public void TestNoneQMFunc()
        {
            var q = new QueriableDummyNoExe<ntup>();
            var r1 = q.Count();
            var qm = DummyQueryExectuor.LastQueryModel;

            var sf = QMFuncFinder.FindQMFunctions(qm);
            Assert.IsNotNull(sf);
            Assert.AreEqual(0, sf.Count(), "# of qm functions");
        }
        public void TestNoneQMFunc()
        {
            var q  = new QueriableDummyNoExe <ntup>();
            var r1 = q.Count();
            var qm = DummyQueryExectuor.LastQueryModel;

            var sf = QMFuncFinder.FindQMFunctions(qm);

            Assert.IsNotNull(sf);
            Assert.AreEqual(0, sf.Count(), "# of qm functions");
        }
        public void TestDuplicateQM()
        {
            var q = new QueriableDummyNoExe <dummyntup>();
            var a = from evt in q.Where(e => e.valC1D.First() > 0)
                    select evt.valC1D.First();

            var r1 = a.Sum();
            var qm = DummyQueryExectuor.LastQueryModel;
            var sf = QMFuncFinder.FindQMFunctions(qm);

            Assert.IsNotNull(sf);
            Assert.AreEqual(1, sf.Count(), "# of qm functions");
        }
        public void TestForNestedFrom()
        {
            var q      = new QueriableDummyNoExe <arrayntup>();
            var result = from d in q
                         from e in d.vals
                         select e;
            var r  = result.Count();
            var qm = DummyQueryExectuor.LastQueryModel;

            var str = FormattingQueryVisitor.Format(qm);

            Console.WriteLine("result: {0}", str);
            Assert.IsTrue(str.Contains("vals"), "Missing vals in '" + str + "'.");
        }
        public void TestDoubleFrom()
        {
            var q = new QueriableDummyNoExe <dummyntup>();
            var a = from evt in q
                    from i in evt.valC1D
                    select i;
            var r1 = a.Count();
            var qm = DummyQueryExectuor.LastQueryModel;

            var sf = QMFuncFinder.FindQMFunctions(qm);

            Assert.IsNotNull(sf);
            Assert.AreEqual(0, sf.Count(), "# of qm functions");
        }
        public void TestForWhere()
        {
            var q      = new QueriableDummyNoExe <ntup>();
            var result = from d in q
                         where d.run > 20
                         select d;
            var c  = result.Count();
            var qm = DummyQueryExectuor.LastQueryModel;

            var str = FormattingQueryVisitor.Format(qm);

            Console.WriteLine("result: {0}", str);
            Assert.IsTrue(str.Contains("where"), "Missing select in '" + str + "'.");
        }
        public void TestSingleQMFuncInWhere()
        {
            var q = new QueriableDummyNoExe<dummyntup>();
            var a = from evt in q
                    where evt.valC1D.Where(i => i > 5).Count() > 5
                    select evt;
            var r1 = a.Count();
            var qm = DummyQueryExectuor.LastQueryModel;

            var sf = QMFuncFinder.FindQMFunctions(qm);
            Assert.IsNotNull(sf);
            Assert.AreEqual(1, sf.Count(), "# of qm functions");
            var f = sf.First();
            Assert.AreEqual(0, f.Arguments.Count(), "# of arguments");
        }
        public void TestSingleQMFuncInWhere()
        {
            var q = new QueriableDummyNoExe <dummyntup>();
            var a = from evt in q
                    where evt.valC1D.Where(i => i > 5).Count() > 5
                    select evt;
            var r1 = a.Count();
            var qm = DummyQueryExectuor.LastQueryModel;

            var sf = QMFuncFinder.FindQMFunctions(qm);

            Assert.IsNotNull(sf);
            Assert.AreEqual(1, sf.Count(), "# of qm functions");
            var f = sf.First();

            Assert.AreEqual(0, f.Arguments.Count(), "# of arguments");
        }
        public void TestDoubleFromWithFuncWithArgDoubleRef()
        {
            var q = new QueriableDummyNoExe <dummyntup>();
            var a = from evt in q
                    from i in evt.valC1D
                    where evt.valC1D.Where(j => i > j && j >= i).Count() > 5
                    select i;
            var r1 = a.Count();
            var qm = DummyQueryExectuor.LastQueryModel;

            var sf = QMFuncFinder.FindQMFunctions(qm);

            Assert.IsNotNull(sf);
            Assert.AreEqual(1, sf.Count(), "# of qm functions");
            var f = sf.First();

            Assert.AreEqual(1, f.Arguments.Count(), "# of arguments");
        }
        public void TestGroupByFunction()
        {
            var q = new QueriableDummyNoExe <LINQToTTreeLib.QueryVisitorTest.NtupWithObjectsDest>();

            var r = from evt in q
                    select from v in evt.var1 group v by v;

            var cnt = from evt in r
                      from grp in evt
                      where grp.Key == 2 && grp.Count() > 5
                      select grp.Key;

            var final = cnt.Count();

            var qm = DummyQueryExectuor.LastQueryModel;

            var sf = QMFuncFinder.FindQMFunctions(qm);

            Assert.AreEqual(1, sf.Count(), "# of qm functions");
        }
        public void TestQMNoFunctionWithSelect()
        {
            var q   = new QueriableDummyNoExe <dummyntup>();
            var evt = from e in q
                      select new
            {
                Jets   = e.valC1D.Where(i => i > 1),
                Tracks = e.valC1D.Where(i => i > 1)
            };
            var r = from e in evt
                    from t in e.Tracks
                    from j in e.Jets
                    where t != j
                    select t;

            var result = r.Count();

            var query = DummyQueryExectuor.LastQueryModel;
            var sf    = QMFuncFinder.FindQMFunctions(query);

            Assert.AreEqual(1, sf.Count(), "# of functions");
            Assert.IsTrue(sf.First().IsSequence, "is sequence");
        }
        public void TestAnonymousObjectSingleResult()
        {
            var q = new QueriableDummyNoExe <dummyntup>();
            var a = from evt in q
                    select new
            {
                Jets   = evt.valC1D,
                Tracks = evt.valC1D
            };

            var b = from evt in a
                    select new
            {
                MatchedJets = from j in evt.Jets
                              where evt.Tracks.Where(t => Math.Abs(t - j) < 0.1).Any()
                              select new
                {
                    Jet   = j,
                    Track = (from t in evt.Tracks orderby Math.Abs(j - t) ascending select t).First()
                }
            };

            var c = from evt in b
                    select(from j in evt.MatchedJets orderby j.Track - j.Jet select j).First();

            var d = from evt in c
                    select evt.Jet;

            var r1 = d.Sum();
            var qm = DummyQueryExectuor.LastQueryModel;

            var sf = QMFuncFinder.FindQMFunctions(qm);

            Assert.IsNotNull(sf);
            Assert.AreEqual(2, sf.Count(), "# of qm functions");
        }
        public void TestDoubleFrom()
        {
            var q = new QueriableDummyNoExe<dummyntup>();
            var a = from evt in q
                    from i in evt.valC1D
                    select i;
            var r1 = a.Count();
            var qm = DummyQueryExectuor.LastQueryModel;

            var sf = QMFuncFinder.FindQMFunctions(qm);
            Assert.IsNotNull(sf);
            Assert.AreEqual(0, sf.Count(), "# of qm functions");
        }
        public void TestAdditonalFromClause()
        {
            var q = new QueriableDummyNoExe<dummyntup>();
            var a = from evt in q
                    select new
                    {
                        Jets = evt.valC1D,
                        Tracks = evt.valC1D
                    };

            var b = from evt in a
                    select new
                    {
                        MatchedJets = from j in evt.Jets
                                      where evt.Tracks.Where(t => Math.Abs(t - j) < 0.1).Any()
                                      select new
                                      {
                                          Jet = j,
                                          Track = (from t in evt.Tracks orderby Math.Abs(j - t) ascending select t).First()
                                      }
                    };

            var c = from evt in b
                    from j in evt.MatchedJets
                    where j.Jet > 30
                    select j.Jet + j.Track;
            var r1 = c.Count();
            var qm = DummyQueryExectuor.LastQueryModel;

            var sf = QMFuncFinder.FindQMFunctions(qm);
            Assert.IsNotNull(sf);
            Assert.AreEqual(2, sf.Count(), "# of qm functions");
        }
        public void TestDoubleFromWithFuncWithArgDoubleRef()
        {
            var q = new QueriableDummyNoExe<dummyntup>();
            var a = from evt in q
                    from i in evt.valC1D
                    where evt.valC1D.Where(j => i > j && j >= i).Count() > 5
                    select i;
            var r1 = a.Count();
            var qm = DummyQueryExectuor.LastQueryModel;

            var sf = QMFuncFinder.FindQMFunctions(qm);
            Assert.IsNotNull(sf);
            Assert.AreEqual(1, sf.Count(), "# of qm functions");
            var f = sf.First();
            Assert.AreEqual(1, f.Arguments.Count(), "# of arguments");
        }
 public void TestDuplicateQM()
 {
     var q = new QueriableDummyNoExe<dummyntup>();
     var a = from evt in q.Where(e => e.valC1D.First() > 0)
             select evt.valC1D.First();
     var r1 = a.Sum();
     var qm = DummyQueryExectuor.LastQueryModel;
     var sf = QMFuncFinder.FindQMFunctions(qm);
     Assert.IsNotNull(sf);
     Assert.AreEqual(1, sf.Count(), "# of qm functions");
 }
        public void TestBogus()
        {
            var q = new QueriableDummyNoExe<dummyntup>();
            var a = from evt in q
                    select new
                    {
                        Jets = evt.valC1D,
                        Tracks = evt.valC1D
                    };

            var b = from evt in a
                    select new
                    {
                        MatchedJets = from j in evt.Jets
                                      where evt.Tracks.Where(t => Math.Abs(t - j) < 0.1).Any()
                                      select new
                                      {
                                          Jet = j,
                                          Track = (from t in evt.Tracks orderby Math.Abs(j - t) ascending select t).First()
                                      }
                    };

            var r1 = b.Where(evt => evt.MatchedJets.Count() > 1).Count();
            var qm = DummyQueryExectuor.LastQueryModel;

            var sf = QMFuncFinder.FindQMFunctions(qm);
            Assert.IsNotNull(sf);
            Assert.AreEqual(3, sf.Count(), "# of qm functions");
            var f = sf.First();
            Assert.AreEqual(1, f.Arguments.Count(), "# of arguments");
        }
        public void NoObjectFunctionReturns()
        {
            var q = new QueriableDummyNoExe<LINQToTTreeLib.ResultOperators.ROFirstLastTest.ntupWithObjects>();

            // Create a dual object. Avoid anonymous objects just for the sake of it.
            var matched = from evt in q
                          select new LINQToTTreeLib.ResultOperators.ROFirstLastTest.TestTranslatedNestedCompareAndSortHolderEvent()
                          {
                              matches = from j in evt.jets
                                        orderby j.v3 ascending
                                        select new LINQToTTreeLib.ResultOperators.ROFirstLastTest.TestTranslatedNestedCompareAndSortHolder()
                                        {
                                            jet = j
                                        }
                          };

            // Filter on the first jet in the sequence.
            var goodmatched = from evt in matched
                              where evt.matches.First().jet.v3 > 0
                              select evt;

            var r = goodmatched.Count();

            var qm = DummyQueryExectuor.LastQueryModel;
            var sf = QMFuncFinder.FindQMFunctions(qm);

            Assert.AreEqual(0, sf.Where(f => !f.IsSequence).Count(), "# of functions");
            Assert.AreEqual(0, sf.Where(f => f.IsSequence).Count(), "# of functions"); // it returns an object...
        }
        public void CatchArgsInOrderBy()
        {
            // This test produces somethign caught in the wild (caused a compile error).
            // The bug has to do with a combination of the First predicate and the CPPCode statement conspiring
            // to cause the problem, unfortunately. So, the test is here.
            var q = new QueriableDummyNoExe<LINQToTTreeLib.ResultOperators.ROFirstLastTest.ntup3>();

            var resultA = from evt in q
                          select new
                          {
                              r1 = evt.run1.Where(r => r > 3).Select(r => LINQToTTreeLib.ResultOperators.ROFirstLastTest.DoItClass.DoIt(r)),
                              r2 = evt.run2.Where(r => r > 4).Select(r => LINQToTTreeLib.ResultOperators.ROFirstLastTest.DoItClass.DoIt(r))
                          };
            var resultB = from e in resultA
                          select new
                          {
                              joinedR = from r1 in e.r1
                                        select (from r2 in e.r2
                                                orderby r1 - r2 ascending
                                                select r2).First()
                          };
            var result = from e in resultB
                         from r in e.joinedR
                         select r;
            var c = result.Sum();

            var qm = DummyQueryExectuor.LastQueryModel;
            var sf = QMFuncFinder.FindQMFunctions(qm);

            Assert.AreEqual(1, sf.Where(f => !f.IsSequence).Count(), "# of non-functions");
            Assert.AreEqual(3, sf.Where(f => f.IsSequence).Count(), "# of sequence functions");
        }
        public void TestGroupByFunction()
        {
            var q = new QueriableDummyNoExe<LINQToTTreeLib.QueryVisitorTest.ntupWithObjectsDest>();

            var r = from evt in q
                    select from v in evt.var1 group v by v;

            var cnt = from evt in r
                      from grp in evt
                      where grp.Key == 2 && grp.Count() > 5
                      select grp.Key;

            var final = cnt.Count();

            var qm = DummyQueryExectuor.LastQueryModel;

            var sf = QMFuncFinder.FindQMFunctions(qm);
            Assert.AreEqual(1, sf.Count(), "# of qm functions");
        }
        /// <summary>
        /// Create a query model that we cna use for tests. We have several possible ones we can create that should be different.
        /// </summary>
        /// <param name="p"></param>
        /// <returns></returns>
        private QueryModel MakeQuery(int queryIndex)
        {
            if (queryIndex == 0)
            {
                var q      = new QueriableDummyNoExe <ntup>();
                var result = from d in q
                             select d;
                var c = result.Count();

                return(DummyQueryExectuor.LastQueryModel);
            }

            if (queryIndex == 1)
            {
                var q      = new QueriableDummyNoExe <ntup>();
                var result = from d in q
                             where d.run > 20
                             select d;
                var c = result.Count();

                return(DummyQueryExectuor.LastQueryModel);
            }

            if (queryIndex == 2)
            {
                var q      = new QueriableDummyNoExe <ntup>();
                var result = from d in q
                             select d.run;
                var r = result.Plot("hi", "there", 20, 0.0, 10.0);
                return(DummyQueryExectuor.LastQueryModel);
            }
            if (queryIndex == 3)
            {
                var q      = new QueriableDummyNoExe <ntup>();
                var result = from d in q
                             select d.run;
                var r = result.Plot("hi", "there", 40, 0.0, 10.0);
                return(DummyQueryExectuor.LastQueryModel);
            }
            if (queryIndex == 4)
            {
                var q      = new QueriableDummyNoExe <ntup>();
                var result = from d in q
                             select d.run;
                var r = result.Plot("hi1", "there is no sppon", 20, 0.0, 10.0);
                return(DummyQueryExectuor.LastQueryModel);
            }

            if (queryIndex == 5)
            {
                var q      = new QueriableDummyNoExe <arrayntup>();
                var result = from d in q
                             from e in d.vals
                             select e;
                var r = result.Count();
                return(DummyQueryExectuor.LastQueryModel);
            }

            if (queryIndex == 6)
            {
                var q      = new QueriableDummyNoExe <arrayntup>();
                var result = from d in q
                             select(d.vals.Count());

                var r = result.Count();
                return(DummyQueryExectuor.LastQueryModel);
            }

            if (queryIndex == 7)
            {
                var q      = new QueriableDummyNoExe <arrayntup>();
                var result = from d in
                             (from s in q select s.vals.Count())
                             select d;
                var r = result.Count();
                return(DummyQueryExectuor.LastQueryModel);
            }

            return(null);
        }
        public void TestQMNoFunctionWithSelect()
        {
            var q = new QueriableDummyNoExe<dummyntup>();
            var evt = from e in q
                      select new
                      {
                          Jets = e.valC1D.Where(i => i > 1),
                          Tracks = e.valC1D.Where(i => i > 1)
                      };
            var r = from e in evt
                    from t in e.Tracks
                    from j in e.Jets
                    where t != j
                    select t;

            var result = r.Count();

            var query = DummyQueryExectuor.LastQueryModel;
            var sf = QMFuncFinder.FindQMFunctions(query);

            Assert.AreEqual(1, sf.Count(), "# of functions");
            Assert.IsTrue(sf.First().IsSequence, "is sequence");
        }