public void VisitTypeElementRelaysEventInfoElements()
{
// Fixture setup
var sut = new Mock <ReflectionVisitor <T> > {
CallBase = true
}.Object;
var visitor1 = new Mock <ReflectionVisitor <T> >().Object;
var visitor2 = new Mock <ReflectionVisitor <T> >().Object;
var visitor3 = new Mock <ReflectionVisitor <T> >().Object;
var visitor4 = new Mock <ReflectionVisitor <T> >().Object;
var expected = new ReflectionVisitor();
var typeElement = typeof(TypeWithEvents).ToElement();
var eventInfoElements = typeElement.Type.GetEvents(GetDefaultBindingFlags())
.Select(e => e.ToElement()).ToArray();
Assert.Equal(3, eventInfoElements.Length);
Mock.Get(sut).Setup(x => x.Visit(It.IsAny <FieldInfoElement[]>())).Returns(visitor1);
Mock.Get(visitor1).Setup(x => x.Visit(It.IsAny <ConstructorInfoElement[]>())).Returns(visitor2);
Mock.Get(visitor2).Setup(x => x.Visit(It.IsAny <PropertyInfoElement[]>())).Returns(visitor3);
Mock.Get(visitor3).Setup(x => x.Visit(It.IsAny <MethodInfoElement[]>())).Returns(visitor4);
Mock.Get(visitor4).Setup(x => x.Visit(It.Is <EventInfoElement[]>(
p => AreEquivalent(p, eventInfoElements))))
.Returns(expected);
// Exercise system
var actual = sut.Visit(typeElement);
// Verify outcome
Assert.Equal(expected, actual);
}
public void VisitNullEventInfoElementThrows()
{
var sut = new Mock <ReflectionVisitor <T> > {
CallBase = true
}.Object;
Assert.Throws <ArgumentNullException>(() => sut.Visit((EventInfoElement)null));
}
public void VisitLocalVariableInfoElementsReturnsItself()
{
var sut = new Mock<MemberReferenceCollector> { CallBase = true }.Object;
sut.ToMock().Setup(x => x.Visit(It.IsAny<LocalVariableInfoElement>())).Throws<InvalidOperationException>();
var localVariableInfoElement = new Methods<ClassForCollectingReference>()
.Select(x => x.ReturnMethod()).GetMethodBody()
.LocalVariables.First().ToElement();
var actual = sut.Visit(new[] { localVariableInfoElement });
Assert.Same(sut, actual);
}
public void VisitAssemblyElementCallsBaseMethod()
{
var assembly = new DelegatingAssembly
{
OnGetTypes = () => new[] { typeof(object), typeof(int) }
};
var sut = new Mock<ReferenceCollector> { CallBase = true }.Object;
var visitor1 = new Mock<ReferenceCollector>().Object;
var visitor2 = new Mock<ReferenceCollector>().Object;
sut.ToMock().Setup(x => x.Visit(typeof(object).ToElement())).Returns(visitor1);
visitor1.ToMock().Setup(x => x.Visit(typeof(int).ToElement())).Returns(visitor2);
var actual = sut.Visit(assembly.ToElement());
Assert.Equal(visitor2, actual);
}
public void VisitAssemblyRelaysTypeElements()
{
var sut = new Mock <ReflectionVisitor <T> > {
CallBase = true
}.Object;
var expected = new ReflectionVisitor();
Assembly assembly = Assembly.GetExecutingAssembly();
var typeElements = assembly.GetTypes().Select(t => t.ToElement()).ToArray();
Mock.Get(sut).Setup(x => x.Visit(It.Is <TypeElement[]>(
p => AreEquivalent(p, typeElements))))
.Returns(expected);
var actual = sut.Visit(assembly.ToElement());
Assert.Equal(expected, actual);
}
public void VisitWriteOnlyPropertyInfoElementOnlyRelaysSetMethodInfoElement()
{
// Fixture setup
var sut = new Mock <ReflectionVisitor <T> > {
CallBase = true
}.Object;
var expected = new ReflectionVisitor();
var writeOnlyPropertyInfoElement = TypeWithProperties.WriteOnlyProperty.ToElement();
var setMethodInfoElement = writeOnlyPropertyInfoElement.PropertyInfo.GetSetMethod().ToElement();
Mock.Get(sut).Setup(x => x.Visit(setMethodInfoElement)).Returns(expected);
// Exercise system
var actual = sut.Visit(writeOnlyPropertyInfoElement);
// Verify outcome
Assert.Equal(expected, actual);
}
public void VisitConstructorInfoElementsRelaysEachConstructorInfoElement()
{
// Fixture setup
var sut = new Mock <ReflectionVisitor <T> > {
CallBase = true
}.Object;
var visitor = new Mock <ReflectionVisitor <T> >().Object;
var expected = new ReflectionVisitor();
var constructorInfoElement1 = TypeWithCtors.Ctor.ToElement();
var constructorInfoElement2 = TypeWithCtors.OtherCtor.ToElement();
Mock.Get(sut).Setup(x => x.Visit(constructorInfoElement1)).Returns(visitor);
Mock.Get(visitor).Setup(x => x.Visit(constructorInfoElement2)).Returns(expected);
// Exercise system
var actual = sut.Visit(new[] { constructorInfoElement1, constructorInfoElement2 });
// Verify outcome
Assert.Equal(expected, actual);
}
public void VisitPropertyInfoElementRelaysNonPublicGetAndSetMethodInfoElements()
{
// Fixture setup
var sut = new Mock <ReflectionVisitor <T> > {
CallBase = true
}.Object;
var visitor = new Mock <ReflectionVisitor <T> >().Object;
var expected = new ReflectionVisitor();
var propertyInfoElement = TypeWithProperties.PrivateProperty.ToElement();
var getMethodInfoElement = propertyInfoElement.PropertyInfo.GetGetMethod(true).ToElement();
var setMethodInfoElement = propertyInfoElement.PropertyInfo.GetSetMethod(true).ToElement();
Mock.Get(sut).Setup(x => x.Visit(getMethodInfoElement)).Returns(visitor);
Mock.Get(visitor).Setup(x => x.Visit(setMethodInfoElement)).Returns(expected);
// Exercise system
var actual = sut.Visit(propertyInfoElement);
// Verify outcome
Assert.Equal(expected, actual);
}
public void VisitEventInfoElementRelaysAddAndRemoveMethodInfoElements(EventInfo eventInfo)
{
// Fixture setup
var sut = new Mock <ReflectionVisitor <T> > {
CallBase = true
}.Object;
var visitor = new Mock <ReflectionVisitor <T> >().Object;
var expected = new ReflectionVisitor();
var eventInfoElement = eventInfo.ToElement();
var addMethodInfoElement = eventInfoElement.EventInfo.GetAddMethod(true).ToElement();
var removeMethodInfoElement = eventInfoElement.EventInfo.GetRemoveMethod(true).ToElement();
Mock.Get(sut).Setup(x => x.Visit(addMethodInfoElement)).Returns(visitor);
Mock.Get(visitor).Setup(x => x.Visit(removeMethodInfoElement)).Returns(expected);
// Exercise system
var actual = sut.Visit(eventInfoElement);
// Verify outcome
Assert.Equal(expected, actual);
}
public void VisitLocalVariableInfoElementsRelaysEachLocalVariableInfoElement()
{
// Fixture setup
var sut = new Mock <ReflectionVisitor <T> > {
CallBase = true
}.Object;
var visitor = new Mock <ReflectionVisitor <T> >().Object;
var expected = new ReflectionVisitor();
var localVariableInfoElement1 = TypeWithLocalVariables.LocalVariable.ToElement();
var localVariableInfoElement2 = TypeWithLocalVariables.OtherLocalVariable.ToElement();
Mock.Get(sut).Setup(x => x.Visit(localVariableInfoElement1)).Returns(visitor);
Mock.Get(visitor).Setup(x => x.Visit(localVariableInfoElement2)).Returns(expected);
// Exercise system
var actual = sut.Visit(new[] { localVariableInfoElement1, localVariableInfoElement2 });
// Verify outcome
Assert.Equal(expected, actual);
}
public void VisitAssemblyElementsRelaysEachAssemblyElement()
{
// Fixture setup
var sut = new Mock <ReflectionVisitor <T> > {
CallBase = true
}.Object;
var visitor = new Mock <ReflectionVisitor <T> >().Object;
var expected = new ReflectionVisitor();
var assemblyElement1 = typeof(ReflectionVisitor <>).Assembly.ToElement();
var assemblyElement2 = typeof(ReflectionVisitorTests <>).Assembly.ToElement();
Mock.Get(sut).Setup(x => x.Visit(assemblyElement1)).Returns(visitor);
Mock.Get(visitor).Setup(x => x.Visit(assemblyElement2)).Returns(expected);
// Exercise system
var actual = sut.Visit(new[] { assemblyElement1, assemblyElement2 });
// Verify outcome
Assert.Equal(expected, actual);
}
public void VisitMethodInfoElementRelaysLocalVariableInfoElements()
{
// Fixture setup
var sut = new Mock <ReflectionVisitor <T> > {
CallBase = true
}.Object;
var visitor = new Mock <ReflectionVisitor <T> >().Object;
var expected = new ReflectionVisitor();
var methodInfoElement = TypeWithMethods.OtherMethod.ToElement();
var localVariableTypes = TypeWithMethods.LocalVariablesOfOtherMethod.Select(l => l.LocalType).ToArray();
Mock.Get(sut).Setup(x => x.Visit(It.IsAny <ParameterInfoElement[]>())).Returns(visitor);
Mock.Get(visitor).Setup(x => x.Visit(It.Is <LocalVariableInfoElement[]>(
l => AreEquivalent(l.Select(li => li.LocalVariableInfo.LocalType).ToArray(), localVariableTypes))))
.Returns(expected);
// Exercise system
var actual = sut.Visit(methodInfoElement);
// Verify outcome
Assert.Equal(expected, actual);
}
public void VisitConstructorInfoElementRelaysParameterInfoElements()
{
// Fixture setup
var sut = new Mock <ReflectionVisitor <T> > {
CallBase = true
}.Object;
var visitor = new Mock <ReflectionVisitor <T> >().Object;
var expected = new ReflectionVisitor();
var constructorInfoElement = TypeWithCtors.OtherCtor.ToElement();
var parameterInfoElements = constructorInfoElement.ConstructorInfo
.GetParameters().Select(pi => pi.ToElement()).ToArray();
Mock.Get(sut).Setup(x => x.Visit(It.Is <ParameterInfoElement[]>(
p => AreEquivalent(p, parameterInfoElements))))
.Returns(visitor);
Mock.Get(visitor).Setup(x => x.Visit(It.IsAny <LocalVariableInfoElement[]>())).Returns(expected);
// Exercise system
var actual = sut.Visit(constructorInfoElement);
// Verify outcome
Assert.Equal(expected, actual);
}
public void VisitTypeElementsRelaysEachTypeElement()
{
// Fixture setup
var sut = new Mock <ReflectionVisitor <T> > {
CallBase = true
}.Object;
var visitor1 = new Mock <ReflectionVisitor <T> >().Object;
var visitor2 = new Mock <ReflectionVisitor <T> >().Object;
var expected = new ReflectionVisitor();
var typeElement1 = typeof(object).ToElement();
var typeElement2 = typeof(int).ToElement();
var typeElement3 = typeof(string).ToElement();
Mock.Get(sut).Setup(x => x.Visit(typeElement1)).Returns(visitor1);
Mock.Get(visitor1).Setup(x => x.Visit(typeElement2)).Returns(visitor2);
Mock.Get(visitor2).Setup(x => x.Visit(typeElement3)).Returns(expected);
// Exercise system
var actual = sut.Visit(new[] { typeElement1, typeElement2, typeElement3 });
// Verify outcome
Assert.Equal(expected, actual);
}
public void VisitThrowsOnNullResults()
{
ParserVisitor target = new Mock<ParserVisitor>().Object;
Assert.ThrowsArgumentNull(() => target.Visit(null), "result");
}
public void VisitMethodInfoElementCollectsAssembliesFromBaseMethod()
{
var references = new[] { typeof(ISet<>).Assembly };
var sut = new Mock<MemberReferenceCollector> { CallBase = true }.Object;
sut.ToMock().Setup(x => x.Visit(It.IsAny<ParameterInfoElement[]>())).Returns(sut);
sut.ToMock().Setup(x => x.Visit(It.IsAny<LocalVariableInfoElement[]>()))
.Returns(new MemberReferenceCollector(references));
var expected = new[]
{
typeof(ClassImplementingMultiple).Assembly,
typeof(IDisposable).Assembly,
typeof(ISpecimenContext).Assembly,
references[0]
};
var dummyMethodInfoElement = new Methods<ClassForCollectingReference>()
.Select(x => x.ReturnMethod()).ToElement();
var actual = sut.Visit(dummyMethodInfoElement);
sut.ToMock().VerifyAll();
Assert.Equal(
expected.OrderBy(x => x.ToString()),
actual.Value.OrderBy(x => x.ToString()));
}
public void VisitMethodInfoElementCollectsCorrectAssembliesForMethodCallInMethodBody()
{
var visitor = new DelegatingReflectionVisitor<IEnumerable<Assembly>>();
var sut = new Mock<ReferenceCollector> { CallBase = true }.Object;
sut.ToMock().Setup(x => x.Visit(It.IsAny<ParameterInfoElement>())).Returns(visitor);
sut.ToMock().Setup(x => x.Visit(It.IsAny<LocalVariableInfoElement>())).Returns(visitor);
var expected = new[]
{
typeof(IDisposable).Assembly,
typeof(Enumerable).Assembly
};
var methodInfoElement = new Methods<ClassForCollectingReference>()
.Select(x => x.MethodCallInMethodBody()).ToElement();
sut.Visit(methodInfoElement);
Assert.Equal(expected.OrderBy(x => x.ToString()), sut.Value.OrderBy(x => x.ToString()));
}
public void VisitPropertyInfoElementsCallsBaseMethod()
{
var sut = new Mock<ReferenceCollector> { CallBase = true }.Object;
var visitor = new DelegatingReflectionVisitor<IEnumerable<Assembly>>();
sut.ToMock().Setup(x => x.Visit(It.IsAny<PropertyInfoElement>())).Returns(visitor);
var propertyInfoElements = typeof(ClassWithMembers).GetProperties(Bindings)
.Select(x => x.ToElement()).ToArray();
var actual = sut.Visit(propertyInfoElements);
Assert.Equal(visitor, actual);
}
public void VisitThrowsOnNullResults()
{
ParserVisitor target = new Mock <ParserVisitor>().Object;
Assert.ThrowsArgumentNull(() => target.Visit(null), "result");
}
public void VisitTypeElementCollectsCorrectAssemblies()
{
var type = typeof(List<ClassImplementingHierarchical>);
var expected = new[]
{
typeof(ClassImplementingMultiple).Assembly,
typeof(IDisposable).Assembly,
typeof(IReflectionElement).Assembly,
typeof(Fixture).Assembly
};
var visitor = new DelegatingReflectionVisitor<IEnumerable<Assembly>>();
var sut = new Mock<ReferenceCollector> { CallBase = true }.Object;
sut.ToMock().Setup(x => x.Visit(It.IsAny<FieldInfoElement>())).Returns(visitor);
sut.ToMock().Setup(x => x.Visit(It.IsAny<ConstructorInfoElement>())).Returns(visitor);
sut.ToMock().Setup(x => x.Visit(It.IsAny<PropertyInfoElement>())).Returns(visitor);
sut.ToMock().Setup(x => x.Visit(It.IsAny<MethodInfoElement>())).Returns(visitor);
sut.ToMock().Setup(x => x.Visit(It.IsAny<EventInfoElement>())).Returns(visitor);
var actual = sut.Visit(type.ToElement());
Assert.Equal(visitor, actual);
Assert.Equal(expected.OrderBy(x => x.ToString()), sut.Value.OrderBy(x => x.ToString()));
}
public void VisitThrowsOnNullResults()
{
var target = new Mock <ParserVisitor>().Object;
Assert.Throws <ArgumentNullException>("result", () => target.Visit(null));
}
public void VisitConstructorInfoElementCollectsCorrectAssembliesForMethodBody()
{
var visitor = new DelegatingReflectionVisitor<IEnumerable<Assembly>>();
var sut = new Mock<ReferenceCollector> { CallBase = true }.Object;
sut.ToMock().Setup(x => x.Visit(It.IsAny<ParameterInfoElement>())).Returns(visitor);
sut.ToMock().Setup(x => x.Visit(It.IsAny<LocalVariableInfoElement>())).Returns(visitor);
var expected = new[]
{
typeof(IDisposable).Assembly,
GetType().Assembly,
typeof(Fixture).Assembly
};
var constructorInfoElement = Constructors.Select(() => new ClassForCollectingReference(0)).ToElement();
var actual = sut.Visit(constructorInfoElement);
Assert.Equal(visitor, actual);
Assert.Equal(expected.OrderBy(x => x.ToString()), sut.Value.OrderBy(x => x.ToString()));
}
public void VisitThrowsOnNullResults()
{
ParserVisitor target = new Mock<ParserVisitor>().Object;
Assert.Throws<ArgumentNullException>("result", () => target.Visit(null));
}
public void VisitTypeElementCollectsCorrectAssemblies(
Type type, Assembly[] expected)
{
var refereces = new[] { typeof(ISet<>).Assembly };
var sut = new Mock<MemberReferenceCollector>(new object[] { refereces }) { CallBase = true }.Object;
sut.ToMock().Setup(x => x.Visit(It.IsAny<FieldInfoElement>())).Throws<InvalidOperationException>();
sut.ToMock().Setup(x => x.Visit(It.IsAny<ConstructorInfoElement>())).Throws<InvalidOperationException>();
sut.ToMock().Setup(x => x.Visit(It.IsAny<PropertyInfoElement>())).Throws<InvalidOperationException>();
sut.ToMock().Setup(x => x.Visit(It.IsAny<MethodInfoElement>())).Throws<InvalidOperationException>();
sut.ToMock().Setup(x => x.Visit(It.IsAny<EventInfoElement>())).Throws<InvalidOperationException>();
var actual = sut.Visit(type.ToElement());
Assert.NotSame(sut, actual);
Assert.Equal(
refereces.Concat(expected).OrderBy(x => x.ToString()),
actual.Value.OrderBy(x => x.ToString()));
}
