public void TestSimpleRename()
{
var array = DeclarableParameter.CreateDeclarableParameterArrayExpression(typeof(int));
var index1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var index2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var st = new StatementPairLoop(array, index1, index2);
var vr = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
vr.RenameRawValue(vr.RawValue, index1.RawValue);
st.Add(new StatementAssign(vr, new ValSimple("ops", typeof(int))));
st.RenameVariable(index1.RawValue, "dude1");
Assert.AreEqual("dude1", index1.RawValue, "index1 after index1 rename");
Assert.AreEqual("dude1", (st.Statements.First() as StatementAssign).ResultVariable.RawValue, "sub statement not renamed correctly");
st.RenameVariable(index2.RawValue, "dude2");
Assert.AreEqual("dude1", index1.RawValue, "index1 after index2 rename");
Assert.AreEqual("dude2", index2.RawValue, "index1 after index1 rename");
st.RenameVariable(array.RawValue, "fork");
Assert.AreEqual("fork", array.RawValue, "array after array rename");
Assert.AreEqual("dude1", index1.RawValue, "index1 after array rename");
Assert.AreEqual("dude2", index2.RawValue, "index1 after array rename");
}
public void TestCombineNestedForLoopOnOneSide()
{
var base1 = new StatementInlineBlock();
var limit = new LINQToTTreeLib.Variables.ValSimple("5", typeof(int));
var loopP1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var loop1 = new StatementForLoop(loopP1, limit);
base1.Add(loop1);
var base2 = new StatementInlineBlock();
var limit2 = new LINQToTTreeLib.Variables.ValSimple("5", typeof(int));
var loopP12 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var loop12 = new StatementForLoop(loopP12, limit);
base2.Add(loop12);
var loopP22 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var loop22 = new StatementForLoop(loopP22, limit);
loop12.Add(loop22);
var r = base1.TryCombineStatement(base2, new dummyOpt());
Assert.IsTrue(r, "combination should work");
Assert.AreEqual(base1, loop1.Parent, "loop 1 parent");
Assert.AreEqual(loop1, loop22.Parent, "Loop 2 parent");
}
public void ForLoopRenameIgnoreDeclaredVariables()
{
var c1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var s1 = new StatementForLoop(c1, new ValSimple("5", typeof(int)));
var a1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var v1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
s1.Add(new StatementAssign(a1, new ValSimple("10", typeof(int))));
s1.Add(new StatementAssign(a1, new ValSimple($"{a1.RawValue}+{v1.RawValue}", typeof(int), new IDeclaredParameter[] { a1, v1 })));
s1.Add(v1);
var c2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var s2 = new StatementForLoop(c2, new ValSimple("5", typeof(int)));
var a2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var v2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
s2.Add(new StatementAssign(a2, new ValSimple("10", typeof(int))));
s2.Add(new StatementAssign(a2, new ValSimple($"{a2.RawValue}+{v2.RawValue}", typeof(int), new IDeclaredParameter[] { a2, v2 })));
s2.Add(v2);
var r = s1.RequiredForEquivalence(s2);
// Since only loop variable matters here, we don't care, and we can do the rename.
Assert.IsTrue(r.Item1, "Should be equivalent");
var renames = r.Item2.ToArray();
Assert.AreEqual(1, renames.Length, "# of renames");
}
public void TestResultScopeCurrentScope()
{
var gc = new GeneratedCode();
var b1 = new StatementInlineBlock();
gc.Add(b1);
gc.SetCurrentScopeAsResultScope();
var outterScope = gc.CurrentScope;
var b2 = new StatementInlineBlock();
gc.Add(b2);
gc.SetCurrentScopeAsResultScope();
gc.AddAtResultScope(DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)));
Assert.AreEqual(0, b1.DeclaredVariables.Count(), "variables at outside loop after 0 add");
Assert.AreEqual(1, b2.DeclaredVariables.Count(), "variables at inner loop after 1 add");
gc.CurrentScope = outterScope;
gc.AddAtResultScope(DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)));
Assert.AreEqual(1, b1.DeclaredVariables.Count(), "variables at outside loop after 1 add");
Assert.AreEqual(1, b2.DeclaredVariables.Count(), "variables at inner loop after 2 add");
}
/// <summary>
/// Add other savers to restore.
/// </summary>
/// <param name="mapParameter"></param>
/// <returns></returns>
internal DeclarableParameter RestoreOtherSaver(IValue mapParameter)
{
// Get the array type that we will use to accumulate items for sorting. This is the "key"
var arrtype = mapParameter.Type.GetGenericArguments()[0].MakeArrayType();
// Get an index variable - this is the variable that the contents of the map are set to and are used in
// the rest of the expression.
var indexVariableType = mapParameter.Type.GetGenericArguments()[1];
if (!indexVariableType.IsArray)
{
throw new ArgumentException(string.Format("Unable to loop over a map that isn't a map of arrays ({0}).", mapParameter.Type.FullName));
}
indexVariableType = indexVariableType.GetElementType();
// Create the saver which we will index over.
var saver = new mapPlaybackInfo()
{
sequence = _mapRecords.Count(),
mapRecords = mapParameter,
sortValueTypeArray = arrtype,
tempListingName = arrtype.CreateUniqueVariableName(),
indexVariable = DeclarableParameter.CreateDeclarableParameterExpression(indexVariableType)
};
_mapRecords.Add(saver);
return(saver.indexVariable);
}
public void CombineFilterAtSameLevelWithDifferentStatements()
{
// Two if statements with same "if", at the same level, and combine second with first.
// Next, we will do the two common ones.
var f1 = new StatementFilter(new ValSimple("f1", typeof(bool)));
var f2 = new StatementFilter(new ValSimple("f1", typeof(bool)));
var p1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var p2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var a1 = new StatementAssign(p1, new ValSimple("5", typeof(int)));
var a2 = new StatementAssign(p2, new ValSimple("15", typeof(int)));
f1.Add(a1);
f1.Add(p1);
f2.Add(a2);
f2.Add(p2);
Console.WriteLine("Before optimization:");
foreach (var l in f1.CodeItUp())
{
Console.WriteLine(l);
}
Assert.IsTrue(f1.TryCombineStatement(f2, null), "Two of the same if statements, and the combine should have worked");
Console.WriteLine("After optimization:");
foreach (var l in f1.CodeItUp())
{
Console.WriteLine(l);
}
Assert.AreEqual(2, f1.Statements.Count());
}
public void TestChangeScopeSpecificNextLevel()
{
GeneratedCode target = new GeneratedCode();
target.Add(new StatementInlineBlock());
IStatement s = new StatementInlineBlock();
var deepestStatementLevel = TestUtils.GetDeepestStatementLevel(target);
var deepestDeclarLevel = TestUtils.GetDeepestBookingLevel(target);
var currentS = target.CurrentScope;
var curVars = deepestDeclarLevel.DeclaredVariables.Count();
var curStatements = deepestStatementLevel.Statements.Count();
var v1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
target.Add(v1);
target.Add(s);
target.CurrentScope = currentS;
var v2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
target.Add(v2);
s.Parent = null;
target.Add(s);
Assert.AreEqual(curStatements + 2, deepestStatementLevel.Statements.Count(), "Scope reset, should always be two extra statements here!");
Assert.AreEqual(curVars + 2, deepestDeclarLevel.DeclaredVariables.Count(), "Scope reset should have also reset where the variable was pointing");
}
public void TestCombineWithRenameVarsDifferent()
{
// If the varialbes are initialized differently, then we can't combine them!
var inline1 = new StatementInlineBlock();
var inline2 = new StatementInlineBlock();
var vdecl1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
vdecl1.SetInitialValue("0");
var vdecl2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
vdecl2.SetInitialValue("1");
inline1.Add(vdecl1);
inline2.Add(vdecl2);
var s1 = new CombineTestStatement(vdecl1);
inline1.Add(s1);
var s2 = new CombineTestStatement(vdecl2);
inline2.Add(s2);
inline2.Add(new Statements.StatementSimpleStatement(string.Format("dude = {0}", vdecl2.RawValue)));
var result = inline1.TryCombineStatement(inline2, null);
Assert.IsTrue(result, "try combine didn't work");
Assert.AreEqual(3, inline1.Statements.Count(), "bad # of combined statements");
}
public void TestCombineWithRenameVarsNotDeclR()
{
// If one of the variables isn't declared, then this is a "result" and it shouldn't
// be combined (or similar - whatever, it is outside the block). So we can't
// do the combine for now!
// This is the same guy as above - but in reverse order. This is important because
// this test needs to be symetric.
var inline1 = new StatementInlineBlock();
var inline2 = new StatementInlineBlock();
var vdecl1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var vdecl2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
inline1.Add(vdecl1);
var s1 = new CombineTestStatement(vdecl1);
inline1.Add(s1);
var s2 = new CombineTestStatement(vdecl2);
inline2.Add(s2);
inline2.Add(new Statements.StatementSimpleStatement(string.Format("dude = {0}", vdecl2.RawValue)));
var result = inline2.TryCombineStatement(inline1, null);
Assert.IsTrue(result, "try combine didn't work");
Assert.AreEqual(3, inline2.Statements.Count(), "bad # of combined statements");
}
public void TestCombineWithRenameSimple()
{
// Try to combine two statements that will combine, but require
// a rename first.
var inline1 = new StatementInlineBlock();
var inline2 = new StatementInlineBlock();
var vdecl1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var vdecl2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
inline1.Add(vdecl1);
inline2.Add(vdecl2);
var s1 = new CombineTestStatement(vdecl1);
inline1.Add(s1);
var s2 = new CombineTestStatement(vdecl2);
inline2.Add(s2);
var result = inline1.TryCombineStatement(inline2, null);
Assert.IsTrue(result, "try combine didn't work");
Assert.AreEqual(1, inline1.Statements.Count(), "bad # of combined statements");
}
public void TestCombineWithRenameDownstream()
{
// When doing a good rename, make sure downstream statements get the rename too.
var inline1 = new StatementInlineBlock();
var inline2 = new StatementInlineBlock();
var vdecl1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var vdecl2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
inline1.Add(vdecl1);
inline2.Add(vdecl2);
var s1 = new CombineTestStatement(vdecl1);
inline1.Add(s1);
var s2 = new CombineTestStatement(vdecl2);
inline2.Add(s2);
inline2.Add(new Statements.StatementSimpleStatement(string.Format("dude = {0}", vdecl2.ParameterName)));
var result = inline1.TryCombineStatement(inline2, null);
Assert.IsTrue(result, "try combine didn't work");
Assert.AreEqual(2, inline1.Statements.Count(), "bad # of combined statements");
Assert.AreEqual(string.Format("dude = {0};", vdecl1.ParameterName), inline1.Statements.Skip(1).First().CodeItUp().First(), "Line wasn't renamed");
}
public void TestForFunctionNumber()
{
CPPTranslator target = new CPPTranslator();
var vInt = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
vInt.SetInitialValue("2");
GeneratedCode code = new GeneratedCode();
code.SetResult(vInt);
var innerBlock = new StatementInlineBlock();
var vInt2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
vInt2.SetInitialValue("5");
innerBlock.Add(vInt2);
code.Add(innerBlock);
var r = TranslateGeneratedCode(target, code);
Assert.IsTrue(r.ContainsKey("NumberOfQueryFunctions"), "Number of functions isn't here");
Assert.IsInstanceOfType(r["NumberOfQueryFunctions"], typeof(int), "# function type");
Assert.AreEqual(1, r["NumberOfQueryFunctions"], "# of functions");
Assert.IsTrue(r.ContainsKey("QueryFunctionBlocks"), "Missing query function blocks");
Assert.IsInstanceOfType(r["QueryFunctionBlocks"], typeof(IEnumerable <IEnumerable <string> >), "Type is incorrect");
var codeBlocks = r["QueryFunctionBlocks"] as IEnumerable <IEnumerable <string> >;
Assert.AreEqual(1, codeBlocks.Count(), "Wrong number of code blocks");
}
public void TestObjectInitalizerInInnerBlock()
{
CPPTranslator target = new CPPTranslator();
var vInt = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
vInt.SetInitialValue("2");
GeneratedCode code = new GeneratedCode();
code.SetResult(vInt);
var innerBlock = new StatementInlineBlock();
var vInt2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
vInt2.SetInitialValue("5");
innerBlock.Add(vInt2);
innerBlock.Add(new StatementSimpleStatement("fork = dork"));
code.Add(innerBlock);
var r = TranslateGeneratedCode(target, code);
var st = (r["QueryFunctionBlocks"] as IEnumerable <IEnumerable <string> >).First().ToArray();
Assert.AreEqual(6, st.Length, "incorrect number of statements");
Assert.AreEqual("int " + vInt2.RawValue + " = 5;", st[2].Trim(), "incorrect initialization");
}
public TooManyStatemnets()
{
var vInt = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
vInt.SetInitialValue("2");
ResultValues = new IDeclaredParameter[] { vInt };
}
/// <summary>
/// Generate a function call statement for the cached function we are going to emit.
/// </summary>
/// <param name="qmSource"></param>
/// <returns></returns>
private void GenerateQMFunctionCall(IQMFunctionSource qmSource)
{
// Assemble what we need for the sequence call.
if (qmSource.Arguments.Any())
{
throw new NotImplementedException("Can only deal with internal functions with no arguments.");
}
// NOTE: If we add parameters then we will have to fix up dependencies below.
var call = string.Format("{0} ()", qmSource.Name);
if (qmSource.IsSequence)
{
// For the sequence we get the resulting vector array.
var cvar = DeclarableParameter.CreateDeclarableParameterExpression(qmSource.ResultType);
_codeEnv.Add(cvar);
_codeEnv.Add(new StatementAssign(cvar, new ValSimple(call, qmSource.ResultType, null)));
// Now, do a loop over it.
var loopVar = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
_codeEnv.Add(new StatementForLoop(loopVar, new ValSimple(string.Format("{0}.size()", cvar.RawValue), typeof(int), new IDeclaredParameter[] { cvar })));
// Finally, we setup the loop index variables to match what they did when we ran the function.
var oldLoopIndex = qmSource.OldLoopIndexVariable;
Expression oldLoopVariable = qmSource.OldLoopExpression;
var arrayLookup = Expression.ArrayIndex(cvar, loopVar);
_codeContext.SetLoopVariable(arrayLookup, loopVar);
}
else
{
// For the non-sequence this just returns a value that we need.
_codeEnv.SetResult(Expression.Parameter(qmSource.ResultType, call));
}
}
/// <summary>
/// Generate a function with no arguments that returns an int given that name. The
/// actual statement is a very simple constant.
/// </summary>
/// <param name="fname"></param>
/// <returns></returns>
public static QMFuncSource GenerateFunction()
{
int[] ints = new int[10];
var qmb = new QueryModelBuilder();
qmb.AddClause(new MainFromClause("i", typeof(int), Expression.Constant(ints)));
qmb.AddClause(new SelectClause(Expression.Constant(1)));
qmb.AddResultOperator(new Remotion.Linq.Clauses.ResultOperators.CountResultOperator());
var h = new QMFuncHeader()
{
Arguments = new object[] { }, QM = qmb.Build()
};
h.QMText = h.QM.ToString();
var f = new QMFuncSource(h);
var p = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var st = new StatementAssign(p, new ValSimple("5", typeof(int)));
var inlineblock = new StatementInlineBlock();
inlineblock.Add(st);
inlineblock.Add(new StatementReturn(p));
f.SetCodeBody(inlineblock);
return(f);
}
public void CombineFilterWithHiddenBehindIf()
{
// Seen in the wild. We have two identical if statements, one outside, and one inside another
// (different) if statement. It is OK to combine these two as the code is identical.
// See test CombineFilterWithHiddenBehindIfAndExtraStatements for the case where at
// least one statement needs to be left behind.
// Top level guy. This is the unique filter statement.
var filterUnique = new StatementFilter(new ValSimple("fUnique", typeof(bool)));
// Next, we will do the two common ones.
var f1 = new StatementFilter(new ValSimple("f1", typeof(bool)));
var f2 = new StatementFilter(new ValSimple("f1", typeof(bool)));
var p = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var a1 = new StatementAssign(p, new ValSimple("5", typeof(int)));
var a2 = new StatementAssign(p, new ValSimple("5", typeof(int)));
f1.Add(p);
f2.Add(p);
f1.Add(a1);
f2.Add(a2);
filterUnique.Add(f1);
Assert.IsTrue(f2.TryCombineStatement(f1, null), "Two of the same if statements, but the target is at a higher level than the merge");
Assert.AreEqual(1, f2.Statements.Count());
}
/// <summary>
/// Create a reference to a ROOT variable that is going to be loaded remotely.
/// </summary>
/// <param name="varName"></param>
/// <param name="rootType"></param>
public ROOTObjectCopiedValue(string varName, Type rootType, string CPPType, string name, string title)
{
if (string.IsNullOrWhiteSpace(varName))
{
throw new ArgumentException("invalid variable name");
}
if (string.IsNullOrWhiteSpace(CPPType))
{
throw new ArgumentException("Invalid C++ type name");
}
if (rootType == null)
{
throw new ArgumentException("Invalid type");
}
///
/// The type and the loader string
///
Type = rootType;
OriginalName = name;
OriginalTitle = title;
StringBuilder loadString = new StringBuilder();
loadString.AppendFormat("LoadFromInputList<{0}>(\"{1}\")", CPPType, varName);
RawValue = loadString.ToString();
Dependants = new IDeclaredParameter[] { DeclarableParameter.CreateDeclarableParameterExpression(varName, rootType) };
}
public void CombineOneTwoLevelAndOneOneLevelFunctions2()
{
var q1 = new GeneratedCode();
var q2 = new GeneratedCode();
var f1 = QMFuncUtils.GenerateFunction();
var r1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var s1 = new Statements.StatementAssign(r1, new Variables.ValSimple(f1.Name + "()", typeof(int)));
var f2 = GenerateFunction2();
var r2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var s2 = new Statements.StatementAssign(r2, new Variables.ValSimple(f2[1].Name + "()", typeof(int)));
q1.Add(f1);
q1.Add(s1);
q1.SetResult(r1);
q2.Add(f2[0]);
q2.Add(f2[1]);
q2.Add(s2);
q2.SetResult(r2);
var target = new CombinedGeneratedCode();
target.AddGeneratedCode(q1);
target.AddGeneratedCode(q2);
target.DumpCodeToConsole();
Assert.AreEqual(2, target.Functions.Count(), "# of functions should be combined to 2");
Assert.AreEqual(1, target.QueryCode().Count(), "# of query code blocks");
Assert.AreEqual(2, target.QueryCode().First().Statements.Count(), "# of statements in the combined block.");
Assert.IsFalse(target.DumpCode().Where(l => l.Contains(f2[0].Name)).Any(), "The new function was still in there");
}
public void SaverManagerNormalObject()
{
VariableSaverManager mgr = GetInitializedSaveManager();
var p = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var s = mgr.Get(p);
}
public void TestAddOutsideLoopWithJustInlineBLock()
{
var target = new GeneratedCode();
target.Add(new Statements.StatementInlineBlock());
target.AddOutsideLoop(DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)));
}
public void AsExpressionWithExpr()
{
var p = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var expr = p.AsExpression();
Assert.AreEqual(p, expr, "translation was not transparent");
}
public void TestFirstBookingBad()
{
var i = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var gc = new GeneratedCode();
Assert.IsNull(gc.FirstAllInScopeFromNow(new IDeclaredParameter[] { i }));
}
/// <summary>
/// Actually try and process this! The count consisits of a count integer and something to increment it
/// at its current spot.
/// </summary>
/// <param name="resultOperator"></param>
/// <param name="queryModel"></param>
/// <param name="codeEnv"></param>
/// <returns></returns>
public Expression ProcessResultOperator(ResultOperatorBase resultOperator, QueryModel queryModel, IGeneratedQueryCode gc, ICodeContext cc, CompositionContainer container)
{
if (gc == null)
{
throw new ArgumentNullException("CodeEnv must not be null!");
}
var c = resultOperator as CountResultOperator;
if (c == null)
{
throw new ArgumentNullException("resultOperator can only be a CountResultOperator and must not be null");
}
//
// The accumulator where we will store the result.
//
var accumulator = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
accumulator.SetInitialValue("0");
//
// Use the Aggregate infrasturcutre to do the adding. This
// has the advantage that it will correctly combine with
// similar statements during query optimization.
//
var add = Expression.Add(accumulator, Expression.Constant((int)1));
var addResolved = ExpressionToCPP.GetExpression(add, gc, cc, container);
gc.Add(new StatementAggregate(accumulator, addResolved));
return(accumulator);
}
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 TestCombineWithSameArray()
{
var index1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var index2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var arrayRecord = DeclarableParameter.CreateDeclarableParameterArrayExpression(typeof(int));
var stp1 = new StatementPairLoop(arrayRecord, index1, index2);
var index3 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var index4 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var stp2 = new StatementPairLoop(arrayRecord, index3, index4);
var statAss = new StatementAssign(index3, new ValSimple("dude", typeof(int)), null);
stp2.Add(statAss);
var opt = new Factories.CodeOptimizerTest(true);
Assert.IsTrue(stp1.TryCombineStatement(stp2, opt), "Combine should have been ok");
Assert.AreEqual(1, stp1.Statements.Count(), "Improper number of combined sub-statements");
var s1 = stp1.Statements.First();
Assert.IsInstanceOfType(s1, typeof(StatementAssign), "Statement is not right type");
var sa = s1 as StatementAssign;
Assert.AreEqual(index1.RawValue, sa.ResultVariable.RawValue, "rename of variables didn't occur correctly");
}
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 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 ValSimpleWithDependents()
{
var d = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var v = new ValSimple($"5+{d.RawValue}", typeof(int), new IDeclaredParameter[] { d });
Assert.IsNotNull(v.Dependants);
Assert.AreEqual(1, v.Dependants.Count());
}
