public void CheckArrayReturnType() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var param = Expression.Parameter(typeof(int), "p"); var expr = Expression.Call(typeof(DoItClass).GetMethod("DoIt"), param); var result = target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); Assert.IsNotNull(result, "result!"); var vname = result.RawValue; Assert.AreEqual(1, gc.CodeBody.Statements.Count(), "# of statements that came back"); var st1 = gc.CodeBody.Statements.First() as IStatement; var expected = new StringBuilder(); expected.AppendFormat("{0} = p*2;", vname); Assert.AreEqual(expected.ToString(), st1.CodeItUp().First(), "statement line incorrect"); Assert.AreEqual(1, gc.IncludeFiles.Count(), "# of include files"); Assert.AreEqual("TLorentzVector.h", gc.IncludeFiles.First(), "include file name"); }
public void CPPRenameVariables() { // two identical expressions var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt_1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_eta = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_phi = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_E = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); // Create call var e1 = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZBE"), p_pt_1, p_eta, p_phi, p_E); var e1Value = target.CodeMethodCall(e1, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); // Now, extract the main statement. Assert.AreEqual(1, gc.CodeBody.Statements.Count(), "# of statements"); var s1 = gc.CodeBody.Statements.First() as IStatement; // Make sure the variable is there and then isn't. var p_pt_2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); Assert.IsTrue(gc.DumpCode().Where(l => l.Contains(p_pt_1.RawValue)).Any(), "the pt variable should be there."); Assert.IsFalse(gc.DumpCode().Where(l => l.Contains(p_pt_2.RawValue)).Any(), "the pt variable should be there."); s1.RenameVariable(p_pt_1.RawValue, p_pt_2.RawValue); Assert.IsFalse(gc.DumpCode().Where(l => l.Contains(p_pt_1.RawValue)).Any(), "the pt variable should be there."); Assert.IsTrue(gc.DumpCode().Where(l => l.Contains(p_pt_2.RawValue)).Any(), "the pt variable should be there."); }
public void TestCMVariables() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_eta = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_phi = p_pt; var p_E = p_eta; var expr = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZ"), p_pt, p_eta, p_phi, p_E); var r = target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); var ccpstatement = gc.CodeBody.Statements.First(); Assert.IsNotNull(ccpstatement); var cmInfo = ccpstatement as ICMStatementInfo; Assert.IsNotNull(cmInfo); Assert.AreEqual(1, cmInfo.ResultVariables.Count(), "# of result variables"); Assert.AreEqual(r.RawValue, cmInfo.ResultVariables.First(), "Result variable name"); Assert.AreEqual(2, cmInfo.DependentVariables.Count(), "# of dependent variables"); Assert.IsTrue(cmInfo.DependentVariables.Contains(p_pt.RawValue), "doesn't have pt"); Assert.IsTrue(cmInfo.DependentVariables.Contains(p_eta.RawValue), "Doesn't have eta"); }
public void CPPNotIdentical() { // two identical expressions var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_eta = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_phi = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_E = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); // Create two identical calls var e1 = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZBE"), p_pt, p_eta, p_phi, p_E); var e1Value = target.CodeMethodCall(e1, gc, MEFUtilities.MEFContainer); var c2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var e2 = Expression.Call(typeof(DoItClass).GetMethod("DoIt"), c2); var e2Value = target.CodeMethodCall(e2, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); // Now, extract the two main statements. Assert.AreEqual(2, gc.CodeBody.Statements.Count(), "# of statements"); var s1 = gc.CodeBody.Statements.First() as ICMStatementInfo; var s2 = gc.CodeBody.Statements.Skip(1).First() as ICMStatementInfo; // Now, see if we can do the requirement. var r = s1.RequiredForEquivalence(s2); Assert.IsFalse(r.Item1, "We should be able to do the translation"); }
public void TestSimpleAddition() { MEFUtilities.Compose(new TypeHandlers.TypeHandlerCache()); AggregateFromSeedResultOperator agg = new AggregateFromSeedResultOperator(Expression.Constant(1), Expression.Lambda(Expression.MakeBinary(ExpressionType.Add, Expression.Parameter(typeof(int), "count"), Expression.Constant(1)), Expression.Parameter(typeof(int), "count")), null); ROAggregate processor = new ROAggregate(); GeneratedCode gc = new GeneratedCode(); var result = ProcessResultOperator(processor, agg, null, gc); Assert.AreEqual(typeof(int), result.Type, "Expected the type to be an integer!"); Assert.IsInstanceOfType(result, typeof(DeclarableParameter), "Expected a var simple!"); var vs = result as DeclarableParameter; Assert.AreEqual("1", vs.InitialValue.RawValue, "Incorrect seed value"); /// /// Now make sure the statements came back ok! /// gc.DumpCodeToConsole(); Assert.AreEqual(0, gc.CodeBody.DeclaredVariables.Count(), "Expected no bookings"); Assert.AreEqual(1, gc.CodeBody.Statements.Count(), "expected a statement!"); Assert.IsInstanceOfType(gc.CodeBody.Statements.First(), typeof(Statements.StatementAggregate), "expected an assignment statement!"); var ass = gc.CodeBody.Statements.First() as Statements.StatementAggregate; StringBuilder bld = new StringBuilder(); bld.AppendFormat("{0}+1", ass.ResultVariable.ParameterName); Assert.AreEqual(bld.ToString(), ass.Expression.RawValue, "the raw value of hte expression is not right"); }
public void TestBasicProcessNew() { /// Test a very simple process new var createTLZ = Expression.New(typeof(ROOTNET.NTLorentzVector).GetConstructor(new Type[0])); var target = new TypeHandlerROOT(); IValue resultOfCall; var gc = new GeneratedCode(); var expr = target.ProcessNew(createTLZ, out resultOfCall, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); Assert.AreEqual(createTLZ.ToString(), expr.ToString(), "Returned expression"); Assert.AreEqual(2, gc.CodeBody.Statements.Count(), "# of coded statements"); var s1 = gc.CodeBody.Statements.First(); var s2 = gc.CodeBody.Statements.Skip(1).First(); Assert.IsInstanceOfType(s1, typeof(Statements.StatementSimpleStatement), "s1 type"); Assert.IsInstanceOfType(s2, typeof(Statements.StatementSimpleStatement), "s1 type"); var s1s = s1 as Statements.StatementSimpleStatement; var s2s = s2 as Statements.StatementSimpleStatement; Assert.IsTrue(s1s.Line.Contains("TLorentzVector"), "first line is not that good"); Assert.IsTrue(s2s.Line.Contains("TLorentzVector *"), "second line is not that good"); }
public void CPPTryCombineNotSame() { // two identical expressions var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt_1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_eta = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_phi = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_E = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); // Create two identical calls var e1 = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZBE"), p_pt_1, p_eta, p_phi, p_E); var e1Value = target.CodeMethodCall(e1, gc, MEFUtilities.MEFContainer); var p_pt_2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var e2 = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZBE"), p_pt_2, p_eta, p_phi, p_E); var e2Value = target.CodeMethodCall(e2, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); // Now, extract the two main statements. Assert.AreEqual(2, gc.CodeBody.Statements.Count(), "# of statements"); var s1 = gc.CodeBody.Statements.First() as IStatement; var s2 = gc.CodeBody.Statements.Skip(1).First() as IStatement; // Now, try-combine should just "work", as it were. var opt = new OptTest(); var r = s1.TryCombineStatement(s2, opt); Assert.IsFalse(r); }
public void TestSimpleCodeAddon() { // See problems referencing return variables var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var param = Expression.Parameter(typeof(int), "p"); var expr = Expression.Call(typeof(DoItClass).GetMethod("DoItWithArray"), param); var result = target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); Assert.AreEqual(typeof(float[]), result.Type); }
/// <summary> /// Do the work of executing the array parse /// </summary> /// <param name="e"></param> private static GeneratedCode ExecuteArrayParseOnExpression(Expression e) { var gc = new GeneratedCode(); var cc = new CodeContext(); IQuerySource s = new DummyQueryReference() { ItemName = "q", ItemType = typeof(int) }; var r = ArrayExpressionParser.ParseArrayExpression(s, e, gc, cc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); Assert.IsNotNull(cc.LoopVariable, "loop variable"); return(gc); }
public void TestQueueTwice() { var t = new TypeHandlerROOT(); var origRootObj = new ROOTNET.NTH1F("hi", "there", 10, 10.0, 20.0); var rootObj = Expression.Constant(origRootObj); var gc = new GeneratedCode(); var result1 = t.ProcessConstantReference(rootObj, gc, MEFUtilities.MEFContainer); var result2 = t.ProcessConstantReference(rootObj, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); Assert.AreEqual(1, gc.VariablesToTransfer.Count(), "Variables to transfer"); Assert.AreEqual(result1.RawValue, result2.RawValue, "Expected the same raw value for the same object in the same expression"); }
public void RenameCPPResultVariable() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var param = Expression.Parameter(typeof(int), "p"); var paramplus = Expression.MakeBinary(ExpressionType.Add, param, Expression.Constant(1)); var expr = Expression.Call(typeof(DoItClass).GetMethod("DoIt"), paramplus); var result = target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.CodeBody.RenameVariable(result.RawValue, "abogus_1234"); gc.DumpCodeToConsole(); Assert.IsTrue(gc.DumpCode().Where(s => s.Contains("int abogus_1234")).Any(), "Didn't find the variable name in the code"); }
public void TestScopingBlock() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt = Expression.Parameter(typeof(double), "ptParam"); var p_eta = Expression.Parameter(typeof(double), "etaParam"); var p_phi = Expression.Parameter(typeof(double), "phiParam"); var p_E = Expression.Parameter(typeof(double), "EParam"); var expr = Expression.Call(typeof(TLZHelper).GetMethod("TestIF"), p_pt, p_eta, p_phi, p_E); target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); var ifstatement = gc.CodeBody.Statements.First().CodeItUp().First(); Assert.IsFalse(ifstatement.EndsWith(";"), string.Format("Line '{0}' ends with a semicolon", ifstatement)); }
public void TestReturnVariableDecl() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt = Expression.Parameter(typeof(double), "ptParam"); var p_eta = Expression.Parameter(typeof(double), "etaParam"); var p_phi = Expression.Parameter(typeof(double), "phiParam"); var p_E = Expression.Parameter(typeof(double), "EParam"); var expr = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZ"), p_pt, p_eta, p_phi, p_E); target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); var declStatement = gc.CodeBody.DeclaredVariables.ToArray(); Assert.AreEqual(1, declStatement.Length); }
public void TestComplexArgumentReplacement() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt = Expression.Parameter(typeof(double), "ptParam"); var p_eta = Expression.Parameter(typeof(double), "etaParam"); var p_phi = Expression.Parameter(typeof(double), "phiParam"); var p_E = Expression.Parameter(typeof(double), "EParam"); var expr = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZ"), p_pt, p_eta, p_phi, p_E); target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); Assert.AreEqual(1, gc.CodeBody.Statements.Count(), "# of statements total"); var setStatement = gc.CodeBody.Statements.First().CodeItUp().Skip(1).First(); Assert.IsNotNull(setStatement, "Bad type for 3rd statement"); Assert.IsTrue(setStatement.Contains("SetPtEtaPhiE(ptParam, etaParam, phiParam, EParam)"), string.Format("Line '{0}' doesn't have correct set statement.", setStatement)); }
public void TestArgReplacementAtStartAndEnd() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt = Expression.Parameter(typeof(double), "ptParam"); var p_eta = Expression.Parameter(typeof(double), "etaParam"); var p_phi = Expression.Parameter(typeof(double), "phiParam"); var p_E = Expression.Parameter(typeof(double), "EParam"); var expr = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZBE"), p_pt, p_eta, p_phi, p_E); target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); Assert.AreEqual(1, gc.CodeBody.Statements.Count(), "# of statements total"); var atEnding = gc.CodeBody.Statements.First().CodeItUp().Skip(1).FirstOrDefault(); Assert.IsNotNull(atEnding, "Bad type for 3rd statement"); Assert.IsTrue(atEnding.EndsWith("ptParam"), string.Format("Line '{0}' doesn't ends with parameter replacement", atEnding)); }
public void RenameCPPInputVariableVariable() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var param = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var paramplus = Expression.MakeBinary(ExpressionType.Add, param, Expression.Constant(1)); var expr = Expression.Call(typeof(DoItClass).GetMethod("DoIt"), paramplus); var result = target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); // Check the dependents. gc.CodeBody.RenameVariable(param.RawValue, "abogus_1234"); gc.DumpCodeToConsole(); var st = gc.CodeBody.Statements.First() as ICMStatementInfo; Assert.AreEqual(1, st.DependentVariables.Count(), "# of dependents"); Assert.AreEqual("abogus_1234", st.DependentVariables.First()); }
public void TestForUniqueReplacement() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt = Expression.Parameter(typeof(double), "ptParam"); var p_eta = Expression.Parameter(typeof(double), "etaParam"); var p_phi = Expression.Parameter(typeof(double), "phiParam"); var p_E = Expression.Parameter(typeof(double), "EParam"); var expr = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZ"), p_pt, p_eta, p_phi, p_E); target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); var declStatement = gc.CodeBody.Statements.First().CodeItUp().Skip(1).First(); var setStatement = gc.CodeBody.Statements.First().CodeItUp().Skip(2).First(); Assert.IsFalse(declStatement.Contains("Unique"), string.Format("Line '{0}' contains a reference to a unique variable", declStatement)); Assert.IsFalse(setStatement.Contains("Unique"), string.Format("Line '{0}' contains a reference to a unique variable", setStatement)); }
public void TestSimpleTimesTwo() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var param = Expression.Parameter(typeof(int), "p"); var paramplus = Expression.MakeBinary(ExpressionType.Add, param, Expression.Constant(1)); var expr = Expression.Call(typeof(DoItClass).GetMethod("DoIt"), paramplus); var result = target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); var vname = result.RawValue; var st2 = gc.CodeBody.Statements.First().CodeItUp().First(); var expected = new StringBuilder(); expected.AppendFormat("{0} = (p+1)*2;", vname); Assert.AreEqual(expected.ToString(), st2, "statement line incorrect"); }
public void TestTwoUniqueReplacements() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt = Expression.Parameter(typeof(double), "ptParam"); var p_eta = Expression.Parameter(typeof(double), "etaParam"); var p_phi = Expression.Parameter(typeof(double), "phiParam"); var p_E = Expression.Parameter(typeof(double), "EParam"); var expr = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZUniqueTest"), p_pt, p_eta, p_phi, p_E); target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); foreach (var line in gc.CodeBody.Statements.First().CodeItUp()) { Assert.IsNotNull(line, "bad statement type"); Assert.IsFalse(line.Contains("Unique"), string.Format("Line '{0}' contains a reference to a unique variable", line)); } }
public void CPPNeedSomeReplacements() { // two identical expressions var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt_1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_eta_1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_phi_1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_E_1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); // Create first call var e1 = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZBE"), p_pt_1, p_eta_1, p_phi_1, p_E_1); var e1Value = target.CodeMethodCall(e1, gc, MEFUtilities.MEFContainer); var p_pt_2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_eta_2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_phi_2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_E_2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var e2 = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZBE"), p_pt_2, p_eta_2, p_phi_2, p_E_2); var e2Value = target.CodeMethodCall(e2, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); // Now, extract the two main statements. Assert.AreEqual(2, gc.CodeBody.Statements.Count(), "# of statements"); var s1 = gc.CodeBody.Statements.First() as ICMStatementInfo; var s2 = gc.CodeBody.Statements.Skip(1).First() as ICMStatementInfo; // Now, see if we can do the requirement. var renames = new Tuple <string, string>[] { new Tuple <string, string>(p_pt_2.RawValue, p_pt_1.RawValue), new Tuple <string, string>(p_eta_2.RawValue, p_eta_1.RawValue) }; var r = s1.RequiredForEquivalence(s2, renames); Assert.IsTrue(r.Item1, "We should be able to do the translation"); Assert.AreEqual(3, r.Item2.Count(), "# of variable translations required"); }
public void CodeAddonWithStringArgument() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var param = Expression.Parameter(typeof(string), "p"); var expr = Expression.Call(typeof(DoItClass).GetMethod("DoItWithAString"), param); var result = target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); Assert.IsNotNull(result, "result!"); var vname = result.RawValue; Assert.AreEqual(1, gc.CodeBody.Statements.Count(), "# of statements that came back"); var st1 = gc.CodeBody.Statements.First() as IStatement; var expected = new StringBuilder(); expected.AppendFormat("{0} = strlen(p);", vname); Assert.AreEqual(expected.ToString(), st1.CodeItUp().First(), "statement line incorrect"); }
public void TestSimpleCodeAddon() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var param = Expression.Parameter(typeof(int), "p"); var expr = Expression.Call(typeof(DoItClass).GetMethod("DoIt"), param); var result = target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); Assert.IsNotNull(result, "result!"); var vname = result.RawValue; Assert.AreEqual(1, gc.CodeBody.Statements.Count(), "# of statements that came back"); var st1 = gc.CodeBody.Statements.First() as IStatement; var expected = new StringBuilder(); expected.AppendFormat("{0} = p*2;", vname); Assert.AreEqual(expected.ToString(), st1.CodeItUp().First(), "statement line incorrect"); Assert.AreEqual(1, gc.IncludeFiles.Count(), "# of include files"); Assert.AreEqual("TLorentzVector.h", gc.IncludeFiles.First(), "include file name"); }
public void CPPRenameVariables() { // two identical expressions var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt_1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_eta = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_phi = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_E = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); // Create call var e1 = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZBE"), p_pt_1, p_eta, p_phi, p_E); var e1Value = target.CodeMethodCall(e1, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); // Now, extract the main statement. Assert.AreEqual(1, gc.CodeBody.Statements.Count(), "# of statements"); var s1 = gc.CodeBody.Statements.First() as IStatement; // Make sure the variable is there and then isn't. var p_pt_2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); Assert.IsTrue(gc.DumpCode().Where(l => l.Contains(p_pt_1.RawValue)).Any(), "the pt variable should be there."); Assert.IsFalse(gc.DumpCode().Where(l => l.Contains(p_pt_2.RawValue)).Any(), "the pt variable should be there."); s1.RenameVariable(p_pt_1.RawValue, p_pt_2.RawValue); Assert.IsFalse(gc.DumpCode().Where(l => l.Contains(p_pt_1.RawValue)).Any(), "the pt variable should be there."); Assert.IsTrue(gc.DumpCode().Where(l => l.Contains(p_pt_2.RawValue)).Any(), "the pt variable should be there."); }
public void CPPTryCombineNotSame() { // two identical expressions var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt_1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_eta = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_phi = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_E = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); // Create two identical calls var e1 = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZBE"), p_pt_1, p_eta, p_phi, p_E); var e1Value = target.CodeMethodCall(e1, gc, MEFUtilities.MEFContainer); var p_pt_2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var e2 = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZBE"), p_pt_2, p_eta, p_phi, p_E); var e2Value = target.CodeMethodCall(e2, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); // Now, extract the two main statements. Assert.AreEqual(2, gc.CodeBody.Statements.Count(), "# of statements"); var s1 = gc.CodeBody.Statements.First() as IStatement; var s2 = gc.CodeBody.Statements.Skip(1).First() as IStatement; // Now, try-combine should just "work", as it were. var opt = new OptTest(); var r = s1.TryCombineStatement(s2, opt); Assert.IsFalse(r); }
public void CPPNeedSomeReplacements() { // two identical expressions var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt_1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_eta_1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_phi_1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_E_1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); // Create first call var e1 = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZBE"), p_pt_1, p_eta_1, p_phi_1, p_E_1); var e1Value = target.CodeMethodCall(e1, gc, MEFUtilities.MEFContainer); var p_pt_2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_eta_2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_phi_2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_E_2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var e2 = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZBE"), p_pt_2, p_eta_2, p_phi_2, p_E_2); var e2Value = target.CodeMethodCall(e2, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); // Now, extract the two main statements. Assert.AreEqual(2, gc.CodeBody.Statements.Count(), "# of statements"); var s1 = gc.CodeBody.Statements.First() as ICMStatementInfo; var s2 = gc.CodeBody.Statements.Skip(1).First() as ICMStatementInfo; // Now, see if we can do the requirement. var renames = new Tuple<string, string>[] { new Tuple<string, string>(p_pt_2.RawValue, p_pt_1.RawValue), new Tuple<string, string>(p_eta_2.RawValue, p_eta_1.RawValue) }; var r = s1.RequiredForEquivalence(s2, renames); Assert.IsTrue(r.Item1, "We should be able to do the translation"); Assert.AreEqual(3, r.Item2.Count(), "# of variable translations required"); }
public void NoLiftAlmostIdenticalLoopOutOfIfStatement() { var gc = new GeneratedCode(); var c1 = AddLoop(gc); gc.Pop(); AddIf(gc); var c2 = AddLoop(gc, addDependentStatement: true); gc.Pop(); AddSum(gc, c1, c2); Console.WriteLine("Before lifting and optimization: "); gc.DumpCodeToConsole(); StatementLifter.Optimize(gc); Console.WriteLine("After lifting and optimization: "); gc.DumpCodeToConsole(); // Now check that things happened as we would expect them to happen. Assert.AreEqual(1, gc.CodeBody.Statements.Where(s => s is StatementForLoop).Count(), "# of for loops at outer level"); Assert.AreEqual(1, gc.CodeBody.Statements.Where(s => s is StatementForLoop).Cast<StatementForLoop>().Where(s => s.Statements.Count() == 1).Count(), "# of statements inside first for loop"); var ifStatement = gc.CodeBody.Statements.Where(s => s is StatementFilter).Cast<StatementFilter>().First(); Assert.IsNotNull(ifStatement, "Finding if statement"); Assert.AreEqual(2, ifStatement.Statements.Count(), "# of statements inside the if statement"); }
public void TestSimpleTimesTwo() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var param = Expression.Parameter(typeof(int), "p"); var paramplus = Expression.MakeBinary(ExpressionType.Add, param, Expression.Constant(1)); var expr = Expression.Call(typeof(DoItClass).GetMethod("DoIt"), paramplus); var result = target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); var vname = result.RawValue; var st2 = gc.CodeBody.Statements.First().CodeItUp().First(); var expected = new StringBuilder(); expected.AppendFormat("{0} = (p+1)*2;", vname); Assert.AreEqual(expected.ToString(), st2, "statement line incorrect"); }
public void DontCombineDependentLoops() { var gc = new GeneratedCode(); var c1 = AddLoop(gc); gc.Pop(); var c2 = AddLoop(gc, useCounter: c1); gc.Pop(); Console.WriteLine("Before lifting"); gc.DumpCodeToConsole(); StatementLifter.Optimize(gc); Console.WriteLine("After lifting"); gc.DumpCodeToConsole(); Assert.AreEqual(2, gc.CodeBody.Statements.Where(s => s is StatementForLoop).Count(), "# of for loops"); }
public void TestTwoUniqueReplacements() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt = Expression.Parameter(typeof(double), "ptParam"); var p_eta = Expression.Parameter(typeof(double), "etaParam"); var p_phi = Expression.Parameter(typeof(double), "phiParam"); var p_E = Expression.Parameter(typeof(double), "EParam"); var expr = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZUniqueTest"), p_pt, p_eta, p_phi, p_E); target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); foreach (var line in gc.CodeBody.Statements.First().CodeItUp()) { Assert.IsNotNull(line, "bad statement type"); Assert.IsFalse(line.Contains("Unique"), string.Format("Line '{0}' contains a reference to a unique variable", line)); } }
public void TestReturnVariableDecl() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt = Expression.Parameter(typeof(double), "ptParam"); var p_eta = Expression.Parameter(typeof(double), "etaParam"); var p_phi = Expression.Parameter(typeof(double), "phiParam"); var p_E = Expression.Parameter(typeof(double), "EParam"); var expr = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZ"), p_pt, p_eta, p_phi, p_E); target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); var declStatement = gc.CodeBody.DeclaredVariables.ToArray(); Assert.AreEqual(1, declStatement.Length); }
public void TestForUniqueReplacement() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt = Expression.Parameter(typeof(double), "ptParam"); var p_eta = Expression.Parameter(typeof(double), "etaParam"); var p_phi = Expression.Parameter(typeof(double), "phiParam"); var p_E = Expression.Parameter(typeof(double), "EParam"); var expr = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZ"), p_pt, p_eta, p_phi, p_E); target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); var declStatement = gc.CodeBody.Statements.First().CodeItUp().Skip(1).First(); var setStatement = gc.CodeBody.Statements.First().CodeItUp().Skip(2).First(); Assert.IsFalse(declStatement.Contains("Unique"), string.Format("Line '{0}' contains a reference to a unique variable", declStatement)); Assert.IsFalse(setStatement.Contains("Unique"), string.Format("Line '{0}' contains a reference to a unique variable", setStatement)); }
public void RenameCPPInputVariableVariable() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var param = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var paramplus = Expression.MakeBinary(ExpressionType.Add, param, Expression.Constant(1)); var expr = Expression.Call(typeof(DoItClass).GetMethod("DoIt"), paramplus); var result = target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); // Check the dependents. gc.CodeBody.RenameVariable(param.RawValue, "abogus_1234"); gc.DumpCodeToConsole(); var st = gc.CodeBody.Statements.First() as ICMStatementInfo; Assert.AreEqual(1, st.DependentVariables.Count(), "# of dependents"); Assert.AreEqual("abogus_1234", st.DependentVariables.First()); }
public void RenameCPPResultVariable() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var param = Expression.Parameter(typeof(int), "p"); var paramplus = Expression.MakeBinary(ExpressionType.Add, param, Expression.Constant(1)); var expr = Expression.Call(typeof(DoItClass).GetMethod("DoIt"), paramplus); var result = target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.CodeBody.RenameVariable(result.RawValue, "abogus_1234"); gc.DumpCodeToConsole(); Assert.IsTrue(gc.DumpCode().Where(s => s.Contains("int abogus_1234")).Any(), "Didn't find the variable name in the code"); }
/// <summary>Test stub for ProcessResultOperator(ResultOperatorBase, QueryModel, IGeneratedCode)</summary> internal GeneratedCode ProcessResultOperator( ROTakeSkipOperators target, ResultOperatorBase resultOperator, QueryModel queryModel, GeneratedCode codeEnv ) { if (codeEnv.ResultValue != null) { throw new ArgumentException("this should not be null for this test"); } if (codeEnv.CodeBody.DeclaredVariables == null) { throw new ArgumentException("Need this declare variables to be defined"); } /// /// We always expect to be inside a loop - and depend on it for doing our declares, so add something... /// var inlineBlock = new StatementInlineBlock(); codeEnv.Add(inlineBlock); /// /// Get the environment setup and run it /// CodeContext c = new CodeContext(); c.SetLoopVariable(Expression.Variable(typeof(int), "d"), null); target.ProcessResultOperator(resultOperator, queryModel, codeEnv, c, MEFUtilities.MEFContainer); codeEnv.DumpCodeToConsole(); /// /// First, there should be a counter now declared and ready to go in the current variable block - which will /// be the outer one for this test. If this is the outter most, then this is going to be burried. /// var declBlock = inlineBlock.Parent.Parent as IBookingStatementBlock; Assert.IsNotNull(declBlock, "Expecting a declaration block above!"); Assert.AreEqual(1, inlineBlock.Statements.Count(), "Expected an if block/increment!"); Assert.IsInstanceOfType(inlineBlock.Statements.First(), typeof(StatementIfOnCount), "if statement not found!"); var s = inlineBlock.Statements.First() as StatementIfOnCount; bool isTopLevel = codeEnv.DumpCode().Where(l => l.Contains("static int")).Any(); if (!isTopLevel) { Assert.AreEqual(1, declBlock.DeclaredVariables.Count(), "Expected only 1 variable to be declared"); Assert.IsInstanceOfType(declBlock.DeclaredVariables.First(), typeof(DeclarableParameter), "Expected it to be a counter"); } else { Assert.AreEqual(1, (s.Parent as IBookingStatementBlock).DeclaredVariables.Count()); } string count = ""; if (resultOperator is SkipResultOperator) { count = (resultOperator as SkipResultOperator).Count.ToString(); } else if (resultOperator is TakeResultOperator) { count = (resultOperator as TakeResultOperator).Count.ToString(); } Assert.AreEqual(count, s.Limit.RawValue, "bad count made it through"); /// /// Finally, the current loop variable should be identical, and there should be no result set. /// Assert.IsNull(codeEnv.ResultValue, "result value"); Assert.IsInstanceOfType(c.LoopVariable, typeof(ParameterExpression), "loop variable type"); var lv = c.LoopVariable as ParameterExpression; Assert.AreEqual("d", lv.Name, "loop variable name"); // // Dump everything and return. To force it out, add a dummy statement // (because if statements, etc., are smart enough to not print anything if they // are empty). // codeEnv.Add(new StatementSimpleStatement("fork = left")); codeEnv.DumpCodeToConsole(); return(codeEnv); }
private static void DoOptimizeTest(GeneratedCode v) { Console.WriteLine("Before Optimization:"); Console.WriteLine(""); v.DumpCodeToConsole(); StatementLifter.Optimize(v); Console.WriteLine(""); Console.WriteLine(""); Console.WriteLine(""); Console.WriteLine("After Optimization:"); Console.WriteLine(""); v.DumpCodeToConsole(); }
public void CombineRepeatedLoops() { var gc = new GeneratedCode(); var c1 = AddLoop(gc); gc.Pop(); var c2 = AddLoop(gc); gc.Pop(); AddSum(gc, c1, c2); Console.WriteLine("Before lifting and optimization: "); gc.DumpCodeToConsole(); StatementLifter.Optimize(gc); Console.WriteLine("After lifting and optimization: "); gc.DumpCodeToConsole(); // Now check that things happened as we would expect them to happen. var ass = gc.CodeBody.Statements.Where(s => s is StatementAssign).Cast<StatementAssign>().First(); Assert.IsNotNull(ass, "Finding the assignment statement"); Assert.AreEqual($"{c1.RawValue}+{c1.RawValue}", ass.Expression.RawValue); Assert.AreEqual(1, gc.CodeBody.DeclaredVariables.Where(dv => dv.RawValue == c1.RawValue).Count(), "# of declared counters"); Assert.AreEqual(1, gc.CodeBody.Statements.Where(s => s is StatementForLoop).Count(), "# of for loops"); Assert.AreEqual(1, gc.CodeBody.Statements.WhereCast<IStatement, StatementForLoop>().Where(s => s.Statements.Count() == 1).Count(), "# of it statements with 2 sub-statements"); }
/// <summary>Test stub for ProcessResultOperator(ResultOperatorBase, QueryModel, IGeneratedCode)</summary> internal GeneratedCode ProcessResultOperator( ROTakeSkipOperators target, ResultOperatorBase resultOperator, QueryModel queryModel, GeneratedCode codeEnv ) { if (codeEnv.ResultValue != null) throw new ArgumentException("this should not be null for this test"); if (codeEnv.CodeBody.DeclaredVariables == null) throw new ArgumentException("Need this declare variables to be defined"); /// /// We always expect to be inside a loop - and depend on it for doing our declares, so add something... /// var inlineBlock = new StatementInlineBlock(); codeEnv.Add(inlineBlock); /// /// Get the environment setup and run it /// CodeContext c = new CodeContext(); c.SetLoopVariable(Expression.Variable(typeof(int), "d"), null); target.ProcessResultOperator(resultOperator, queryModel, codeEnv, c, MEFUtilities.MEFContainer); codeEnv.DumpCodeToConsole(); /// /// First, there should be a counter now declared and ready to go in the current variable block - which will /// be the outer one for this test. If this is the outter most, then this is going to be burried. /// var declBlock = inlineBlock.Parent.Parent as IBookingStatementBlock; Assert.IsNotNull(declBlock, "Expecting a declaration block above!"); Assert.AreEqual(1, inlineBlock.Statements.Count(), "Expected an if block/increment!"); Assert.IsInstanceOfType(inlineBlock.Statements.First(), typeof(StatementIfOnCount), "if statement not found!"); var s = inlineBlock.Statements.First() as StatementIfOnCount; bool isTopLevel = codeEnv.DumpCode().Where(l => l.Contains("static int")).Any(); if (!isTopLevel) { Assert.AreEqual(1, declBlock.DeclaredVariables.Count(), "Expected only 1 variable to be declared"); Assert.IsInstanceOfType(declBlock.DeclaredVariables.First(), typeof(DeclarableParameter), "Expected it to be a counter"); } else { Assert.AreEqual(1, (s.Parent as IBookingStatementBlock).DeclaredVariables.Count()); } string count = ""; if (resultOperator is SkipResultOperator) { count = (resultOperator as SkipResultOperator).Count.ToString(); } else if (resultOperator is TakeResultOperator) { count = (resultOperator as TakeResultOperator).Count.ToString(); } Assert.AreEqual(count, s.Limit.RawValue, "bad count made it through"); /// /// Finally, the current loop variable should be identical, and there should be no result set. /// Assert.IsNull(codeEnv.ResultValue, "result value"); Assert.IsInstanceOfType(c.LoopVariable, typeof(ParameterExpression), "loop variable type"); var lv = c.LoopVariable as ParameterExpression; Assert.AreEqual("d", lv.Name, "loop variable name"); // // Dump everything and return. To force it out, add a dummy statement // (because if statements, etc., are smart enough to not print anything if they // are empty). // codeEnv.Add(new StatementSimpleStatement("fork = left")); codeEnv.DumpCodeToConsole(); return codeEnv; }
public void CodeAddonWithStringArgument() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var param = Expression.Parameter(typeof(string), "p"); var expr = Expression.Call(typeof(DoItClass).GetMethod("DoItWithAString"), param); var result = target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); Assert.IsNotNull(result, "result!"); var vname = result.RawValue; Assert.AreEqual(1, gc.CodeBody.Statements.Count(), "# of statements that came back"); var st1 = gc.CodeBody.Statements.First() as IStatement; var expected = new StringBuilder(); expected.AppendFormat("{0} = strlen(p);", vname); Assert.AreEqual(expected.ToString(), st1.CodeItUp().First(), "statement line incorrect"); }
public void TestLiftTwoStatements() { var v = new GeneratedCode(); var loopP = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var loop = new StatementForLoop(loopP, new LINQToTTreeLib.Variables.ValSimple("10", typeof(int))); v.Add(loop); v.Add(new StatementWithSideEffects(loopP)); v.Add(new StatementWithNoSideEffects()); v.Add(new StatementWithNoSideEffects()); Console.WriteLine("Before optimization"); v.DumpCodeToConsole(); StatementLifter.Optimize(v); Console.WriteLine("After optimization"); v.DumpCodeToConsole(); var firstStatement = v.CodeBody.Statements.First(); Assert.IsInstanceOfType(firstStatement, typeof(StatementWithNoSideEffects), "first statement"); var thirdstatement = v.CodeBody.Statements.Skip(1).First(); Assert.IsInstanceOfType(thirdstatement, typeof(StatementForLoop), "third statement"); }
public void DontLiftThroughTwoForStatements() { var gc = new GeneratedCode(); var counter = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); counter.InitialValue = new ValSimple("0", typeof(int)); gc.Add(counter); // The two for loops var fc1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var for1 = new StatementForLoop(fc1, new ValSimple("5", typeof(int))); gc.Add(for1); var innerCounter = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); innerCounter.InitialValue = new ValSimple("0", typeof(int)); gc.Add(innerCounter); var fc2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var for2 = new StatementForLoop(fc2, new ValSimple("5", typeof(int))); gc.Add(for2); // Now, calculation based only on fc1 var a1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var ass1 = new StatementAssign(a1, new ValSimple($"{fc1}*2", typeof(int), new IDeclaredParameter[] { fc1 })); gc.Add(ass1); var agg1 = new StatementAggregate(innerCounter, new ValSimple($"{innerCounter.RawValue}+{a1.RawValue}", typeof(int), new IDeclaredParameter[] { innerCounter, a1 })); gc.Add(agg1); // and the outer sum. gc.Pop(); var agg2 = new StatementAggregate(counter, new ValSimple($"{counter.RawValue}+{innerCounter.RawValue}", typeof(int), new IDeclaredParameter[] { counter, innerCounter })); gc.Add(agg2); // Great! Console.WriteLine("Unoptimized"); gc.DumpCodeToConsole(); Console.WriteLine(""); Console.WriteLine(""); Console.WriteLine(""); StatementLifter.Optimize(gc); Console.WriteLine("Optimized"); Console.WriteLine(""); gc.DumpCodeToConsole(); // Make sure the inner aggregate got lifted out properly. Assert.AreEqual(1, for2.Statements.Count(), "# of statements in the inner for loop"); }
public void NoLiftSimpleStatement() { var gc = new GeneratedCode(); AddLoop(gc); Console.WriteLine("Before optimization"); gc.DumpCodeToConsole(); StatementLifter.Optimize(gc); Console.WriteLine("After optimization"); gc.DumpCodeToConsole(); Assert.AreEqual(1, gc.CodeBody.Statements.Count(), "# of statements"); Assert.AreEqual(1, gc.CodeBody.Statements.Where(s => s is StatementForLoop).Count(), "# of for loops"); }
public void LiftConstantStatementInLoop() { var gc = new GeneratedCode(); var counter = AddLoop(gc, mainStatementType: MainStatementType.IsConstant); gc.Pop(); Console.WriteLine("Before optimization"); gc.DumpCodeToConsole(); StatementLifter.Optimize(gc); Console.WriteLine("After optimization"); gc.DumpCodeToConsole(); Assert.AreEqual(2, gc.CodeBody.Statements.Count(), "# of statements"); Assert.AreEqual(1, gc.CodeBody.Statements.Where(s => s is StatementAssign).Count(), "# of assign statements"); Assert.AreEqual(1, gc.CodeBody.Statements.Where(s => s is StatementForLoop).Cast<StatementForLoop>().Where(s => s.Statements.Count() == 0).Count(), "# of if statements with zero statements in it"); }
public void LiftNoSideEffectFromNestedIdenticalLoops() { var v = new GeneratedCode(); var limit = new LINQToTTreeLib.Variables.ValSimple("10", typeof(int)); var loopP1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var loop1 = new StatementForLoop(loopP1, limit); v.Add(loop1); var loopP2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var loop2 = new StatementForLoop(loopP2, limit); v.Add(loop2); v.Add(new StatementWithNoSideEffects()); Console.WriteLine("Unoptimized:"); v.DumpCodeToConsole(); StatementLifter.Optimize(v); Console.WriteLine(""); Console.WriteLine("Optimized:"); v.DumpCodeToConsole(); // Check to see if it got lifted. Assert.AreEqual(1, v.CodeBody.Statements.WhereCast<IStatement, StatementWithNoSideEffects>().Count(), "#of no side effect statements"); }
/// <summary> /// Do the work of executing the array parse /// </summary> /// <param name="e"></param> private static GeneratedCode ExecuteArrayParseOnExpression(Expression e) { var gc = new GeneratedCode(); var cc = new CodeContext(); IQuerySource s = new DummyQueryReference() { ItemName = "q", ItemType = typeof(int) }; var r = ArrayExpressionParser.ParseArrayExpression(s, e, gc, cc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); Assert.IsNotNull(cc.LoopVariable, "loop variable"); return gc; }
public void TestComplexArgumentReplacement() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt = Expression.Parameter(typeof(double), "ptParam"); var p_eta = Expression.Parameter(typeof(double), "etaParam"); var p_phi = Expression.Parameter(typeof(double), "phiParam"); var p_E = Expression.Parameter(typeof(double), "EParam"); var expr = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZ"), p_pt, p_eta, p_phi, p_E); target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); Assert.AreEqual(1, gc.CodeBody.Statements.Count(), "# of statements total"); var setStatement = gc.CodeBody.Statements.First().CodeItUp().Skip(1).First(); Assert.IsNotNull(setStatement, "Bad type for 3rd statement"); Assert.IsTrue(setStatement.Contains("SetPtEtaPhiE(ptParam, etaParam, phiParam, EParam)"), string.Format("Line '{0}' doesn't have correct set statement.", setStatement)); }
public void TestArgReplacementAtStartAndEnd() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt = Expression.Parameter(typeof(double), "ptParam"); var p_eta = Expression.Parameter(typeof(double), "etaParam"); var p_phi = Expression.Parameter(typeof(double), "phiParam"); var p_E = Expression.Parameter(typeof(double), "EParam"); var expr = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZBE"), p_pt, p_eta, p_phi, p_E); target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); Assert.AreEqual(1, gc.CodeBody.Statements.Count(), "# of statements total"); var atEnding = gc.CodeBody.Statements.First().CodeItUp().Skip(1).FirstOrDefault(); Assert.IsNotNull(atEnding, "Bad type for 3rd statement"); Assert.IsTrue(atEnding.EndsWith("ptParam"), string.Format("Line '{0}' doesn't ends with parameter replacement", atEnding)); }
public void LiftLoopInvarient() { var v = new GeneratedCode(); var limit = new LINQToTTreeLib.Variables.ValSimple("5", typeof(int)); var loopP1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var loop1 = new StatementForLoop(loopP1, limit); v.Add(loop1); var p2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var assign1 = new StatementAssign(p2, new ValSimple("f", typeof(int))); loop1.Add(p2); loop1.Add(assign1); Console.WriteLine("Unoptimized:"); v.DumpCodeToConsole(); StatementLifter.Optimize(v); Console.WriteLine(""); Console.WriteLine("Optimized:"); v.DumpCodeToConsole(); Assert.AreEqual(0, loop1.Statements.Count()); }
public void CPPNotIdentical() { // two identical expressions var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_eta = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_phi = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_E = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); // Create two identical calls var e1 = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZBE"), p_pt, p_eta, p_phi, p_E); var e1Value = target.CodeMethodCall(e1, gc, MEFUtilities.MEFContainer); var c2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var e2 = Expression.Call(typeof(DoItClass).GetMethod("DoIt"), c2); var e2Value = target.CodeMethodCall(e2, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); // Now, extract the two main statements. Assert.AreEqual(2, gc.CodeBody.Statements.Count(), "# of statements"); var s1 = gc.CodeBody.Statements.First() as ICMStatementInfo; var s2 = gc.CodeBody.Statements.Skip(1).First() as ICMStatementInfo; // Now, see if we can do the requirement. var r = s1.RequiredForEquivalence(s2); Assert.IsFalse(r.Item1, "We should be able to do the translation"); }
public void TestCMVariables() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_eta = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double)); var p_phi = p_pt; var p_E = p_eta; var expr = Expression.Call(typeof(TLZHelper).GetMethod("CreateTLZ"), p_pt, p_eta, p_phi, p_E); var r = target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); var ccpstatement = gc.CodeBody.Statements.First(); Assert.IsNotNull(ccpstatement); var cmInfo = ccpstatement as ICMStatementInfo; Assert.IsNotNull(cmInfo); Assert.AreEqual(1, cmInfo.ResultVariables.Count(), "# of result variables"); Assert.AreEqual(r.RawValue, cmInfo.ResultVariables.First(), "Result variable name"); Assert.AreEqual(2, cmInfo.DependentVariables.Count(), "# of dependent variables"); Assert.IsTrue(cmInfo.DependentVariables.Contains(p_pt.RawValue), "doesn't have pt"); Assert.IsTrue(cmInfo.DependentVariables.Contains(p_eta.RawValue), "Doesn't have eta"); }
public void LiftConstantDefinedInLoop() { var gc = new GeneratedCode(); var counter = AddLoop(gc, mainStatementType: MainStatementType.IsConstant, defineCounterInsideBlock: true); Console.WriteLine("Before optimization"); gc.DumpCodeToConsole(); StatementLifter.Optimize(gc); Console.WriteLine("After optimization"); gc.DumpCodeToConsole(); Assert.AreEqual(2, gc.CodeBody.Statements.Count(), "# of statements"); Assert.AreEqual(1, gc.CodeBody.Statements.WhereCast<IStatement,StatementAssign>().Count(), "# of assign statements"); Assert.AreEqual(1, gc.CodeBody.Statements.WhereCast<IStatement, StatementForLoop>().Where(s => s.Statements.Count() == 0).Count(), "# of if statements with zero statements in it"); Assert.AreEqual(1, gc.CodeBody.DeclaredVariables.Count(), "# of declarations"); }
public void TestScopingBlock() { var target = new TypeHandlerCPPCode(); var gc = new GeneratedCode(); var context = new CodeContext(); var p_pt = Expression.Parameter(typeof(double), "ptParam"); var p_eta = Expression.Parameter(typeof(double), "etaParam"); var p_phi = Expression.Parameter(typeof(double), "phiParam"); var p_E = Expression.Parameter(typeof(double), "EParam"); var expr = Expression.Call(typeof(TLZHelper).GetMethod("TestIF"), p_pt, p_eta, p_phi, p_E); target.CodeMethodCall(expr, gc, MEFUtilities.MEFContainer); gc.DumpCodeToConsole(); var ifstatement = gc.CodeBody.Statements.First().CodeItUp().First(); Assert.IsFalse(ifstatement.EndsWith(";"), string.Format("Line '{0}' ends with a semicolon", ifstatement)); }
public void TestSimpleAddition() { MEFUtilities.Compose(new TypeHandlers.TypeHandlerCache()); AggregateFromSeedResultOperator agg = new AggregateFromSeedResultOperator(Expression.Constant(1), Expression.Lambda(Expression.MakeBinary(ExpressionType.Add, Expression.Parameter(typeof(int), "count"), Expression.Constant(1)), Expression.Parameter(typeof(int), "count")), null); ROAggregate processor = new ROAggregate(); GeneratedCode gc = new GeneratedCode(); var result = ProcessResultOperator(processor, agg, null, gc); Assert.AreEqual(typeof(int), result.Type, "Expected the type to be an integer!"); Assert.IsInstanceOfType(result, typeof(DeclarableParameter), "Expected a var simple!"); var vs = result as DeclarableParameter; Assert.AreEqual("1", vs.InitialValue.RawValue, "Incorrect seed value"); /// /// Now make sure the statements came back ok! /// gc.DumpCodeToConsole(); Assert.AreEqual(0, gc.CodeBody.DeclaredVariables.Count(), "Expected no bookings"); Assert.AreEqual(1, gc.CodeBody.Statements.Count(), "expected a statement!"); Assert.IsInstanceOfType(gc.CodeBody.Statements.First(), typeof(Statements.StatementAggregate), "expected an assignment statement!"); var ass = gc.CodeBody.Statements.First() as Statements.StatementAggregate; StringBuilder bld = new StringBuilder(); bld.AppendFormat("{0}+1", ass.ResultVariable.ParameterName); Assert.AreEqual(bld.ToString(), ass.Expression.RawValue, "the raw value of hte expression is not right"); }