public void Test2()
{
PersonDoc doc = TypeAccessor <PersonDoc> .CreateInstance();
doc.Series_PersonDoc = "PersonDoc";
doc.Validate();
}
public void AccessorTest()
{
var test = TypeAccessor <Test> .CreateInstance();
var mapper = Map.GetObjectMapper <Test, Test>();
var testCopy = mapper(test);
}
public void Test()
{
MyClassB original = TypeAccessor <MyClassB> .CreateInstance();
MyClassB serialized;
XmlSerializer sr = new XmlSerializer(/*[a]*/ TypeAccessor <MyClassB> .Type /*[/a]*/);
original.ValueB = "string value B";
original.ValueMyClassA.ValueA = "string value A";
original.MyList.Add(TypeAccessor <MyClassA> .CreateInstance());
original.MyList.Add(TypeAccessor <MyClassC> .CreateInstance());
using (MemoryStream stm = new MemoryStream())
{
sr.Serialize(stm, original);
stm.Position = 0L;
serialized = (MyClassB)sr.Deserialize(stm);
}
Assert.That(serialized.ValueB, Is.EqualTo(original.ValueB));
Assert.That(serialized.ValueMyClassA.ValueA, Is.EqualTo(original.ValueMyClassA.ValueA));
Assert.AreEqual(original.MyList.Count, serialized.MyList.Count);
Assert.That(serialized.MyList[0] is MyClassA);
Assert.That(serialized.MyList[1] is MyClassA);
Assert.That(serialized.MyList[1] is MyClassC);
Assert.AreEqual(serialized.MyList[0].GetType(), TypeFactory.GetType(typeof(MyClassA)));
Assert.AreEqual(serialized.MyList[1].GetType(), TypeFactory.GetType(typeof(MyClassC)));
}
public void MismatchedAgsTest()
{
Assert.Throws <TargetInvocationException>(() =>
{
TypeAccessor.CreateInstance(typeof(BadObject));
});
}
public void Test()
{
TestClass tc = TypeAccessor <TestClass> .CreateInstance();
TestClass.Value = 1;
int value1 = tc.CachedMethod(1, 2);
TestClass.Value = 2;
int value2 = tc.CachedMethod(1, 2);
// The cached values are equal.
//
Assert.AreEqual(value1, value2);
tc.ClearCache();
TestClass.Value = 3;
// Previous and returned values are not equal.
//
Assert.AreNotEqual(value1, tc.CachedMethod(1, 2));
tc.ClearCache2();
}
public void AssemblyResolver()
{
var setup = new AppDomainSetup();
var basePath = GetType().Assembly.GetName(false).CodeBase;
basePath = basePath.Replace("file:///", "");
basePath = Path.GetDirectoryName(basePath);
setup.ApplicationBase = "file:///" + basePath;
var appDomain = AppDomain.CreateDomain("NewDomain", null, setup);
basePath = GetType().Assembly.GetName(false).CodeBase;
basePath = Path.GetFileName(basePath).ToLower().Replace(".dll", "");
var test = (TypeFactoryTest)appDomain.CreateInstanceAndUnwrap(basePath, GetType().FullName);
var o = (TestObject)TypeAccessor.CreateInstance(typeof(TestObject));
o.Number = 23;
var n = test.GetNumber(o);
AppDomain.Unload(appDomain);
Assert.AreEqual(23, n);
}
public static ModelMetadata GetModelMetadata <T>(this T entity)
where T : EntityBase <T>
{
T model = TypeAccessor <T> .CreateInstance();
return(ModelMetadataProviders.Current.GetMetadataForType(() => model, model.GetType()));
}
public void Test4([DataContexts] string contexts)
{
using (var db = GetDataContext(contexts))
{
db.Child.Delete(p => p.ParentID == 1001);
db.Parent.Delete(p => p.ParentID == 1001);
try
{
var child = TypeAccessor.CreateInstance <ChildX>();
var parent = TypeAccessor.CreateInstance <ParentX>();
parent.ParentID = 1001;
parent.Value1 = 1;
db.Insert(parent);
child.ChildID = 1001;
child.Parent = parent;
db.Insert(child);
}
finally
{
db.Child.Delete(p => p.ParentID == 1001);
db.Parent.Delete(p => p.ParentID == 1001);
}
}
}
public void OverloadTest()
{
OverloadTestObject o = /*[a]*/ TypeAccessor /*[/a]*/ <OverloadTestObject> .CreateInstance();
Assert.AreEqual(1, o./*[a]*/ Test/*[/a]*/ (1));
Assert.AreEqual(0, o./*[a]*/ Test/*[/a]*/ ("str"));
}
public void Test()
{
EmitHelper emit = new AssemblyBuilderHelper("HelloWorld.dll")
.DefineType("Hello", typeof(object), typeof(IHello))
.DefineMethod(typeof(IHello).GetMethod("SayHello"))
.Emitter;
/*[a]*/ emit /*[/a]*/
// string.Format("Hello, {0}!", toWhom)
//
./*[a]*/ ldstr/*[/a]*/ ("Hello, {0}!")
./*[a]*/ ldarg_1 /*[/a]*/
./*[a]*/ call/*[/a]*/ (typeof(string), "Format", typeof(string), typeof(object))
// Console.WriteLine("Hello, World!");
//
./*[a]*/ call/*[/a]*/ (typeof(Console), "WriteLine", typeof(string))
./*[a]*/ ret/*[/a]*/ ()
;
Type type = emit.Method.Type.Create();
IHello hello = (IHello)TypeAccessor.CreateInstance(type);
hello.SayHello("World");
}
public void NullKeyTest()
{
Master m = TypeAccessor.CreateInstance <Master>();
Detail d = TypeAccessor.CreateInstance <Detail>();
List <Master> masters = new List <Master>();
List <Detail> details = new List <Detail>();
masters.Add(m);
details.Add(d);
Map.ResultSets(new MapResultSet[] { new MapResultSet(typeof(Master), masters),
new MapResultSet(typeof(Detail), details) });
Assert.IsFalse(object.ReferenceEquals(d.Master, m));
Assert.AreEqual(0, m.Details.Count);
m.MasterId = 1;
d.DetailId = 1;
d.Master.MasterId = 1;
Map.ResultSets(new MapResultSet[] { new MapResultSet(typeof(Master), masters),
new MapResultSet(typeof(Detail), details) });
Assert.IsTrue(object.ReferenceEquals(d.Master, m));
Assert.AreEqual(1, m.Details.Count);
}
public void Test()
{
TypeFactory.SetGlobalAssembly("InternalTypesTest.dll", new Version(1, 2, 3, 4), "TypeBuilder/InternalTypesTest.snk");
InternalObject o = TypeAccessor.CreateInstance <InternalObject>();
Assert.IsNotNull(o);
PublicObject o2 = TypeAccessor.CreateInstance <PublicObject>();
Assert.IsNotNull(o2);
TypeFactory.SaveGlobalAssembly();
TypeAccessor ta = TypeAccessor <PublicObject> .Instance;
Assert.IsNotNull(ta["InternalField"]);
Assert.IsTrue(ta["InternalField"].HasGetter);
Assert.IsTrue(ta["InternalField"].HasSetter);
Assert.IsNotNull(ta["PublicValue"]);
Assert.IsTrue(ta["PublicValue"].HasGetter);
Assert.IsTrue(ta["PublicValue"].HasSetter);
Assert.IsNotNull(ta["InternalValue"]);
Assert.IsTrue(ta["InternalValue"].HasGetter);
Assert.IsTrue(ta["InternalValue"].HasSetter);
Assert.IsNotNull(ta["ProtectedInternalValue"]);
Assert.IsTrue(ta["ProtectedInternalValue"].HasGetter);
Assert.IsTrue(ta["ProtectedInternalValue"].HasSetter);
Assert.IsNotNull(ta["NonAbstractValue"]);
Assert.IsTrue(ta["NonAbstractValue"].HasGetter);
Assert.IsTrue(ta["NonAbstractValue"].HasSetter);
}
public void TrackTypeNewHistoryTest()
{
using (var repo = TypeAccessor.CreateInstance <TruckTypeRepository>())
{
var res = repo.GetHistory(null, null);
}
}
public static void Test()
{
TestObject1 o = (TestObject1)TypeAccessor.CreateInstance(typeof(TestObject1));
o.IntField = 10;
o.IntProp = 11;
o.ObjField = 12;
o.ObjProp = 13;
Assert.AreEqual(10, o.IntField);
Assert.AreEqual(22, o.IntProp);
Assert.AreEqual(12, o.ObjField);
Assert.AreEqual(39, o.ObjProp);
DateTime testDate = new DateTime(2000, 1, 1);
o.DowField = DayOfWeek.Monday;
o.DowProp = DayOfWeek.Sunday;
o.DateField = testDate;
o.DateProp = testDate;
Assert.AreEqual(DayOfWeek.Monday, o.DowField);
Assert.AreEqual(DayOfWeek.Sunday, o.DowProp);
Assert.AreEqual(testDate, o.DateField);
Assert.AreEqual(testDate, o.DateProp);
o.ArrField = new ArrayList(17);
o.ArrProp = new ArrayList(21);
Assert.AreEqual(17, o.ArrField.Capacity);
Assert.AreEqual(21, o.ArrProp.Capacity);
}
public void Test()
{
TestClass t = TypeAccessor.CreateInstance <TestClass>();
DateTime begin = DateTime.Now;
for (TestClass.Value = 777; t.Test(2, 2) == 777; TestClass.Value++)
{
continue;
}
Assert.IsTrue((DateTime.Now - begin).TotalMilliseconds >= 500);
TestClass.Value = 1; Assert.AreEqual(1, t.Test(1, 1));
TestClass.Value = 2; Assert.AreEqual(1, t.Test(1, 1));
TestClass.Value = 3; Assert.AreEqual(3, t.Test(2, 1));
CacheAspect.ClearCache(typeof(TestClass), "Test", typeof(int), typeof(int));
TestClass.Value = 4; Assert.AreEqual(4, t.Test(2, 1));
CacheAspect.ClearCache(t.GetType(), "Test", typeof(int), typeof(int));
TestClass.Value = 5; Assert.AreEqual(5, t.Test(2, 1));
CacheAspect.ClearCache();
TestClass.Value = 6; Assert.AreEqual(6, t.Test(2, 1));
}
public void Test1()
{
TestClass t = (TestClass)TypeAccessor.CreateInstance(typeof(TestClass));
t.Test();
t.Test(new ArrayList(), 567, "876", 'X');
}
public void Test()
{
Entity e = (Entity)TypeAccessor.CreateInstance(typeof(Entity));
Test2.IInterface1 t2a = (Test2.IInterface1)e;
t2a.DoAction();
// because of boxing :(
Assert.AreEqual(null /*"Test2.IAction1.DoAction"*/, e.Str);
Test1.IInterface1 t1a = (Test1.IInterface1)e;
t1a.DoAction();
Assert.AreEqual("Test1.IAction1.DoAction", e.Str);
IInterface2 a2 = (IInterface2)e;
a2.DoAction();
Assert.AreEqual(123, e.Int);
Assert.AreEqual(MyDateTime.TestDate1, e.Date);
a2.DoAction(456, null);
Assert.AreEqual(456, e.Int);
Assert.AreEqual(MyDateTime.TestDate2, e.Date);
Assert.AreEqual(2, e.CallCounter);
ISetInfo si = (ISetInfo)e;
si.SetInfo(1, null, 2);
Assert.AreEqual("Str", e.Str);
}
public void MapFieldTest()
{
var p = (Person)TypeAccessor.CreateInstance(typeof(Person));
p.ID = 12345;
p.First.Name = "Crazy";
p.Last.Name = "Frog";
p.Last.Suffix = "Jr";
p.Last.Type = typeof(DbManager);
p.Last.First.Name = "Crazy Frog";
p.Name = "Froggy";
p.Type = typeof(DbManager);
var p2 = (Person2)Map.ObjectToObject(p, typeof(Person2));
Assert.AreEqual(p.ID, p2.ID);
Assert.AreEqual(p.First.Name, p2.First.Name);
Assert.AreEqual(p.Last.Name, p2.Last.Name);
Assert.AreEqual(p.Last.Suffix, p2.Last.Suffix);
Assert.AreEqual(p.Last.First.Name, p2.Last.First.Name);
Assert.AreEqual(p.Name, p2.Name);
Assert.AreEqual(p.Type.FullName, p2.Type);
// The 'Last.Type' field should be ignored by mapping process.
//
Assert.IsNull(p2.Last.Type);
}
public void OverloadTest()
{
TestObject o = TypeAccessor.CreateInstance <TestObject>();
o.Test(12345, "str");
Assert.AreEqual(12345, o.IntValue);
Assert.AreEqual("str", o.StrValue);
Assert.AreEqual(Guid.Empty, o.GuidValue);
o.Test(Guid.NewGuid(), 123);
Assert.AreEqual(123, o.IntValue);
Assert.AreEqual("(default)", o.StrValue);
Assert.AreNotEqual(Guid.Empty, o.GuidValue);
o.Test("foo");
Assert.AreEqual(0, o.IntValue);
Assert.AreEqual("foo", o.StrValue);
Assert.AreEqual(Guid.Empty, o.GuidValue);
o.Test(Guid.NewGuid());
Assert.AreEqual(0, o.IntValue);
Assert.AreEqual("(default)", o.StrValue);
Assert.AreNotEqual(Guid.Empty, o.GuidValue);
Assert.AreEqual(1, o.Generic(1));
}
public void AnyNameTest()
{
AsyncTestObject o = TypeAccessor <AsyncTestObject> .CreateInstance();
IAsyncResult ar = o./*[a]*/ AnyName/*[/a]*/ (2, null, null, null);
Assert.AreEqual(2, o./*[a]*/ AnyName/*[/a]*/ (ar));
}
public void Test()
{
TestObject o = TypeAccessor <TestObject> .CreateInstance();
IAsyncResult ar = o.BeginTest(42);
Assert.AreEqual(42, o.EndTest(ar));
}
public void TestNull()
{
NullValue v = (NullValue)TypeAccessor.CreateInstance(typeof(NullValue));
v.Value = null;
((IReturnNullInterface)v).DoNull();
}
public void StaticMethodTest()
{
TestObject o = TypeAccessor.CreateInstance <TestObject>();
int intVal = o.StaticMethod(123);
Assert.AreEqual(123, intVal);
}
public void Test2()
{
Assert.Throws <ApplicationException>(() =>
{
var t = (TestClass)TypeAccessor.CreateInstance(typeof(TestClass));
t.Test(123);
});
}
//[Test]
public void GenericMethodTest()
{
var i = TypeAccessor.CreateInstance <TestClass1>().Get <int> ();
var d = TypeAccessor.CreateInstance <TestClass1>().Get <DateTime>();
i = TypeAccessor.CreateInstance <TestClass1>().Get <int> (0);
d = TypeAccessor.CreateInstance <TestClass1>().Get <DateTime>(0);
}
public void TestPrivate()
{
TestObject2 o = (TestObject2)TypeAccessor.CreateInstance(typeof(TestObject2));
o.ID = 1;
Assert.AreEqual("ID", o.NotifiedName);
}
public void Test1()
{
Assert.Throws <ArgumentNullException>(() =>
{
TestObject1 o = (TestObject1)TypeAccessor.CreateInstance(typeof(TestObject1));
o.Foo1("str1", null, "str3");
});
}
public void AsyncTest()
{
AsyncTestObject o = /*[a]*/ TypeAccessor /*[/a]*/ <AsyncTestObject> .CreateInstance();
IAsyncResult ar = o./*[a]*/ BeginTest/*[/a]*/ (1, "10");
Assert.AreEqual(1, o./*[a]*/ EndTest/*[/a]*/ (ar));
}
public void TestMemberImpl()
{
Test4 t = TypeAccessor <Test4> .CreateInstance();
t.Test.Name = "John";
Assert.AreEqual("John", t.Test.Name);
}
public void AbstractProperties()
{
var o = TypeAccessor.CreateInstance <TestObject>();
Assert.IsNotNull(o.IntArray1);
Assert.AreSame(o.IntArray1, o.IntArray2);
Assert.IsNotNull(o.ByteArray);
}
public object CreateInstance(TypeAccessor typeAccessor, InitContext context)
{
if (context == null)
throw new Exception("InitContext is null while mapping from DataReader!");
return typeAccessor.CreateInstance();
}
public object CreateInstance(TypeAccessor typeAccessor)
{
return typeAccessor.CreateInstance();
}
