public void AssignShouldAcceptRightableAndLeftable()
{
const string expected =
@"public System.String Call(System.String par)
{
par = ""another"";
return par;
}";
var newExpression = Function.Create()
.WithParameter <string>("par")
.WithBody(
CodeLine.Assign(Operation.Variable("par"), Operation.Constant("another"))
)
.Returns("par");
var newSource = newExpression.ToString();
AssertString.AreEqual(expected, newSource);
var lambda = newExpression.ToLambda <Func <string, string> >();
Assert.IsNotNull(lambda);
var result = lambda("test");
Assert.AreEqual("another", result);
}
public void AssignShouldWorkForInternalVariables()
{
const string expected =
@"public System.String Call(System.String par)
{
System.String var;
var = ""another"";
var += par;
return var;
}";
var newExpression = Function.Create()
.WithParameter <string>("par")
.WithBody(
CodeLine.CreateVariable <string>("var"),
CodeLine.Assign("var", Operation.Constant("another")),
CodeLine.Assign(Operation.Variable("var"), Operation.Variable("par"), AssignementOperator.SumAssign)
)
.Returns("var");
AssertString.AreEqual(expected, newExpression.ToString());
var lambda = newExpression.ToLambda <Func <string, string> >();
Assert.IsNotNull(lambda);
var result = lambda("test");
Assert.AreEqual("anothertest", result);
}
public void AssignShouldAssignObjects()
{
const string expected =
@"public ExpressionBuilder.Test.TestObject Call(ExpressionBuilder.Test.TestObject first, ExpressionBuilder.Test.TestObject second)
{
first = second;
return first;
}";
var newExpression = Function.Create()
.WithParameter <TestObject>("first")
.WithParameter <TestObject>("second")
.WithBody(
CodeLine.Assign("first", "second")
)
.Returns("first");
AssertString.AreEqual(expected, newExpression.ToString());
var lambda = newExpression.ToLambda <Func <TestObject, TestObject, TestObject> >();
Assert.IsNotNull(lambda);
var expectedResult = new TestObject();
var result = lambda(new TestObject(), expectedResult);
Assert.AreSame(expectedResult, result);
}
public void ItShouldPossibleToInvokeStringFormat()
{
const string expected =
@"public System.String Call(System.String par1, System.String par2)
{
System.String result;
result = System.String.Format(""{0}-{1}"", par1, par2);
return result;
}";
var newExpression = Function.Create()
.WithParameter <string>("par1")
.WithParameter <string>("par2")
.WithBody(
CodeLine.CreateVariable <string>("result"),
CodeLine.Assign(Operation.Variable("result"),
StringOperation.Format(
"{0}-{1}",
Operation.Variable("par1"),
Operation.Variable("par2")))
)
.Returns("result");
AssertString.AreEqual(expected, newExpression.ToString());
var lambda = newExpression.ToLambda <Func <string, string, string> >();
Assert.IsNotNull(lambda);
var result = lambda("a", "b");
Assert.AreEqual("a-b", result);
}
public void AssignShouldAssign()
{
const string expected =
@"public System.String Call(System.String first, System.String second)
{
first = second;
return first;
}";
var newExpression = Function.Create()
.WithParameter(typeof(string), "first")
.WithParameter <string>("first")
.WithParameter <string>("second")
.WithBody(
CodeLine.Assign("first", "second"),
CodeLine.Assign("FirstName", Operation.Get("person.icdoperson.firstname"))
)
.Returns("first");
AssertString.AreEqual(expected, newExpression.ToString());
var lambda = newExpression.ToLambda <Func <string, string, string> >();
Assert.IsNotNull(lambda);
var result = lambda("test", "another");
Assert.AreEqual("another", result);
}
public void ItShouldPossibleToInvokeMethodsOnObjects()
{
const string expected =
@"public System.String Call(ExpressionBuilder.Test.SimpleObject par)
{
System.String result;
result = par.GetName();
return result;
}";
var newExpression = Function.Create()
.WithParameter <SimpleObject>("par")
.WithBody(
CodeLine.CreateVariable <string>("result"),
CodeLine.Assign("result", Operation.InvokeReturn("par", "GetName"))
)
.Returns("result");
AssertString.AreEqual(expected, newExpression.ToString());
var lambda = newExpression.ToLambda <Func <SimpleObject, string> >();
Assert.IsNotNull(lambda);
var so = new SimpleObject();
var result = lambda(so);
Assert.AreEqual("SimpleObject", result);
}
public void CastShouldCastSpecifiyingType()
{
const string expected =
@"public System.Int64 Call(System.Int32 first, System.Int64 second)
{
second = ((System.Int64)2);
second += ((System.Int64)first);
return second;
}";
var newExpression = Function.Create()
.WithParameter <int>("first")
.WithParameter <long>("second")
.WithBody(
CodeLine.Assign("second", Operation.CastConst(2, typeof(long))),
CodeLine.Assign("second", Operation.Cast("first", typeof(long)), AssignementOperator.SumAssign)
)
.Returns("second");
AssertString.AreEqual(expected, newExpression.ToString());
var lambda = newExpression.ToLambda <Func <int, long, long> >();
Assert.IsNotNull(lambda);
var result = lambda(3, 7);
Assert.AreEqual(5, result);
}
public void ItShouldPossibleToInvokeStaticMethodsOnObjects()
{
const string expected =
@"public System.Boolean Call(System.Int32 year)
{
System.Boolean result;
result = System.DateTime.IsLeapYear(year);
return result;
}";
var newExpression = Function.Create()
.WithParameter <int>("year")
.WithBody(
CodeLine.CreateVariable <bool>("result"),
CodeLine.Assign("result", Operation.InvokeReturn <DateTime>("IsLeapYear", Operation.Variable("year")))
)
.Returns("result");
AssertString.AreEqual(expected, newExpression.ToString());
var lambda = newExpression.ToLambda <Func <int, bool> >();
Assert.IsNotNull(lambda);
var result = lambda(2011);
Assert.IsFalse(result);
result = lambda(2012);
Assert.IsTrue(result);
}
public void ItShouldPossibleToInvokeStringCompare()
{
const string expected =
@"public System.Int32 Call(System.String par1, System.String par2)
{
System.Int32 result;
result = System.String.Compare(par1, par2, CurrentCulture);
return result;
}";
var newExpression = Function.Create()
.WithParameter <string>("par1")
.WithParameter <string>("par2")
.WithBody(
CodeLine.CreateVariable <int>("result"),
CodeLine.Assign(Operation.Variable("result"), StringOperation.Compare("par1", "par2"))
)
.Returns("result");
AssertString.AreEqual(expected, newExpression.ToString());
var lambda = newExpression.ToLambda <Func <string, string, int> >();
Assert.IsNotNull(lambda);
var result = lambda("a", "a");
Assert.AreEqual(0, result);
result = lambda("a", "b");
Assert.AreEqual(-1, result);
}
public void ItShouldPossibleToInvokeConstructorWithParameters()
{
const string expected =
@"public System.String Call(System.String name)
{
System.String result;
ExpressionBuilder.Test.SimpleObject par;
par = new ExpressionBuilder.Test.SimpleObject(name);
result = par.GetName();
return result;
}";
var newExpression = Function.Create()
.WithParameter <string>("name")
.WithBody(
CodeLine.CreateVariable <string>("result"),
CodeLine.CreateVariable <SimpleObject>("par"),
CodeLine.Assign("par", Operation.CreateInstance <SimpleObject>(Operation.Variable("name"))),
CodeLine.Assign("result", Operation.InvokeReturn("par", "GetName"))
)
.Returns("result");
AssertString.AreEqual(expected, newExpression.ToString());
var lambda = newExpression.ToLambda <Func <string, string> >();
Assert.IsNotNull(lambda);
var result = lambda("paramName");
Assert.AreEqual("paramName", result);
}
public void ItShouldPossibleToInvokeToString()
{
const string expected =
@"public System.String Call(System.Int32 par)
{
System.String result;
result = par.ToString();
return result;
}";
var newExpression = Function.Create()
.WithParameter <int>("par")
.WithBody(
CodeLine.CreateVariable <string>("result"),
CodeLine.Assign(Operation.Variable("result"), StringOperation.ToString("par"))
)
.Returns("result");
AssertString.AreEqual(expected, newExpression.ToString());
var lambda = newExpression.ToLambda <Func <int, string> >();
Assert.IsNotNull(lambda);
var result = lambda(1);
Assert.AreEqual("1", result);
}
public void SumAssignShouldWorkForStrings()
{
const string expected =
@"public System.String Call(System.String first, System.String second)
{
first += second;
return first;
}";
var newExpression = Function.Create()
.WithParameter <string>("first")
.WithParameter <string>("second")
.WithBody(
CodeLine.Assign("first", "second", AssignementOperator.SumAssign)
)
.Returns("first");
AssertString.AreEqual(expected, newExpression.ToString());
var lambda = newExpression.ToLambda <Func <string, string, string> >();
Assert.IsNotNull(lambda);
var result = lambda("test", "another");
Assert.AreEqual("testanother", result);
}
public void SubtractAssignShouldWorkForValueTypes()
{
const string expected =
@"public System.Int32 Call(System.Int32 first, System.Int32 second)
{
first -= second;
return first;
}";
var newExpression = Function.Create()
.WithParameter <int>("first")
.WithParameter <int>("second")
.WithBody(
CodeLine.Assign("first", "second", AssignementOperator.SubtractAssign)
)
.Returns("first");
AssertString.AreEqual(expected, newExpression.ToString());
var lambda = newExpression.ToLambda <Func <int, int, int> >();
Assert.IsNotNull(lambda);
var result = lambda(4, 2);
Assert.AreEqual(2, result);
}
public void ReturnShouldBeHandledCorrectlyInsideIfs()
{
const string expected =
@"public System.String Call(System.String par)
{
System.String result;
if(par == ""then"")
{
result = ""then"";
return result;
}
else
{
if(par == ""elseif"")
{
result = ""elseif"";
return result;
}
else
{
result = ""else"";
return result;
};
};
return result;
}";
var newExpression = Function.Create()
.WithParameter <string>("par")
.WithBody(
CodeLine.CreateVariable <string>("result"),
CodeLine.CreateIf(Condition.CompareConst("par", "then"))
.Then(
CodeLine.AssignConstant("result", "then"),
CodeLine.Return())
.ElseIf(Condition.Compare("par", Operation.Constant("elseif")))
.Then(
CodeLine.AssignConstant("result", "elseif"),
CodeLine.Return())
.Else(
CodeLine.AssignConstant("result", "else"),
CodeLine.Return())
)
.Returns("result");
AssertString.AreEqual(expected, newExpression.ToString());
var lambda = newExpression.ToLambda <Func <string, string> >();
Assert.IsNotNull(lambda);
var result = lambda("then");
Assert.AreEqual("then", result);
result = lambda("elseif");
Assert.AreEqual("elseif", result);
result = lambda("else");
Assert.AreEqual("else", result);
}
public void CreateVariablesShouldWorkInsideWhileIfAndThen()
{
const string expected =
@"public void Call(System.String par)
{
System.Int32 count;
count = 1;
while(count == 0)
{
if(True == True)
{
System.String var;
var = par;
}
else
{
System.String var;
var = par;
};
};
}";
var newExpression = Function.Create()
.WithParameter <string>("par")
.WithBody(
CodeLine.CreateVariable <int>("count"),
CodeLine.AssignConstant("count", 1),
CodeLine.CreateWhile(Condition.CompareConst("count", 0))
.Do(
CodeLine.CreateIf(Condition.CompareConst(Operation.Constant(true), true))
.Then(
CodeLine.CreateVariable <string>("var"),
CodeLine.Assign("var", "par")
)
.ElseIf(Condition.CompareConst(Operation.Constant(true), true))
.Then(
CodeLine.CreateVariable <string>("var"),
CodeLine.Assign("var", "par")
)
.Else(
CodeLine.CreateVariable <string>("var"),
CodeLine.Assign("var", "par")
)
)
);
AssertString.AreEqual(expected, newExpression.ToString());
var lambda = newExpression.ToLambda <Action <string> >();
Assert.IsNotNull(lambda);
lambda("test");
}
public void WhileLoopShouldAllowForcedReturn()
{
const string expected =
@"public System.Int32 Call(System.Int32 par)
{
System.Int32 first;
first = 0;
while(first < par)
{
first += 1;
if(first >= 10)
{
return first;
};
};
return first;
}";
var newExpression = Function.Create()
.WithParameter <int>("par")
.WithBody(
CodeLine.CreateVariable <int>("first"),
CodeLine.AssignConstant("first", 0),
CodeLine.CreateWhile(Condition.Compare("first", "par", ComparaisonOperator.Smaller))
.Do(
CodeLine.AssignConstant("first", Operation.Constant(1), AssignementOperator.SumAssign),
CodeLine.CreateIf(Condition.CompareConst("first", 10, ComparaisonOperator.GreaterEqual))
.Then(
CodeLine.Return()
))
)
.Returns("first");
AssertString.AreEqual(expected, newExpression.ToString());
var lambda = newExpression.ToLambda <Func <int, int> >();
Assert.IsNotNull(lambda);
var result = lambda(4);
Assert.AreEqual(4, result);
result = lambda(20);
Assert.AreEqual(10, result);
}
public void CanBeCreatedAFunctionWithoutParametersAndReturn()
{
const string expected =
@"public void Call()
{
//No Operation;
}";
var newExpression = Function.Create()
.WithBody(CodeLine.Nop);
AssertString.AreEqual(expected, newExpression.ToString());
var lambda = newExpression.ToLambda <Action>();
Assert.IsNotNull(lambda);
lambda();
}
public void CanBeCreatedAFunctionReturningVoid()
{
const string expected =
@"public void Call(System.String first, System.String second)
{
//No Operation;
}";
var newExpression = Function.Create()
.WithParameter <string>("first")
.WithParameter <string>("second")
.WithBody(CodeLine.Nop);
AssertString.AreEqual(expected, newExpression.ToString());
var lambda = newExpression.ToLambda <Action <string, string> >();
Assert.IsNotNull(lambda);
lambda("test", "another");
}
public void ShouldBePossibleToCallLambdaFunction()
{
const string expected =
@"public System.String Call(System.String first, System.String second)
{
System.String result;
result = System.Func<System.Object, System.String, System.String>(first, second);
return result;
}";
var newExpression = Function.Create()
.WithParameter <string>("first")
.WithParameter <string>("second")
.WithBody(
CodeLine.CreateVariable <string>("result"),
CodeLine.Assign("result",
Operation.Func <object, string, string>(
(a, b) =>
{
b += "-extra";
return(string.Format("{0}-{1}", a, b));
},
Operation.Variable("first"),
Operation.Variable("second"))
)
)
.Returns("result");
AssertString.AreEqual(expected, newExpression.ToString());
var lambda = newExpression.ToLambda <Func <string, string, string> >();
Assert.IsNotNull(lambda);
var result = lambda("a", "b");
Assert.AreEqual("a-b-extra", result);
}
public void ItShouldBePossibleToDeclareParametersAndReturn()
{
const string expected =
@"public System.String Call(System.String first, System.String second)
{
//No Operation;
return first;
}";
var newExpression = Function.Create()
.WithParameter <string>("first")
.WithParameter <string>("second")
.WithBody(CodeLine.Nop)
.Returns("first");
AssertString.AreEqual(expected, newExpression.ToString());
var lambda = newExpression.ToLambda <Func <string, string, string> >();
Assert.IsNotNull(lambda);
Assert.AreEqual("test", lambda("test", "another"));
}