public void InvalidArgTest3()
{
Assert.Throws <ArgumentException>(() =>
{
_ = (Child1?)DuckTyping.Implement(typeof(Child1), new Child2());
});
}
public void InvalidArgTest1()
{
TestInterface o = null;
TestInterface duck1 = DuckTyping.Implement <TestInterface>(o);
TestInterface duck2 = (TestInterface)DuckTyping.Implement(typeof(TestInterface), o);
}
public void InvalidArgTest2()
{
Assert.Throws <TypeBuilderException>(() =>
{
_ = (NonPublicInterface?)DuckTyping.Implement(typeof(NonPublicInterface), new TestClass());
});
}
public void TestInterfaceProxyMethodVariance()
{
Duck duck = new Duck();
IInterface proxy = DuckTyping.Cast <IInterface>(duck);
string stringValue = "String value.";
int intValue = 5;
Assert.AreEqual(stringValue, proxy.ContravariantMethod(stringValue), "Contravariant method returned wrong value.");
Assert.IsNull(proxy.ContravariantMethod(null), "Passing and returning a null value to and from a contravariant method failed.");
try
{
proxy.ContravariantMethod(new object[0]);
Assert.Fail("Passing a non-string object through a contravariant method that takes a string parameter should have thrown an InvalidCastException.");
}
catch (InvalidCastException)
{ }
try
{
proxy.ContravariantValueMethod(7);
Assert.Fail("Passing a non-DateTime object through a contravariant method that takes a DateTime parameter should have thrown an InvalidCastException.");
}
catch (InvalidCastException)
{ }
try
{
proxy.ContravariantValueMethod(null);
Assert.Fail("Passing null through a contravariant method that takes a value type parameter should have thrown a NullReferenceException.");
}
catch (NullReferenceException)
{ }
Assert.AreEqual("Method", proxy.ContravariantEnumMethod("Method"), "Contravariant method returned wrong enum value.");
try
{
proxy.ContravariantEnumMethod(null);
Assert.Fail("Passing null through a contravariant method that taks an enum parameter should have thrown a NullReferenceException.");
}
catch (NullReferenceException)
{ }
Assert.AreEqual(stringValue, proxy.CovariantMethod(stringValue), "Covariant method returned wrong value.");
Assert.IsNull(null, proxy.CovariantMethod(null), "Passing and returning a null value to and from a covariant method failed.");
Assert.AreEqual(intValue, proxy.CovariantValueMethod(intValue), "Covariant method returned wrong int value.");
Assert.AreEqual(AttributeTargets.Class, proxy.CovariantEnumMethod(AttributeTargets.Class), "Covariant method returned wrong enum value.");
// Note: This next line is primarily to check whether the system handles a recursive cast properly. If it doesn't,
// a StackOverflowException will be thrown.
Assert.IsTrue(proxy.Equals(proxy.VariantByRecursiveCastMethod(duck)), "Variant by recursive cast method returned wrong value.");
Assert.AreEqual(duck, proxy.VariantByUncastMethod(proxy), "Variant by uncast method returned wrong value.");
}
public void TestCanCast()
{
Duck duck = new Duck();
IInterface proxy = DuckTyping.Cast <IInterface>(duck);
Assert.IsTrue(DuckTyping.CanCast <IInterface, Duck>(), "CanCast should have returned true.");
Assert.IsTrue(DuckTyping.CanCast <IInterface>(duck), "CanCast should have returned true.");
Assert.IsTrue(DuckTyping.CanCast <IInterface>(typeof(Duck)), "CanCast should have returned true.");
Assert.IsTrue(DuckTyping.CanCast(typeof(IInterface), duck), "CanCast should have returned true.");
Assert.IsTrue(DuckTyping.CanCast(typeof(IInterface), typeof(Duck)), "CanCast should have returned true.");
Assert.IsTrue(DuckTyping.CanCast <Duck, IInterface>(), "CanCast should have returned true.");
Assert.IsFalse(DuckTyping.CanCast <IFormattable>(duck), "CanCast should have returned false.");
Assert.IsTrue(DuckTyping.CanCast <GeneralDelegate, SpecializedDelegate>(), "CanCast should have returned true.");
Assert.IsTrue(DuckTyping.CanCast <SpecializedDelegate, GeneralDelegate>(), "CanCast should have returned true.");
Assert.IsFalse(DuckTyping.CanCast <GeneralDelegate, EventHandler>(), "CanCast should have returned false.");
Assert.IsTrue(DuckTyping.CanCast <AttributeTargets, string>(), "CanCast should have returned true.");
Assert.IsTrue(DuckTyping.CanCast <string, AttributeTargets>(), "CanCast should have returned true.");
Assert.IsFalse(DuckTyping.CanCast <AttributeTargets, DateTime>(), "CanCast should have returned false.");
}
public void TestInterfaceProxyToString()
{
Duck duck = new Duck();
IInterface proxy = DuckTyping.Cast <IInterface>(duck);
Assert.AreEqual(duck.ToString(), proxy.ToString(), "Interface proxy does not properly forward calls to ToString method.");
}
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 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 StructTest()
{
DuckTyping.AllowStaticMembers = true;
TestInterface duck = DuckTyping.Implement <TestInterface> (new TestStruct());
Assert.AreEqual(43, duck.Method(40));
}
/// <summary>
/// Register an 'OnUpdate' method for use in the editor.
/// This should be done in the OnAwake method of the module, and will ensure that all modules have the
/// registered method called in order of declaration of the module in the part file.
/// </summary>
/// <param name="module">Module that is being registered.</param>
/// <param name="action">Method to call</param>
public static void RegisterOnUpdateEditor(this PartModule module, Action action)
{
if (!HighLogic.LoadedSceneIsEditor)
{
return;
}
Part part = module.part;
IOnEditorUpdateUtility utility;
foreach (MonoBehaviour c in part.GetComponents <MonoBehaviour>())
{
if (c.GetType().FullName == typeof(OnEditorUpdateUtility).FullName)
{
utility = DuckTyping.Cast <IOnEditorUpdateUtility>(c);
goto found;
}
}
PartModule onEditorUpdate = (PartModule)part.gameObject.AddComponent(OnEditorUpdateUtility.LatestVersion);
utility = DuckTyping.Cast <IOnEditorUpdateUtility>(onEditorUpdate);
part.Modules.Add(onEditorUpdate);
found:
utility.AddOnUpdate(module, action);
}
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 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 StaticTest()
{
DuckTyping.AllowStaticMembers = true;
var duck = DuckTyping.Implement <TestInterface, StaticClass>(new StaticClass());
Assert.AreEqual(43, duck.Method(40));
}
public void BuildTimeAggregateExceptionTest()
{
Assert.Throws <TypeBuilderException>(() =>
{
// Exception here.
//
_ = DuckTyping.Aggregate <IOptionalInterface>(string.Empty, Guid.Empty);
});
}
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 BuildTimeExceptionTest()
{
Assert.Throws <TypeBuilderException>(() =>
{
// Exception here.
//
_ = DuckTyping.Implement <IOptionalInterface>(string.Empty);
});
}
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 TestStaticInterfaceCast()
{
IAdder adder = DuckTyping.StaticCast <IAdder>(typeof(StaticAdder));
Assert.AreEqual(4, adder.Add(2, 2));
Assert.AreEqual(4, adder.LastTotal);
adder.LastTotal = 15;
Assert.AreEqual(15, adder.LastTotal);
}
public void TestPrepareCast()
{
string proxyAssemblyName = "DuckInterfaceProxy_" + typeof(IPrepareCastInterface).Name.Replace(".", "_").Replace("+", "-") + "_" + typeof(PrepareCastDuck).Name.Replace(".", "_").Replace("+", "-") + ".dll";
Assert.IsNull(FindAssembly(proxyAssemblyName), "Proxy assembly has already been generated, so PrepareCast test cannot be done.");
DuckTyping.PrepareCast <IPrepareCastInterface, PrepareCastDuck>();
Assert.IsNotNull(FindAssembly(proxyAssemblyName), "PrepareCast did not result in a proxy assembly being generated.");
}
public void RuntimeExceptionTest()
{
var duck = DuckTyping.Implement <IOptionalInterface>(new TestClass());
Assert.AreEqual(1, duck.RequiredMethod());
// Exception here.
//
duck.OptionalMethod();
}
public void MissedMethodsAggregateTest()
{
var duck = DuckTyping.Aggregate <IClass1>(new Version(1, 0), Guid.NewGuid());
Assert.That(duck, Is.Not.Null);
// Neither System.Guid nor System.Version will ever have Method1.
//
Assert.That(duck.Method1(), Is.EqualTo(0));
}
public void InvalidArgTest1()
{
Assert.Throws <ArgumentNullException>(() =>
{
TestInterface?o = null;
_ = DuckTyping.Implement <TestInterface>(o);
_ = (TestInterface?)typeof(TestInterface).Implement(o);
});
}
public void RuntimeAggregateExceptionTest()
{
var duck = DuckTyping.Aggregate <IOptionalInterface>(new TestClass(), new EmptyClass());
Assert.AreEqual(1, duck.RequiredMethod());
// Exception here.
//
duck.OptionalMethod();
}
public static Texture2D GetMonitorTexture(this IProgcomMonitor mon)
{
FieldInfo image = mMonitorType.GetField("image",
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (image == null)
{
return(null);
}
return((Texture2D)image.GetValue(DuckTyping.Uncast(mon)));
}
public static IProgcomCPU CreateCPU()
{
LoadTypes();
if (mCPUType == null)
{
throw new MissingReferenceException("Could not find ProgCom.CPUem");
}
object cpu = Activator.CreateInstance(mCPUType);
return(DuckTyping.Cast <IProgcomCPU>(cpu));
}
public void TestInterfaceCast()
{
Duck duck = new Duck();
IInterface proxy = DuckTyping.Cast <IInterface>(duck);
Assert.IsNotNull(proxy, "DuckTyping.Cast<IInterface>(duck) return null.");
Assert.IsTrue(proxy is IDuckProxy, "Cast did not return a proxy.");
Assert.AreEqual(duck, ((IDuckProxy)proxy).UnwrapDuck(), "Cast returned a proxy that refers to the wrong duck object.");
Assert.AreEqual(duck, DuckTyping.Cast <Duck>(proxy), "Reverse cast returned the wrong value.");
}
void Main()
{
MyAdder myAdder = new MyAdder();
// Even though ICanAdd is not implemented by MyAdder,
// we can duck cast it because it implements all the members:
ICanAdd adder = DuckTyping.Cast <ICanAdd>(myAdder);
// Now we can call adder as you would any ICanAdd object.
// Transparently, this call is being forwarded to myAdder.
int sum = adder.Add(2, 2);
}
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 static IProgcomAssembler GetCompatibleAssembler(this IProgcomCPU cpu)
{
LoadTypes();
if (mAssemblerType == null)
{
throw new MissingReferenceException("Could not find ProgCom.Assembler2");
}
object assembler = mCPUType.InvokeMember("getCompatibleAssembler",
BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Instance,
null, DuckTyping.Uncast(cpu), null);
return(DuckTyping.Cast <IProgcomAssembler>(assembler));
}
public void TestInterfaceProxyEquals()
{
Duck duck1 = new Duck();
Duck duck2 = new Duck();
IInterface proxy1a = DuckTyping.Cast <IInterface>(duck1);
IInterface proxy1b = DuckTyping.Cast <IInterface>(duck1);
IInterface proxy2 = DuckTyping.Cast <IInterface>(duck2);
Assert.IsTrue(proxy1a.Equals(proxy1b), "Interface proxy does not properly forward calls to the Equals method.");
Assert.IsTrue(!proxy1a.Equals(proxy2), "Interface proxy overrides the Equals method improperly.");
Assert.AreEqual(proxy1a.GetHashCode(), duck1.GetHashCode(), "Interface proxy does not properly forward calls to the GetHashCode method.");
}
