Rename ConditionExpression => VariableExpression
This commit is contained in:
atlimit8
347
OpenRA.Test/OpenRA.Game/VariableExpressionTest.cs
Normal file
347
OpenRA.Test/OpenRA.Game/VariableExpressionTest.cs
Normal file
@@ -0,0 +1,347 @@
|
||||
#region Copyright & License Information
|
||||
/*
|
||||
* Copyright 2007-2017 The OpenRA Developers (see AUTHORS)
|
||||
* This file is part of OpenRA, which is free software. It is made
|
||||
* available to you under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation, either version 3 of
|
||||
* the License, or (at your option) any later version. For more
|
||||
* information, see COPYING.
|
||||
*/
|
||||
#endregion
|
||||
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using System.Linq;
|
||||
using NUnit.Framework;
|
||||
using OpenRA.Support;
|
||||
|
||||
namespace OpenRA.Test
|
||||
{
|
||||
[TestFixture]
|
||||
public class VariableExpressionTest
|
||||
{
|
||||
IReadOnlyDictionary<string, int> testValues = new ReadOnlyDictionary<string, int>(new Dictionary<string, int>()
|
||||
{
|
||||
{ "one", 1 },
|
||||
{ "five", 5 }
|
||||
});
|
||||
|
||||
void AssertFalse(string expression)
|
||||
{
|
||||
Assert.False(new VariableExpression(expression).Evaluate(testValues) > 0, expression);
|
||||
}
|
||||
|
||||
void AssertTrue(string expression)
|
||||
{
|
||||
Assert.True(new VariableExpression(expression).Evaluate(testValues) > 0, expression);
|
||||
}
|
||||
|
||||
void AssertValue(string expression, int value)
|
||||
{
|
||||
Assert.AreEqual(value, new VariableExpression(expression).Evaluate(testValues), expression);
|
||||
}
|
||||
|
||||
void AssertParseFailure(string expression)
|
||||
{
|
||||
Assert.Throws(typeof(InvalidDataException), () => new VariableExpression(expression).Evaluate(testValues), expression);
|
||||
}
|
||||
|
||||
void AssertParseFailure(string expression, string errorMessage)
|
||||
{
|
||||
var actualErrorMessage = Assert.Throws(typeof(InvalidDataException),
|
||||
() => new VariableExpression(expression).Evaluate(testValues),
|
||||
expression).Message;
|
||||
Assert.AreEqual(errorMessage, actualErrorMessage, expression + " ===> " + actualErrorMessage);
|
||||
}
|
||||
|
||||
[TestCase(TestName = "Numbers")]
|
||||
public void TestNumbers()
|
||||
{
|
||||
AssertParseFailure("1a", "Number 1 and variable merged at index 0");
|
||||
AssertValue("0", 0);
|
||||
AssertValue("1", 1);
|
||||
AssertValue("12", 12);
|
||||
AssertValue("-1", -1);
|
||||
AssertValue("-12", -12);
|
||||
}
|
||||
|
||||
[TestCase(TestName = "Variables")]
|
||||
public void TestVariables()
|
||||
{
|
||||
AssertValue("one", 1);
|
||||
AssertValue("five", 5);
|
||||
}
|
||||
|
||||
[TestCase(TestName = "Boolean Constants")]
|
||||
public void TestBoolConsts()
|
||||
{
|
||||
AssertValue(" true", 1);
|
||||
AssertValue(" true ", 1);
|
||||
AssertValue("true", 1);
|
||||
AssertValue("false", 0);
|
||||
AssertValue("tru", 0);
|
||||
AssertValue("fals", 0);
|
||||
AssertValue("tr", 0);
|
||||
AssertValue("fal", 0);
|
||||
}
|
||||
|
||||
[TestCase(TestName = "Booleans")]
|
||||
public void TestBooleans()
|
||||
{
|
||||
AssertValue("false", 0);
|
||||
AssertValue("true", 1);
|
||||
}
|
||||
|
||||
[TestCase(TestName = "AND operation")]
|
||||
public void TestAnd()
|
||||
{
|
||||
AssertTrue("true && true");
|
||||
AssertFalse("false && false");
|
||||
AssertFalse("true && false");
|
||||
AssertFalse("false && true");
|
||||
AssertValue("2 && false", 0);
|
||||
AssertValue("false && 2", 0);
|
||||
AssertValue("3 && 2", 1);
|
||||
AssertValue("2 && 3", 1);
|
||||
}
|
||||
|
||||
[TestCase(TestName = "OR operation")]
|
||||
public void TestOR()
|
||||
{
|
||||
AssertTrue("true || true");
|
||||
AssertFalse("false || false");
|
||||
AssertTrue("true || false");
|
||||
AssertTrue("false || true");
|
||||
AssertValue("2 || false", 1);
|
||||
AssertValue("false || 2", 1);
|
||||
AssertValue("3 || 2", 1);
|
||||
AssertValue("2 || 3", 1);
|
||||
}
|
||||
|
||||
[TestCase(TestName = "Equals operation")]
|
||||
public void TestEquals()
|
||||
{
|
||||
AssertTrue("true == true");
|
||||
AssertTrue("false == false");
|
||||
AssertFalse("true == false");
|
||||
AssertFalse("false == true");
|
||||
AssertTrue("1 == 1");
|
||||
AssertTrue("0 == 0");
|
||||
AssertFalse("1 == 0");
|
||||
AssertTrue("1 == true");
|
||||
AssertFalse("1 == false");
|
||||
AssertTrue("0 == false");
|
||||
AssertFalse("0 == true");
|
||||
AssertValue("12 == 12", 1);
|
||||
AssertValue("1 == 12", 0);
|
||||
}
|
||||
|
||||
[TestCase(TestName = "Not-equals operation")]
|
||||
public void TestNotEquals()
|
||||
{
|
||||
AssertFalse("true != true");
|
||||
AssertFalse("false != false");
|
||||
AssertTrue("true != false");
|
||||
AssertTrue("false != true");
|
||||
AssertValue("1 != 2", 1);
|
||||
AssertValue("1 != 1", 0);
|
||||
AssertFalse("1 != true");
|
||||
AssertFalse("0 != false");
|
||||
AssertTrue("1 != false");
|
||||
AssertTrue("0 != true");
|
||||
}
|
||||
|
||||
[TestCase(TestName = "NOT operation")]
|
||||
public void TestNOT()
|
||||
{
|
||||
AssertValue("!true", 0);
|
||||
AssertValue("!false", 1);
|
||||
AssertValue("!!true", 1);
|
||||
AssertValue("!!false", 0);
|
||||
AssertValue("!0", 1);
|
||||
AssertValue("!1", 0);
|
||||
AssertValue("!5", 0);
|
||||
AssertValue("!!5", 1);
|
||||
AssertValue("!-5", 0);
|
||||
}
|
||||
|
||||
[TestCase(TestName = "Relation operations")]
|
||||
public void TestRelations()
|
||||
{
|
||||
AssertValue("2 < 5", 1);
|
||||
AssertValue("0 < 5", 1);
|
||||
AssertValue("5 < 2", 0);
|
||||
AssertValue("5 < 5", 0);
|
||||
AssertValue("-5 < 0", 1);
|
||||
AssertValue("-2 < -5", 0);
|
||||
AssertValue("-5 < -2", 1);
|
||||
AssertValue("-5 < -5", 0);
|
||||
AssertValue("-7 < 5", 1);
|
||||
AssertValue("0 <= 5", 1);
|
||||
AssertValue("2 <= 5", 1);
|
||||
AssertValue("5 <= 2", 0);
|
||||
AssertValue("5 <= 5", 1);
|
||||
AssertValue("5 <= 0", 0);
|
||||
AssertValue("-2 <= -5", 0);
|
||||
AssertValue("-5 <= -2", 1);
|
||||
AssertValue("-5 <= -5", 1);
|
||||
AssertValue("-7 <= 5", 1);
|
||||
AssertValue("0 <= -5", 0);
|
||||
AssertValue("-5 <= 0", 1);
|
||||
AssertValue("5 > 2", 1);
|
||||
AssertValue("0 > 5", 0);
|
||||
AssertValue("2 > 5", 0);
|
||||
AssertValue("5 > 5", 0);
|
||||
AssertValue("5 > 0", 1);
|
||||
AssertValue("-2 > -5", 1);
|
||||
AssertValue("-7 > -5", 0);
|
||||
AssertValue("-5 > -5", 0);
|
||||
AssertValue("-4 > -5", 1);
|
||||
AssertValue("5 >= 0", 1);
|
||||
AssertValue("0 >= 5", 0);
|
||||
AssertValue("5 >= 2", 1);
|
||||
AssertValue("2 >= 5", 0);
|
||||
AssertValue("5 >= 5", 1);
|
||||
AssertValue("-5 >= 0", 0);
|
||||
AssertValue("0 >= -5", 1);
|
||||
AssertValue("-7 >= 5", 0);
|
||||
AssertValue("-5 >= -5", 1);
|
||||
AssertValue("-4 >= -5", 1);
|
||||
}
|
||||
|
||||
[TestCase(TestName = "Relation Mixed Precedence")]
|
||||
public void TestRelationMixedPrecedence()
|
||||
{
|
||||
AssertValue("5 <= 5 && 2 > 1", 1);
|
||||
AssertValue("5 > 5 || 2 > 1", 1);
|
||||
AssertValue("5 > 5 || 1 > 1", 0);
|
||||
AssertValue("5 <= 5 == 2 > 1", 1);
|
||||
AssertValue("5 > 5 == 2 > 1", 0);
|
||||
AssertValue("5 > 5 == 1 > 1", 1);
|
||||
AssertValue("5 <= 5 != 2 > 1", 0);
|
||||
AssertValue("5 > 5 != 2 > 1", 1);
|
||||
AssertValue("5 > 5 != 1 > 1", 0);
|
||||
AssertValue("5 > 5 != 1 >= 1", 1);
|
||||
}
|
||||
|
||||
[TestCase(TestName = "AND-OR Precedence")]
|
||||
public void TestAndOrPrecedence()
|
||||
{
|
||||
AssertTrue("true && false || true");
|
||||
AssertFalse("false || false && true");
|
||||
AssertTrue("true && !true || !false");
|
||||
AssertFalse("false || !true && !false");
|
||||
}
|
||||
|
||||
[TestCase(TestName = "Parenthesis")]
|
||||
public void TestParens()
|
||||
{
|
||||
AssertTrue("(true)");
|
||||
AssertTrue("((true))");
|
||||
AssertFalse("(false)");
|
||||
AssertFalse("((false))");
|
||||
}
|
||||
|
||||
[TestCase(TestName = "Arithmetic")]
|
||||
public void TestArithmetic()
|
||||
{
|
||||
AssertValue("~0", ~0);
|
||||
AssertValue("-0", 0);
|
||||
AssertValue("-a", 0);
|
||||
AssertValue("-true", -1);
|
||||
AssertValue("~-0", -1);
|
||||
AssertValue("2 + 3", 5);
|
||||
AssertValue("2 + 0", 2);
|
||||
AssertValue("2 + 3", 5);
|
||||
AssertValue("5 - 3", 2);
|
||||
AssertValue("5 - -3", 8);
|
||||
AssertValue("5 - 0", 5);
|
||||
AssertValue("2 * 3", 6);
|
||||
AssertValue("2 * 0", 0);
|
||||
AssertValue("2 * -3", -6);
|
||||
AssertValue("-2 * 3", -6);
|
||||
AssertValue("-2 * -3", 6);
|
||||
AssertValue("6 / 3", 2);
|
||||
AssertValue("7 / 3", 2);
|
||||
AssertValue("-6 / 3", -2);
|
||||
AssertValue("6 / -3", -2);
|
||||
AssertValue("-6 / -3", 2);
|
||||
AssertValue("8 / 3", 2);
|
||||
AssertValue("6 % 3", 0);
|
||||
AssertValue("7 % 3", 1);
|
||||
AssertValue("8 % 3", 2);
|
||||
AssertValue("7 % 0", 0);
|
||||
AssertValue("-7 % 3", -1);
|
||||
AssertValue("7 % -3", 1);
|
||||
AssertValue("-7 % -3", -1);
|
||||
AssertValue("8 / 0", 0);
|
||||
}
|
||||
|
||||
[TestCase(TestName = "Arithmetic Mixed")]
|
||||
public void TestArithmeticMixed()
|
||||
{
|
||||
AssertValue("~~0", 0);
|
||||
AssertValue("-~0", 1);
|
||||
AssertValue("~- 0", -1);
|
||||
AssertValue("2 * 3 + 4", 10);
|
||||
AssertValue("2 * 3 - 4", 2);
|
||||
AssertValue("2 + 3 * 4", 14);
|
||||
AssertValue("2 + 3 % 4", 5);
|
||||
AssertValue("2 + 3 / 4", 2);
|
||||
AssertValue("2 * 3 / 4", 1);
|
||||
AssertValue("8 / 2 == 4", 1);
|
||||
AssertValue("~2 + ~3", -7);
|
||||
AssertValue("~(~2 + ~3)", 6);
|
||||
}
|
||||
|
||||
[TestCase(TestName = "Parenthesis and mixed operations")]
|
||||
public void TestMixedParens()
|
||||
{
|
||||
AssertTrue("(!false)");
|
||||
AssertTrue("!(false)");
|
||||
AssertFalse("!(!false)");
|
||||
AssertTrue("(true) || (false)");
|
||||
AssertTrue("true && (false || true)");
|
||||
AssertTrue("(true && false) || true");
|
||||
AssertTrue("!(true && false) || false");
|
||||
AssertTrue("((true != true) == false) && true");
|
||||
AssertFalse("(true != false) == false && true");
|
||||
AssertTrue("true || ((true != false) != !(false && true))");
|
||||
AssertFalse("((true != false) != !(false && true))");
|
||||
}
|
||||
|
||||
[TestCase(TestName = "Test parser errors")]
|
||||
public void TestParseErrors()
|
||||
{
|
||||
AssertParseFailure("()", "Empty parenthesis at index 0");
|
||||
AssertParseFailure("! && true", "Missing value or sub-expression or there is an extra operator `!` at index 0 or `&&` at index 2");
|
||||
AssertParseFailure("(true", "Unclosed opening parenthesis at index 0");
|
||||
AssertParseFailure(")true", "Unmatched closing parenthesis at index 0");
|
||||
AssertParseFailure("false)", "Unmatched closing parenthesis at index 5");
|
||||
AssertParseFailure("false(", "Missing binary operation before `(` at index 5");
|
||||
AssertParseFailure("(", "Missing value or sub-expression at end for `(` operator");
|
||||
AssertParseFailure(")", "Unmatched closing parenthesis at index 0");
|
||||
AssertParseFailure("false!", "Missing binary operation before `!` at index 5");
|
||||
AssertParseFailure("true false", "Missing binary operation before `false` at index 5");
|
||||
AssertParseFailure("true & false", "Unexpected character '&' at index 5 - should it be `&&`?");
|
||||
AssertParseFailure("true | false", "Unexpected character '|' at index 5 - should it be `||`?");
|
||||
AssertParseFailure("true : false", "Invalid character ':' at index 5");
|
||||
AssertParseFailure("true & false && !", "Unexpected character '&' at index 5 - should it be `&&`?");
|
||||
AssertParseFailure("(true && !)", "Missing value or sub-expression or there is an extra operator `!` at index 9 or `)` at index 10");
|
||||
AssertParseFailure("&& false", "Missing value or sub-expression at beginning for `&&` operator");
|
||||
AssertParseFailure("false ||", "Missing value or sub-expression at end for `||` operator");
|
||||
AssertParseFailure("1 <", "Missing value or sub-expression at end for `<` operator");
|
||||
AssertParseFailure("-1a", "Number -1 and variable merged at index 0");
|
||||
AssertParseFailure("-", "Missing value or sub-expression at end for `-` operator");
|
||||
}
|
||||
|
||||
[TestCase(TestName = "Undefined symbols are treated as `false` (0) values")]
|
||||
public void TestUndefinedSymbols()
|
||||
{
|
||||
AssertFalse("undef1 || undef2");
|
||||
AssertValue("undef1", 0);
|
||||
AssertValue("undef1 + undef2", 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user