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);
}
