public void TestCaseConstruction3() { var @operator = new ArithmeticNeutralOperator("operator", TypeConverter); Assert.AreEqual("operator", @operator.Symbol); Assert.AreEqual(1, @operator.Precedence); }
public void TestCaseOperatorRegistration() { var tokenizer = new Tokenizer("irrelevant"); var lexer = new Lexer(tokenizer, ExpressionFlowSymbols.Default, StringComparer.OrdinalIgnoreCase); var neutral = new ArithmeticNeutralOperator(TypeConverter); var sum = new ArithmeticSumOperator(TypeConverter); ExpectArgumentNullException("operator", () => lexer.RegisterOperator(null)); Assert.AreEqual(lexer, lexer.RegisterOperator(neutral)); Assert.AreEqual(lexer, lexer.RegisterOperator(sum)); ExpectOperatorAlreadyRegisteredException(neutral.ToString(), () => lexer.RegisterOperator(neutral)); ExpectOperatorAlreadyRegisteredException(sum.ToString(), () => lexer.RegisterOperator(sum)); /* Clashing with specials */ lexer.RegisterSpecial("FALSE", false); var clashingOp1 = new ArithmeticNeutralOperator("FALSE", TypeConverter); var clashingOp2 = new ArithmeticSumOperator("FALSE", TypeConverter); ExpectOperatorAlreadyRegisteredException(clashingOp1.ToString(), () => lexer.RegisterOperator(clashingOp1)); ExpectOperatorAlreadyRegisteredException(clashingOp2.ToString(), () => lexer.RegisterOperator(clashingOp2)); /* Flow */ ExpectOperatorAlreadyRegisteredException("(", () => lexer.RegisterOperator(new ArithmeticNeutralOperator("(", TypeConverter))); lexer.RegisterOperator(new ArithmeticNeutralOperator(")", TypeConverter)); lexer.RegisterOperator(new ArithmeticNeutralOperator(".", TypeConverter)); lexer.RegisterOperator(new ArithmeticNeutralOperator(",", TypeConverter)); lexer.RegisterOperator(new ArithmeticSumOperator("(", TypeConverter)); ExpectOperatorAlreadyRegisteredException(")", () => lexer.RegisterOperator(new ArithmeticSumOperator(")", TypeConverter))); ExpectOperatorAlreadyRegisteredException(".", () => lexer.RegisterOperator(new ArithmeticSumOperator(".", TypeConverter))); ExpectOperatorAlreadyRegisteredException(",", () => lexer.RegisterOperator(new ArithmeticSumOperator(",", TypeConverter))); }
public void TestCaseEvaluation() { var @operator = new ArithmeticNeutralOperator(TypeConverter); AssertEvaluation <double>(@operator, 0, 0); AssertEvaluation <double>(@operator, double.NaN, double.NaN); AssertEvaluation <double>(@operator, -double.NaN, -double.NaN); }
public void TestCaseOperatorRegistration1() { var expression = new Expression(); var unaryOpPlus = new ArithmeticNeutralOperator("+", TypeConverter); var binaryOpPlus = new ArithmeticSumOperator("+", TypeConverter); expression.RegisterOperator(unaryOpPlus); ExpectOperatorAlreadyRegisteredException(unaryOpPlus.ToString(), () => expression.RegisterOperator(unaryOpPlus)); expression.RegisterOperator(binaryOpPlus); ExpectOperatorAlreadyRegisteredException(binaryOpPlus.ToString(), () => expression.RegisterOperator(binaryOpPlus)); }
public void TestCaseCaseSensitivity() { var expressionIns = new Expression(ExpressionFlowSymbols.Default, StringComparer.OrdinalIgnoreCase); var expressionSens = new Expression(ExpressionFlowSymbols.Default, StringComparer.Ordinal); var testOperator = new ArithmeticNeutralOperator("lower_case_operator", TypeConverter); expressionIns.RegisterOperator(testOperator); expressionSens.RegisterOperator(testOperator); Assert.IsTrue(expressionIns.IsSupportedOperator(testOperator.Symbol.ToUpper())); Assert.IsTrue(expressionIns.IsSupportedOperator(testOperator.Symbol)); Assert.IsFalse(expressionSens.IsSupportedOperator(testOperator.Symbol.ToUpper())); Assert.IsTrue(expressionSens.IsSupportedOperator(testOperator.Symbol)); expressionIns.FeedSymbol(testOperator.Symbol.ToUpper()); expressionSens.FeedSymbol(testOperator.Symbol.ToUpper()); Assert.AreEqual("lower_case_operator{??}", expressionIns.ToString(ExpressionFormatStyle.Canonical)); Assert.AreEqual("@LOWER_CASE_OPERATOR", expressionSens.ToString(ExpressionFormatStyle.Canonical)); }
public void TestCaseSpecialRegistration() { var tokenizer = new Tokenizer("irrelevant"); var lexer = new Lexer(tokenizer, ExpressionFlowSymbols.Default, StringComparer.OrdinalIgnoreCase); /* Exceptions */ ExpectArgumentNullException("keyword", () => lexer.RegisterSpecial(null, null)); ExpectArgumentEmptyException("keyword", () => lexer.RegisterSpecial(string.Empty, null)); ExpectArgumentNotIdentifierException("keyword", () => lexer.RegisterSpecial("12ABC", null)); var clashingOp1 = new ArithmeticNeutralOperator("T1", TypeConverter); var clashingOp2 = new ArithmeticSumOperator("T2", TypeConverter); lexer.RegisterOperator(clashingOp1); lexer.RegisterOperator(clashingOp2); ExpectSpecialCannotBeRegisteredException("T1", () => lexer.RegisterSpecial("T1", true)); ExpectSpecialCannotBeRegisteredException("T2", () => lexer.RegisterSpecial("T2", true)); Assert.AreEqual(lexer, lexer.RegisterSpecial("FALSE", false)); Assert.AreEqual(lexer, lexer.RegisterSpecial("FALSE", false)); }
public void TestCaseSupportedOperators() { var expression = new Expression(); var neutral = new ArithmeticNeutralOperator(TypeConverter); var sum = new ArithmeticSumOperator(TypeConverter); /* Unary */ expression.RegisterOperator(neutral); Assert.AreEqual(1, expression.SupportedOperators.Count); Assert.AreEqual(neutral, expression.SupportedOperators[0]); Assert.IsTrue(expression.IsSupportedOperator(neutral.Symbol)); /* Binary */ expression.RegisterOperator(sum); Assert.AreEqual(2, expression.SupportedOperators.Count); Assert.AreEqual(sum, expression.SupportedOperators[1]); Assert.IsTrue(expression.IsSupportedOperator(sum.Symbol)); ExpectArgumentNullException("symbol", () => expression.IsSupportedOperator(null)); ExpectArgumentEmptyException("symbol", () => expression.IsSupportedOperator(string.Empty)); }
public void TestCaseOperatorRegistration2() { var expression = new Expression(); var unary1 = new ArithmeticNeutralOperator("(", TypeConverter); var unary2 = new ArithmeticNeutralOperator(")", TypeConverter); var unary3 = new ArithmeticNeutralOperator(".", TypeConverter); var unary4 = new ArithmeticNeutralOperator(",", TypeConverter); var binary1 = new ArithmeticSumOperator("(", TypeConverter); var binary2 = new ArithmeticSumOperator(")", TypeConverter); var binary3 = new ArithmeticSumOperator(".", TypeConverter); var binary4 = new ArithmeticSumOperator(",", TypeConverter); ExpectOperatorAlreadyRegisteredException(unary1.ToString(), () => expression.RegisterOperator(unary1)); ExpectOperatorAlreadyRegisteredException(unary2.ToString(), () => expression.RegisterOperator(unary2)); ExpectOperatorAlreadyRegisteredException(unary3.ToString(), () => expression.RegisterOperator(unary3)); ExpectOperatorAlreadyRegisteredException(unary4.ToString(), () => expression.RegisterOperator(unary4)); ExpectOperatorAlreadyRegisteredException(binary1.ToString(), () => expression.RegisterOperator(binary1)); ExpectOperatorAlreadyRegisteredException(binary2.ToString(), () => expression.RegisterOperator(binary2)); ExpectOperatorAlreadyRegisteredException(binary3.ToString(), () => expression.RegisterOperator(binary3)); ExpectOperatorAlreadyRegisteredException(binary4.ToString(), () => expression.RegisterOperator(binary4)); }
public void TestCaseEvaluationExceptions() { var @operator = new ArithmeticNeutralOperator(TypeConverter); ExpectArgumentNullException("context", () => @operator.Evaluate(null, 1)); }
public void TestCaseConstruction2() { var @operator = new ArithmeticNeutralOperator(TypeConverter); Assert.AreEqual("+", @operator.Symbol); }