VAR/VAR.ExpressionEvaluator
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rearrangements

Browse Source 
Migrate to Sdk projects.
Migrate tests to xUnit.
Bump version 0.2.3.
Migrate to NetStandar2.0.
This commit is contained in:
Valeriano A.R.
2021-06-13 20:10:23 +02:00
parent 196131a66b
commit fa13af7f82
16 changed files with 379 additions and 532 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
VAR.ExpressionEvaluator.Tests/ExpressionBinaryNodeTests.cs
View File

@@ -1,11 +1,10 @@
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Xunit;
namespace VAR.ExpressionEvaluator.Tests
{
[TestClass()]
public class ExpressionBinaryNodeTests
{
[TestMethod()]
[Fact]
public void ExpressionBinaryNode__Plus()
{
var expr = new ExpressionBinaryNode(
@@ -16,10 +15,10 @@ namespace VAR.ExpressionEvaluator.Tests
var result = expr.Eval(null);
Assert.AreEqual(30m, result);
Assert.Equal(30m, result);
}
[TestMethod()]
[Fact]
public void ExpressionBinaryNode__Minus()
{
var expr = new ExpressionBinaryNode(
@@ -30,10 +29,10 @@ namespace VAR.ExpressionEvaluator.Tests
var result = expr.Eval(null);
Assert.AreEqual(-10m, result);
Assert.Equal(-10m, result);
}
[TestMethod()]
[Fact]
public void ExpressionBinaryNode__Multiply()
{
var expr = new ExpressionBinaryNode(
@@ -44,10 +43,10 @@ namespace VAR.ExpressionEvaluator.Tests
var result = expr.Eval(null);
Assert.AreEqual(200m, result);
Assert.Equal(200m, result);
}
[TestMethod()]
[Fact]
public void ExpressionBinaryNode__Division()
{
var expr = new ExpressionBinaryNode(
@@ -58,7 +57,7 @@ namespace VAR.ExpressionEvaluator.Tests
var result = expr.Eval(null);
Assert.AreEqual(2m, result);
Assert.Equal(2m, result);
}
}
}

15
VAR.ExpressionEvaluator.Tests/ExpressionNumberNodeTests.cs
View File

@@ -1,29 +1,28 @@
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Xunit;
namespace VAR.ExpressionEvaluator.Tests
{
[TestClass()]
public class ExpressionNumberNodeTests
{
[TestMethod()]
[Fact]
public void ExpressionNumberNode__One()
{
IExpressionNode node = new ExpressionNumberNode(1);
Assert.AreEqual(1m, node.Eval(null));
Assert.Equal(1m, node.Eval(null));
}
[TestMethod()]
[Fact]
public void ExpressionNumberNode__Two()
{
IExpressionNode node = new ExpressionNumberNode(2);
Assert.AreEqual(2m, node.Eval(null));
Assert.Equal(2m, node.Eval(null));
}
[TestMethod()]
[Fact]
public void ExpressionNumberNode__OneHundredDotFortyFive()
{
IExpressionNode node = new ExpressionNumberNode(100.45m);
Assert.AreEqual(100.45m, node.Eval(null));
Assert.Equal(100.45m, node.Eval(null));
}
}
}

15
VAR.ExpressionEvaluator.Tests/ExpressionStringNodeTests.cs
View File

@@ -1,29 +1,28 @@
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Xunit;
namespace VAR.ExpressionEvaluator.Tests
{
[TestClass()]
public class ExpressionStringNodeTests
{
[TestMethod()]
[Fact]
public void ExpressionNumberNode__Hello()
{
IExpressionNode node = new ExpressionStringNode("Hello");
Assert.AreEqual("Hello", node.Eval(null));
Assert.Equal("Hello", node.Eval(null));
}
[TestMethod()]
[Fact]
public void ExpressionNumberNode__World()
{
IExpressionNode node = new ExpressionStringNode("World");
Assert.AreEqual("World", node.Eval(null));
Assert.Equal("World", node.Eval(null));
}
[TestMethod()]
[Fact]
public void ExpressionNumberNode__Hello_World()
{
IExpressionNode node = new ExpressionStringNode("Hello World");
Assert.AreEqual("Hello World", node.Eval(null));
Assert.Equal("Hello World", node.Eval(null));
}
}
}

371
VAR.ExpressionEvaluator.Tests/ParserTests.cs
View File

@@ -1,175 +1,174 @@
using System;
using System.Linq;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Xunit;
namespace VAR.ExpressionEvaluator.Tests
{
[TestClass()]
public class ParserTests
{
#region Plus and Minus
[TestMethod()]
[Fact]
public void PlusAndMinus__Ten_EqualsTen()
{
string expression = "10";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(10m, result);
Assert.Equal(10m, result);
}
[TestMethod()]
[Fact]
public void PlusAndMinus__OnePlusTwo_EqualsThree()
{
string expression = "1 + 2";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(3m, result);
Assert.Equal(3m, result);
}
[TestMethod()]
[Fact]
public void PlusAndMinus__OneMinusTwo_EqualsMinusOne()
{
string expression = "1 - 2";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(-1m, result);
Assert.Equal(-1m, result);
}
[TestMethod()]
[Fact]
public void PlusAndMinus__OneMillionMinusHundredThousands_EqualsNineHundredThousands()
{
string expression = "1000000 - 100000";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(900000m, result);
Assert.Equal(900000m, result);
}
#endregion Plus and minus
#region Number signs
[TestMethod()]
[Fact]
public void Signs__MinusTen()
{
string expression = "-10";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(-10m, result);
Assert.Equal(-10m, result);
}
[TestMethod()]
[Fact]
public void Signs__PlusTen()
{
string expression = "+10";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(10m, result);
Assert.Equal(10m, result);
}
[TestMethod()]
[Fact]
public void Signs__MinusMinusTen()
{
string expression = "--10";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(10m, result);
Assert.Equal(10m, result);
}
[TestMethod()]
[Fact]
public void Signs__MinusPlusChainTen()
{
string expression = "--++-+-10";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(10m, result);
Assert.Equal(10m, result);
}
[TestMethod()]
[Fact]
public void Signs__10Minus20Minus30()
{
string expression = "10 + -20 - +30";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(-40m, result);
Assert.Equal(-40m, result);
}
#endregion Number signs
#region Decimal numbers
[TestMethod()]
[Fact]
public void Decimals__OnePointZero()
{
string expression = "1.0";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(1.0m, result);
Assert.Equal(1.0m, result);
}
[TestMethod()]
[Fact]
public void Decimals__OnePointOne()
{
string expression = "1.1";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(1.1m, result);
Assert.Equal(1.1m, result);
}
#endregion Decimal numbers
#region Multiplication and division
[TestMethod()]
[Fact]
public void MultAndDiv__10MutiplyBy2()
{
string expression = "10 * 2";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(20m, result);
Assert.Equal(20m, result);
}
[TestMethod()]
[Fact]
public void MultAndDiv__10DividedBy2()
{
string expression = "10 / 2";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(5m, result);
Assert.Equal(5m, result);
}
[TestMethod()]
[Fact]
public void MultAndDiv__5DividedBy2()
{
string expression = "5 / 2";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(2.5m, result);
Assert.Equal(2.5m, result);
}
[TestMethod()]
[Fact]
public void MultAndDiv__5DividedBy2Plus1()
{
string expression = "5 / 2 + 1";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(3.5m, result);
Assert.Equal(3.5m, result);
}
[TestMethod()]
[Fact]
public void MultAndDiv__1Plus5DividedBy2()
{
string expression = "1 + 5 / 2";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(3.5m, result);
Assert.Equal(3.5m, result);
}
[TestMethod()]
[Fact]
public void MultAndDiv__5DividedByParen1Plus1()
{
string expression = "5 / (1 + 1)";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(2.5m, result);
Assert.Equal(2.5m, result);
}
[TestMethod()]
[Fact]
public void MultAndDiv__Paren2Plus2DividedByParen1Plus1()
{
string expression = "(2 + 2) / (1 + 1)";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(2m, result);
Assert.Equal(2m, result);
}
#endregion Multiplication and division
#region Variables
[TestMethod()]
[Fact]
public void Variables__Var1PlusVar2()
{
EvaluationContext evaluationContex = new EvaluationContext();
@@ -177,10 +176,10 @@ namespace VAR.ExpressionEvaluator.Tests
evaluationContex.SetVariable("v2", 1);
string expression = "v1 + v2";
object result = Parser.EvaluateString(expression, evaluationContex);
Assert.AreEqual(2m, result);
Assert.Equal(2m, result);
}
[TestMethod()]
[Fact]
public void Variables__Var1MultiplyVar2()
{
EvaluationContext evaluationContex = new EvaluationContext();
@@ -188,10 +187,10 @@ namespace VAR.ExpressionEvaluator.Tests
evaluationContex.SetVariable("v2", 5);
string expression = "v1 * v2";
object result = Parser.EvaluateString(expression, evaluationContex);
Assert.AreEqual(50m, result);
Assert.Equal(50m, result);
}
[TestMethod()]
[Fact]
public void Variables__Var1DivideVar2()
{
EvaluationContext evaluationContex = new EvaluationContext();
@@ -199,14 +198,14 @@ namespace VAR.ExpressionEvaluator.Tests
evaluationContex.SetVariable("$v2", 20);
string expression = "_v1 / $v2";
object result = Parser.EvaluateString(expression, evaluationContex);
Assert.AreEqual(5m, result);
Assert.Equal(5m, result);
}
#endregion Variables
#region Functions
[TestMethod()]
[Fact]
public void Functions__MaxFunction()
{
EvaluationContext evaluationContex = new EvaluationContext();
@@ -216,10 +215,10 @@ namespace VAR.ExpressionEvaluator.Tests
});
string expression = "max(1,2,10,5)";
object result = Parser.EvaluateString(expression, evaluationContex);
Assert.AreEqual(10m, result);
Assert.Equal(10m, result);
}
[TestMethod()]
[Fact]
public void Functions__NestedTest()
{
EvaluationContext evaluationContex = new EvaluationContext();
@@ -239,22 +238,22 @@ namespace VAR.ExpressionEvaluator.Tests
});
string expression = "iif(linea1>linea2,iif(linea1>linea4, linea1, iif(linea4>linea2,linea4,linea2)),iif(linea2>linea4,linea2,linea4))";
object result = Parser.EvaluateString(expression, evaluationContex);
Assert.AreEqual(4m, result);
Assert.Equal(4m, result);
}
#endregion Functions
#region Strings
[TestMethod()]
[Fact]
public void Strings__Contatenate_Hello_World()
{
string expression = "\"Hello\" + ' ' +\"World\"";
object result = Parser.EvaluateString(expression);
Assert.AreEqual("Hello World", result);
Assert.Equal("Hello World", result);
}
[TestMethod()]
[Fact]
public void Strings__Contatenate_Hello_World_WithVariables()
{
EvaluationContext evaluationContex = new EvaluationContext();
@@ -263,45 +262,45 @@ namespace VAR.ExpressionEvaluator.Tests
evaluationContex.SetVariable("v3", "World");
string expression = "v1 + v2 + v3";
object result = Parser.EvaluateString(expression, evaluationContex);
Assert.AreEqual("Hello World", result);
Assert.Equal("Hello World", result);
}
[TestMethod()]
[Fact]
public void Strings__Fail_Minus()
{
string expression = "'Hello' - 'World'";
try
{
object result = Parser.EvaluateString(expression);
Assert.Fail();
Assert.True(false);
}
catch (Exception)
{
}
}
[TestMethod()]
[Fact]
public void Strings__Fail_Multiply()
{
string expression = "'Hello' * 'World'";
try
{
object result = Parser.EvaluateString(expression);
Assert.Fail();
Assert.True(false);
}
catch (Exception)
{
}
}
[TestMethod()]
[Fact]
public void Strings__Fail_Division()
{
string expression = "'Hello' / 'World'";
try
{
object result = Parser.EvaluateString(expression);
Assert.Fail();
Assert.True(false);
}
catch (Exception)
{
@@ -312,230 +311,230 @@ namespace VAR.ExpressionEvaluator.Tests
#region Relations
[TestMethod()]
[Fact]
public void Relations_1GreatherThan2_EqualsFalse()
{
string expression = "1>2";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(false, result);
Assert.False((bool?)result);
}
[TestMethod()]
[Fact]
public void Relations_StringEmptyGreatherThan1_EqualsFalse()
{
string expression = "\"\">1";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(false, result);
Assert.False((bool?)result);
}
[TestMethod()]
[Fact]
public void Relations_1GreatherThanStringEmpty_EqualsFalse()
{
string expression = "1>\"\"";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(false, result);
Assert.False((bool?)result);
}
[TestMethod()]
[Fact]
public void Relations_1Equals1_EqualsTrue()
{
string expression = "1=1";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(true, result);
Assert.True((bool?)result);
}
[TestMethod()]
[Fact]
public void Relations_StringEmptyEquals1_EqualsFalse()
{
string expression = "\"\"=1";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(false, result);
Assert.False((bool?)result);
}
[TestMethod()]
[Fact]
public void Relations_1EqualsStringEmpty_EqualsFalse()
{
string expression = "1=\"\"";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(false, result);
Assert.False((bool?)result);
}
[TestMethod()]
[Fact]
public void Relations_10NotEquals1_EqualsTrue()
{
string expression = "10!=1";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(true, result);
Assert.True((bool?)result);
}
[TestMethod()]
[Fact]
public void Relations_StringEmptyNotEquals1_EqualsTrue()
{
string expression = "\"\"!=1";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(true, result);
Assert.True((bool?)result);
}
[TestMethod()]
[Fact]
public void Relations_1NotEqualsStringEmpty_EqualsTrue()
{
string expression = "1!=\"\"";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(true, result);
Assert.True((bool?)result);
}
[TestMethod()]
[Fact]
public void Relations_10Different1_EqualsTrue()
{
string expression = "10<>1";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(true, result);
Assert.True((bool?)result);
}
[TestMethod()]
[Fact]
public void Relations_StringEmptyDifferent1_EqualsTrue()
{
string expression = "\"\"<>1";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(true, result);
Assert.True((bool?)result);
}
[TestMethod()]
[Fact]
public void Relations_1DifferentStringEmpty_EqualsTrue()
{
string expression = "1<>\"\"";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(true, result);
Assert.True((bool?)result);
}
[TestMethod()]
[Fact]
public void Relations_10LessThan1_EqualsFalse()
{
string expression = "10<1";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(false, result);
Assert.False((bool?)result);
}
[TestMethod()]
[Fact]
public void Relations_StringEmptyLessThan1_EqualsFalse()
{
string expression = "\"\"<1";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(false, result);
Assert.False((bool?)result);
}
[TestMethod()]
[Fact]
public void Relations_1LessThanStringEmpty_EqualsFalse()
{
string expression = "1<\"\"";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(false, result);
Assert.False((bool?)result);
}
[TestMethod()]
[Fact]
public void Relations_1GreaterOrEqualThan1_EqualsTrue()
{
string expression = "1>=1";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(true, result);
Assert.True((bool?)result);
}
[TestMethod()]
[Fact]
public void Relations_StringEmptyGreaterOrEqualThan1_EqualsFalse()
{
string expression = "\"\">=1";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(false, result);
Assert.False((bool?)result);
}
[TestMethod()]
[Fact]
public void Relations_1GreaterOrEqualThanStringEmpty_EqualsFalse()
{
string expression = "1>=\"\"";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(false, result);
Assert.False((bool?)result);
}
[TestMethod()]
[Fact]
public void Relations_1LessOrEqualThan1_EqualsTrue()
{
string expression = "1<=1";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(true, result);
Assert.True((bool?)result);
}
[TestMethod()]
[Fact]
public void Relations_1GreaterOrEqualThan10_EqualsFalse()
{
string expression = "1>=10";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(false, result);
Assert.False((bool?)result);
}
[TestMethod()]
[Fact]
public void Relations_10LessOrEqualThan1_EqualsFalse()
{
string expression = "10<=1";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(false, result);
Assert.False((bool?)result);
}
[TestMethod()]
[Fact]
public void Relations_StringEmptyLessOrEqualThan1_EqualsFalse()
{
string expression = "\"\"<=1";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(false, result);
Assert.False((bool?)result);
}
[TestMethod()]
[Fact]
public void Relations_1LessOrEqualThanStringEmpty_EqualsFalse()
{
string expression = "1<=\"\"";
object result = Parser.EvaluateString(expression);
Assert.AreEqual(false, result);
Assert.False((bool?)result);
}
#endregion Relations
#region BooleanOps
[TestMethod()]
[Fact]
public void BooleanOps_And()
{
Assert.AreEqual(false, Parser.EvaluateString("false and false"));
Assert.AreEqual(false, Parser.EvaluateString("false and true"));
Assert.AreEqual(false, Parser.EvaluateString("true and false"));
Assert.AreEqual(true, Parser.EvaluateString("true and true"));
Assert.False((bool?)Parser.EvaluateString("false and false"));
Assert.False((bool?)Parser.EvaluateString("false and true"));
Assert.False((bool?)Parser.EvaluateString("true and false"));
Assert.True((bool?)Parser.EvaluateString("true and true"));
Assert.AreEqual(false, Parser.EvaluateString("false && false"));
Assert.AreEqual(false, Parser.EvaluateString("false && true"));
Assert.AreEqual(false, Parser.EvaluateString("true && false"));
Assert.AreEqual(true, Parser.EvaluateString("true && true"));
Assert.False((bool?)Parser.EvaluateString("false && false"));
Assert.False((bool?)Parser.EvaluateString("false && true"));
Assert.False((bool?)Parser.EvaluateString("true && false"));
Assert.True((bool?)Parser.EvaluateString("true && true"));
}
[TestMethod()]
[Fact]
public void BooleanOps_Or()
{
Assert.AreEqual(false, Parser.EvaluateString("false or false"));
Assert.AreEqual(true, Parser.EvaluateString("false or true"));
Assert.AreEqual(true, Parser.EvaluateString("true or false"));
Assert.AreEqual(true, Parser.EvaluateString("true or true"));
Assert.False((bool?)Parser.EvaluateString("false or false"));
Assert.True((bool?)Parser.EvaluateString("false or true"));
Assert.True((bool?)Parser.EvaluateString("true or false"));
Assert.True((bool?)Parser.EvaluateString("true or true"));
Assert.AreEqual(false, Parser.EvaluateString("false || false"));
Assert.AreEqual(true, Parser.EvaluateString("false || true"));
Assert.AreEqual(true, Parser.EvaluateString("true || false"));
Assert.AreEqual(true, Parser.EvaluateString("true || true"));
Assert.False((bool?)Parser.EvaluateString("false || false"));
Assert.True((bool?)Parser.EvaluateString("false || true"));
Assert.True((bool?)Parser.EvaluateString("true || false"));
Assert.True((bool?)Parser.EvaluateString("true || true"));
}
[TestMethod()]
[Fact]
public void BooleanOps_Not()
{
Assert.AreEqual(true, Parser.EvaluateString("!false"));
Assert.AreEqual(false, Parser.EvaluateString("!true"));
Assert.True((bool?)Parser.EvaluateString("!false"));
Assert.False((bool?)Parser.EvaluateString("!true"));
Assert.AreEqual(true, Parser.EvaluateString("not false"));
Assert.AreEqual(false, Parser.EvaluateString("not true"));
Assert.True((bool?)Parser.EvaluateString("not false"));
Assert.False((bool?)Parser.EvaluateString("not true"));
}
@@ -544,224 +543,224 @@ namespace VAR.ExpressionEvaluator.Tests
#region Null value
[TestMethod()]
[Fact]
public void NullValue_NullPlusAnything_EqualsNull()
{
Assert.AreEqual(null, Parser.EvaluateString("null + 1"));
Assert.AreEqual(null, Parser.EvaluateString("null + 100"));
Assert.AreEqual(null, Parser.EvaluateString("1 + null"));
Assert.AreEqual(null, Parser.EvaluateString("100 + null"));
Assert.AreEqual(null, Parser.EvaluateString("null + null"));
Assert.Null((bool?)Parser.EvaluateString("null + 1"));
Assert.Null((bool?)Parser.EvaluateString("null + 100"));
Assert.Null((bool?)Parser.EvaluateString("1 + null"));
Assert.Null((bool?)Parser.EvaluateString("100 + null"));
Assert.Null((bool?)Parser.EvaluateString("null + null"));
}
[TestMethod()]
[Fact]
public void NullValue_NullMinusAnything_EqualsNull()
{
Assert.AreEqual(null, Parser.EvaluateString("null - 1"));
Assert.AreEqual(null, Parser.EvaluateString("null - 100"));
Assert.AreEqual(null, Parser.EvaluateString("1 - null"));
Assert.AreEqual(null, Parser.EvaluateString("100 - null"));
Assert.AreEqual(null, Parser.EvaluateString("null - null"));
Assert.Null((bool?)Parser.EvaluateString("null - 1"));
Assert.Null((bool?)Parser.EvaluateString("null - 100"));
Assert.Null((bool?)Parser.EvaluateString("1 - null"));
Assert.Null((bool?)Parser.EvaluateString("100 - null"));
Assert.Null((bool?)Parser.EvaluateString("null - null"));
}
[TestMethod()]
[Fact]
public void NullValue_NullByAnything_EqualsNull()
{
Assert.AreEqual(null, Parser.EvaluateString("null * 1"));
Assert.AreEqual(null, Parser.EvaluateString("null * 100"));
Assert.AreEqual(null, Parser.EvaluateString("1 * null"));
Assert.AreEqual(null, Parser.EvaluateString("100 * null"));
Assert.AreEqual(null, Parser.EvaluateString("null * null"));
Assert.Null((bool?)Parser.EvaluateString("null * 1"));
Assert.Null((bool?)Parser.EvaluateString("null * 100"));
Assert.Null((bool?)Parser.EvaluateString("1 * null"));
Assert.Null((bool?)Parser.EvaluateString("100 * null"));
Assert.Null((bool?)Parser.EvaluateString("null * null"));
Assert.AreEqual(null, Parser.EvaluateString("null / 1"));
Assert.AreEqual(null, Parser.EvaluateString("null / 100"));
Assert.AreEqual(null, Parser.EvaluateString("1 / null"));
Assert.AreEqual(null, Parser.EvaluateString("100 / null"));
Assert.AreEqual(null, Parser.EvaluateString("null / null"));
Assert.Null((bool?)Parser.EvaluateString("null / 1"));
Assert.Null((bool?)Parser.EvaluateString("null / 100"));
Assert.Null((bool?)Parser.EvaluateString("1 / null"));
Assert.Null((bool?)Parser.EvaluateString("100 / null"));
Assert.Null((bool?)Parser.EvaluateString("null / null"));
}
#endregion
#region Excepctions
[TestMethod()]
[Fact]
public void Exceptions__HelloAtEnd__UnexpectedCharactersAtEndException()
{
try
{
string expression = "1 + 1 \"Hello\"";
object result = Parser.EvaluateString(expression);
Assert.Fail();
Assert.True(false);
}
catch (Exception ex)
{
Assert.IsInstanceOfType(ex, typeof(Parser.UnexpectedCharactersAtEndException));
Assert.IsType<Parser.UnexpectedCharactersAtEndException>(ex);
}
}
[TestMethod()]
[Fact]
public void Exceptions__TrueAtEndInsideParens__MissingCloseParenthesisException()
{
try
{
string expression = "(1+1 true)";
object result = Parser.EvaluateString(expression);
Assert.Fail();
Assert.True(false);
}
catch (Exception ex)
{
Assert.IsInstanceOfType(ex, typeof(Parser.MissingCloseParenthesisException));
Assert.IsType<Parser.MissingCloseParenthesisException>(ex);
}
}
[TestMethod()]
[Fact]
public void Exceptions__TrueAtEndInsideFunctionCall__MissingCloseParenthesisException()
{
try
{
string expression = "Func(1 true)";
object result = Parser.EvaluateString(expression);
Assert.Fail();
Assert.True(false);
}
catch (Exception ex)
{
Assert.IsInstanceOfType(ex, typeof(Parser.MissingCloseParenthesisException));
Assert.IsType<Parser.MissingCloseParenthesisException>(ex);
}
}
[TestMethod()]
[Fact]
public void Exceptions__EOF__UnexpectedEOFException()
{
try
{
string expression = "";
object result = Parser.EvaluateString(expression);
Assert.Fail();
Assert.True(false);
}
catch (Exception ex)
{
Assert.IsInstanceOfType(ex, typeof(Parser.UnexpectedEOFException));
Assert.IsType<Parser.UnexpectedEOFException>(ex);
}
}
[TestMethod()]
[Fact]
public void Exceptions__Plus__UnexpectedEOFException()
{
try
{
string expression = "+";
object result = Parser.EvaluateString(expression);
Assert.Fail();
Assert.True(false);
}
catch (Exception ex)
{
Assert.IsInstanceOfType(ex, typeof(Parser.UnexpectedEOFException));
Assert.IsType<Parser.UnexpectedEOFException>(ex);
}
}
[TestMethod()]
[Fact]
public void Exceptions__Minus__UnexpectedEOFException()
{
try
{
string expression = "-";
object result = Parser.EvaluateString(expression);
Assert.Fail();
Assert.True(false);
}
catch (Exception ex)
{
Assert.IsInstanceOfType(ex, typeof(Parser.UnexpectedEOFException));
Assert.IsType<Parser.UnexpectedEOFException>(ex);
}
}
[TestMethod()]
[Fact]
public void Exceptions__OpenParens__UnexpectedEOFException()
{
try
{
string expression = "(";
object result = Parser.EvaluateString(expression);
Assert.Fail();
Assert.True(false);
}
catch (Exception ex)
{
Assert.IsInstanceOfType(ex, typeof(Parser.UnexpectedEOFException));
Assert.IsType<Parser.UnexpectedEOFException>(ex);
}
}
[TestMethod()]
[Fact]
public void Exceptions__Comma__UnexpectedTokenException()
{
try
{
string expression = ",";
object result = Parser.EvaluateString(expression);
Assert.Fail();
Assert.True(false);
}
catch (Exception ex)
{
Assert.IsInstanceOfType(ex, typeof(Parser.UnexpectedTokenException));
Assert.IsType<Parser.UnexpectedTokenException>(ex);
}
}
[TestMethod()]
[Fact]
public void Exceptions__Division__UnexpectedTokenException()
{
try
{
string expression = "/";
object result = Parser.EvaluateString(expression);
Assert.Fail();
Assert.True(false);
}
catch (Exception ex)
{
Assert.IsInstanceOfType(ex, typeof(Parser.UnexpectedTokenException));
Assert.IsType<Parser.UnexpectedTokenException>(ex);
}
}
[TestMethod()]
[Fact]
public void Exceptions__Multiply__UnexpectedTokenException()
{
try
{
string expression = "*";
object result = Parser.EvaluateString(expression);
Assert.Fail();
Assert.True(false);
}
catch (Exception ex)
{
Assert.IsInstanceOfType(ex, typeof(Parser.UnexpectedTokenException));
Assert.IsType<Parser.UnexpectedTokenException>(ex);
}
}
[TestMethod()]
[Fact]
public void Exceptions__CloseParens__UnexpectedTokenException()
{
try
{
string expression = ")";
object result = Parser.EvaluateString(expression);
Assert.Fail();
Assert.True(false);
}
catch (Exception ex)
{
Assert.IsInstanceOfType(ex, typeof(Parser.UnexpectedTokenException));
Assert.IsType<Parser.UnexpectedTokenException>(ex);
}
}
[TestMethod()]
[Fact]
public void Exceptions__Parens__UnexpectedTokenException()
{
try
{
string expression = "()";
object result = Parser.EvaluateString(expression);
Assert.Fail();
Assert.True(false);
}
catch (Exception ex)
{
Assert.IsInstanceOfType(ex, typeof(Parser.UnexpectedTokenException));
Assert.IsType<Parser.UnexpectedTokenException>(ex);
}
}

9
VAR.ExpressionEvaluator.Tests/Properties/AssemblyInfo.cs
View File

@@ -1,9 +0,0 @@
using System.Reflection;
using System.Runtime.InteropServices;
[assembly: AssemblyTitle("VAR.ExpressionEvaluator.Tests")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyProduct("VAR.ExpressionEvaluator.Tests")]
[assembly: ComVisible(false)]
[assembly: Guid("3195f0e0-9489-49ce-8fc2-627a73f80cc7")]

137
VAR.ExpressionEvaluator.Tests/TokenizerTests.cs
View File

@@ -1,230 +1,229 @@
using System.IO;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Xunit;
namespace VAR.ExpressionEvaluator.Tests
{
[TestClass()]
public class TokenizerTests
{
[TestMethod()]
[Fact]
public void Tokenizer__Plus()
{
var testString = "10 + 20";
var t = new Tokenizer(new StringReader(testString));
// "10"
Assert.AreEqual(t.Token, Token.Number);
Assert.AreEqual(t.Number, 10);
Assert.Equal(Token.Number, t.Token);
Assert.Equal(10, t.Number);
t.NextToken();
// "+"
Assert.AreEqual(t.Token, Token.Plus);
Assert.Equal(Token.Plus, t.Token);
t.NextToken();
// "20"
Assert.AreEqual(t.Token, Token.Number);
Assert.AreEqual(t.Number, 20);
Assert.Equal(Token.Number, t.Token);
Assert.Equal(20, t.Number);
t.NextToken();
Assert.AreEqual(t.Token, Token.EOF);
Assert.Equal(Token.EOF, t.Token);
}
[TestMethod()]
[Fact]
public void Tokenizer__PlusMinusAndDecimal()
{
var testString = "10 + 20 - 30.123";
var t = new Tokenizer(new StringReader(testString));
// "10"
Assert.AreEqual(t.Token, Token.Number);
Assert.AreEqual(t.Number, 10);
Assert.Equal(Token.Number, t.Token);
Assert.Equal(10, t.Number);
t.NextToken();
// "+"
Assert.AreEqual(t.Token, Token.Plus);
Assert.Equal(Token.Plus, t.Token);
t.NextToken();
// "20"
Assert.AreEqual(t.Token, Token.Number);
Assert.AreEqual(t.Number, 20);
Assert.Equal(Token.Number, t.Token);
Assert.Equal(20, t.Number);
t.NextToken();
// "-"
Assert.AreEqual(t.Token, Token.Minus);
Assert.Equal(Token.Minus, t.Token);
t.NextToken();
// "20"
Assert.AreEqual(t.Token, Token.Number);
Assert.AreEqual(t.Number, 30.123m);
Assert.Equal(Token.Number, t.Token);
Assert.Equal(30.123m, t.Number);
t.NextToken();
Assert.AreEqual(t.Token, Token.EOF);
Assert.Equal(Token.EOF, t.Token);
}
[TestMethod()]
[Fact]
public void Tokenizer__SimpleString()
{
var testString = "\"Hello World\"";
var t = new Tokenizer(new StringReader(testString));
// "Hello World"
Assert.AreEqual(t.Token, Token.String);
Assert.AreEqual(t.Text, "Hello World");
Assert.Equal(Token.String, t.Token);
Assert.Equal("Hello World", t.Text);
t.NextToken();
Assert.AreEqual(t.Token, Token.EOF);
Assert.Equal(Token.EOF, t.Token);
}
[TestMethod()]
[Fact]
public void Tokenizer__StringWithEscaping()
{
var testString = "\"Hello \\\"World\\\"\"";
var t = new Tokenizer(new StringReader(testString));
// "Hello \"World\""
Assert.AreEqual(t.Token, Token.String);
Assert.AreEqual(t.Text, "Hello \"World\"");
Assert.Equal(Token.String, t.Token);
Assert.Equal("Hello \"World\"", t.Text);
t.NextToken();
Assert.AreEqual(t.Token, Token.EOF);
Assert.Equal(Token.EOF, t.Token);
}
[TestMethod()]
[Fact]
public void Tokenizer__Identifiers()
{
var testString = "null true false _$variable1 $variable2 [;{}#]";
var t = new Tokenizer(new StringReader(testString));
// "null"
Assert.AreEqual(t.Token, Token.Identifier);
Assert.AreEqual(t.Text, "null");
Assert.Equal(Token.Identifier, t.Token);
Assert.Equal("null", t.Text);
t.NextToken();
// "true"
Assert.AreEqual(t.Token, Token.Identifier);
Assert.AreEqual(t.Text, "true");
Assert.Equal(Token.Identifier, t.Token);
Assert.Equal("true", t.Text);
t.NextToken();
// "false"
Assert.AreEqual(t.Token, Token.Identifier);
Assert.AreEqual(t.Text, "false");
Assert.Equal(Token.Identifier, t.Token);
Assert.Equal("false", t.Text);
t.NextToken();
// "_$variable1"
Assert.AreEqual(t.Token, Token.Identifier);
Assert.AreEqual(t.Text, "_$variable1");
Assert.Equal(Token.Identifier, t.Token);
Assert.Equal("_$variable1", t.Text);
t.NextToken();
// "$variable2"
Assert.AreEqual(t.Token, Token.Identifier);
Assert.AreEqual(t.Text, "$variable2");
Assert.Equal(Token.Identifier, t.Token);
Assert.Equal("$variable2", t.Text);
t.NextToken();
// ";{}#"
Assert.AreEqual(t.Token, Token.Identifier);
Assert.AreEqual(t.Text, ";{}#");
Assert.Equal(Token.Identifier, t.Token);
Assert.Equal(";{}#", t.Text);
t.NextToken();
Assert.AreEqual(t.Token, Token.EOF);
Assert.Equal(Token.EOF, t.Token);
}
[TestMethod()]
[Fact]
public void Tokenizer__AllTogether()
{
var testString = "(10 + 20) * -30.123 + \"Hello \\\"World\\\"\" = false";
var t = new Tokenizer(new StringReader(testString));
// "("
Assert.AreEqual(t.Token, Token.ParenthesisStart);
Assert.Equal(Token.ParenthesisStart, t.Token);
t.NextToken();
// "10"
Assert.AreEqual(t.Token, Token.Number);
Assert.AreEqual(t.Number, 10);
Assert.Equal(Token.Number, t.Token);
Assert.Equal(10, t.Number);
t.NextToken();
// "+"
Assert.AreEqual(t.Token, Token.Plus);
Assert.Equal(Token.Plus, t.Token);
t.NextToken();
// "20"
Assert.AreEqual(t.Token, Token.Number);
Assert.AreEqual(t.Number, 20);
Assert.Equal(Token.Number, t.Token);
Assert.Equal(20, t.Number);
t.NextToken();
// ")"
Assert.AreEqual(t.Token, Token.ParenthesisEnd);
Assert.Equal(Token.ParenthesisEnd, t.Token);
t.NextToken();
// "*"
Assert.AreEqual(t.Token, Token.Multiply);
Assert.Equal(Token.Multiply, t.Token);
t.NextToken();
// "-"
Assert.AreEqual(t.Token, Token.Minus);
Assert.Equal(Token.Minus, t.Token);
t.NextToken();
// "20"
Assert.AreEqual(t.Token, Token.Number);
Assert.AreEqual(t.Number, 30.123m);
Assert.Equal(Token.Number, t.Token);
Assert.Equal(30.123m, t.Number);
t.NextToken();
// "+"
Assert.AreEqual(t.Token, Token.Plus);
Assert.Equal(Token.Plus, t.Token);
t.NextToken();
// "Hello \"World\""
Assert.AreEqual(t.Token, Token.String);
Assert.AreEqual(t.Text, "Hello \"World\"");
Assert.Equal(Token.String, t.Token);
Assert.Equal("Hello \"World\"", t.Text);
t.NextToken();
// "="
Assert.AreEqual(t.Token, Token.Equals);
Assert.Equal(Token.Equals, t.Token);
t.NextToken();
// "false"
Assert.AreEqual(t.Token, Token.Identifier);
Assert.AreEqual(t.Text, "false");
Assert.Equal(Token.Identifier, t.Token);
Assert.Equal("false", t.Text);
t.NextToken();
Assert.AreEqual(t.Token, Token.EOF);
Assert.Equal(Token.EOF, t.Token);
}
[TestMethod()]
[Fact]
public void Tokenizer__MoreTokens()
{
var testString = "= < > <= >= == === ";
var t = new Tokenizer(new StringReader(testString));
// "="
Assert.AreEqual(t.Token, Token.Equals);
Assert.Equal(Token.Equals, t.Token);
t.NextToken();
// "<"
Assert.AreEqual(t.Token, Token.LessThan);
Assert.Equal(Token.LessThan, t.Token);
t.NextToken();
// ">"
Assert.AreEqual(t.Token, Token.GreaterThan);
Assert.Equal(Token.GreaterThan, t.Token);
t.NextToken();
// "<="
Assert.AreEqual(t.Token, Token.LessOrEqualThan);
Assert.Equal(Token.LessOrEqualThan, t.Token);
t.NextToken();
// ">="
Assert.AreEqual(t.Token, Token.GreaterOrEqualThan);
Assert.Equal(Token.GreaterOrEqualThan, t.Token);
t.NextToken();
// "=="
Assert.AreEqual(t.Token, Token.Equals);
Assert.Equal(Token.Equals, t.Token);
t.NextToken();
// "==="
Assert.AreEqual(t.Token, Token.ExclusiveEquals);
Assert.Equal(Token.ExclusiveEquals, t.Token);
t.NextToken();
Assert.AreEqual(t.Token, Token.EOF);
Assert.Equal(Token.EOF, t.Token);
}
}

111
VAR.ExpressionEvaluator.Tests/VAR.ExpressionEvaluator.Tests.csproj
View File

@@ -1,97 +1,26 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
<ProjectGuid>{3195F0E0-9489-49CE-8FC2-627A73F80CC7}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>VAR.ExpressionEvaluator.Tests</RootNamespace>
<AssemblyName>VAR.ExpressionEvaluator.Tests</AssemblyName>
<TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
<FileAlignment>512</FileAlignment>
<ProjectTypeGuids>{3AC096D0-A1C2-E12C-1390-A8335801FDAB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}</ProjectTypeGuids>
<VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">10.0</VisualStudioVersion>
<VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
<ReferencePath>$(ProgramFiles)\Common Files\microsoft shared\VSTT\$(VisualStudioVersion)\UITestExtensionPackages</ReferencePath>
<IsCodedUITest>False</IsCodedUITest>
<TestProjectType>UnitTest</TestProjectType>
<TargetFrameworkProfile />
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<TargetFramework>net5.0</TargetFramework>
<IsPackable>false</IsPackable>
</PropertyGroup>
<ItemGroup>
<Reference Include="System" />
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.4" />
<PackageReference Include="xunit" Version="2.4.1" />
<PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
<PrivateAssets>all</PrivateAssets>
</PackageReference>
<PackageReference Include="coverlet.collector" Version="3.0.2">
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
<PrivateAssets>all</PrivateAssets>
</PackageReference>
</ItemGroup>
<Choose>
<When Condition="('$(VisualStudioVersion)' == '10.0' or '$(VisualStudioVersion)' == '') and '$(TargetFrameworkVersion)' == 'v3.5'">
<ItemGroup>
<Reference Include="Microsoft.VisualStudio.QualityTools.UnitTestFramework, Version=10.1.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL" />
</ItemGroup>
</When>
<Otherwise>
<ItemGroup>
<Reference Include="Microsoft.VisualStudio.QualityTools.UnitTestFramework" />
</ItemGroup>
</Otherwise>
</Choose>
<ItemGroup>
<Compile Include="..\SharedAssemblyInfo.cs">
<Link>Properties\SharedAssemblyInfo.cs</Link>
</Compile>
<Compile Include="ExpressionBinaryNodeTests.cs" />
<Compile Include="ExpressionNumberNodeTests.cs" />
<Compile Include="ExpressionStringNodeTests.cs" />
<Compile Include="ParserTests.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<Compile Include="TokenizerTests.cs" />
<ProjectReference Include="..\VAR.ExpressionEvaluator\VAR.ExpressionEvaluator.csproj" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\VAR.ExpressionEvaluator\VAR.ExpressionEvaluator.csproj">
<Project>{74635F68-55B1-4819-84A3-9EA818D396D9}</Project>
<Name>VAR.ExpressionEvaluator</Name>
</ProjectReference>
</ItemGroup>
<Choose>
<When Condition="'$(VisualStudioVersion)' == '10.0' And '$(IsCodedUITest)' == 'True'">
<ItemGroup>
<Reference Include="Microsoft.VisualStudio.QualityTools.CodedUITestFramework, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
<Private>False</Private>
</Reference>
<Reference Include="Microsoft.VisualStudio.TestTools.UITest.Common, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
<Private>False</Private>
</Reference>
<Reference Include="Microsoft.VisualStudio.TestTools.UITest.Extension, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
<Private>False</Private>
</Reference>
<Reference Include="Microsoft.VisualStudio.TestTools.UITesting, Version=10.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a, processorArchitecture=MSIL">
<Private>False</Private>
</Reference>
</ItemGroup>
</When>
</Choose>
<Import Project="$(VSToolsPath)\TeamTest\Microsoft.TestTools.targets" Condition="Exists('$(VSToolsPath)\TeamTest\Microsoft.TestTools.targets')" />
<Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
<!-- To modify your build process, add your task inside one of the targets below and uncomment it.
Other similar extension points exist, see Microsoft.Common.targets.
<Target Name="BeforeBuild">
</Target>
<Target Name="AfterBuild">
</Target>
-->
</Project>
</Project>