/// <summary>
/// Forwards an interface (and optionally ints inherited interfaces) to a target implementation, overriding some members with anonymous implementations.
/// </summary>
/// <typeparam name="TInterface">The interface type.</typeparam>
/// <param name="defaultTarget">The target implementation, which receives any interface calls not overriden by the anonymous implementation.</param>
/// <param name="anonymousDefinition">The anonymous implementation definition delegate, which receives and returns an anonymous implementation builder. Do not call <c>Create</c> on the anonymous implementation builder.</param>
/// <param name="includeInheritedInterfaces"><c>true</c> to forward/implement inherited interfaces; <c>false</c> to only forward/implement the specified interface type.</param>
public AmalgamBuilder Override<TInterface>(TInterface defaultTarget, Func<AnonymousInterface.Util.Builder<TInterface>, AnonymousInterface.Util.Builder<TInterface>> anonymousDefinition, bool includeInheritedInterfaces = true) where TInterface : class
{
var builder = Anonymous.Implement<TInterface>(defaultTarget);
builder = anonymousDefinition(builder);
Add(typeof(TInterface), builder.Create(), includeInheritedInterfaces);
return this;
}
object IAmalgamator.CreateAmalgam()
{
Anonymous.Implement <ITest>()
.Method <Action>(x => x.A, () => { })
.Method <Action <int> >(x => x.A, _ => { })
.Method <TestDelegate1>(x => x.A, (out int x) => { x = 0; })
.Method <TestDelegate2>(x => x.A, (int x, ref int y) => { })
.Method <Func <int> >(x => x.B, () => 2)
.PropertyGet(x => x.valg, () => 17)
.PropertyGet(x => x.val, () => 13)
.PropertySet(x => x.val, value => { })
.PropertySet <int>("vals", value => { })
.EventSubscribe <Action>("X", value => { })
.EventUnsubscribe <Action>("X", value => { })
.IndexGet <Func <int, string> >(index => null)
.IndexSet <Action <int, string> >((index, value) => { })
.Create();
return(Amalgamation.Build()
.Forward <ILongCountable>(a, false)
.Forward <IContainsCountable>(this)
.Override <ICountable>(a, anon => anon
.PropertyGet(x => x.Count, OverrideCount)
.Method <Func <int> >(x => x.GetCount, OverrideCount))
.Create());
}
public void GenericMethod_RequiresImplementation()
{
var core = new GenericMethodTest();
var instance = Anonymous.Implement <ITest>(core)
.Create();
instance.E(13);
Assert.AreEqual(13, core.observed);
}
public void Method_WithNormalParameters()
{
int observed = 0;
var instance = Anonymous.Implement <ITest>()
.Method <Action <int> >(x => x.A, x => { observed = x; })
.Create();
instance.A(13);
Assert.AreEqual(13, observed);
}
public void PropertySet_WhichDoesNotHaveGet()
{
int observed = 0;
var instance = Anonymous.Implement <ITest>()
.PropertySet <int>("vals", x => { observed = x; })
.Create();
instance.vals = 13;
Assert.AreEqual(13, observed);
}
public void PropertySet_WhichAlsoHasGet()
{
int observed = 0;
var instance = Anonymous.Implement <ITest>()
.PropertySet(x => x.val, x => { observed = x; })
.Create();
instance.val = 13;
Assert.AreEqual(13, observed);
}
public void PropertyGet_WhichDoesNotHaveSet()
{
int retval = 13;
var instance = Anonymous.Implement <ITest>()
.PropertyGet(x => x.valg, () => retval)
.Create();
int val = instance.valg;
Assert.AreEqual(13, val);
}
public void Method_HiddenFromBaseInterface()
{
int observed = 0;
var instance = Anonymous.Implement <ITest>()
.Method <Action>(x => ((ITestBase)x).A, () => { observed = 13; })
.Create() as ITestBase;
instance.A();
Assert.AreEqual(13, observed);
}
public void Method_WithParams()
{
int[] observed = null;
var instance = Anonymous.Implement <ITest>()
.Method <Action <int[]> >(x => x.C, x => { observed = x; })
.Create();
instance.C(3, 5, 7);
Assert.IsTrue(observed.SequenceEqual(new[] { 3, 5, 7 }));
}
public void Method_WithReturnValue()
{
int retval = 11;
var instance = Anonymous.Implement <ITest>()
.Method <Func <int> >(x => x.B, () => retval)
.Create();
int val = instance.B();
Assert.AreEqual(11, val);
}
public void Method_WithOutParameters()
{
int retval = 11;
var instance = Anonymous.Implement <ITest>()
.Method <TestDelegate1>(x => x.A, (out int x) => { x = retval; })
.Create();
int val = 0;
instance.A(out val);
Assert.AreEqual(11, val);
}
public void EventUnsubscribe()
{
Action observed = null;
var instance = Anonymous.Implement <ITest>()
.EventUnsubscribe <Action>("X", x => { observed = x; })
.Create();
Action value = () => { };
instance.X -= value;
Assert.AreEqual(value, observed);
}
public void IndexSet()
{
int observedIndex = 0;
string observedValue = null;
var instance = Anonymous.Implement <ITest>()
.IndexSet <Action <int, string> >((index, value) => { observedIndex = index; observedValue = value; })
.Create();
instance[13] = "test";
Assert.AreEqual(13, observedIndex);
Assert.AreEqual("test", observedValue);
}
public void IndexGet()
{
int observedIndex = 0;
string retval = "test";
var instance = Anonymous.Implement <ITest>()
.IndexGet <Func <int, string> >(index => { observedIndex = index; return(retval); })
.Create();
string val = instance[15];
Assert.AreEqual(15, observedIndex);
Assert.AreEqual("test", val);
}
public void Method_WithDefaultValues()
{
int observed = 0;
var instance = Anonymous.Implement <ITest>()
.Method <Action <int> >(x => x.D, x => { observed = x; })
.Create();
instance.D();
Assert.AreEqual(3, observed);
instance.D(13);
Assert.AreEqual(13, observed);
}
public void Method_WithRefParameters()
{
int observedX = 0;
int observedY = 0;
int retval = 11;
var instance = Anonymous.Implement <ITest>()
.Method <TestDelegate2>(x => x.A, (int x, ref int y) => { observedX = x; observedY = y; y = retval; })
.Create();
int valX = 3;
int valY = 5;
instance.A(valX, ref valY);
Assert.AreEqual(3, observedX);
Assert.AreEqual(5, observedY);
Assert.AreEqual(11, valY);
}
