/// <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 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 TestNoDeclare()
{
var i = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var sv = new ValSimple("5", typeof(int));
var s1 = new StatementAssign(i, sv);
Assert.IsTrue(s1.CodeItUp().First().Trim().StartsWith("aInt32_"), "Check for decl: " + s1.CodeItUp().First());
}
public void TryCombineTwoNoneDeclaresDeclFound()
{
var i = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var sv = new ValSimple("5", typeof(int));
var s1 = new StatementAssign(i, sv);
var s2 = new StatementAssign(i, sv);
Assert.IsTrue(s1.TryCombineStatement(s2, new DummyTrackingOptimizationService(true)), "Combine when no decl found");
}
Tuple <IDeclaredParameter, IStatement> CreateAssignStatement(IValue valToAssign, IDeclaredParameter p1 = null)
{
if (p1 == null)
{
p1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
}
IStatement s1 = new StatementAssign(p1, valToAssign);
return(Tuple.Create(p1, s1));
}
/// <summary>
/// Helper to create an assignment to a constant.
/// </summary>
/// <returns></returns>
Tuple <IDeclaredParameter, IStatement> CreateConstAssignStatement(IDeclaredParameter p1 = null)
{
if (p1 == null)
{
p1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
}
IStatement s1 = new StatementAssign(p1, new ValSimple("5", typeof(int)));
return(Tuple.Create(p1, s1));
}
public void TestBasicCMValues()
{
var i = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var sv = new ValSimple("5", typeof(int));
var s1 = new StatementAssign(i, sv);
Assert.AreEqual(1, s1.ResultVariables.Count(), "# result variables");
Assert.AreEqual(i.RawValue, s1.ResultVariables.First(), "the name");
Assert.AreEqual(0, s1.DependentVariables.Count(), "no dependent variables");
}
public void AssignDependents()
{
var p1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var p2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var v = new ValSimple($"{p2.RawValue}+10", typeof(int), new IDeclaredParameter[] { p2 });
var a = new StatementAssign(p1, v);
Assert.AreEqual(1, a.DependentVariables.Count());
Assert.AreEqual(p2.RawValue, a.DependentVariables.First());
}
public void TestCMValuesForSimpleExpression()
{
var i = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var di = DeclarableParameter.CreateDeclarableParameterExpression(typeof(double));
var sv = new ValSimple("5", typeof(int), new IDeclaredParameter[] { di });
var s1 = new StatementAssign(i, sv);
Assert.AreEqual(1, s1.ResultVariables.Count(), "# result variables");
Assert.AreEqual(i.RawValue, s1.ResultVariables.First(), "the name");
Assert.AreEqual(1, s1.DependentVariables.Count(), "no dependent variables");
Assert.AreEqual(di.RawValue, s1.DependentVariables.First(), "a dependent variable");
}
public void AssignEquivalentDiffFunc()
{
var p1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var d1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var s1 = new StatementAssign(p1, new ValSimple($"{d1.RawValue}", typeof(int), new IDeclaredParameter[] { d1 }));
var s2 = new StatementAssign(p1, new ValSimple($"sin({d1.RawValue})", typeof(int), new IDeclaredParameter[] { d1 }));
var r = s1.RequiredForEquivalence(s2);
Assert.IsFalse(r.Item1, "should not be able to do the combination");
}
public void AssignEquivalentSame()
{
var p1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var d1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var s1 = new StatementAssign(p1, new ValSimple($"{d1.RawValue}", typeof(int), new IDeclaredParameter[] { d1 }));
var s2 = new StatementAssign(p1, new ValSimple($"{d1.RawValue}", typeof(int), new IDeclaredParameter[] { d1 }));
var r = s1.RequiredForEquivalence(s2);
Assert.IsTrue(r.Item1, "can do the combination");
Assert.AreEqual(0, r.Item2.Count(), "# of variables to rename");
}
public void DependentAndResultVariablesWithDecl()
{
var counter = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var s = new StatementForLoop(counter, new ValSimple("5", typeof(int)));
var result = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
s.Add(result);
var assign = new StatementAssign(result, new ValSimple($"{result.RawValue}+{counter.RawValue}", typeof(int), new IDeclaredParameter[] { counter, result }));
s.Add(assign);
Assert.AreEqual(0, s.DependentVariables.Count(), "# of dependent variables");
Assert.AreEqual(0, s.ResultVariables.Count(), "# of result variables");
}
public void AssignEquivalentTwoDifferentDependents()
{
// Replacing two dependents gets to be more than we can do becasue of ordering and the roll they might
// be playing.
var p1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var d1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var d2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var d3 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var d4 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var s1 = new StatementAssign(p1, new ValSimple($"{d1.RawValue}+{d2.RawValue}", typeof(int), new IDeclaredParameter[] { d1, d2 }));
var s2 = new StatementAssign(p1, new ValSimple($"{d3.RawValue}+{d4.RawValue}", typeof(int), new IDeclaredParameter[] { d3, d4 }));
var r = s1.RequiredForEquivalence(s2);
Assert.IsTrue(r.Item1, "can do the combination");
}
public void AssignEquivalentSameAfterReplacementWith2Vars()
{
var p1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var d1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var d2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var d3 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var d4 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var s1 = new StatementAssign(p1, new ValSimple($"{d1.RawValue}+{d2.RawValue}", typeof(int), new IDeclaredParameter[] { d1, d2 }));
var s2 = new StatementAssign(p1, new ValSimple($"{d3.RawValue}+{d4.RawValue}", typeof(int), new IDeclaredParameter[] { d3, d4 }));
var r = s1.RequiredForEquivalence(s2, new Tuple <string, string>[] { new Tuple <string, string>(d3.RawValue, d1.RawValue) });
Assert.IsTrue(r.Item1, "can do the combination");
Assert.AreEqual(1, r.Item2.Count(), "# of variables to rename");
Assert.AreEqual(d4.RawValue, r.Item2.First().Item1);
}
private QMFuncSource[] GenerateFunction2()
{
var fsub = QMFuncUtils.GenerateFunction();
int[] ints = new int[10];
var h = new QMFuncHeader()
{
Arguments = new object[] { }, QM = new QueryModel(new MainFromClause("i", typeof(int), Expression.Constant(ints)), new SelectClause(Expression.Constant(10)))
};
h.QMText = h.QM.ToString();
var f = new QMFuncSource(h);
var p = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int));
var st = new StatementAssign(p, new ValSimple(fsub.Name + "()", typeof(int)));
var inlineblock = new StatementInlineBlock();
inlineblock.Add(st);
inlineblock.Add(new StatementReturn(p));
f.SetCodeBody(inlineblock);
return(new QMFuncSource[] { fsub, f });
}
