public void ClassArrayHaveNullTest() { var finder = new DescribersFinder(typeof(TestClassC), typeof(TestClassC[])); var provider = new DescriberProvider(finder); var ser = new Serializer(provider); var cs = new TestClassC[] { null, new TestClassC(), null }; var buffer = ser.ObjectToBuffer(cs); var value = ser.BufferToObject(buffer) as TestClassC[]; NUnit.Framework.Assert.AreEqual(cs[0], value[0]); NUnit.Framework.Assert.AreNotEqual(null, value[1]); NUnit.Framework.Assert.AreEqual(cs[2], value[2]); }
public void TestLateGetObservableRefreshesCache() { var itemA = new TestClassA(); var itemB = new TestClassB(); var itemC = new TestClassC(); var interfaceObserver = new CountObserver <ITestClassA>(); var itemAObserver = new CountObserver <TestClassA>(); var itemBObserver = new CountObserver <TestClassB>(); var itemCObserver = new CountObserver <TestClassC>(); var demux = new Demultiplexor(); demux.GetObservable <TestClassA>().Subscribe(itemAObserver); demux.GetObservable <TestClassB>().Subscribe(itemBObserver); demux.GetObservable <TestClassC>().Subscribe(itemCObserver); demux.OnNext(itemA); demux.GetObservable <ITestClassA>().Subscribe(interfaceObserver); demux.OnNext(itemB); demux.OnNext(itemC); Assert.AreEqual(2, interfaceObserver.Count); Assert.AreEqual(3, itemAObserver.Count); Assert.AreEqual(2, itemBObserver.Count); Assert.AreEqual(1, itemCObserver.Count); }
public void ClassArrayHaveNullTest() { DescribersFinder finder = new DescribersFinder(typeof(TestClassC), typeof(TestClassC[])); DescriberProvider provider = new DescriberProvider(finder); Serializer ser = new Serializer(provider); TestClassC[] cs = new TestClassC[] { null, new TestClassC(), null }; byte[] buffer = ser.ObjectToBuffer(cs); TestClassC[] value = ser.BufferToObject(buffer) as TestClassC[]; Xunit.Assert.Equal(cs[0], value[0]); Xunit.Assert.NotEqual(null, value[1]); Xunit.Assert.Equal(cs[2], value[2]); }
public void MapTest() { var a = new TestClassA(); var c = new TestClassC(); PropertyInfo fromProp = typeof(TestClassA).GetProperty("Name"); PropertyInfo toProp = typeof(TestClassA).GetProperty("Name"); var mock = new ConverterMock(); bool executed = false; mock.ConvertAction = (f, fp, t, tp, s) => { Assert.AreEqual(c, f); Assert.AreEqual(fromProp, fp); Assert.AreEqual(a, t); Assert.AreEqual(toProp, tp); Assert.IsTrue(s); executed = true; }; var target = new ReflectionPropertyMappingInfo <TestClassC, TestClassA>( fromProp, toProp, true, mock); target.Map(c, a); Assert.IsTrue(executed); }
public void GivenRegistry_WhenResolvingToUnresolveableDestination_ItShouldThrowCannotResolveSemanticException() { var instanceClassA = new TestClassA(); var instanceClassC = new TestClassC(); // arrange var semanaticBuilder = new SemanticBuilder(); semanaticBuilder.InstallPipe <TestClassA, TestClassB>((a, semanticBroker) => new TestClassB()); semanaticBuilder.InstallPipe <TestClassB, TestClassA>((b, semanticBroker) => new TestClassA()); ISemanticBroker broker = semanaticBuilder.CreateBroker(); // act var exception1 = Assert.Throws <CannotResolveSemanticException>(async() => await broker.On(instanceClassA).Output <TestClassC>()); var exception2 = Assert.Throws <CannotResolveSemanticException>(async() => await broker.On(instanceClassC).Output <TestClassA>()); // assert string expectedExceptionMessage1 = string.Format("The input type '{0}' could not be resolved to output a type of {1}", typeof(TestClassA), typeof(TestClassC)); string expectedExceptionMessage2 = string.Format("The input type '{0}' could not be resolved to output a type of {1}", typeof(TestClassC), typeof(TestClassA)); Assert.AreEqual(expectedExceptionMessage1, exception1.Message); Assert.AreEqual(expectedExceptionMessage2, exception2.Message); }
public void MapAll_ValidInput_CallsRepository() { var mapperMock = A.Fake<IExtensibleMapper<TestClassE, TestClassC>>(); var target = new TestClassE[10]; var output = new TestClassC[10]; A.CallTo(() => mapperMock.MapMultiple(target)).Returns(output); var repoMock = A.Fake<IMappingRepository>(); A.CallTo(() => repoMock.ResolveMapper<TestClassE, TestClassC>()).Returns(mapperMock); IEnumerable<TestClassC> result = target.MapAll<TestClassE, TestClassC>(repoMock); Assert.AreEqual(output, result); }
public static void UnitTest_Out2() { Dictionary <string, TestClassC[]> data = new Dictionary <string, TestClassC[]>(); data["key"] = new TestClassC[1] { new TestClassC() }; TestClassC[] item; data.TryGetValue("key", out item); Console.WriteLine("value : " + item[0]); }
public void MapTo_ValidInput_UsesProvidedMapper() { var source = new TestClassC(); var mapperMock = A.Fake <IExtensibleMapper <TestClassC, TestClassB> >(); var expected = new TestClassB(); A.CallTo(() => mapperMock.Map((object)source)).Returns(expected); var actual = source.MapTo <TestClassB>(mapperMock); Assert.AreEqual(expected, actual); MappingRepository.Default.Clear(); }
public async Task MapTo_ValidInputAndTarget_UsesProvidedMapper() { var source = new TestClassC(); var mapperMock = A.Fake <IExtensibleMapper <TestClassC, TestClassB> >(); var expected = new TestClassB(); A.CallTo(() => mapperMock.Map(source, (object)expected)).Returns(expected); TestClassB actual = await source.MapToAsync(expected, mapperMock); Assert.AreEqual(expected, actual); MappingRepository.Default.Clear(); }
public void MapAll_ValidInput_CallsRepository() { var mapperMock = A.Fake <IExtensibleMapper <TestClassE, TestClassC> >(); var target = new TestClassE[10]; var output = new TestClassC[10]; A.CallTo(() => mapperMock.MapMultiple(target)).Returns(output); var repoMock = A.Fake <IMappingRepository>(); A.CallTo(() => repoMock.ResolveMapper <TestClassE, TestClassC>()).Returns(mapperMock); IEnumerable <TestClassC> result = target.MapAll <TestClassE, TestClassC>(repoMock); Assert.AreEqual(output, result); }
public void Given_PropertiesRelatedInitialDateTimeInformed_When_TryValidateObject_Then_TrueRetrieved() { var classObj = new TestClassC { TestDate = DateTime.Now }; var validationContext = new ValidationContext(classObj) { MemberName = nameof(TestClassA.TestString) }; var validationResults = new List <ValidationResult>(); var result = Validator.TryValidateObject(classObj, validationContext, validationResults, true); Assert.True(result); }
public void MapTo_ValidInputAndTarget_UsesProvidedRepo() { var source = new TestClassC(); var mapperMock = A.Fake <IExtensibleMapper <TestClassC, TestClassB> >(); var expected = new TestClassB(); A.CallTo(() => mapperMock.Map(source, (object)expected)).Returns(expected); var repoMock = A.Fake <IMappingRepository>(); A.CallTo(() => repoMock.ResolveMapper(typeof(TestClassC), typeof(TestClassB))).Returns(mapperMock); TestClassB actual = source.MapTo(expected, repoMock); Assert.AreEqual(expected, actual); MappingRepository.Default.Clear(); }
public async Task MapTo_ValidInput_UsesProvidedRepo() { var source = new TestClassC(); var mapperMock = A.Fake <IExtensibleMapper <TestClassC, TestClassB> >(); var expected = new TestClassB(); A.CallTo(() => mapperMock.Map((object)source)).Returns(expected); var repoMock = A.Fake <IMappingRepository>(); A.CallTo(() => repoMock.ResolveMapper(typeof(TestClassC), typeof(TestClassB))).Returns(mapperMock); var actual = await source.MapToAsync <TestClassB>(repoMock); Assert.AreEqual(expected, actual); MappingRepository.Default.Clear(); }
public async Task GivenRegistryWithMultiplePipes_WhenResolvingFromAToD_ItShouldChainAllThePipes() { for (int counter = 0; counter < 15; counter++) { // pre-arrange var instanceClassA = new TestClassA(); var instanceClassB = new TestClassB(); var instanceClassC = new TestClassC(); var instanceClassD = new TestClassD(); // arrange var semanticBuilder = new SemanticBuilder(); var enrollmentList = new List<Action> { () => semanticBuilder.InstallPipe<TestClassA, TestClassB>((a, innerBroker) => { Assert.AreSame(instanceClassA, a); return instanceClassB; }), () => semanticBuilder.InstallPipe<TestClassB, TestClassC>((b, innerBroker) => { Assert.AreSame(instanceClassB, b); return instanceClassC; }), () => semanticBuilder.InstallPipe<TestClassC, TestClassD>((c, innerBroker) => { Assert.AreSame(instanceClassC, c); return instanceClassD; }), }; var enrollmentActions = enrollmentList.OrderBy(x=>Guid.NewGuid()); foreach (var enrollmentAction in enrollmentActions) { enrollmentAction(); } ISemanticBroker broker = semanticBuilder.CreateBroker(); // act var solvedExecution = await broker.On(instanceClassA).Output<TestClassD>(); // assert Assert.AreEqual(instanceClassD, solvedExecution); } }
public async Task GivenRegistryWithMultiplePipes_WhenResolvingFromAToD_ItShouldChainAllThePipes() { for (int counter = 0; counter < 15; counter++) { // pre-arrange var instanceClassA = new TestClassA(); var instanceClassB = new TestClassB(); var instanceClassC = new TestClassC(); var instanceClassD = new TestClassD(); // arrange var semanticBuilder = new SemanticBuilder(); var enrollmentList = new List <Action> { () => semanticBuilder.InstallPipe <TestClassA, TestClassB>((a, innerBroker) => { Assert.AreSame(instanceClassA, a); return(instanceClassB); }), () => semanticBuilder.InstallPipe <TestClassB, TestClassC>((b, innerBroker) => { Assert.AreSame(instanceClassB, b); return(instanceClassC); }), () => semanticBuilder.InstallPipe <TestClassC, TestClassD>((c, innerBroker) => { Assert.AreSame(instanceClassC, c); return(instanceClassD); }), }; var enrollmentActions = enrollmentList.OrderBy(x => Guid.NewGuid()); foreach (var enrollmentAction in enrollmentActions) { enrollmentAction(); } ISemanticBroker broker = semanticBuilder.CreateBroker(); // act var solvedExecution = await broker.On(instanceClassA).Output <TestClassD>(); // assert Assert.AreEqual(instanceClassD, solvedExecution); } }
public async Task GivenRegistryWithMultipleSources_WhenResolvingToSpecificType_ItShouldResolve() { // pre-arrange var instanceClassA = new TestClassA(); var instanceClassB = new TestClassB(); var instanceClassC = new TestClassC(); // arrange var semanaticBuilder = new SemanticBuilder(); semanaticBuilder.InstallPipe<TestClassA, TestClassB>((a, semanticBroker) => instanceClassB); semanaticBuilder.InstallPipe<TestClassA, TestClassC>((a, semanticBroker) => instanceClassC); ISemanticBroker broker = semanaticBuilder.CreateBroker(); // act var solveToB = await broker.On(instanceClassA).Output<TestClassB>(); var solveToC = await broker.On(instanceClassA).Output<TestClassC>(); // assert Assert.AreEqual(instanceClassB, solveToB); Assert.AreEqual(instanceClassC, solveToC); }
public void MapTest() { var a = new TestClassA(); var c = new TestClassC(); PropertyInfo fromProp = typeof (TestClassA).GetProperty("Name"); PropertyInfo toProp = typeof (TestClassA).GetProperty("Name"); var mock = new ConverterMock(); bool executed = false; mock.ConvertAction = (f, fp, t, tp, s) => { Assert.AreEqual(c, f); Assert.AreEqual(fromProp, fp); Assert.AreEqual(a, t); Assert.AreEqual(toProp, tp); Assert.IsTrue(s); executed = true; }; var target = new ReflectionPropertyMappingInfo<TestClassC, TestClassA>( fromProp, toProp, true, mock); target.Map(c, a); Assert.IsTrue(executed); }
public async Task GivenRegistryWithMultipleSources_WhenResolvingToSpecificType_ItShouldResolve() { // pre-arrange var instanceClassA = new TestClassA(); var instanceClassB = new TestClassB(); var instanceClassC = new TestClassC(); // arrange var semanaticBuilder = new SemanticBuilder(); semanaticBuilder.InstallPipe <TestClassA, TestClassB>((a, semanticBroker) => instanceClassB); semanaticBuilder.InstallPipe <TestClassA, TestClassC>((a, semanticBroker) => instanceClassC); ISemanticBroker broker = semanaticBuilder.CreateBroker(); // act var solveToB = await broker.On(instanceClassA).Output <TestClassB>(); var solveToC = await broker.On(instanceClassA).Output <TestClassC>(); // assert Assert.AreEqual(instanceClassB, solveToB); Assert.AreEqual(instanceClassC, solveToC); }
public TestClassB(TestClassC testClassC) { IsInitialized = true; }
public TestClassD(TestClassC c) { }
public void MapAll_NullMapper_Throws() { var target = new TestClassC[1]; target.MapAll((IMapper<TestClassC, TestClassA>) null); }
public TestClassA(TestClassB testClassB, TestClassC testClassC) { }
public void MapAll_NullMapper_Throws() { var target = new TestClassC[1]; target.MapAll((IMapper <TestClassC, TestClassA>)null); }
public async Task MapTo_ValidInput_UsesProvidedRepo() { var source = new TestClassC(); var mapperMock = A.Fake<IExtensibleMapper<TestClassC, TestClassB>>(); var expected = new TestClassB(); A.CallTo(() => mapperMock.Map((object) source)).Returns(expected); var repoMock = A.Fake<IMappingRepository>(); A.CallTo(() => repoMock.ResolveMapper(typeof (TestClassC), typeof (TestClassB))).Returns(mapperMock); var actual = await source.MapToAsync<TestClassB>(repoMock); Assert.AreEqual(expected, actual); MappingRepository.Default.Clear(); }
public async Task MapTo_ValidInputAndTarget_UsesProvidedMapper() { var source = new TestClassC(); var mapperMock = A.Fake<IExtensibleMapper<TestClassC, TestClassB>>(); var expected = new TestClassB(); A.CallTo(() => mapperMock.Map(source, (object) expected)).Returns(expected); TestClassB actual = await source.MapToAsync(expected, mapperMock); Assert.AreEqual(expected, actual); MappingRepository.Default.Clear(); }
public void GivenRegistry_WhenResolvingToUnresolveableDestination_ItShouldThrowCannotResolveSemanticException() { var instanceClassA = new TestClassA(); var instanceClassC = new TestClassC(); // arrange var semanaticBuilder = new SemanticBuilder(); semanaticBuilder.InstallPipe<TestClassA, TestClassB>((a, semanticBroker) => new TestClassB()); semanaticBuilder.InstallPipe<TestClassB, TestClassA>((b, semanticBroker) => new TestClassA()); ISemanticBroker broker = semanaticBuilder.CreateBroker(); // act var exception1 = Assert.Throws<CannotResolveSemanticException>(async () => await broker.On(instanceClassA).Output<TestClassC>()); var exception2 = Assert.Throws<CannotResolveSemanticException>(async () => await broker.On(instanceClassC).Output<TestClassA>()); // assert string expectedExceptionMessage1 = string.Format("The input type '{0}' could not be resolved to output a type of {1}", typeof (TestClassA), typeof (TestClassC)); string expectedExceptionMessage2 = string.Format("The input type '{0}' could not be resolved to output a type of {1}", typeof (TestClassC), typeof (TestClassA)); Assert.AreEqual(expectedExceptionMessage1, exception1.Message); Assert.AreEqual(expectedExceptionMessage2, exception2.Message); }
public void MapTo_ValidInputAndTarget_UsesProvidedRepo() { var source = new TestClassC(); var mapperMock = A.Fake<IExtensibleMapper<TestClassC, TestClassB>>(); var expected = new TestClassB(); A.CallTo(() => mapperMock.Map(source, (object) expected)).Returns(expected); var repoMock = A.Fake<IMappingRepository>(); A.CallTo(() => repoMock.ResolveMapper(typeof (TestClassC), typeof (TestClassB))).Returns(mapperMock); TestClassB actual = source.MapTo(expected, repoMock); Assert.AreEqual(expected, actual); MappingRepository.Default.Clear(); }
public void MapTo_ValidInput_UsesProvidedMapper() { var source = new TestClassC(); var mapperMock = A.Fake<IExtensibleMapper<TestClassC, TestClassB>>(); var expected = new TestClassB(); A.CallTo(() => mapperMock.Map((object) source)).Returns(expected); var actual = source.MapTo<TestClassB>(mapperMock); Assert.AreEqual(expected, actual); MappingRepository.Default.Clear(); }
public int Add3(TestClassC env1, TestClassB env2, int val) { return(env1.Val + env2.Val + val); }