[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); }