public void TestMethodPropertyPropertyMapped6() { MappedTestClass obj = new MappedTestClass(); BeethovenFactory factory = new BeethovenFactory(); ITestProperties test = factory.Generate <ITestProperties>( new PropertyDefinition <string>(nameof(ITestProperties.Property2)) .MappedFrom(obj)); Assert.AreEqual(null, test.Property2); obj.Property2 = "42"; Assert.AreEqual("42", test.Property2); }
public void TestMethodPropertyPropertyMapped5() { MappedTestClass obj = new MappedTestClass(); BeethovenFactory factory = new BeethovenFactory(); ITestProperties test = factory.Generate <ITestProperties>( new PropertyDefinition <int>(nameof(ITestProperties.Property1)) .MappedFrom(obj)); Assert.AreEqual(0, test.Property1); obj.Property1 = 42; Assert.AreEqual(42, test.Property1); }
public void TestMethodProperty2() { int setCount = 0; Action <int> action = value => setCount++; BeethovenFactory factory = new BeethovenFactory(); ITestProperties test = factory.Generate <ITestProperties>( new PropertyDefinition <int>(nameof(ITestProperties.Property1)) .DelegatedSetter(action)); test.Property1 = 5; Assert.AreEqual(1, setCount); }
public void TestMethodPropertyValidityCheck1() { BeethovenFactory factory = new BeethovenFactory(); ITestProperties test = factory.Generate <ITestProperties>( new PropertyDefinition <int>(nameof(ITestProperties.Property1)) .ValidityCheck(value => value % 2 == 0) .SetterGetter()); Assert.AreEqual(0, test.Property1); test.Property1 = 10; Assert.AreEqual(10, test.Property1); }
public void TestMethodPropertyRangeCheck1() { BeethovenFactory factory = new BeethovenFactory(); ITestProperties test = factory.Generate <ITestProperties>( new PropertyDefinition <int>(nameof(ITestProperties.Property1)) .RangeCheck(0, 42) .SetterGetter()); Assert.AreEqual(0, test.Property1); test.Property1 = 42; Assert.AreEqual(42, test.Property1); }
public void LinkedMethodsReturnValueTest4() { CustomImplentation implementation = new CustomImplentation(); BeethovenFactory beethovenFactory = new BeethovenFactory(); ITestMethods instance = beethovenFactory.Generate <ITestMethods>( new LinkedMethodsReturnValue(nameof(ITestMethods.OutAndRef)) .MappedMethod(implementation, nameof(CustomImplentation.OutAndRef)) .InvertResult() .Action(Assert.Fail)); string text2 = "wetwt"; instance.OutAndRef(out string _, ref text2, 5); }
public void LinkedMethodsTest4() { BeethovenFactory beethovenFactory = new BeethovenFactory(); bool skip = true; ITestMethods instance = beethovenFactory.Generate <ITestMethods>( LinkedMethodsReturnValue.Create <ITestMethods>(nameof(ITestMethods.ReturnValue)) .SkipIf(() => skip) .Func(() => 477)); Assert.AreEqual(0, instance.ReturnValue()); skip = false; Assert.AreEqual(477, instance.ReturnValue()); }
public void EventSimpleRemoved1() { BeethovenFactory factory = new BeethovenFactory(); ITestEvents test = factory.Generate <ITestEvents>(); Action trigger = new EventTrigger(test, nameof(ITestEvents.Simple)).ToAction(); bool simpleEventCalled = false; Action delegate1 = delegate { simpleEventCalled = true; }; test.Simple += delegate1; test.Simple -= delegate1; trigger(); Assert.IsFalse(simpleEventCalled); }
public void GenericSimpleTest3() { BeethovenFactory beethovenFactory = new BeethovenFactory(); IGenericMethods instance = beethovenFactory.Generate <IGenericMethods>( new SimpleFuncMethod <string>("Simple", () => "abcd"), new SimpleFuncMethod <int>("Simple", () => 5), new SimpleFuncMethod <short>("Simple", () => 0) ); Assert.AreEqual(5, instance.Simple <int>()); Assert.AreEqual(0, instance.Simple <short>()); Assert.AreEqual("abcd", instance.Simple <string>()); }
public void TestMethodPropertySkipIfEqual3() { BeethovenFactory factory = new BeethovenFactory(); int setCount = 0; ITestProperties test = factory.Generate <ITestProperties>( new PropertyDefinition <int>(nameof(ITestProperties.Property1)) .SkipIfEqual() .DelegatedSetter(value => setCount++)); test.Property1 = 5; test.Property1 = 6; Assert.AreEqual(2, setCount); }
public void EventWithReturnValue3() { BeethovenFactory factory = new BeethovenFactory(); ITestEvents test = factory.Generate <ITestEvents>(); Func <string, bool> trigger = new EventTrigger(test, nameof(ITestEvents.WithReturnValue)).ToFunc <string, bool>(); test.WithReturnValue += value => false; test.WithReturnValue += value => true; bool returnValue = trigger("123"); Assert.AreEqual(true, returnValue); }
public void GenericSimpleTest1() { GenericMethods genericMethods = new GenericMethods(); BeethovenFactory beethovenFactory = new BeethovenFactory(); IGenericMethods instance = beethovenFactory.Generate <IGenericMethods>(genericMethods); List <string> calledMethods = new List <string>(); genericMethods.MethodCalled += s => calledMethods.Add(s); Assert.AreEqual(5, instance.Simple <int>()); Assert.AreEqual(0, instance.Simple <short>()); Assert.AreEqual("abcd", instance.Simple <string>()); CollectionAssert.AreEquivalent(new[] { "Simple", "Simple", "Simple" }, calledMethods); }
public void LinkedMethodsReturnValueTest3() { Logger logger = new Logger(); CustomImplementation implementation = new CustomImplementation(); BeethovenFactory beethovenFactory = new BeethovenFactory(); ITestMethods unused = beethovenFactory.Generate <ITestMethods>( LinkedMethodsReturnValue.Create <ITestMethods>(nameof(ITestMethods.WithParameters)) .MappedMethod(logger, nameof(logger.LogBefore)) .AutoMappedMethod(implementation) .MappedMethod(logger, nameof(logger.LogAfter))); Assert.Fail(); }
public void TestMethodDefaultPropertySetterGetter1() { BeethovenFactory factory = new BeethovenFactory(); ITestProperties test = factory.Generate <ITestProperties>( new DefaultProperty() .SetterGetter()); Assert.AreEqual(0, test.Property1); test.Property2 = "Some value"; Assert.AreEqual("Some value", test.Property2); test.Property1 = 55; Assert.AreEqual(55, test.Property1); }
public void TestMethodProperty3() { BeethovenFactory factory = new BeethovenFactory(); ITestProperties test = factory.Generate <ITestProperties>( new PropertyDefinition <string>(nameof(ITestProperties.Property2)) .SetterGetter()); ITestProperties test2 = factory.Generate <ITestProperties>( new PropertyDefinition <string>(nameof(ITestProperties.Property2)) .SetterGetter()); test.Property2 = "abc"; Assert.AreEqual(null, test2.Property2); }
public void TestMethodDefaultPropertyDelegated3() { DefaultImplementation2 implementation = new DefaultImplementation2(); BeethovenFactory factory = new BeethovenFactory(); ITestProperties test = factory.Generate <ITestProperties>( new DefaultProperty() .DelegatedSetter(implementation, nameof(implementation.DelegatedSetter))); Assert.AreEqual(0, test.Property1); test.Property2 = "Nothing"; test.Property2 = "Some value"; test.Property1 = 55; CollectionAssert.AreEquivalent(new object[] { 55, "Some value" }, implementation.GetObjects()); }
public void TestMethodPropertyDelegatedGetter1() { int value = 0; // ReSharper disable once AccessToModifiedClosure Func <int> action = () => value; BeethovenFactory factory = new BeethovenFactory(); ITestProperties test = factory.Generate <ITestProperties>( new PropertyDefinition <int>(nameof(ITestProperties.Property1)) .DelegatedGetter(action)); Assert.AreEqual(0, test.Property1); value = 5; Assert.AreEqual(5, test.Property1); }
public void EventWithParameters2() { BeethovenFactory factory = new BeethovenFactory(); ITestEvents test = factory.Generate <ITestEvents>(); IEventTrigger trigger = factory.CreateEventTrigger(test, nameof(ITestEvents.WithParameters)); double gotValue1 = 0; string gotValue2 = null; test.WithParameters += (value1, value2) => gotValue1 = value1; test.WithParameters += (value1, value2) => gotValue2 = value2; trigger.Notify(54.0, "abe"); Assert.AreEqual(54.0, gotValue1); Assert.AreEqual("abe", gotValue2); }
public void LinkedMethodsReturnValueTest2() { CustomImplementation implementation = new CustomImplementation(); BeethovenFactory beethovenFactory = new BeethovenFactory(); ITestMethods instance = beethovenFactory.Generate <ITestMethods>( LinkedMethodsReturnValue.Create <ITestMethods>(nameof(ITestMethods.OutAndRef)) .MappedMethod(implementation, nameof(implementation.OutAndRef1)) .AutoMappedMethod(implementation)); string text1 = "abc"; Assert.AreEqual(20, instance.OutAndRef(out string text2, ref text1, 5)); Assert.AreEqual("cba", text1); Assert.AreEqual("abc abc abc abc abc", text2); }
public void LinkedMethodsReturnValueTest1() { Logger logger = new Logger(); CustomImplementation implementation = new CustomImplementation(); BeethovenFactory beethovenFactory = new BeethovenFactory(); ITestMethods instance = beethovenFactory.Generate <ITestMethods>( LinkedMethodsReturnValue.Create <ITestMethods>(nameof(ITestMethods.WithParameters), 1) .MappedMethod(logger, nameof(logger.LogBefore)) .MappedMethod(implementation, nameof(CustomImplementation.GetLength)) .MappedMethod(logger, nameof(logger.LogAfter))); Assert.AreEqual(10, instance.WithParameters("w", "sd", 7)); Assert.AreEqual(2, logger.Log.Count); }
public void MethodWithParameters1() { ITestMethods fake = A.Fake <ITestMethods>(); BeethovenFactory factory = new BeethovenFactory(); ITestMethods test = factory.Generate <ITestMethods>(fake); A.CallTo(() => fake.WithParameters("123", "abc")).Returns(42); A.CallTo(() => fake.WithParameters("", "")).Returns(41); A.CallTo(() => fake.WithParameters("123", "abc", 0)).Returns(0); Assert.AreEqual(42, test.WithParameters("123", "abc")); A.CallTo(() => fake.WithParameters("123", "abc")).MustHaveHappenedOnceExactly(); A.CallTo(() => fake.WithParameters("123", "abc", 0)).MustNotHaveHappened(); A.CallTo(() => fake.WithParameters("", "")).MustNotHaveHappened(); }
public void LinkedMethodsTest3() { BeethovenFactory beethovenFactory = new BeethovenFactory(); ITestMethods instance = beethovenFactory.Generate <ITestMethods>( LinkedMethodsReturnValue.Create <ITestMethods>(nameof(ITestMethods.WithParameters)) .SkipIf <string, string>((text1, text2) => string.IsNullOrEmpty(text1)) .SkipIf <string, string>((text1, text2) => string.IsNullOrEmpty(text2)) .Func((string text1, string text2) => text1.Length + text2.Length)); //Assert.AreEqual(0, instance.WithParameters(null, null)); //Assert.AreEqual(0, instance.WithParameters("", "dsfgdsfhsd")); //Assert.AreEqual(0, instance.WithParameters("gjgkffg", "")); Assert.AreEqual(15, instance.WithParameters("fdsfd", "dsfgdsfhsd")); }
public void LinkedMethodsTest10() { List <string> log = new List <string>(); SimpleImplementation implementation = new SimpleImplementation(); BeethovenFactory beethovenFactory = new BeethovenFactory(); ITestMethods instance = beethovenFactory.Generate <ITestMethods>( new LinkedObjects( ActionMethod.Create("Simple", () => log.Add("Before")), implementation, ActionMethod.Create("Simple", () => log.Add("After")))); instance.Simple(); CollectionAssert.AreEquivalent(new[] { "Before", "After" }, log); }
public void LinkedMethodsTest1() { List <string> log = new List <string>(); SimpleImplementation implementation = new SimpleImplementation(); BeethovenFactory beethovenFactory = new BeethovenFactory(); ITestMethods instance = beethovenFactory.Generate <ITestMethods>( new LinkedMethods(nameof(ITestMethods.Simple)) .Action(() => log.Add("Before")) .AutoMappedMethod(implementation) .Action(() => log.Add("After"))); instance.Simple(); CollectionAssert.AreEquivalent(new[] { "Before", "After" }, log); }
public void TestMethodLazyCreatorProperty3() { int count = 0; BeethovenFactory factory = new BeethovenFactory(); ITestProperties test = factory.Generate <ITestProperties>( new PropertyDefinition <int>(nameof(ITestProperties.Property1)) .LazyCreator(() => ++ count) .SetterGetter()); Assert.AreEqual(1, test.Property1); Assert.AreEqual(1, test.Property1); Assert.AreEqual(1, test.Property1); Assert.AreEqual(1, count); }
public void LinkedMethodsReturnValueTest5() { CustomImplementation implementation = new CustomImplementation(); BeethovenFactory beethovenFactory = new BeethovenFactory(); bool called = false; ITestMethods instance = beethovenFactory.Generate <ITestMethods>( LinkedMethodsReturnValue.Create <ITestMethods>(nameof(ITestMethods.OutAndRef)) .MappedMethod(implementation, nameof(CustomImplementation.OutAndRef1)) .Action(() => called = true)); string text2 = "wetwt"; instance.OutAndRef(out string _, ref text2, 5); Assert.IsTrue(called); }
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 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 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 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); }