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);
}
