public void InvalidArgTest3()
{
Assert.Throws <ArgumentException>(() =>
{
_ = (Child1?)DuckTyping.Implement(typeof(Child1), new Child2());
});
}
public void InvalidArgTest2()
{
Assert.Throws <TypeBuilderException>(() =>
{
_ = (NonPublicInterface?)DuckTyping.Implement(typeof(NonPublicInterface), new TestClass());
});
}
public void Test()
{
var duck = DuckTyping.Implement <TestInterface> (new TestClass());
var same = DuckTyping.Implement <TestInterface> (duck);
var duck2 = DuckTyping.Implement <TestInterface2>(same);
Assert.AreSame(duck, same);
duck.Method(33, out var value);
Assert.AreEqual(33, value);
Assert.AreEqual(42, duck.Method(40));
Assert.AreEqual(22, duck.Prop);
duck.Event += duck_Event;
duck.CallEvent();
Assert.AreEqual(55, eventValue);
duck2.I2Method(33, out value);
Assert.AreEqual(33, value);
Assert.AreEqual(42, duck2.Method(40));
}
public void AggregateTest()
{
var duck = DuckTyping.Aggregate <IAggregatable>(new AggregateClass1(), new AggregateClass2());
Assert.IsNotNull(duck);
Assert.AreEqual(1, duck.Method1());
Assert.AreEqual(2, duck.Method2());
// It is still possible to get access
// to an interface of an underlying object.
//
var cls2 = DuckTyping.Implement <IClass2>(duck);
Assert.IsNotNull(cls2);
Assert.AreEqual(2, cls2.Method2());
// Even to switch from one aggregated object to another
//
var cls1 = DuckTyping.Implement <IClass1>(cls2);
Assert.IsNotNull(cls1);
Assert.AreEqual(1, cls1.Method1());
Assert.AreEqual(3, cls1.Method3());
}
public void InvalidArgTest1()
{
TestInterface o = null;
TestInterface duck1 = DuckTyping.Implement <TestInterface>(o);
TestInterface duck2 = (TestInterface)DuckTyping.Implement(typeof(TestInterface), o);
}
public void StructTest()
{
DuckTyping.AllowStaticMembers = true;
TestInterface duck = DuckTyping.Implement <TestInterface> (new TestStruct());
Assert.AreEqual(43, duck.Method(40));
}
public void BulkTest()
{
TestInterface[] ducks = DuckTyping.Implement <TestInterface, TestClass> (new Child1(), new Child2());
Assert.IsNotEmpty(ducks);
Assert.AreEqual(42, ducks[0].Method(40));
Assert.AreEqual(42, ducks[1].Method(40));
}
public void StaticTest()
{
DuckTyping.AllowStaticMembers = true;
var duck = DuckTyping.Implement <TestInterface, StaticClass>(new StaticClass());
Assert.AreEqual(43, duck.Method(40));
}
public void BulkTest2()
{
var ducks = DuckTyping.Implement <TestInterface>(new Child1(), new Child2());
Assert.IsNotEmpty(ducks);
Assert.AreEqual(45, ducks[0].Method(40));
Assert.AreEqual(50, ducks[1].Method(40));
}
public void InheritanceTest2()
{
var duck1 = DuckTyping.Implement <TestInterface, TestClass>(new Child1());
var duck2 = DuckTyping.Implement <TestInterface, TestClass>(new Child2());
Assert.AreNotSame(duck1, duck2);
Assert.AreEqual(42, duck1.Method(40));
Assert.AreEqual(42, duck2.Method(40));
}
public void InheritanceTest()
{
TestInterface duck1 = DuckTyping.Implement <TestInterface> (new Child1());
TestInterface duck2 = DuckTyping.Implement <TestInterface> (new Child2());
Assert.AreNotSame(duck1, duck2);
Assert.AreEqual(45, duck1.Method(40));
Assert.AreEqual(50, duck2.Method(40));
}
public void BuildTimeExceptionTest()
{
Assert.Throws <TypeBuilderException>(() =>
{
// Exception here.
//
_ = DuckTyping.Implement <IOptionalInterface>(string.Empty);
});
}
public void RuntimeExceptionTest()
{
var duck = DuckTyping.Implement <IOptionalInterface>(new TestClass());
Assert.AreEqual(1, duck.RequiredMethod());
// Exception here.
//
duck.OptionalMethod();
}
public void InvalidArgTest1()
{
Assert.Throws <ArgumentNullException>(() =>
{
TestInterface?o = null;
_ = DuckTyping.Implement <TestInterface>(o);
_ = (TestInterface?)typeof(TestInterface).Implement(o);
});
}
public void GenericInterfaceTest()
{
var o = new GenericClass <int>();
var duck = DuckTyping.Implement <GenericInterface <int> >(o);
var duck2 = DuckTyping.Implement <TestInterface2> (o);
Assert.AreEqual(40, duck.Method(40));
Assert.AreEqual(40, duck2.Method(40));
duck2.I2Method(33, out var value);
Assert.AreEqual(35, value);
}
public void Test()
{
var duck = DuckTyping.Implement <IOptionalInterfaceNoException> (new TestClass());
Assert.AreEqual(1, duck.RequiredMethod());
Assert.AreEqual(0, duck.OtherOptionalMethod());
Assert.AreEqual(2, duck.SameMethodName());
duck = DuckTyping.Aggregate <IOptionalInterfaceNoException>(new TestClass(), string.Empty, Guid.Empty);
Assert.AreEqual(1, duck.RequiredMethod());
Assert.AreEqual(0, duck.OtherOptionalMethod());
Assert.AreEqual(2, duck.SameMethodName());
}
public void AsLikeBehaviourTest()
{
var duck = DuckTyping.Implement <IOtherOptionalInterface>(new TestClass());
Assert.IsNotNull(duck);
duck = DuckTyping.Implement <IOtherOptionalInterface>(new EmptyClass());
Assert.IsNull(duck);
duck = DuckTyping.Implement <IOtherOptionalInterface>(new EmptyClass());
Assert.IsNull(duck);
duck = DuckTyping.Aggregate <IOtherOptionalInterface>(new EmptyClass(), string.Empty);
Assert.IsNull(duck);
}
protected virtual bool IsNull(
DbManager db,
object value,
object parameter)
{
// Speed up for scalar and nullable types.
//
switch (System.Convert.GetTypeCode(value))
{
// null, DBNull.Value, Nullable<T> without a value.
//
case TypeCode.Empty:
case TypeCode.DBNull:
return(true);
case TypeCode.Object:
break;
// int, byte, string, DateTime and other primitives except Guid.
// Also Nullable<T> with a value.
//
default:
return(false);
}
// Speed up for SqlTypes.
//
INullable nullable = value as INullable;
if (nullable != null)
{
return(nullable.IsNull);
}
// All other types which have 'IsNull' property but does not implement 'INullable' interface.
// For example: 'Oracle.DataAccess.Types.OracleDecimal'.
//
// For types without 'IsNull' property the return value is always false.
//
INullableInternal nullableInternal =
(INullableInternal)DuckTyping.Implement(typeof(INullableInternal), value);
return(nullableInternal.IsNull);
}
public void InvalidArgTest2()
{
NonPublicInterface duck = (NonPublicInterface)DuckTyping.Implement(typeof(NonPublicInterface), new TestClass());
}
public void InvalidArgTest3()
{
Child1 duck = (Child1)DuckTyping.Implement(typeof(Child1), new Child2());
}
public void InvalidArgTest4()
{
TestInterface duck = (TestInterface)DuckTyping.Implement(typeof(TestInterface), typeof(TestInterface), new TestClass());
}
public void BuildtimeExceptionTest()
{
// Exception here.
//
var duck1 = DuckTyping.Implement <IOptionalInterface> (string.Empty);
}