mirror of https://github.com/dahall/Vanara.git
180 lines
6.6 KiB
C#
180 lines
6.6 KiB
C#
using Vanara.Extensions;
|
|
using NUnit.Framework;
|
|
using System;
|
|
using System.Drawing;
|
|
using static Vanara.Extensions.ReflectionExtensions;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
|
|
namespace Vanara.Extensions.Tests
|
|
{
|
|
[TestFixture()]
|
|
public class ReflectionExtensionsTests
|
|
{
|
|
public class X
|
|
{
|
|
public string Str { get; set; }
|
|
}
|
|
|
|
[Test()]
|
|
public void GetPropertyValueTest()
|
|
{
|
|
var dt = DateTime.Today;
|
|
// Has public value
|
|
Assert.That(dt.GetPropertyValue("Ticks", 0L), Is.EqualTo(dt.Ticks));
|
|
Assert.That(dt.GetPropertyValue<long>("Ticks"), Is.EqualTo(dt.Ticks));
|
|
// Has private value
|
|
Assert.That(dt.GetPropertyValue<long>("InternalTicks"), Is.EqualTo(dt.Ticks));
|
|
// Bad propname
|
|
Assert.That(() => dt.GetPropertyValue<long?>("Tacks"), Throws.Exception);
|
|
Assert.That(() => dt.GetPropertyValue<long?>("Tacks", null), Is.Null);
|
|
// Diff ret type
|
|
Assert.That(() => dt.GetPropertyValue<string>("Ticks"), Throws.Exception);
|
|
Assert.That(dt.GetPropertyValue("Ticks", string.Empty), Is.EqualTo(string.Empty));
|
|
// Has null val
|
|
var x = new X();
|
|
Assert.That(x.GetPropertyValue("Str", ""), Is.Null);
|
|
}
|
|
|
|
[TestCase(typeof(string), typeof(char))]
|
|
[TestCase(typeof(IEnumerable), typeof(object))]
|
|
[TestCase(typeof(IEnumerable<Guid>), typeof(Guid))]
|
|
[TestCase(typeof(IEnumerable<string>), typeof(string))]
|
|
[TestCase(typeof(List<string>), typeof(string))]
|
|
[TestCase(typeof(IEnum), typeof(object))]
|
|
[TestCase(typeof(IGenEnum), typeof(int))]
|
|
[TestCase(typeof(DerIGenEnum), typeof(int))]
|
|
[TestCase(typeof(int), null)]
|
|
public void FindElementTypeTest(Type t, Type e)
|
|
{
|
|
Assert.That(t.FindElementType(), Is.EqualTo(e));
|
|
}
|
|
|
|
[Test]
|
|
public void FindElementTypeTest2()
|
|
{
|
|
Assert.That("Fred".GetType().FindElementType(), Is.EqualTo(typeof(char)));
|
|
Assert.That(new IEnum().GetType().FindElementType(), Is.EqualTo(typeof(object)));
|
|
Assert.That(new IGenEnum().GetType().FindElementType(), Is.EqualTo(typeof(int)));
|
|
Assert.That(new DerIGenEnum().GetType().FindElementType(), Is.EqualTo(typeof(int)));
|
|
Assert.That(new Guid[2].GetType().FindElementType(), Is.EqualTo(typeof(Guid)));
|
|
Assert.That(new string[2].GetType().FindElementType(), Is.EqualTo(typeof(string)));
|
|
Assert.That(new List<string>().GetType().FindElementType(), Is.EqualTo(typeof(string)));
|
|
|
|
Assert.That(3.GetType().FindElementType(), Is.Null);
|
|
|
|
var ie = GetEnum();
|
|
Assert.That(ie.GetType().FindElementType(), Is.EqualTo(typeof(object)));
|
|
var ige = GetGenEnum();
|
|
Assert.That(ige.GetType().FindElementType(), Is.EqualTo(typeof(int)));
|
|
|
|
IEnumerable GetEnum()
|
|
{
|
|
yield return 1;
|
|
yield return 2;
|
|
}
|
|
|
|
IEnumerable<int> GetGenEnum()
|
|
{
|
|
yield return 1;
|
|
yield return 2;
|
|
}
|
|
}
|
|
|
|
private class IEnum : IEnumerable
|
|
{
|
|
public IEnumerator GetEnumerator() => throw new NotImplementedException();
|
|
}
|
|
|
|
private class IGenEnum : IEnumerable<int>
|
|
{
|
|
public IEnumerator<int> GetEnumerator() => throw new NotImplementedException();
|
|
IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
|
|
}
|
|
|
|
private class DerIGenEnum : IGenEnum
|
|
{
|
|
|
|
}
|
|
|
|
[Test()]
|
|
public void InvokeMethodRetTest()
|
|
{
|
|
var dt = DateTime.Today;
|
|
Assert.That(dt.InvokeMethod<long>("ToBinary"), Is.Not.EqualTo(0));
|
|
Assert.That(dt.InvokeMethod<DateTime>("AddHours", (double)1), Is.EqualTo(dt + TimeSpan.FromHours(1)));
|
|
Assert.That(dt.InvokeMethod<long>("ToBinary", Type.EmptyTypes, null), Is.Not.EqualTo(0));
|
|
Assert.That(dt.InvokeMethod<DateTime>("AddHours", new[] { typeof(double) }, new object[] { 1f }), Is.EqualTo(dt + TimeSpan.FromHours(1)));
|
|
|
|
Assert.That(() => dt.InvokeMethod<long>("ToBin"), Throws.Exception);
|
|
Assert.That(() => dt.InvokeMethod<long>("ToBinary", 1), Throws.Exception);
|
|
Assert.That(() => dt.InvokeMethod<DateTime>("ToBinary", 1), Throws.Exception);
|
|
Assert.That(() => dt.InvokeMethod<TimeSpan>("Subtract", new[] {typeof(long)}, new object[] {1}), Throws.ArgumentException);
|
|
Assert.That(() => dt.InvokeMethod<TimeSpan>("Subtract", new[] { typeof(DateTime) }, new object[] { 1 }), Throws.ArgumentException);
|
|
Assert.That(() => dt.InvokeMethod<long>("Subtract", new[] { typeof(DateTime) }, new object[] { DateTime.Now }), Throws.ArgumentException);
|
|
}
|
|
|
|
[Test()]
|
|
public void InvokeMethodTest()
|
|
{
|
|
var s = new System.Collections.Specialized.StringCollection();
|
|
s.AddRange(new[] { "A", "B", "C" });
|
|
var sa = new string[3];
|
|
Assert.That(() => s.InvokeMethod("CopyTo", new[] { typeof(string[]), typeof(int) }, new object[] { sa, 0 }), Throws.Nothing);
|
|
Assert.That(() => s.InvokeMethod("CopyTo", sa, 0), Throws.Nothing);
|
|
Assert.That(sa[0] == "A");
|
|
Assert.That(() => s.InvokeMethod("Clear"), Throws.Nothing);
|
|
Assert.That(s.Count == 0);
|
|
s.AddRange(sa);
|
|
Assert.That(() => s.InvokeMethod("Clear", Type.EmptyTypes, null), Throws.Nothing);
|
|
Assert.That(s.Count == 0);
|
|
Assert.That(() => s.InvokeMethod("Clr", Type.EmptyTypes, null), Throws.ArgumentException);
|
|
Assert.That(() => s.InvokeMethod<DateTime>("ToBinary", Type.EmptyTypes, null), Throws.ArgumentException);
|
|
}
|
|
|
|
[Test()]
|
|
public void InvokeMethodTest1()
|
|
{
|
|
Assert.That(typeof(Rectangle).InvokeMethod<bool>("Contains", 1, 1), Is.False);
|
|
}
|
|
|
|
[Test()]
|
|
public void InvokeMethodTypeTest()
|
|
{
|
|
var dt = typeof(DateTime);
|
|
Assert.That(dt.InvokeMethod<long>(new object[] { 2017, 1, 1 }, "ToBinary"), Is.Not.EqualTo(0));
|
|
Assert.That(dt.InvokeMethod<DateTime>(new object[] { 2017, 1, 1 }, "AddHours", (double)1), Is.EqualTo(new DateTime(2017, 1, 1) + TimeSpan.FromHours(1)));
|
|
}
|
|
[Test()]
|
|
public void InvokeNotOverrideTest()
|
|
{
|
|
var t = new TestDerived();
|
|
var mi = typeof(TestBase).GetMethod("GetValue", Type.EmptyTypes);
|
|
Assert.That(mi.InvokeNotOverride(t), Is.EqualTo(0));
|
|
Assert.That(() => mi.InvokeNotOverride(t, 2), Throws.Exception);
|
|
mi = typeof(TestBase).GetMethod("GetValue", new[] { typeof(int), typeof(int) });
|
|
Assert.That(mi.InvokeNotOverride(t, 1, 2), Is.EqualTo(0));
|
|
mi = typeof(TestBase).GetMethod("GetValue", new[] { typeof(int), typeof(int) });
|
|
Assert.That(() => mi.InvokeNotOverride(t, 'c', 2), Throws.Exception);
|
|
}
|
|
|
|
[Test()]
|
|
public void LoadTypeTest()
|
|
{
|
|
Assert.That(() => LoadType("X", "Asm"), Is.Null);
|
|
Assert.That(LoadType("System.Uri", @"C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.5.2\System.dll"), Is.Not.Null);
|
|
Assert.That(LoadType("Vanara.Extensions.Tests.ReflectionExtensionsTests", null), Is.Not.Null);
|
|
}
|
|
private class TestBase
|
|
{
|
|
public virtual int GetValue() => 0;
|
|
public virtual int GetValue(int a, int b) => 0;
|
|
}
|
|
|
|
private class TestDerived : TestBase
|
|
{
|
|
public override int GetValue() => 1;
|
|
public override int GetValue(int a, int b) => 1;
|
|
}
|
|
}
|
|
} |