using System.Collections.Generic;
|
using System.Linq;
|
using NUnit.Framework;
|
using DynamicExpresso.Exceptions;
|
|
namespace DynamicExpresso.UnitTest
|
{
|
[TestFixture]
|
public class DetectIdentifiersTest
|
{
|
[Test]
|
public void Detect_identifiers_empty()
|
{
|
var target = new Interpreter();
|
|
var detectedIdentifiers = target.DetectIdentifiers("");
|
|
Assert.That(detectedIdentifiers.UnknownIdentifiers.Count(), Is.EqualTo(0));
|
Assert.That(detectedIdentifiers.Identifiers.Count(), Is.EqualTo(0));
|
Assert.That(detectedIdentifiers.Types.Count(), Is.EqualTo(0));
|
}
|
|
[Test]
|
public void Detect_identifiers_null()
|
{
|
var target = new Interpreter();
|
|
var detectedIdentifiers = target.DetectIdentifiers(null);
|
|
Assert.That(detectedIdentifiers.UnknownIdentifiers.Count(), Is.EqualTo(0));
|
Assert.That(detectedIdentifiers.Identifiers.Count(), Is.EqualTo(0));
|
Assert.That(detectedIdentifiers.Types.Count(), Is.EqualTo(0));
|
}
|
|
[Test]
|
public void Detect_unknown_identifiers()
|
{
|
var target = new Interpreter();
|
|
var detectedIdentifiers = target.DetectIdentifiers("x + y");
|
|
Assert.That(
|
detectedIdentifiers.UnknownIdentifiers,
|
Is.EqualTo(new[] { "x", "y" }));
|
}
|
|
[Test]
|
public void Should_detect_various_format_of_identifiers()
|
{
|
var target = new Interpreter();
|
|
var validNames = new[] { "x", "y", "_z", "x23", "asdas_afsdf" };
|
|
foreach (var name in validNames)
|
{
|
var detectedIdentifiers = target.DetectIdentifiers(name);
|
|
Assert.That(
|
detectedIdentifiers.UnknownIdentifiers,
|
Is.EqualTo(new[] { name }));
|
}
|
}
|
|
[Test]
|
public void An_Unknown_Identifier_used_multiple_times_is_detected_only_once()
|
{
|
var target = new Interpreter();
|
|
var detectedIdentifiers = target.DetectIdentifiers("x + x");
|
|
Assert.That(
|
detectedIdentifiers.UnknownIdentifiers,
|
Is.EqualTo(new[] { "x" }));
|
}
|
|
[Test]
|
public void With_case_insensitive_An_Unknown_Identifier_used_multiple_times_is_detected_only_once()
|
{
|
var target = new Interpreter(InterpreterOptions.DefaultCaseInsensitive);
|
|
var detectedIdentifiers = target.DetectIdentifiers("x + X");
|
|
Assert.That(
|
detectedIdentifiers.UnknownIdentifiers,
|
Is.EqualTo(new[] { "x" }));
|
}
|
|
[Test]
|
public void A_Known_Identifier_used_multiple_times_is_detected_only_once()
|
{
|
var target = new Interpreter()
|
.SetVariable("x", 213);
|
|
var detectedIdentifiers = target.DetectIdentifiers("x + x");
|
|
Assert.That(
|
detectedIdentifiers.Identifiers.Select(p => p.Name).ToArray(),
|
Is.EqualTo(new[] { "x" }));
|
}
|
|
[Test]
|
public void With_case_insensitive_A_Known_Identifier_used_multiple_times_is_detected_only_once()
|
{
|
var target = new Interpreter(InterpreterOptions.DefaultCaseInsensitive)
|
.SetVariable("x", 213);
|
|
var detectedIdentifiers = target.DetectIdentifiers("x + X");
|
|
Assert.That(
|
detectedIdentifiers.Identifiers.Select(p => p.Name).ToArray(),
|
Is.EqualTo(new[] { "x" }));
|
}
|
|
[Test]
|
public void A_Known_Type_used_multiple_times_is_detected_only_once()
|
{
|
var target = new Interpreter();
|
|
var detectedIdentifiers = target.DetectIdentifiers("string.Empty + string.Empty");
|
|
Assert.That(
|
detectedIdentifiers.Types.Select(p => p.Name).ToArray(),
|
Is.EqualTo(new[] { "string" }));
|
}
|
|
[Test]
|
public void With_case_insensitive_A_Known_Type_used_multiple_times_is_detected_only_once()
|
{
|
var target = new Interpreter(InterpreterOptions.DefaultCaseInsensitive);
|
|
var detectedIdentifiers = target.DetectIdentifiers("string.Empty + STRING.Empty");
|
|
Assert.That(
|
detectedIdentifiers.Types.Select(p => p.Name).ToArray(),
|
Is.EqualTo(new[] { "string" }));
|
}
|
|
[Test]
|
public void Detect_known_identifiers_variables()
|
{
|
var target = new Interpreter()
|
.SetVariable("x", 3)
|
.SetVariable("y", 4);
|
|
var detectedIdentifiers = target.DetectIdentifiers("x + y");
|
|
Assert.That(detectedIdentifiers.Identifiers.Count(), Is.EqualTo(2));
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(0).Name, Is.EqualTo("x"));
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(1).Name, Is.EqualTo("y"));
|
}
|
|
[Test]
|
public void Detect_known_identifiers_types()
|
{
|
var target = new Interpreter();
|
|
var detectedIdentifiers = target.DetectIdentifiers("string.Empty");
|
|
Assert.That(detectedIdentifiers.Types.Count(), Is.EqualTo(1));
|
Assert.That(detectedIdentifiers.Types.ElementAt(0).Name, Is.EqualTo("string"));
|
Assert.That(detectedIdentifiers.Types.ElementAt(0).Type, Is.EqualTo(typeof(string)));
|
}
|
|
[Test]
|
[TestCase("x + y")]
|
[TestCase("x + y + 654")]
|
[TestCase("x + y + 654.564")]
|
[TestCase("x.method + y[0]")]
|
[TestCase("x+y")]
|
[TestCase("x[y]")]
|
[TestCase("x.method1.method2(y)")]
|
[TestCase("x + y + \"z\"")]
|
[TestCase("x + y + \"lorem ipsum\"")]
|
[TestCase(@"x + y + ""literal \""2""")]
|
[TestCase("x + y + \"\"")]
|
[TestCase("x + y + 'z'")]
|
[TestCase("x + y + '\\a'")]
|
[TestCase("x + y + '\\''")]
|
[TestCase("x+y")]
|
public void Detect_identifiers_inside_other_expressions(string testCase)
|
{
|
var target = new Interpreter();
|
|
var detectedIdentifiers = target.DetectIdentifiers(testCase);
|
|
Assert.That(detectedIdentifiers.UnknownIdentifiers.Count(), Is.EqualTo(2));
|
Assert.That(detectedIdentifiers.UnknownIdentifiers.ElementAt(0), Is.EqualTo("x"));
|
Assert.That(detectedIdentifiers.UnknownIdentifiers.ElementAt(1), Is.EqualTo("y"));
|
}
|
|
[Test]
|
public void Detect_identifiers_inside_lambda_expression_GitHub_Issue_226()
|
{
|
var target = new Interpreter(InterpreterOptions.Default | InterpreterOptions.LambdaExpressions);
|
target.SetVariable("list", new List<string>());
|
|
var detectedIdentifiers = target.DetectIdentifiers("list.Any(x => x == null)");
|
Assert.That(detectedIdentifiers.UnknownIdentifiers, Is.Empty);
|
|
Assert.That(detectedIdentifiers.Identifiers.Count(), Is.EqualTo(3));
|
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(0).Name, Is.EqualTo("list"));
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(0).Expression.Type, Is.EqualTo(typeof(List<string>)));
|
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(1).Name, Is.EqualTo("x"));
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(1).Expression.Type, Is.EqualTo(typeof(object)));
|
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(2).Name, Is.EqualTo("null"));
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(2).Expression.Type, Is.EqualTo(typeof(object)));
|
}
|
|
[Test]
|
public void Detect_identifiers_inside_lambda_expression_2()
|
{
|
var target = new Interpreter(InterpreterOptions.Default | InterpreterOptions.LambdaExpressions);
|
|
var detectedIdentifiers = target.DetectIdentifiers("x => x + 5");
|
Assert.That(detectedIdentifiers.UnknownIdentifiers, Is.Empty);
|
|
Assert.That(detectedIdentifiers.Identifiers.Count(), Is.EqualTo(1));
|
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(0).Name, Is.EqualTo("x"));
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(0).Expression.Type, Is.EqualTo(typeof(object)));
|
}
|
|
[Test]
|
public void Detect_identifiers_inside_lambda_expression_multiple_params()
|
{
|
var target = new Interpreter(InterpreterOptions.Default | InterpreterOptions.LambdaExpressions);
|
|
var detectedIdentifiers = target.DetectIdentifiers("(x, _1y) => x + _1y");
|
Assert.That(detectedIdentifiers.UnknownIdentifiers, Is.Empty);
|
|
Assert.That(detectedIdentifiers.Identifiers.Count(), Is.EqualTo(2));
|
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(0).Name, Is.EqualTo("x"));
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(0).Expression.Type, Is.EqualTo(typeof(object)));
|
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(1).Name, Is.EqualTo("_1y"));
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(1).Expression.Type, Is.EqualTo(typeof(object)));
|
}
|
|
[Test]
|
public void Detect_identifiers_inside_lambda_expression_multiple_params_with_type()
|
{
|
var target = new Interpreter(InterpreterOptions.Default | InterpreterOptions.LambdaExpressions);
|
|
var detectedIdentifiers = target.DetectIdentifiers("(int x, string @class) => x + @class");
|
Assert.That(detectedIdentifiers.UnknownIdentifiers, Is.Empty);
|
|
Assert.That(detectedIdentifiers.Types.Count(), Is.EqualTo(2));
|
Assert.That(detectedIdentifiers.Types.ElementAt(0).Name, Is.EqualTo("int"));
|
Assert.That(detectedIdentifiers.Types.ElementAt(0).Type, Is.EqualTo(typeof(int)));
|
Assert.That(detectedIdentifiers.Types.ElementAt(1).Name, Is.EqualTo("string"));
|
Assert.That(detectedIdentifiers.Types.ElementAt(1).Type, Is.EqualTo(typeof(string)));
|
|
Assert.That(detectedIdentifiers.Identifiers.Count(), Is.EqualTo(2));
|
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(0).Name, Is.EqualTo("x"));
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(0).Expression.Type, Is.EqualTo(typeof(int)));
|
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(1).Name, Is.EqualTo("@class"));
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(1).Expression.Type, Is.EqualTo(typeof(string)));
|
}
|
|
[Test]
|
public void Detect_identifiers_inside_lambda_expression_duplicate_param_name()
|
{
|
var target = new Interpreter(InterpreterOptions.Default | InterpreterOptions.LambdaExpressions);
|
|
var detectedIdentifiers =
|
target.DetectIdentifiers(
|
"(x, int y, z, int a) => x.Select(z => z + y).Select((string a, string b) => b)");
|
Assert.That(detectedIdentifiers.UnknownIdentifiers, Is.Empty);
|
|
Assert.That(detectedIdentifiers.Types.Count(), Is.EqualTo(2));
|
Assert.That(detectedIdentifiers.Types.ElementAt(0).Name, Is.EqualTo("int"));
|
Assert.That(detectedIdentifiers.Types.ElementAt(0).Type, Is.EqualTo(typeof(int)));
|
Assert.That(detectedIdentifiers.Types.ElementAt(1).Name, Is.EqualTo("string"));
|
Assert.That(detectedIdentifiers.Types.ElementAt(1).Type, Is.EqualTo(typeof(string)));
|
|
Assert.That(detectedIdentifiers.Identifiers.Count(), Is.EqualTo(5));
|
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(0).Name, Is.EqualTo("x"));
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(0).Expression.Type, Is.EqualTo(typeof(object)));
|
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(1).Name, Is.EqualTo("y"));
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(1).Expression.Type, Is.EqualTo(typeof(int)));
|
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(2).Name, Is.EqualTo("z"));
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(2).Expression.Type, Is.EqualTo(typeof(object)));
|
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(3).Name, Is.EqualTo("a"));
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(3).Expression.Type, Is.EqualTo(typeof(object)));
|
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(4).Name, Is.EqualTo("b"));
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(4).Expression.Type, Is.EqualTo(typeof(string)));
|
}
|
|
[Test]
|
[TestCase("@class")]
|
[TestCase("français_holé")]
|
[TestCase("中文")]
|
[TestCase("_1中0文")]
|
[TestCase("日本語")]
|
[TestCase("русский")]
|
public void Detect_all_identifiers_including_not_ascii(string identifier)
|
{
|
var code = $"1 + {identifier}.Method()";
|
|
var target = new Interpreter(InterpreterOptions.Default | InterpreterOptions.LambdaExpressions);
|
var detectedIdentifiers = target.DetectIdentifiers(code);
|
|
Assert.That(detectedIdentifiers.UnknownIdentifiers.Count(), Is.EqualTo(1));
|
Assert.That(detectedIdentifiers.UnknownIdentifiers.ElementAt(0), Is.EqualTo(identifier));
|
}
|
|
[Test]
|
public void Dont_detect_members_with_at()
|
{
|
var code = "@class.@if()";
|
|
var target = new Interpreter(InterpreterOptions.Default | InterpreterOptions.LambdaExpressions);
|
var detectedIdentifiers = target.DetectIdentifiers(code);
|
|
// @class should be detected as an identifier, but not the @if because it's a member
|
Assert.That(detectedIdentifiers.UnknownIdentifiers.Count(), Is.EqualTo(1));
|
Assert.That(detectedIdentifiers.UnknownIdentifiers.ElementAt(0), Is.EqualTo("@class"));
|
}
|
|
|
[Test]
|
[TestCase("1L")]
|
[TestCase("2M")]
|
[TestCase("3.0D")]
|
[TestCase("4.0F")]
|
[TestCase("6.7e-8")]
|
[TestCase("9U")]
|
[TestCase("10ul")]
|
[TestCase("11lu")]
|
public void Dont_detect_numbers_with_suffix(string code)
|
{
|
var target = new Interpreter(InterpreterOptions.Default | InterpreterOptions.LambdaExpressions);
|
var detectedIdentifiers = target.DetectIdentifiers(code);
|
Assert.That(detectedIdentifiers.UnknownIdentifiers, Is.Empty);
|
}
|
|
class TestClass
|
{
|
public int Age { get; set; }
|
public string Name { get; set; }
|
}
|
|
[Test]
|
public void Detect_class_members_invocations()
|
{
|
TestClass customer = new TestClass() { Age = 1, Name = "abc" };
|
Interpreter target = new Interpreter();
|
target.SetVariable("test", customer);
|
|
// Known properties
|
IdentifiersInfo detectedIdentifiers = target.DetectIdentifiers("test.Name");
|
Assert.That(detectedIdentifiers.UnknownIdentifiers, Is.Empty);
|
Assert.That(detectedIdentifiers.Identifiers.Count(), Is.EqualTo(1));
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(0).Name, Is.EqualTo("test"));
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(0).Expression.Type, Is.EqualTo(typeof(TestClass)));
|
Assert.That(target.Eval("test.Name"), Is.EqualTo("abc"));
|
|
// Unknown properties, for now we don't detect them, eval how to support this for the future
|
detectedIdentifiers = target.DetectIdentifiers("test.Unknown");
|
Assert.That(detectedIdentifiers.UnknownIdentifiers.Count(), Is.EqualTo(0));
|
Assert.That(detectedIdentifiers.Identifiers.Count(), Is.EqualTo(1));
|
Assert.That(detectedIdentifiers.Identifiers.ElementAt(0).Name, Is.EqualTo("test"));
|
Assert.That(() => target.Eval("test.Unknown"), Throws.TypeOf<ParseException>());
|
}
|
}
|
}
|
