/// <summary>
        /// Enumerates the segments in a path and calls a corresponding delegate verifier on each segment.
        /// Do not overuse this method: most test cases don't need to over-baseline what the expected segments are.
        /// </summary>
        public static void VerifyPath(ODataPath path, Action<ODataPathSegment>[] segmentVerifiers)
        {
            path.Count().Should().Be(segmentVerifiers.Count());

            var i = 0;
            foreach (var segment in path)
            {
                segmentVerifiers[i++](segment);
            }
        }
        /// <summary>
        /// Enumerates the segments in a path and calls a corresponding delegate verifier on each segment.
        /// </summary>
        private void VerifyPath(IEnumerable<string> path, Action<string>[] segmentVerifiers)
        {
            path.Count().Should().Be(segmentVerifiers.Count());

            var i = 0;
            foreach (var segment in path)
            {
                segmentVerifiers[i++](segment);
            }
        }
Esempio n. 3
0
        public void PropertiesTest()
        {
            // arrange
            // act
            var allMembers = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
            var subject = TypeOverrideDescriptor.Create(typeof(PropertyTestType3));

            // assert
            var propertyAsserts = new Action<PropertyInfo>[]
            {
                m => Assert.AreEqual(m, typeof(PropertyTestType3).GetProperty("Overridable1", allMembers)),
                m => Assert.AreEqual(m, typeof(PropertyTestType3).GetProperty("Overridable2", allMembers)),
                m => Assert.AreEqual(m, typeof(PropertyTestType3).GetProperty("Overridable4", allMembers)),
                m => Assert.AreEqual(m, typeof(PropertyTestType3).GetProperty("Overridable6", allMembers)),
                m => Assert.AreEqual(m, typeof(PropertyTestType3).GetProperty("Overridable3", allMembers))
            };

            Assert.AreEqual(propertyAsserts.Count(), subject.OverridableProperties.Count());
            for (var i = 0; i < subject.OverridableProperties.Count(); i++)
            {
                propertyAsserts[i](subject.OverridableProperties.ElementAt(i));
            }
        }
Esempio n. 4
0
        public void MethodsTest()
        {
            // arrange
            // act
            var allMembers = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
            var subject = TypeOverrideDescriptor.Create(typeof(MethodTestType3));

            // assert
            var methodAsserts = new Action<MethodInfo>[]
            {
                m => Assert.AreEqual(m, typeof(MethodTestType3).GetMethod("Overridable1", allMembers, null, Type.EmptyTypes, null)),
                m => Assert.AreEqual(m, typeof(MethodTestType3).GetMethod("Overridable2", allMembers)),
                m => Assert.AreEqual(m, typeof(MethodTestType3).GetMethod("Overridable4", allMembers), "XX"),
                m => Assert.AreEqual(m, typeof(MethodTestType3).GetMethod("Overridable6", allMembers), "ZZ"),
                m => Assert.AreEqual(m, typeof(MethodTestType3).GetMethod("Overridable3", allMembers)),
                m => Assert.AreEqual(m, typeof(MethodTestType3).GetMethod("ToString", allMembers)),
                m => Assert.AreEqual(m, typeof(MethodTestType3).GetMethod("Equals", allMembers)),
                m => Assert.AreEqual(m, typeof(MethodTestType3).GetMethod("GetHashCode", allMembers)),
            };

            Assert.AreEqual(methodAsserts.Count(), subject.OverridableMethods.Count());
            for (var i = 0; i < subject.OverridableMethods.Count(); i++)
            {
                methodAsserts[i](subject.OverridableMethods.ElementAt(i));
            }
        }