using System;
|
using System.Collections;
|
using System.Linq;
|
using DynamicExpresso.Exceptions;
|
using NUnit.Framework;
|
|
namespace DynamicExpresso.UnitTest
|
{
|
[TestFixture]
|
public class ConstructorTest
|
{
|
[Test]
|
public void New_Of_Base_Type()
|
{
|
var target = new Interpreter();
|
|
Assert.That(target.Eval("new DateTime(2015, 1, 24)"), Is.EqualTo(new DateTime(2015, 1, 24)));
|
Assert.That(target.Eval("new string('a', 10)"), Is.EqualTo(new string('a', 10)));
|
}
|
|
[Test]
|
public void New_Of_Custom_Type()
|
{
|
var target = new Interpreter();
|
|
target.Reference(typeof(Uri));
|
|
Assert.That(target.Eval("new Uri(\"http://www.google.com\")"), Is.EqualTo(new Uri("http://www.google.com")));
|
}
|
|
[Test]
|
public void New_And_Member_Access()
|
{
|
var target = new Interpreter();
|
|
Assert.That(target.Eval("new DateTime(2015, 1, 24).Month"), Is.EqualTo(new DateTime(2015, 1, 24).Month));
|
Assert.That(target.Eval("new DateTime( 2015, 1, 24).Month + 34"), Is.EqualTo(new DateTime(2015, 1, 24).Month + 34));
|
}
|
|
[Test]
|
public void Constructor_invocation_without_new_is_not_supported()
|
{
|
var target = new Interpreter();
|
|
Assert.Throws<ParseException>(() => target.Parse("DateTime(2010, 5, 23)"));
|
}
|
|
[Test]
|
public void Unknown_New_Type_Is_Not_Supported()
|
{
|
var target = new Interpreter();
|
|
Assert.Throws<UnknownIdentifierException>(() => target.Parse("new unkkeyword()"));
|
}
|
|
[Test]
|
public void Empty_object_initializer()
|
{
|
var target = new Interpreter();
|
target.Reference(typeof(MyClass));
|
|
Assert.That(target.Eval("new MyClass() {}"), Is.EqualTo(new MyClass() { }));
|
Assert.That(target.Eval("new MyClass(\"test\") {}"), Is.EqualTo(new MyClass("test") { }));
|
Assert.That(target.Eval("new MyClass{}"), Is.EqualTo(new MyClass { }));
|
}
|
|
[Test]
|
public void Object_initializer()
|
{
|
var target = new Interpreter();
|
target.Reference(typeof(MyClass));
|
|
// each member initializer can end with a comma, even if there's nothing afterwards
|
Assert.That(target.Eval("new MyClass { StrProp = \"test\", }"), Is.EqualTo(new MyClass { StrProp = "test", }));
|
Assert.That(target.Eval("new MyClass { StrProp = \"test\" }"), Is.EqualTo(new MyClass { StrProp = "test" }));
|
|
Assert.That(target.Eval("new MyClass(\"test\") { IntField = 5, }"), Is.EqualTo(new MyClass("test") { IntField = 5, }));
|
Assert.That(target.Eval("new MyClass(\"test\") { IntField = 5 }"), Is.EqualTo(new MyClass("test") { IntField = 5 }));
|
|
Assert.That(target.Eval("new MyClass() { StrProp = \"test\", IntField = 5, }"), Is.EqualTo(new MyClass() { StrProp = "test", IntField = 5, }));
|
Assert.That(target.Eval("new MyClass() { StrProp = \"test\", IntField = 5 }"), Is.EqualTo(new MyClass() { StrProp = "test", IntField = 5 }));
|
}
|
|
[Test]
|
public void Constructor_invocation_generics()
|
{
|
var target = new Interpreter();
|
target.Reference(typeof(Tuple<>));
|
target.Reference(typeof(Tuple<,>));
|
target.Reference(typeof(Tuple<,,>));
|
Assert.That(target.Eval("new Tuple<int>(1).Item1"), Is.EqualTo(1));
|
Assert.That(target.Eval("new Tuple<int, string>(5, \"My str item\").Item2"), Is.EqualTo("My str item"));
|
Assert.That(target.Eval("new Tuple<int, int, int>(1, 2, 3).Item3"), Is.EqualTo(3));
|
}
|
|
[Test]
|
public void Constructor_invocation_named_generics_with_arity()
|
{
|
var target = new Interpreter();
|
target.Reference(typeof(Tuple<>), "Toto`1");
|
target.Reference(typeof(Tuple<,>), "Toto`2");
|
target.Reference(typeof(Tuple<,,>), "Toto`3");
|
Assert.That(target.Eval("new Toto<int>(1).Item1"), Is.EqualTo(1));
|
Assert.That(target.Eval("new Toto<int, string>(5, \"My str item\").Item2"), Is.EqualTo("My str item"));
|
Assert.That(target.Eval("new Toto<int, int, int>(1, 2, 3).Item3"), Is.EqualTo(3));
|
}
|
|
[Test]
|
public void Constructor_invocation_named_generics()
|
{
|
var target = new Interpreter();
|
target.Reference(typeof(Tuple<,>), "Tuple");
|
Assert.That(target.Eval("new Tuple<int, string>(5, \"My str item\").Item2"), Is.EqualTo("My str item"));
|
|
target.Reference(typeof(Tuple<>), "Tuple1");
|
target.Reference(typeof(Tuple<,,>), "Tuple3");
|
Assert.That(target.Eval("new Tuple1<int>(1).Item1"), Is.EqualTo(1));
|
Assert.That(target.Eval("new Tuple3<int, int, int>(1, 2, 3).Item3"), Is.EqualTo(3));
|
}
|
|
[Test]
|
public void Object_initializer_syntax_error()
|
{
|
var target = new Interpreter();
|
target.Reference(typeof(MyClass));
|
Assert.Throws<ParseException>(() => target.Parse("new MyClass() { StrProp }"));
|
Assert.Throws<ParseException>(() => target.Parse("new MyClass() { StrProp = }"));
|
Assert.Throws<ArgumentException>(() => target.Parse("new MyClass() { StrProp = 5 }")); // type mismatch
|
Assert.Throws<ArgumentException>(() => target.Parse("new MyClass() { ReadOnlyProp = 5 }")); // read only prop
|
Assert.Throws<ParseException>(() => target.Parse("new MyClass() { UnkProp = 5 }")); // unknown property
|
Assert.Throws<ParseException>(() => target.Parse("new MyClass() { StrProp ")); // no close bracket
|
Assert.Throws<ParseException>(() => target.Parse("new MyClass() StrProp }")); // no open bracket
|
Assert.Throws<ParseException>(() => target.Parse("new MyClass() {{IntField = 5}}")); // multiple bracket
|
Assert.Throws<ParseException>(() => target.Parse("new MyClass() {5}")); // collection initializer not supported
|
}
|
|
[Test]
|
public void Ctor_params_array()
|
{
|
var target = new Interpreter();
|
target.Reference(typeof(MyClass));
|
Assert.That(target.Eval("new MyClass(6, 5, 4, 3).MyArr"), Is.EqualTo(new MyClass(6, 5, 4, 3).MyArr));
|
}
|
|
[Test]
|
public void Array_constructor()
|
{
|
var target = new Interpreter();
|
var arr = target.Eval<int[]>("new int[] { 1, 2 }");
|
Assert.That(arr.Length, Is.EqualTo(2));
|
Assert.That(arr[0], Is.EqualTo(1));
|
Assert.That(arr[1], Is.EqualTo(2));
|
}
|
|
[Test]
|
public void Array_constructor_type_mismatch()
|
{
|
// Exception: an expression of type 'System.Char' cannot be used to initialize an array of type 'System.Int32'
|
var target = new Interpreter();
|
Assert.Throws<ParseException>(() => target.Eval<int[]>("new int[] { 1, 'a' }"));
|
}
|
|
[Test]
|
public void Jagged_array_constructor()
|
{
|
var target = new Interpreter();
|
var arr = target.Eval<int[][]>("new int[][] { new int[] { 1, 2, }, new int[] { 3, 4, }, }");
|
Assert.That(arr.Length, Is.EqualTo(2));
|
Assert.That(arr[0][0], Is.EqualTo(1));
|
Assert.That(arr[0][1], Is.EqualTo(2));
|
Assert.That(arr[1][0], Is.EqualTo(3));
|
Assert.That(arr[1][1], Is.EqualTo(4));
|
}
|
|
[Test]
|
public void Array_multi_dimension_constructor()
|
{
|
// creating a multidimensional array is not supported
|
var target = new Interpreter();
|
Assert.Throws<ParseException>(() => target.Parse("new int[,] { { 1 }, { 2 } }"));
|
}
|
|
[Test]
|
public void Ctor_NewDictionaryWithItems()
|
{
|
var target = new Interpreter();
|
target.Reference(typeof(System.Collections.Generic.Dictionary<,>));
|
var l = target.Eval<System.Collections.Generic.Dictionary<int, string>>("new Dictionary<int, string>(){{1, \"1\"}, {2, \"2\"}, {3, \"3\"}, {4, \"4\"}, {5, \"5\"}}");
|
Assert.That(l.Count, Is.EqualTo(5));
|
for (int i = 0; i < l.Count; ++i)
|
{
|
Assert.That(l[i + 1], Is.EqualTo(i + 1 + ""));
|
}
|
}
|
|
[Test]
|
public void Ctor_NewMyClassWithItems()
|
{
|
var target = new Interpreter();
|
target.Reference(typeof(MyClassAdder));
|
|
Assert.That(target.Eval<MyClassAdder>("new MyClassAdder(){{ 1, 2, 3, 4, 5},{\"6\" },7 }.Add(true)"), Is.EqualTo(new MyClassAdder() { { 1, 2, 3, 4, 5 }, { "6" }, 7 }));
|
}
|
|
[Test]
|
public void Ctor_NewMyClass_ExpectedValues()
|
{
|
var target = new Interpreter();
|
target.Reference(typeof(MyClassAdder));
|
target.Reference(typeof(MyClass));
|
var strProp = new Parameter("StrProp", typeof(string).MakeByRefType(), "0");
|
var intProp = new Parameter("IntField", typeof(int).MakeByRefType(), int.MaxValue);
|
var args = new object[]
|
{
|
strProp.Value,
|
intProp.Value
|
};
|
Assert.That(
|
target.Parse("new MyClassAdder(){{ 1, 2, 3, 4, 5},{StrProp = \"6\" },7}", strProp, intProp).Invoke(args),
|
Is.EqualTo(new MyClassAdder() { { 1, 2, 3, 4, 5 }, "6", 7 }));
|
Assert.That(
|
target.Eval<MyClassAdder>("new MyClassAdder(){{ 1, 2, 3, 4, 5},string.Empty, 7}"),
|
Is.EqualTo(new MyClassAdder() { { 1, 2, 3, 4, 5 }, string.Empty, 7 }));
|
|
var IntField = int.MaxValue;
|
Assert.That(
|
target.Parse("new MyClassAdder(){ { IntField = 5 }, { 1, 2, 3, 4, 5},{StrProp = \"6\" }, IntField}", strProp, intProp).Invoke(args),
|
Is.EqualTo(new MyClassAdder() { { IntField = 5 }, { 1, 2, 3, 4, IntField }, "6" }));
|
}
|
|
[Test]
|
public void Ctor_NewMyClass_CanStillUseMemberSyntax()
|
{
|
var target = new Interpreter();
|
target.Reference(typeof(MyClassAdder));
|
target.Reference(typeof(MyClass));
|
Assert.That(
|
target.Eval<MyClassAdder>("new MyClassAdder() {StrProp = string.Empty, MyArr = new int[] {1, 2, 3, 4, 5}, IntField = int.MinValue }"),
|
Is.EqualTo(new MyClassAdder() { StrProp = string.Empty, MyArr = new[] { 1, 2, 3, 4, 5 }, IntField = int.MinValue }));
|
}
|
|
[Test]
|
public void Ctor_InvalidInitializerMemberDeclarator()
|
{
|
var target = new Interpreter();
|
target.Reference(typeof(MyClassAdder));
|
target.Reference(typeof(MyClass));
|
Assert.Throws<ParseException>(() => target.Eval<MyClassAdder>("new MyClassAdder(){{ 1, 2, 3, 4, 5},{StrProp = \"6\" },7 }"));
|
//Start with collection, then do member init
|
Assert.Throws<ParseException>(() => target.Eval<MyClassAdder>("new MyClassAdder(){{ 1, 2, 3, 4, 5},StrProp = \"6\" ,7 }"));
|
//Member init first, then attempt a collection init.
|
Assert.Throws<ParseException>(() => target.Eval<MyClassAdder>("new MyClassAdder(){StrProp = \"6\" ,{ 1, 2, 3, 4, 5},7 }"));
|
}
|
|
[Test]
|
public void Ctor_CannotUseCollectionInitDoesNotImplementIEnumerable()
|
{
|
var target = new Interpreter();
|
target.Reference(typeof(MyClassAdder));
|
target.Reference(typeof(MyClass));
|
Assert.Throws<ParseException>(() => target.Eval<MyClass>("new MyClass(){ 1, 2, 3, 4, 5}"));
|
}
|
|
[Test]
|
public void Ctor_NewListWithItems()
|
{
|
Ctor_NewListGeneric<string>("\"1\"", "\"2\"", "\"3\"", "{string.Empty}", "string.Empty", "int.MaxValue.ToString()", "{int.MinValue.ToString()}");
|
Ctor_NewListGeneric<int>("1", "2", "3", "int.MinValue", "int.MaxValue", "{int.MinValue}", "{int.MaxValue}");
|
Ctor_NewListGeneric<object>("string.Empty", "int.MinValue");
|
}
|
|
[Test]
|
public void Ctor_NewListCantFindAddMethod()
|
{
|
var target = new Interpreter();
|
target.Reference(typeof(System.Collections.Generic.List<>));
|
try
|
{
|
target.Eval<System.Collections.Generic.List<int>>("new List<int>(){string.Empty}");
|
}
|
catch (ParseException ex)
|
{
|
if (ex.Message.Contains("The best overloaded Add "))
|
{
|
Assert.That(ex.Message, Does.Contain("Add"));
|
}
|
else
|
{
|
throw;
|
}
|
}
|
Assert.Throws<ParseException>(() => target.Eval<System.Collections.Generic.List<string>>("new List<string>(){int.MaxValue}"));
|
}
|
|
public void Ctor_NewListGeneric<TObject>(params string[] items)
|
{
|
var target = new Interpreter();
|
target.Reference(typeof(System.Collections.Generic.List<>));
|
target.Reference(typeof(TObject));
|
//Create a random list of values to test.
|
var actual = new System.Collections.Generic.List<TObject>();
|
foreach (var v in items)
|
{
|
actual.Add(target.Eval<TObject>(v.Trim('}', '{')));
|
}
|
for (var min = 0; min < actual.Count; ++min)
|
{
|
for (var count = Math.Min(min, 1); count <= actual.Count - min; ++count)
|
{
|
var evalText = $"new List<{typeof(TObject).Name}>(){{{string.Join(",", items.Skip(min).Take(count))}}}";
|
System.Collections.Generic.List<TObject> eval = null;
|
Assert.DoesNotThrow(() => eval = target.Eval<System.Collections.Generic.List<TObject>>(evalText), evalText);
|
Assert.That(eval.Count, Is.EqualTo(count));
|
for (var i = 0; i < count; ++i)
|
{
|
Assert.That(eval[i], Is.EqualTo(actual[i + min]));
|
}
|
}
|
}
|
}
|
|
[Test]
|
public void Ctor_NewListWithString()
|
{
|
var target = new Interpreter();
|
target.Reference(typeof(System.Collections.Generic.List<>));
|
var list = target.Eval<System.Collections.Generic.List<string>>("new List<string>(){string.Empty}");
|
Assert.That(list.Count, Is.EqualTo(1));
|
for (int i = 0; i < list.Count; ++i)
|
{
|
Assert.That(list[i], Is.SameAs(string.Empty));
|
}
|
list = target.Eval<System.Collections.Generic.List<string>>("new List<string>(){StrProp = string.Empty}", new Parameter("StrProp", "0"));
|
Assert.That(list[0], Is.SameAs(string.Empty));
|
list = target.Eval<System.Collections.Generic.List<string>>("new List<string>(){{StrProp = string.Empty}}", new Parameter("StrProp", "0"));
|
Assert.That(list[0], Is.SameAs(string.Empty));
|
list = target.Eval<System.Collections.Generic.List<string>>("new List<string>(){StrValue()}", new Parameter("StrValue", new Func<string>(() => "Func")));
|
Assert.That(list[0], Is.EqualTo("Func"));
|
}
|
|
|
private class MyClass
|
{
|
public int IntField;
|
public string StrProp { get; set; }
|
public int ReadOnlyProp { get; }
|
public int[] MyArr { get; set; }
|
|
public MyClass()
|
{
|
}
|
|
public MyClass(string strValue)
|
{
|
StrProp = strValue;
|
}
|
|
public MyClass(params int[] intValues)
|
{
|
MyArr = intValues;
|
}
|
|
public override bool Equals(object obj)
|
{
|
return Equals(obj as MyClass);
|
}
|
|
public bool Equals(MyClass p)
|
{
|
if (p is null) return false;
|
if (ReferenceEquals(this, p)) return true;
|
return IntField == p.IntField && StrProp == p.StrProp && ReadOnlyProp == p.ReadOnlyProp;
|
}
|
|
// remove compilation warning
|
public override int GetHashCode()
|
{
|
return 0;
|
}
|
}
|
|
private class MyClassAdder : MyClass, System.Collections.IEnumerable
|
{
|
|
public MyClassAdder Add(string s)
|
{
|
StrProp = s;
|
return this;
|
}
|
|
public MyClassAdder Add(int intValue)
|
{
|
IntField = intValue;
|
return this;
|
}
|
|
public MyClassAdder Add(params int[] intValues)
|
{
|
MyArr = intValues;
|
return this;
|
}
|
|
public MyClassAdder Add(bool returnMe)
|
{
|
if (returnMe)
|
{
|
return this;
|
}
|
return null;
|
}
|
|
IEnumerator IEnumerable.GetEnumerator()
|
{
|
yield break;
|
}
|
|
}
|
}
|
}
|
