public void TestWhere() { var q = new QueriableDummy<ntup>(); var r = from d in q where d.run > 10 select d; var c = r.Count(); Assert.IsNotNull(DummyQueryExectuor.FinalResult, "Expecting some code to have been generated!"); var res = DummyQueryExectuor.FinalResult; res.DumpCodeToConsole(); /// /// We expect a single top level statement /// Assert.AreEqual(1, res.CodeBody.Statements.Count(), "only single statement expected"); var ifStatement = res.CodeBody.Statements.First() as StatementFilter; Assert.IsNotNull(ifStatement, "if statement isn't an if statement!"); Assert.AreEqual("((*this).run)>10", ifStatement.TestExpression.RawValue, "incorrect if statement"); /// /// Finally, the count statement should be down here! /// Assert.AreEqual(1, ifStatement.Statements.Count(), "expected a single statement inside the if statemenet!"); Assert.IsInstanceOfType(ifStatement.Statements.First(), typeof(StatementAggregate), "incorrect if statement"); }
public void RemoteBashCmdLocalIncludeFile() { // Write out the local include file. The system should pick it up from here. using (var writer = File.CreateText("bogus_function.h")) { writer.WriteLine("int bogus() { return 15; }"); writer.WriteLine(); writer.Close(); } // Run on ints, though for this test it won't matter. var rootFile = TestUtils.CreateFileOfInt(10); // Run the special function. var q = new QueriableDummy <TestNtupe>(); var listing = from evt in q where TTreeQueryExecutorTest.CPPHelperFunctions.ReturnCustomFuncValue() > 10.0 select evt; var dude = listing.Count(); var query = DummyQueryExectuor.LastQueryModel; // Run the execution environment. var exe = new TTreeQueryExecutor(new[] { rootFile.AsRemoteBashUri() }, "dude", typeof(ntuple), typeof(TestNtupe)); exe.CleanupQuery = false; int result = exe.ExecuteScalar <int>(query); Assert.AreEqual(10, result); }
public void TestBasicUniqueCombo() { var q = new QueriableDummy <ntupArray>(); var results = from evt in q select evt.run.UniqueCombinations().Count(); var total = results.Aggregate(0, (seed, val) => seed + val); //var total = results.Count(); Assert.IsNotNull(DummyQueryExectuor.FinalResult, "expecing some code to have been generated"); DummyQueryExectuor.FinalResult.DumpCodeToConsole(); var code = DummyQueryExectuor.FinalResult.CodeBody as IBookingStatementBlock; Assert.AreEqual(1, code.Statements.Count(), "# fo statements"); Assert.AreEqual(1, DummyQueryExectuor.FinalResult.Functions.Count(), "# of functiosn"); code = DummyQueryExectuor.FinalResult.Functions.First().StatementBlock as IBookingStatementBlock; var innerloop = code.Statements.Skip(2).First() as IBookingStatementBlock; Assert.IsNotNull(innerloop, "inner loop"); Assert.AreEqual(1, innerloop.Statements.Count(), "# of statements in the inner loop - the push statement"); var last = code.Statements.Skip(3).First(); Assert.IsInstanceOfType(last, typeof(LINQToTTreeLib.Statements.StatementPairLoop), "last statement incorrect"); var res = DummyQueryExectuor.FinalResult.ResultValue; Assert.IsNotNull(res, "final result"); Assert.AreEqual(typeof(int), res.Type, "final result type"); }
public void TestSubExpressionBuriedArgument() { //// /// This is a regression we found in code. Bummer. There seems to be a problem with /// doing parameter replacement that is a subquery expression. /// var cc = new CodeContext(); /// /// Create the sub query expression that is /// d.PVs => First() - so take the first of an array. /// To create the sub query expression we need a query expression! /// We then thake .nTracks, and that becomes the argubment "v". /// var q = new QueriableDummy <TestSubExpressionBuriedArgumentClass>(); var result = (from d in q select d.PVs.First()).Count(); var qm = DummyQueryExectuor.LastQueryModel; var squery = qm.SelectClause.Selector as SubQueryExpression; var ntracks = Expression.MakeMemberAccess(squery, typeof(TestSubExpressionBuriedArgumentPVClass).GetMember("nTracks").First()); Console.WriteLine("The internal subquery ntrack expression: {0}", ntracks.ToString()); Console.WriteLine("And the query model for the squery expression above is {0}.", squery.QueryModel.ToString()); Assert.Inconclusive(); }
public void TestSimpleLoopCombine() { var q = new QueriableDummy <LocalNtup>(); var dudeQ1 = from evt in q from l in evt.myvectorofint select l; var dude1 = dudeQ1.Count(); var gc1 = DummyQueryExectuor.FinalResult; var dudeQ2 = from evt in q from l in evt.myvectorofint select l; var dude2 = dudeQ2.Count(); var gc2 = DummyQueryExectuor.FinalResult; // Combine them! Assert.IsTrue(gc1.CodeBody.TryCombineStatement(gc2.CodeBody, null), "Unable to do combine!"); gc1.DumpCodeToConsole(); Assert.AreEqual(1, gc1.CodeBody.Statements.Count(), "# of statements at top level"); var booking = gc1.CodeBody.Statements.First() as IBookingStatementBlock; Assert.AreEqual(2, booking.Statements.Count(), "# of statements in inside loop"); }
public void RemoteBashExceptionGeneratedBySTDLIB() { const int numberOfIter = 25; var rootFile = TestUtils.CreateFileOfVectorInt(numberOfIter); // Attempt to access something that is way out beyond the edge. This should cause an exception // in our vector code. var q = new QueriableDummy <TestNtupeArr>(); var dudeQ = from evt in q where (evt.myvectorofint[50] == 0) select evt; var dude = dudeQ.Count(); var query = DummyQueryExectuor.LastQueryModel; DummyQueryExectuor.FinalResult.DumpCodeToConsole(); // Ok, now we can actually see if we can make it "go". try { var exe = new TTreeQueryExecutor(new Uri[] { rootFile.AsRemoteBashUri() }, "dude", typeof(ntuple), typeof(TestNtupeArr)); var result = exe.ExecuteScalar <int>(query); } catch (AggregateException exp) { var exception = exp.UnrollAggregateExceptions(); Console.WriteLine($"Caught error with message: {exception.Message}"); Assert.IsTrue(exception.Message.Contains("Error caught in"), "Error message from running of root"); // We should catch a data processing exception when this occurs. throw exception; } }
public void TestBasicUniqueCombo() { var q = new QueriableDummy<ntupArray>(); var results = from evt in q select evt.run.UniqueCombinations().Count(); var total = results.Aggregate(0, (seed, val) => seed + val); //var total = results.Count(); Assert.IsNotNull(DummyQueryExectuor.FinalResult, "expecing some code to have been generated"); DummyQueryExectuor.FinalResult.DumpCodeToConsole(); var code = DummyQueryExectuor.FinalResult.CodeBody as IBookingStatementBlock; Assert.AreEqual(1, code.Statements.Count(), "# fo statements"); Assert.AreEqual(1, DummyQueryExectuor.FinalResult.Functions.Count(), "# of functiosn"); code = DummyQueryExectuor.FinalResult.Functions.First().StatementBlock as IBookingStatementBlock; var innerloop = code.Statements.Skip(2).First() as IBookingStatementBlock; Assert.IsNotNull(innerloop, "inner loop"); Assert.AreEqual(1, innerloop.Statements.Count(), "# of statements in the inner loop - the push statement"); var last = code.Statements.Skip(3).First(); Assert.IsInstanceOfType(last, typeof(LINQToTTreeLib.Statements.StatementPairLoop), "last statement incorrect"); var res = DummyQueryExectuor.FinalResult.ResultValue; Assert.IsNotNull(res, "final result"); Assert.AreEqual(typeof(int), res.Type, "final result type"); }
public void TestMaxVariableDeclaredCorrectly() { var q = new QueriableDummy <ntup2>(); var result = from evt in q where (from r in evt.run select r).Max() > 10 select evt; var c = result.Count(); Assert.IsNotNull(DummyQueryExectuor.FinalResult, "Expecting some code to have been generated!"); var res = DummyQueryExectuor.FinalResult; res.DumpCodeToConsole(); // // Code body should have the init for the for loop boundary for loop generated by the (fromxxx) up there and the // if statement that tests for > 10. // Assert.AreEqual(1, res.Functions.Count(), "# of functions"); var code = res.Functions.First().StatementBlock; var minmax = code.FindStatement <StatementMinMaxTest>(); Assert.IsNotNull(minmax, "Unable to find the minmax statements"); var mmaxVar = minmax.MaxMinVariable; var declstatement = code.FindDeclarationStatement(mmaxVar); Assert.IsNotNull(declstatement, string.Format("Unable to find where {0} for minmax was declared!", mmaxVar.ToString())); }
public void TTreeWithZeroEntries() { // Test a full round trip for a really simple CSV dump. var rootFile = TestUtils.CreateFileOfInt(10); // Simple query that will return nothing. var q = new QueriableDummy <singleIntNtuple>(); q .Select(e => new customObjectAllValidTypes() { vDouble = (double)e.run, vBool = e.run == 10, vInt = (int)e.run }) .Where(e => false) .AsTTree(outputROOTFile: new FileInfo("allguys.root")); var query = DummyQueryExectuor.LastQueryModel; // Run it. var exe = new TTreeQueryExecutor(new[] { rootFile }, "dude", typeof(ntuple), typeof(singleIntNtuple)); exe.CleanupQuery = false; var result = exe.ExecuteScalar <FileInfo[]>(query); Assert.IsNotNull(result); Assert.AreEqual(1, result.Length); var fout = ROOTNET.NTFile.Open(result[0].FullName, "READ"); var t = fout.Get("DataTree") as NTTree; Assert.IsNotNull(t); Assert.AreEqual(0, t.GetEntries()); }
public void TestSimpleLoopCombine() { var q = new QueriableDummy<LocalNtup>(); var dudeQ1 = from evt in q from l in evt.myvectorofint select l; var dude1 = dudeQ1.Count(); var gc1 = DummyQueryExectuor.FinalResult; var dudeQ2 = from evt in q from l in evt.myvectorofint select l; var dude2 = dudeQ2.Count(); var gc2 = DummyQueryExectuor.FinalResult; // Combine them! Assert.IsTrue(gc1.CodeBody.TryCombineStatement(gc2.CodeBody, null), "Unable to do combine!"); gc1.DumpCodeToConsole(); Assert.AreEqual(1, gc1.CodeBody.Statements.Count(), "# of statements at top level"); var booking = gc1.CodeBody.Statements.First() as IBookingStatementBlock; Assert.AreEqual(2, booking.Statements.Count(), "# of statements in inside loop"); }
public void TestSaveOnlyOneIndex() { var q = new QueriableDummy <SourceType1>(); var objs = from evt in q select from j in evt.jets select new { Value = j.val1 }; var testVeachOne = from evt in objs select evt.First(); var testV = from evt in testVeachOne where evt.Value > 10 select evt; var cnt = testV.Count(); var res = DummyQueryExectuor.FinalResult; res.DumpCodeToConsole(); var l = (res.CodeBody.Statements.First() as IBookingStatementBlock).Statements.First(); var sr = l as StatementRecordValue; Assert.IsNotNull(l, "record value should not be null"); Assert.AreEqual(4, sr.CodeItUp().Count(), "Expecting 3 lines of code."); }
public void TestFirstAndTranslationWithObjects() { var q = new QueriableDummy <ntupWithObjects>(); // Create a dual object. Avoid anonymous objects just for the sake of it. var matched = from evt in q select new TestTranslatedNestedCompareAndSortHolderEvent() { matches = from j in evt.jets orderby j.v3 ascending select new 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 code = DummyQueryExectuor.FinalResult; code.DumpCodeToConsole(); // The current test is: the fact that this didn't crash, means it worked. But // we will do a simple test here. }
public void TestWithSplitExpressionForTranslation() { /// /// Create an agregate result operator from scratch ere... /// var q = new QueriableDummy <transNtup>(); var vals = from evt in q from v in evt.stuff select v; var c = vals.ApplyToObject( new ROOTNET.NTH1F("dude", "put a fork in it", 10, 0.0, 20.0), (h1, n1) => h1.Fill(n1.values)); Assert.IsNotNull(DummyQueryExectuor.FinalResult, "Expecting some code to have been generated!"); var res = DummyQueryExectuor.FinalResult; Assert.AreEqual(res.ResultValue.Type, typeof(ROOTNET.NTH1F), "incorrect result type came back!"); /// /// Get the "Fill" line out /// var filline = (from l in res.CodeBody.CodeItUp() where l.Contains("Fill") select l).FirstOrDefault(); Console.WriteLine("Found line '{0}'", filline); Assert.IsFalse(filline.Contains("stuff"), "The stuff should have been translated away '" + filline + "'"); }
public void TestDeltaR2() { var rootFile = TestUtils.CreateFileOfInt(10); /// /// Generate a proxy .h file that we can use /// var proxyFile = TestUtils.GenerateROOTProxy(rootFile, "dude"); /// /// Get a simple query we can "play" with /// var q = new QueriableDummy<LINQToTTreeLib.TTreeQueryExecutorTest.TestNtupe>(); var listing = from evt in q let tlz = ROOTUtils.CreateTLZ(evt.run * 2.2, 1.0, 0.0) where tlz.DeltaR2(tlz) < 1.0 select evt; var dude = listing.Count(); var query = DummyQueryExectuor.LastQueryModel; /// /// Ok, now we can actually see if we can make it "go". /// ntuple._gProxyFile = proxyFile.FullName; var exe = new TTreeQueryExecutor(new Uri[] { rootFile }, "dude", typeof(ntuple), typeof(LINQToTTreeLib.TTreeQueryExecutorTest.TestNtupe)); int result = exe.ExecuteScalar<int>(query); Assert.AreEqual(10, result); }
public void TestDeltaR2() { var rootFile = TestUtils.CreateFileOfInt(10); /// /// Generate a proxy .h file that we can use /// var proxyFile = TestUtils.GenerateROOTProxy(rootFile, "dude"); /// /// Get a simple query we can "play" with /// var q = new QueriableDummy <LINQToTTreeLib.TTreeQueryExecutorTest.TestNtupe>(); var listing = from evt in q let tlz = ROOTUtils.CreateTLZ(evt.run * 2.2, 1.0, 0.0) where tlz.DeltaR2(tlz) < 1.0 select evt; var dude = listing.Count(); var query = DummyQueryExectuor.LastQueryModel; /// /// Ok, now we can actually see if we can make it "go". /// ntuple._gProxyFile = proxyFile.FullName; var exe = new TTreeQueryExecutor(new Uri[] { rootFile }, "dude", typeof(ntuple), typeof(LINQToTTreeLib.TTreeQueryExecutorTest.TestNtupe)); int result = exe.ExecuteScalar <int>(query); Assert.AreEqual(10, result); }
/// <summary> /// Simple pass-through request /// </summary> private static void ASimpleQuery() { var q = new QueriableDummy <singleIntNtuple>(); q .AsTTree(outputROOTFile: new FileInfo("hi.root")); }
/// <summary> /// Run a simple test that looks for errors and warnings /// </summary> /// <param name="configureMe"></param> private static void RunSimpleTestForErrorsAndWarnings(Action <TTreeQueryExecutor> configureMe) { var rootFile = TestUtils.CreateFileOfInt(20); // Get a simple query we can "play" with var q = new QueriableDummy <TestNtupe>(); var dude = q.Count(); var query = DummyQueryExectuor.LastQueryModel; // Ok, now we can actually see if we can make it "go". var exe = new TTreeQueryExecutor(new[] { rootFile.AsRemoteBashUri() }, "dude", typeof(ntuple), typeof(TestNtupe)); configureMe(exe); // Look for warning or error var errorLines = new List <string>(); CommandLineExecutor.AddLogEndpoint(s => { if (s.ToLower().Contains("warning") || s.ToLower().Contains("error")) { errorLines.Add(s); } }); int result = exe.ExecuteScalar <int>(query); foreach (var l in errorLines) { Console.WriteLine("************ Contains error or warning: " + l); } Assert.AreEqual(0, errorLines.Count, "See std out for list of error liens"); }
public void LocalBashCmdLineSendObjectsToSelector() { var rootFile = TestUtils.CreateFileOfInt(20); // Get a simple query that includes packing over a histogram. // The funny way we do the bin content is to make sure the histogram is accessed // in a query data dependent way - otherwise the system optimizes the histogram access // to the host! var q = new QueriableDummy <TestNtupe>(); var h = new ROOTNET.NTH1F("hi", "there", 1, 0.0, 10.0); h.Directory = null; h.Fill(5, 3.0); GC.WaitForPendingFinalizers(); var dude = q.Select(i => h.GetBinContent(i.run != 1 ? 1 : i.run)).Where(i => i > 2.5).Count(); var query = DummyQueryExectuor.LastQueryModel; // Ok, now we can actually see if we can make it "go". var exe = new TTreeQueryExecutor(new[] { rootFile.AsLocalBashUri() }, "dude", typeof(ntuple), typeof(TestNtupe)); exe.CompileDebug = true; int result = exe.ExecuteScalar <int>(query); Assert.AreEqual(20, result); }
public void LocalBashCmdLineDictifyClasses() { var rootFile = TestUtils.CreateFileOfInt(20); // Load up an extra dictionary ntuple._gClassesToDeclare = new[] { "vector<vector<vector<float>>>" }; ntuple._gClassesToDeclareIncludes = new[] { "vector" }; // Get a simple query we can "play" with var q = new QueriableDummy <TestNtupe>(); var dude = q.Where(r => LocalBashCmdLineDictifyClassesHelpers.DoDictDump() > 0).Count(); var query = DummyQueryExectuor.LastQueryModel; // Ok, now we can actually see if we can make it "go". var exe = new TTreeQueryExecutor(new[] { rootFile.AsLocalBashUri() }, "dude", typeof(ntuple), typeof(TestNtupe)); exe.CleanupQuery = false; bool seenTDataType = false; CommandLineExecutor.AddLogEndpoint(s => { seenTDataType |= s.Contains("TDataType"); Console.WriteLine(s); }); int result = exe.ExecuteScalar <int>(query); Assert.IsTrue(seenTDataType); }
public void TestLinkedQuery() { int numberOfIter = 10; var rootFile = TestUtils.CreateFileOfInt(numberOfIter); var q = new QueriableDummy <TestNtupe>(); var dude1 = q.Count(); var query1 = DummyQueryExectuor.LastQueryModel; var dude2 = q.Where(v => v.run > 20).Count(); var query2 = DummyQueryExectuor.LastQueryModel; var exe = new TTreeQueryExecutor(new Uri[] { rootFile }, "dude", typeof(ntuple), typeof(TestNtupe)); var result1 = exe.ExecuteScalarAsFuture <int>(query1); var result2 = exe.ExecuteScalarAsFuture <int>(query2); Assert.IsFalse(result1.HasValue, "r1 should not have a value yet"); Assert.IsFalse(result2.HasValue, "r2 should not have a value yet"); var r1v = result1.Value; Assert.IsTrue(result1.HasValue, "r1 should have a value"); Assert.IsTrue(result2.HasValue, "r2 should have a value"); Assert.AreEqual(0, result2.Value, "incorrect r2"); Assert.AreEqual(numberOfIter, result1.Value, "incorrect r1"); }
public void TestMaxVariableDeclaredCorrectly() { var q = new QueriableDummy<ntup2>(); var result = from evt in q where (from r in evt.run select r).Max() > 10 select evt; var c = result.Count(); Assert.IsNotNull(DummyQueryExectuor.FinalResult, "Expecting some code to have been generated!"); var res = DummyQueryExectuor.FinalResult; res.DumpCodeToConsole(); // // Code body should have the init for the for loop boundary for loop generated by the (fromxxx) up there and the // if statement that tests for > 10. // Assert.AreEqual(1, res.Functions.Count(), "# of functions"); var code = res.Functions.First().StatementBlock; var minmax = code.FindStatement<StatementMinMaxTest>(); Assert.IsNotNull(minmax, "Unable to find the minmax statements"); var mmaxVar = minmax.MaxMinVariable; var declstatement = code.FindDeclarationStatement(mmaxVar); Assert.IsNotNull(declstatement, string.Format("Unable to find where {0} for minmax was declared!", mmaxVar.ToString())); }
/// <summary> /// Create a query with an anonymous object. /// </summary> private static void QueryTupleAnonyoumsObject() { var q = new QueriableDummy <singleIntNtuple>(); q .Select(e => new { col2 = (int)e.run + 1, col3 = e.run + 2, col1 = e.run }) .AsTTree(outputROOTFile: new FileInfo("hi.root")); }
public void BadObjectMultBy2() { // An end-to-end code test to see if we can generate code to multiply by 2. var q = new QueriableDummy <ntup>(); var mym = new MyBrokenCode(); var i = q.Select(e => mym.MultBy2(e.run)).Where(x => x > 2).Count(); }
/// <summary> /// Create a AsCSV from an anonymous object. /// </summary> private static void QuerySimpleSingleRunWithCustomObject() { var q = new QueriableDummy <singleIntNtuple>(); q .Select(e => new { Col2 = e.run, Col1 = e.run * 2 }) .AsCSV(new FileInfo("hi.csv")); }
/// <summary> /// Generate a simple single run query /// </summary> private static void QuerySimpleSingleRun() { var q = new QueriableDummy <singleIntNtuple>(); q .Select(e => e.run) .AsCSV(new FileInfo("hi.csv"), "firstCol"); }
/// <summary> /// A tuple with two doubles. /// </summary> private static void QueryTupleSevenDoubles() { var q = new QueriableDummy <singleIntNtuple>(); q .Select(e => Tuple.Create(e.run, e.run, e.run, e.run, e.run, e.run, e.run)) .AsCSV(new FileInfo("hi.csv"), "firstCol", "second Col", "col3", "col4", "col5", "col6", "col7"); }
public void TopLevelResultOperatorSkip() { // A query that should come back with 10 items. var q = new QueriableDummy <TestNtupe>(); var dude = q.Take(10).Count(); var query = DummyQueryExectuor.LastQueryModel; Assert.IsTrue(query.HasStatefulOperator()); }
public void PrettyPrintSimpleQuery() { var q = new QueriableDummy<ntup>(); var r = q.Select(rq => rq.run * 2).PrettyPrintQuery(); Console.WriteLine(r); Assert.IsTrue(r.Contains("select")); Assert.IsTrue(r.Contains("[rq].run * 2")); }
public void SelectForJetsAndTake() { // A query that should come back with 10 items. var q = new QueriableDummy <TestNtupeArr>(); var dude = q.SelectMany(e => e.myvectorofint).Take(10).Count(); var query = DummyQueryExectuor.LastQueryModel; Assert.IsTrue(query.HasStatefulOperator()); }
public void SelectForJetsAndTakeForOnlySingleEvent() { // A query that should come back with 10 items. var q = new QueriableDummy <TestNtupeArr>(); var dude = q.Where(e => e.myvectorofint.Take(2).Count() > 2).Count(); var query = DummyQueryExectuor.LastQueryModel; Assert.IsFalse(query.HasStatefulOperator()); }
/// <summary> /// Generate a simple single run query /// </summary> private static void QueryNothingLeft() { var q = new QueriableDummy <singleIntNtuple>(); q .Select(e => e.run) .Where(e => e > 100000000) .AsCSV(new FileInfo("hi.csv"), "firstCol"); }
public void PrettyPrintHideTuples() { var q = new QueriableDummy<ntup>(); var r = q.Select(rq => Tuple.Create(rq.run * 2, 1)).Select(rq => rq.Item1).PrettyPrintQuery(); Console.WriteLine(r); Assert.IsFalse(r.Contains("Tuple")); Assert.IsTrue(r.Contains("[rq].run * 2")); }
public void TestBasicUniqueCombo() { var q = new QueriableDummy<ntupArray>(); var results = from evt in q select evt.run.PairWiseAll((r1, r2) => r1 != r2).Count(); var total = results.Aggregate(0, (seed, val) => seed + val); //var total = results.Count(); Assert.IsNotNull(DummyQueryExectuor.FinalResult, "expecing some code to have been generated"); DummyQueryExectuor.FinalResult.DumpCodeToConsole(); }
/// <summary> /// We forget to initalize a varaible. Use to make sure the system gives a good /// error so the user can figure out what is going on. /// </summary> private static void QueryTupleOurCustomObjectMissingVar() { var q = new QueriableDummy <singleIntNtuple>(); q .Select(e => new ourCustomObject() { col2 = (int)e.run + 1, col3 = e.run + 2 }) .AsTTree(outputROOTFile: new FileInfo("hi.root")); }
/// <summary> /// Generage a query that fills all variable type. /// </summary> private static void QueryTupleAllTypes() { var q = new QueriableDummy <singleIntNtuple>(); q .Select(e => new customObjectAllValidTypes() { vDouble = (double)e.run, vBool = e.run == 10, vInt = (int)e.run }) .AsTTree(outputROOTFile: new FileInfo("allguys.root")); }
/// <summary> /// Reset the leaf names /// </summary> private static void QueryTupleOurCustomObjectCustomLeafNames() { var q = new QueriableDummy <singleIntNtuple>(); q .Select(e => new ourCustomObject() { col1 = e.run, col2 = (int)e.run + 1, col3 = e.run + 2 }) .AsTTree("DataTree", "this is a test", null, "c1", "c2"); }
public void TestSimpleCountReturn() { var q = new QueriableDummy<ntup2>(); var result = q.Count(); Assert.IsNotNull(DummyQueryExectuor.FinalResult, "final result"); var r = DummyQueryExectuor.FinalResult.ResultValue; Assert.AreEqual(typeof(int), r.Type, "result type"); Assert.AreEqual(DeclarableParameter.ExpressionType, r.NodeType, "Expression type incorrect"); var dv = r as DeclarableParameter; Assert.IsTrue(dv.InitialValue == null || dv.InitialValue.RawValue == "0", "Initial value incorrect"); }
public void TestMaxOfSimpleSequence() { /// You can't run a query at the top level /// The reason is techincal: have to add the infrastructure to save a bool var in the /// class instance w/out transfering it back out. Simple, but more work than really /// need right now. var q = new QueriableDummy<ntup>(); var result = from d in q select d.run; var c = result.Max(); }
/// <summary> /// Generate a tree against a byte, a type that we don't currently support. /// </summary> private static void QueryTupleWithBadType() { var q = new QueriableDummy <singleIntNtuple>(); q .Select(e => new customObjectWithByte() { Var1 = (byte)(e.run + 1) }) .AsTTree("DataTree", "not going to happen", null, "c1", "c2"); }
/// <summary> /// Simple query for a customized object. /// </summary> private static void QueryTupleOurCustomObjectTitleAndNameDefaultFile() { var q = new QueriableDummy <singleIntNtuple>(); q .Select(e => new ourCustomObject() { col1 = e.run, col2 = (int)e.run + 1, col3 = e.run + 2 }) .AsTTree("PhysicsTree", "Data that we've written for a physics tree"); }
public void PrettyPrintComplexQueryII() { var q = new QueriableDummy<dummyntup>(); var r = from e in q let rf = (from s in e.valC1D where s > 22 select s * 2).Sum() where rf > 20 select e.run; var sr = r.PrettyPrintQuery(); Console.WriteLine(sr); }
public void TestSimpleLoopAndFilterCombine() { const int numberOfIter = 25; var rootFile = TestUtils.CreateFileOfVectorInt(numberOfIter); /// /// Generate a proxy .h file that we can use /// var proxyFile = TestUtils.GenerateROOTProxy(rootFile, "dude"); /// /// Get a simple query we can "play" with. That this works /// depends on each event having 10 entries in the array, which contains /// the numbers 0-10. /// var q = new QueriableDummy<TestUtils.TestNtupeArr>(); var dudeQ1 = from evt in q where (evt.myvectorofint.Max() > 5) select evt; var dude1 = dudeQ1.Count(); var query1 = DummyQueryExectuor.LastQueryModel; var dudeQ2 = from evt in q where (evt.myvectorofint.Max() > 5) select evt; var dude2 = dudeQ2.Count(); var query2 = DummyQueryExectuor.LastQueryModel; // // Convert to future's // ntuple._gProxyFile = proxyFile.FullName; var exe = new TTreeQueryExecutor(new Uri[] { rootFile }, "dude", typeof(ntuple), typeof(TestUtils.TestNtupeArr)); var q1future = exe.ExecuteScalarAsFuture<int>(query1); var q2future = exe.ExecuteScalarAsFuture<int>(query2); // // Run them! // exe.ExecuteQueuedQueries(); // // And check // Assert.AreEqual(q1future.Value, numberOfIter); Assert.AreEqual(q2future.Value, numberOfIter); }
public void PrettyPrintComplexQueryI() { var q = new QueriableDummy<dummyntup>(); var r = from e in q from s in e.valC1D where s > 22 select s * 2; var sr = r.PrettyPrintQuery(); Console.WriteLine(sr); Assert.AreEqual(4, CountLines(sr)); }
public void TestBasicCount() { var q = new QueriableDummy<ntup>(); var result = from d in q select d; var c = result.Count(); Assert.IsNotNull(DummyQueryExectuor.FinalResult, "Expecting some code to have been generated!"); var res = DummyQueryExectuor.FinalResult; /// Return type is correct Assert.IsNotNull(res.ResultValue, "Expected a result from the count!"); Assert.AreEqual(res.ResultValue.Type, typeof(int), "integer return type expected"); }
public void TestQueryWithTwoRangeVariablesNamedSameThing() { var q = new QueriableDummy<ntup>(); var result1 = from evt in q where evt.run > 5 select evt; var result2 = from evt in result1 where evt.run > 10 select evt; var c = result2.Count(); Assert.IsNotNull(DummyQueryExectuor.FinalResult, "Expecting some code to have been generated!"); DummyQueryExectuor.FinalResult.DumpCodeToConsole(); /// Looking for an infinite loop! }
public void TestPlotFromTemplateWithWeight() { // Create the plot var p = PlottingUtils.MakePlotterSpec<LINQToTTreeLib.TTreeQueryExecutorTest.TestNtupe>(10, 0.0, 10.0, evt => evt.run, "dude", "fork", weight: evt => 0.5); /// /// Get a simple query we can "play" with /// var q = new QueriableDummy<LINQToTTreeLib.TTreeQueryExecutorTest.TestNtupe>(); var r = q.Plot(p, "fork"); DummyQueryExectuor.FinalResult.DumpCodeToConsole(); Assert.IsTrue(DummyQueryExectuor.FinalResult.CodeBody.CodeItUp().Where(l => l.Contains("Fill(((double)(*this).run),0.5*1.0)")).Any(), "no line contains the proper size call!"); }
public void TestResolveSubExpression() { var q = new QueriableDummy<LINQToTTreeLib.QueryVisitorTest.ntupWithObjects>(); var result1 = from evt in q where (from jet in evt.jets where jet.var1 > 1.0 select jet).Count() == 1 select evt; var c = result1.Count(); Assert.IsNotNull(DummyQueryExectuor.FinalResult, "Expecting some code to have been generated!"); DummyQueryExectuor.FinalResult.DumpCodeToConsole(); // Extract the code and count the number of loops. There should be just one for that "where" sub-expression. Assert.AreEqual(1, DummyQueryExectuor.FinalResult.Functions.Count(), "# of functions"); var code = DummyQueryExectuor.FinalResult.Functions.First().StatementBlock.Statements; var loopCount = code.Where(s => s is StatementForLoop).Count(); Assert.AreEqual(1, loopCount, "# of loops incorrect"); }
public void TestSimpleSum() { var q = new QueriableDummy<ntup>(); var s = q.Sum(i => i.run); var result = DummyQueryExectuor.FinalResult; result.DumpCodeToConsole(); // // Look for the assignment operator in the loop // var toplevel = result.CodeBody.Statements; var assign = toplevel.First() as LINQToTTreeLib.Statements.StatementAssign; Assert.IsNotNull(assign, "Assign statement missing"); Assert.IsTrue(assign.Expression.RawValue.Contains("+"), "the plus sign is missing"); }
public void TestSimpleFirst() { var q = new QueriableDummy<ntup2>(); var result = from evt in q where evt.run.First() > 10 select evt; var c = result.Count(); Assert.IsNotNull(DummyQueryExectuor.FinalResult, "Expecting some code to have been generated!"); var query = DummyQueryExectuor.FinalResult; query.DumpCodeToConsole(); Assert.AreEqual(1, query.CodeBody.Statements.Count(), "# of statements in the code body"); Assert.AreEqual(1, query.Functions.Count(), "# of functions"); var code = query.Functions.First().StatementBlock; Assert.IsInstanceOfType(code.Statements.Skip(2).First(), typeof(Statements.StatementForLoop), "Expecting a for loop as the first statement"); Assert.IsInstanceOfType(code.Statements.Skip(3).First(), typeof(Statements.StatementThrowIfTrue), "Expecting a filter statement next from the First statement"); }
public void TestNestedQuery() { var q = new QueriableDummy<ntup>(); var result = from d in q from m in d.other select d; var c = result.Count(); Assert.IsNotNull(DummyQueryExectuor.FinalResult, "Expecting some code to have been generated!"); /// Return type is correct Assert.IsNotNull(DummyQueryExectuor.FinalResult.ResultValue, "Expected a result from the count!"); Assert.AreEqual(DummyQueryExectuor.FinalResult.ResultValue.Type, typeof(int), "integer return type expected"); var res = DummyQueryExectuor.FinalResult; /// /// We should be booking "d" as a variable that hangs out for a while at the top level /// Assert.AreEqual(0, res.CodeBody.DeclaredVariables.Count(), "Don't need to book any variables for this"); /// /// Now, take a lok at the statements and make sure that we see them all correctly. This first guy should be the /// loop statement over the d.other guys. /// Assert.AreEqual(1, res.CodeBody.Statements.Count(), "Expected a single statement"); Assert.IsInstanceOfType(res.CodeBody.Statements.First(), typeof(IBookingStatementBlock), "loop missing!"); var loop = res.CodeBody.Statements.First() as IBookingStatementBlock; var firstLine = loop.CodeItUp().First(); /// /// And below that should be one statement that does the incrementing /// Assert.AreEqual(1, loop.Statements.Count(), "incorrect # of statements"); var statement = loop.Statements.First(); Assert.IsInstanceOfType(statement, typeof(StatementAggregate), "count should be incrementing an integer!"); }
public void TestSingleTopLevelQuery() { var q = new QueriableDummy<ntup>(); var result = from d in q select d; var c = result.Count(); Assert.IsNotNull(DummyQueryExectuor.FinalResult, "Expecting some code to have been generated!"); /// Return type is correct Assert.IsNotNull(DummyQueryExectuor.FinalResult.ResultValue, "Expected a result from the count!"); Assert.AreEqual(DummyQueryExectuor.FinalResult.ResultValue.Type, typeof(int), "integer return type expected"); var res = DummyQueryExectuor.FinalResult; /// /// Now, take a lok at the statements and make sure that we see them all correctly. /// Assert.AreEqual(1, res.CodeBody.Statements.Count(), "incorrect # of statements"); var statement = res.CodeBody.Statements.First(); Assert.IsInstanceOfType(statement, typeof(StatementAggregate), "count should be incrementing an integer!"); Assert.AreEqual(DummyQueryExectuor.FinalResult.ResultValue, (statement as StatementAggregate).ResultVariable, "The variable should match"); }
public void TestSubExpressionBuriedArgument() { //// /// This is a regression we found in code. Bummer. There seems to be a problem with /// doing parameter replacement that is a subquery expression. /// var cc = new CodeContext(); /// /// Create the sub query expression that is /// d.PVs => First() - so take the first of an array. /// To create the sub query expression we need a query expression! /// We then thake .nTracks, and that becomes the argubment "v". /// var q = new QueriableDummy<TestSubExpressionBuriedArgumentClass>(); var result = (from d in q select d.PVs.First()).Count(); var qm = DummyQueryExectuor.LastQueryModel; var squery = qm.SelectClause.Selector as SubQueryExpression; var ntracks = Expression.MakeMemberAccess(squery, typeof(TestSubExpressionBuriedArgumentPVClass).GetMember("nTracks").First()); Console.WriteLine("The internal subquery ntrack expression: {0}", ntracks.ToString()); Console.WriteLine("And the query model for the squery expression above is {0}.", squery.QueryModel.ToString()); Assert.Inconclusive(); }
public void TestBasicUniqueComboCheckItemAccess() { var q = new QueriableDummy<ntupArray>(); var combos = from evt in q select (from cmb in evt.run.PairWiseAll((r1, r2) => r1 != r2) select cmb).Aggregate(0, (seed, val) => seed + val); var arg = combos.Aggregate(0, (seed, val) => seed + val); Assert.IsNotNull(DummyQueryExectuor.FinalResult, "expecing some code to have been generated"); DummyQueryExectuor.FinalResult.DumpCodeToConsole(); var res = DummyQueryExectuor.FinalResult.ResultValue; Assert.IsNotNull(res, "final result"); Assert.AreEqual(typeof(int), res.Type, "final result type"); }
public void TestScope() { // Make sure that if anything funky needs to be done outside our loop, // it gets declared correctly. var q = new QueriableDummy<ntupArray>(); var results = from evt in q select evt.run.PairWiseAll((r1, r2) => CPPHelperFunctions.Calc(r1) != r2).Count(); var total = results.Aggregate(0, (seed, val) => seed + val); DummyQueryExectuor.FinalResult.DumpCodeToConsole(); // // The *2 should be burried in the loop. However, we've seen it popped up to the top // in a bug. So test for that regression. // var seen2 = DummyQueryExectuor.FinalResult.CodeBody.Statements.Where(s => s is StatementSimpleStatement).Cast<StatementSimpleStatement>().Where(s => s.ToString().Contains("]*2")).Any(); Assert.IsFalse(seen2, "Saw a ']*2' in a top level code statement!"); }
public void TestAnonDirectCompareObjects() { var q = new QueriableDummy<ntupArray>(); var anon = from evt in q select (from r in evt.run select new { Value = r }); var results = from evt in anon select evt.PairWiseAll((r1, r2) => r1 != r2).Count(); var tot = results.Aggregate(0, (seed, val) => seed + val); DummyQueryExectuor.FinalResult.DumpCodeToConsole(); }
public void TestTakeSkipLevelBurreidWith2Tests() { var q = new QueriableDummy<dummyntup>(); var c = q.SelectMany(x => x.valC1D).Where(x => x > 10).Where(x => x < 20).Take(5).Count(); Assert.IsNotNull(DummyQueryExectuor.FinalResult, "Expecting some code to have been generated!"); var res = DummyQueryExectuor.FinalResult; res.DumpCodeToConsole(); Assert.AreEqual(1, res.DumpCode().Where(l => l.Contains("static int")).Count()); }
public void TestTakeSkipLevelInFromExpression() { var q = new QueriableDummy<dummyntup>(); var c1 = from evt in q.Where(x => x.run > 10).Take(5).SelectMany(x => x.valC1D) where evt > 50 select evt; var c = c1.Count(); Assert.IsNotNull(DummyQueryExectuor.FinalResult, "Expecting some code to have been generated!"); var res = DummyQueryExectuor.FinalResult; Console.WriteLine(DummyQueryExectuor.LastQueryModel.ToString()); res.DumpCodeToConsole(); Assert.AreEqual(1, res.DumpCode().Where(l => l.Contains("static int")).Count()); }
public void TestTakeSkipLevelBurreidTwice() { var q = new QueriableDummy<dummyntup>(); var c = q.Where(x => x.run > 10).Select(x => Tuple.Create(x.run, x.vals)).Select(x => x.Item2).SelectMany(x => x).Select(x => x + 1).Where(x => x > 10).Where(x => x > 5).Take(5).Count(); Assert.IsNotNull(DummyQueryExectuor.FinalResult, "Expecting some code to have been generated!"); var res = DummyQueryExectuor.FinalResult; res.DumpCodeToConsole(); Assert.AreEqual(1, res.DumpCode().Where(l => l.Contains("static int")).Count()); }
public void TestTakeSkipAtSubLevel() { /// /// The below is invalid because the "Take" is at the top level - we are taking only a certain /// number of events. That is not legal! So we need to throw when that happens! /// var q = new QueriableDummy<dummyntup>(); var result = from d in q where d.valC1D.Take(1).Sum() > 0 select d; var c = result.Count(); Assert.IsNotNull(DummyQueryExectuor.FinalResult, "Expecting some code to have been generated!"); var res = DummyQueryExectuor.FinalResult; res.DumpCodeToConsole(); Assert.AreEqual(0, res.DumpCode().Where(l => l.Contains("static")).Count()); }
public void CacheObjectWhenCPPChanges() { TestUtils.ResetLINQLibrary(); // Make sure that when the C++ code changes, the cache key for lookup of results will also change. var q = new QueriableDummy<ntup>(); var i = q.Select(e => DoItClass.DoIt(e.run)).Where(x => x > 2).Count(); var query = DummyQueryExectuor.LastQueryModel; // Look for a hash value. var str1 = FormattingQueryVisitor.Format(query); Console.WriteLine(str1); var m = Regex.Match(str1, @"DoIt([^\(]+)"); Assert.IsTrue(m.Success); }