public void TestMethodPropertyLinkedObjects3()
{
BeethovenFactory factory = new BeethovenFactory();
int setCount = 0;
ITestProperties test = factory.Generate <ITestProperties>(
new LinkedObjects(
new PropertyDefinition <int>(nameof(ITestProperties.Property1))
.SkipIfEqual(),
new PropertyDefinition <int>(nameof(ITestProperties.Property1))
.DelegatedSetter(value => setCount++)));
test.Property1 = 5;
test.Property1 = 6;
Assert.AreEqual(2, setCount);
}
public void TestMethodDefaultPropertyNotifyChanged1()
{
BeethovenFactory factory = new BeethovenFactory();
ITestProperties test = factory.Generate <ITestProperties>(
new DefaultProperty()
.NotifyChanged());
List <string> changes = new List <string>();
test.PropertyChanged += (sender, args) => changes.Add(args.PropertyName);
test.Property1 = 5;
test.Property2 = "5";
CollectionAssert.AreEquivalent(
new[] { "Property1", "Property2" },
changes);
}
public void LinkedMethodsReturnValueTest6()
{
CustomImplentation implementation = new CustomImplentation();
BeethovenFactory beethovenFactory = new BeethovenFactory();
bool called = false;
ITestMethods instance = beethovenFactory.Generate <ITestMethods>(
new LinkedMethodsReturnValue(nameof(ITestMethods.OutAndRef))
.MappedMethod(implementation, nameof(CustomImplentation.OutAndRef))
.FlowControl(() => false)
.Action(() => called = true));
string text2 = "wetwt";
instance.OutAndRef(out string _, ref text2, 5);
Assert.IsFalse(called);
}
public void TestMethodDefaultPropertyFallback1()
{
BeethovenFactory factory = new BeethovenFactory();
ITestProperties test = factory.Generate <ITestProperties>(
new PropertyDefinition <int>(nameof(ITestProperties.Property1))
.MappedGetter(() => 6),
new DefaultProperty()
.SetterGetter());
Assert.AreEqual(6, test.Property1);
test.Property2 = "Some value";
Assert.AreEqual("Some value", test.Property2);
test.Property1 = 55;
Assert.AreEqual(6, test.Property1);
}
public void EventWithReturnValue1()
{
BeethovenFactory factory = new BeethovenFactory();
ITestEvents test = factory.Generate <ITestEvents>();
IEventTrigger trigger = factory.CreateEventTrigger(test, nameof(ITestEvents.WithReturnValue));
bool withReturnValueEventCalled = false;
bool otherEventCalled = false;
test.Simple += delegate { otherEventCalled = true; };
test.WithParameters += delegate { otherEventCalled = true; };
test.WithReturnValue += delegate { return(withReturnValueEventCalled = true); };
trigger.Notify("");
Assert.IsTrue(withReturnValueEventCalled);
Assert.IsFalse(otherEventCalled);
}
public void LinkedMethodsTest9()
{
List <string> log = new List <string>();
SimpleImplementation implementation = new SimpleImplementation();
BeethovenFactory beethovenFactory = new BeethovenFactory();
const string name = nameof(ITestMethods.Simple);
ITestMethods instance = beethovenFactory.Generate <ITestMethods>(
new LinkedObjects(
ActionMethod.Create(name, () => log.Add("Before")),
new MappedMethod(name, implementation),
ActionMethod.Create(name, () => log.Add("After"))));
instance.Simple();
CollectionAssert.AreEquivalent(new[] { "Before", "After" }, log);
}
public IApproverChain CreateChain(params IApprover[] approvers)
{
LinkedMethodsReturnValue linkedMethods = approvers
.Aggregate(new LinkedMethodsReturnValue(nameof(IApproverChain.Approve)),
(value, approver) => value
.AutoMappedMethod(approver)
.InvertResult());
/*
* In the linked methods, the method return true to continue execution, and also to interrupt.
* It is illogical that 'Approve' should return false for non-approved.
* InvertResult simply inverts the result of a bool-method.
*/
return(beethovenFactory.Generate <IApproverChain>(linkedMethods));
}
public void LinkedMethodsReturnValueTest4()
{
BeethovenFactory beethovenFactory = new BeethovenFactory();
string gotValue1 = "";
string gotValue2 = "";
ITestMethods instance = beethovenFactory.Generate <ITestMethods>(
new LinkedMethodsReturnValue(nameof(ITestMethods.WithParameters))
.Action((string text1) => gotValue1 = text1)
.Action((string text2) => gotValue2 = text2)
);
instance.WithParameters("w", "sd", 3);
Assert.AreEqual(gotValue1, "w");
Assert.AreEqual(gotValue2, "sd");
}
public void TestMethodLazyCreatorProperty2()
{
BeethovenFactory factory = new BeethovenFactory();
ITestProperties test = factory.Generate <ITestProperties>(
new PropertyDefinition <int>(nameof(ITestProperties.Property1))
.LazyCreator(() =>
{
Assert.Fail();
return(0);
})
.SetterGetter());
test.Property1 = 7;
Assert.AreEqual(7, test.Property1);
}
public void EventWithParameters1()
{
BeethovenFactory factory = new BeethovenFactory();
ITestEvents test = factory.Generate <ITestEvents>();
Action <double, string> trigger =
new EventTrigger(test, nameof(ITestEvents.WithParameters)).ToAction <double, string>();
bool withParametersEventCalled = false;
bool otherEventCalled = false;
test.Simple += delegate { otherEventCalled = true; };
test.WithParameters += delegate { withParametersEventCalled = true; };
test.WithReturnValue += delegate { return(otherEventCalled = true); };
trigger(4.4, "");
Assert.IsTrue(withParametersEventCalled);
Assert.IsFalse(otherEventCalled);
}
public void LinkedMethodsTest13()
{
List <string> log = new List <string>();
List <int> implementation = new List <int> {
5, 2, 17
};
BeethovenFactory beethovenFactory = new BeethovenFactory();
IEnumerable <int> instance = beethovenFactory.Generate <IEnumerable <int> >(
new LinkedObjects(
ActionMethod.Create("GetEnumerator", () => log.Add("Before")),
implementation,
ActionMethod.Create("GetEnumerator", () => log.Add("After"))));
CollectionAssert.AreEqual(new[] { 5, 2, 17 }, instance.ToArray());
CollectionAssert.AreEquivalent(new[] { "Before", "After" }, log);
}
public void LinkedMethodsTest6()
{
BeethovenFactory beethovenFactory = new BeethovenFactory();
int calledCount = 0;
ValueCheck valueCheck = new ValueCheck();
ITestMethods instance = beethovenFactory.Generate <ITestMethods>(
new LinkedMethods(nameof(ITestMethods.NoReturnValue))
.SkipIf(valueCheck, nameof(valueCheck.HasNoValue1))
.Action(delegate { calledCount++; }));
instance.NoReturnValue("", "afasf");
instance.NoReturnValue(null, "afasf");
Assert.AreEqual(0, calledCount);
instance.NoReturnValue("fdgdf", "afasf");
Assert.AreEqual(1, calledCount);
}
public void EventSimpleError()
{
BeethovenFactory factory = new BeethovenFactory();
ITestEvents test = factory.Generate <ITestEvents>(new DefaultEvent());
Action <int> trigger =
new EventTrigger(test, nameof(ITestEvents.Simple)).ToAction <int>();
bool simpleEventCalled = false;
bool otherEventCalled = false;
test.Simple += delegate { simpleEventCalled = true; };
test.WithParameters += delegate { otherEventCalled = true; };
test.WithReturnValue += delegate { return(otherEventCalled = true); };
trigger(123);
Assert.IsTrue(simpleEventCalled);
Assert.IsFalse(otherEventCalled);
}
public void LinkedMethodsReturnValueTest1()
{
PartialMethods partialMethods = new PartialMethods();
BeethovenFactory beethovenFactory = new BeethovenFactory();
ITestMethods instance = beethovenFactory.Generate <ITestMethods>(
new LinkedMethodsReturnValue(nameof(ITestMethods.WithParameters))
.PartialMatchMethod(partialMethods, nameof(partialMethods.WithParameters1))
.PartialMatchMethod(partialMethods, nameof(partialMethods.WithParameters2))
.PartialMatchMethod(partialMethods, nameof(partialMethods.WithParametersCount))
.PartialMatchMethod(partialMethods, nameof(partialMethods.WithParameters)));
Assert.AreEqual(9, instance.WithParameters("w", "sd", 3));
Assert.AreEqual(0, instance.WithParameters(null, "sd", 3));
Assert.AreEqual(0, instance.WithParameters("w", "sd", -68));
Assert.AreEqual(0, instance.WithParameters("w", "", 7));
}
public void TestMethodDefaultPropertyDelegated4()
{
DefaultImplementation2 implementation = new DefaultImplementation2();
BeethovenFactory factory = new BeethovenFactory();
ITestProperties test = factory.Generate <ITestProperties>(
new DefaultProperty()
.DelegatedSetter(implementation, nameof(implementation.DelegatedSetter))
.DelegatedGetter(implementation, nameof(implementation.DelegatedGetter)));
Assert.AreEqual(0, test.Property1);
test.Property2 = "Nothing";
test.Property2 = "Some value";
Assert.AreEqual("Some value", test.Property2);
test.Property1 = 55;
Assert.AreEqual(55, test.Property1);
}
public void LinkedMethodsTest7()
{
BeethovenFactory beethovenFactory = new BeethovenFactory();
int calledCount = 0;
ValueCheck valueCheck = new ValueCheck();
ITestMethods instance = beethovenFactory.Generate <ITestMethods>(
LinkedMethodsReturnValue.Create <ITestMethods>(nameof(ITestMethods.WithParameters))
.SkipIf(valueCheck, nameof(valueCheck.HasNoValue2))
.Func((string text1, string text2) => calledCount++));
instance.WithParameters("", "");
instance.WithParameters("fegf", null);
Assert.AreEqual(0, calledCount);
instance.WithParameters("fdgdf", "afasf");
Assert.AreEqual(1, calledCount);
}
public void EventWithReturnValue2()
{
BeethovenFactory factory = new BeethovenFactory();
ITestEvents test = factory.Generate <ITestEvents>();
IEventTrigger trigger = factory.CreateEventTrigger(test, nameof(ITestEvents.WithReturnValue));
string gotValue = null;
test.WithReturnValue += value =>
{
gotValue = value;
return(true);
};
bool returnValue = (bool)trigger.Notify("123");
Assert.AreEqual(true, returnValue);
Assert.AreEqual("123", gotValue);
}
public void TestMethodDefaultMethod1()
{
List <string> methodsCalled = new List <string>();
object LogCall(MethodInfo methodInfo, object[] _)
{
methodsCalled.Add(methodInfo.Name);
return(null);
}
BeethovenFactory factory = new BeethovenFactory();
ITestMethods test = factory.Generate <ITestMethods>(
new DefaultMethod(LogCall));
test.NoReturnValue("asd", "gggggdsss");
CollectionAssert.AreEquivalent(new[] { "NoReturnValue" }, methodsCalled);
}
public void LinkedMethodsTest5()
{
BeethovenFactory beethovenFactory = new BeethovenFactory();
bool skip = true;
int calledCount = 0;
ITestMethods instance = beethovenFactory.Generate <ITestMethods>(
new LinkedMethods(nameof(ITestMethods.Simple))
.SkipIf(() => skip)
.Action(() => calledCount++));
instance.Simple();
instance.Simple();
Assert.AreEqual(0, calledCount);
skip = false;
instance.Simple();
Assert.AreEqual(1, calledCount);
}
public void TestMethodPropertyDelegatedGetter2()
{
int getCount = 0;
Func <int> action = () =>
{
getCount++;
return(55);
};
BeethovenFactory factory = new BeethovenFactory();
ITestProperties test = factory.Generate <ITestProperties>(
new PropertyDefinition <int>(nameof(ITestProperties.Property1))
.DelegatedGetter(action));
Assert.AreEqual(0, getCount);
Assert.AreEqual(55, test.Property1);
Assert.AreEqual(1, getCount);
}
public void EventWithReturnValue2()
{
BeethovenFactory factory = new BeethovenFactory();
ITestEvents test = factory.Generate <ITestEvents>();
Func <string, bool> trigger =
new EventTrigger(test, nameof(ITestEvents.WithReturnValue)).ToFunc <string, bool>();
string gotValue = null;
test.WithReturnValue += value =>
{
gotValue = value;
return(true);
};
bool returnValue = trigger("123");
Assert.AreEqual(true, returnValue);
Assert.AreEqual("123", gotValue);
}
public void TestMethodDefaultPropertyFallback2()
{
BeethovenFactory factory = new BeethovenFactory();
ITestProperties test = factory.Generate <ITestProperties>(
new PropertyDefinition <int>(nameof(ITestProperties.Property1))
.SetterGetter(),
new DefaultProperty()
.NotifyChanged()
.SetterGetter());
List <string> changes = new List <string>();
test.PropertyChanged += (sender, args) => changes.Add(args.PropertyName);
test.Property1 = 5;
test.Property2 = "5";
CollectionAssert.AreEquivalent(
new[] { "Property2" },
changes);
}
public void ImplementsTest1()
{
BeethovenFactory factory = new BeethovenFactory();
ITestImplements instance = factory.Generate <ITestImplements>(
new PropertyDefinition <string>("Property2")
.ValidityCheck(name => !string.IsNullOrEmpty(name))
.SkipIfEqual()
.SetterGetter()
.NotifyChanged(),
new SimpleEventDefinition <PropertyChangedEventHandler>(nameof(INotifyPropertyChanged.PropertyChanged)));
int count = 0;
instance.PropertyChanged += (_, __) => count++;
instance.Property2 = "123";
instance.Property2 = "123";
instance.Property2 = "1e23";
Assert.AreEqual(2, count);
}
public void TestMethodDefaultMethod5()
{
List <string> methodsCalled = new List <string>();
object LogCall(MethodInfo methodInfo, object[] _)
{
methodsCalled.Add(methodInfo.Name);
return(null);
}
BeethovenFactory factory = new BeethovenFactory();
ITestMethods test = factory.Generate <ITestMethods>(
ActionMethod.Create(nameof(ITestMethods.Simple), () => { }),
new DefaultMethod(LogCall));
test.Simple();
CollectionAssert.AreEquivalent(new string[0], methodsCalled);
}
public IValueHolder Create(string name, int value, byte[] data)
{
IValueHolder valueHolder = beethovenFactory.Generate <IValueHolder>(
new DefaultProperty()
.InitialValue(new byte[0])
.SetterGetter(),
LinkedMappedMethods.Create(ComparerCreator));
if (name != null)
{
valueHolder.Name = name;
}
valueHolder.Value = value;
if (data != null)
{
valueHolder.Data = data;
}
return(valueHolder);
}
public IValueHolder Create(string name, int value, byte[] data)
{
IValueHolder valueHolder = beethovenFactory.Generate <IValueHolder>(
new DefaultProperty()
.InitialValue(new byte[0])
.SetterGetter(),
new EqualsGetHash <IValueHolder>(ValuesGetterFunc));
if (name != null)
{
valueHolder.Name = name;
}
valueHolder.Value = value;
if (data != null)
{
valueHolder.Data = data;
}
return(valueHolder);
}
public void LinkedMethodsTest8()
{
BeethovenFactory beethovenFactory = new BeethovenFactory();
int calledCount = 0;
WithParametersImplementation implentation = new WithParametersImplementation();
ITestMethods instance = beethovenFactory.Generate <ITestMethods>(
LinkedMethodsReturnValue.Create <ITestMethods>(nameof(ITestMethods.WithParameters), 1)
.Func((int count) => count)
.SkipIfResultCondition((int count) => count == 0)
.AutoMappedMethod(implentation)
.Action(() => calledCount++));
int result1 = instance.WithParameters("fegf", "ggn", 0);
Assert.AreEqual(0, calledCount);
Assert.AreEqual(0, result1);
int result2 = instance.WithParameters("fdgdf", "afasf", 3);
Assert.AreEqual(1, calledCount);
Assert.AreEqual(30, result2);
}
public void AutoAssignTest2()
{
var defaultValues = new
{
Name = "The evil company",
Address = "2460 Sunshine road"
};
BeethovenFactory factory = null;
IValueLookup lookup = new CompositeValueLookup(
new AnonymousValueLookup(defaultValues),
new InterfaceFactoryValueLookup((type, name) => factory.Generate(type)));
factory = new BeethovenFactory(
new DefaultProperty()
.ValueLookup(lookup)
.SetterGetter());
ICompany company = factory.Generate <ICompany>();
Assert.AreEqual("The evil company", company.Information.Name);
Assert.AreEqual("2460 Sunshine road", company.Information.Address);
}
public void AutoAssignTest4()
{
Dictionary <string, object> defaultValues = new Dictionary <string, object>
{
{ "Name", "The evil company" },
{ "Address", 2460 }
};
BeethovenFactory factory = null;
IValueLookup lookup = new CompositeValueLookup(
new DictionaryValueLookup(defaultValues),
new InterfaceFactoryValueLookup((type, name) => factory.Generate(type)));
factory = new BeethovenFactory(
new DefaultProperty()
.ValueLookup(lookup)
.SetterGetter());
ICompany company = factory.Generate <ICompany>();
Assert.AreEqual("The evil company", company.Information.Name);
Assert.AreEqual(null, company.Information.Address);
}
public void TestMethodDefaultMethod4()
{
BeethovenFactory factory = new BeethovenFactory();
ITestMethods test = factory.Generate <ITestMethods>(
new DefaultMethod((methodInfo, parameters) =>
{
Type intRefType = typeof(int).MakeByRefType();
ParameterInfo[] parameterInfos = methodInfo.GetParameters();
foreach (ParameterInfo parameterInfo in parameterInfos.Where(info => info.ParameterType == intRefType))
{
parameters[parameterInfo.Position] = 5;
}
}));
string b = "";
test.OutAndRef(out string a, ref b, 5);
int value = 0;
test.Ref(ref value);
Assert.AreEqual(5, value);
}