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); }