[Test] // improve: either?
public void Problem1_AddAllNaturalNumbersBelow1000_ThatAreMultiplesOf3Or5()
{
var code = "(1..1000).Where(x => (x mod 3 == 0) or (x mod 5 == 0)).Sum()";
var result = CompilationHelper.CompileAndEvaluate(code);
Assert.AreEqual(new Integer(233168), result);
}
public void BigInteger()
{
const string bigIntegerString = "1000000000000000000000000000000000000000";
var value = CompilationHelper.CompileAndEvaluate(bigIntegerString);
Assert.AreEqual(Framework.Integer.Parse(bigIntegerString), value);
}
public void SimpleInteger(string expressionString, int expectedFrom, int expectedTo)
{
var compiled = CompilationHelper.CompileAndEvaluate(expressionString);
Assert.AreElementsEqual(
Enumerable.Range(expectedFrom, expectedTo - expectedFrom).Select(x => new Integer(x)),
compiled
);
}
public void Simple(string valueString, object expectedValue)
{
var value = CompilationHelper.CompileAndEvaluate(valueString);
Assert.AreEqual(TestArgumentConverter.Convert(expectedValue), value);
}
public void Integer(string expressionString, int expectedValue)
{
var compiled = CompilationHelper.CompileAndEvaluate(expressionString);
Assert.AreEqual(new Integer(expectedValue), compiled);
}
public void SimpleConstants(string expressionString, object expectedValue)
{
var compiled = CompilationHelper.CompileAndEvaluate(expressionString);
Assert.AreEqual(expectedValue, compiled);
}
public void NewExternalObjectWithArguments()
{
var result = CompilationHelper.CompileAndEvaluate("new Version('1.1.1.1')");
Assert.AreEqual(new Version("1.1.1.1"), result);
}
public void NewExternalObjectWithNoArguments()
{
var result = CompilationHelper.CompileAndEvaluate("new Random()");
Assert.IsInstanceOfType <Random>(result);
}
public void LambdaExpression_Identity_InMethodCall(string lambda)
{
var result = CompilationHelper.CompileAndEvaluate("TestMethods.AcceptsGenericTToT(7, " + lambda + ")");
Assert.IsInstanceOfType <Func <Integer, Integer> >(result);
}
public void LambdaExpression_TypedParameter_Condition()
{
var result = CompilationHelper.CompileAndEvaluate("(integer x) => x > 5");
Assert.IsInstanceOfType <Func <Integer, bool> >(result);
}
public void LambdaExpression_TypedParameter_Identity()
{
var result = CompilationHelper.CompileAndEvaluate("(integer x) => x");
Assert.IsInstanceOfType <Func <Integer, Integer> >(result);
}
public void MethodGroup_External_GenericMethod_WithoutOverloads_InMethodCall()
{
var result = CompilationHelper.CompileAndEvaluate("TestMethods.AcceptsGenericTToObject(5, TestMethods.GenericTToObject)");
Assert.IsInstanceOfType <Func <Integer, object> >(result);
}
public void MethodGroup_External_StaticMethod_WithoutOverloads()
{
var result = CompilationHelper.CompileAndEvaluate("TimeSpan.FromMinutes");
Assert.IsInstanceOfType <Func <double, TimeSpan> >(result);
}
public void Simple(string expressionString, object[] expectedValues)
{
var compiled = ((Array)CompilationHelper.CompileAndEvaluate(expressionString)).Cast <object>().ToArray();
Assert.AreElementsEqual(TestArgumentConverter.Convert(expectedValues), compiled);
}
public void MathPow(double x, double y)
{
var result = CompilationHelper.CompileAndEvaluate(string.Format("Math.Pow(({0:0.00}).ToDouble(), ({1:0.00}).ToDouble())", x, y));
Assert.AreEqual(Math.Pow(10, 10), result);
}
public void LambdaExpression_Condition_InMethodCall(string lambda)
{
var result = CompilationHelper.CompileAndEvaluate("[1, 2, 3, 4, 5].Where(" + lambda + ")");
Assert.AreElementsEqual(new[] { new Integer(4), new Integer(5) }, result);
}
public void ExternalExtensionMethodWithNoOtherArguments()
{
var result = CompilationHelper.CompileAndEvaluate("[1,1,1,2].Distinct()");
Assert.AreElementsEqualIgnoringOrder(new[] { new Integer(1), new Integer(2) }, result);
}
public void ExternalObjectInstanceProperty()
{
var result = CompilationHelper.CompileAndEvaluate("'abc'.Length");
Assert.AreEqual(3, result);
}