Example #1
0
        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);
        }
Example #2
0
        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);
        }
Example #5
0
        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);
        }
Example #6
0
        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);
        }
Example #7
0
        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);
        }
Example #8
0
        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);
        }
Example #9
0
        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);
        }
Example #10
0
        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);
        }
Example #11
0
        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);
        }
Example #12
0
        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);
        }
Example #13
0
        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);
        }
Example #14
0
        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);
        }
Example #19
0
        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()));
        }
Example #21
0
        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()));
        }