How to use Method2 method of Xunit1.ClassWith2TestMethods class

1using System;
2using System.Collections.Generic;
3using Xunit;
4using Xunit.Sdk;
5
6namespace Xunit1
7{
8    public class TypeUtilityTests
9    {
10        [Fact]
11        public void ClassContains2MethodsWithTestAttribute()
12        {
13            List<IMethodInfo> testMethods =
14                new List<IMethodInfo>(TypeUtility.GetTestMethods(Reflector.Wrap(typeof(ClassWith2TestMethods))));
15
16            Assert.Equal(2, testMethods.Count);
17        }
18
19        [Fact]
20        public void ClassContainsNoMethodsWithTestAttribute()
21        {
22            List<IMethodInfo> testMethods =
23                new List<IMethodInfo>(TypeUtility.GetTestMethods(Reflector.Wrap(typeof(ClassWithNoTestMethods))));
24
25            Assert.Equal(0, testMethods.Count);
26        }
27
28        [Fact]
29        public void ClassContainsTestMethods()
30        {
31            Assert.True(TypeUtility.ContainsTestMethods(Reflector.Wrap(typeof(ClassWith2TestMethods))));
32        }
33
34        [Fact]
35        public void ClassDoesNotContainTestMethods()
36        {
37            Assert.False(TypeUtility.ContainsTestMethods(Reflector.Wrap(typeof(ClassWithNoTestMethods))));
38        }
39
40        [Fact]
41        public void ClassHasRunWithAttributeReturnsTypeThatDoesNotImplementsITestClassCommand()
42        {
43            Type testClassType = typeof(CustomRunWithInvalidClass);
44
45            Assert.Null(TypeUtility.GetRunWith(Reflector.Wrap(testClassType)));
46        }
47
48        [Fact]
49        public void ClassHasRunWithAttributeReturnsTypeThatImplementsITestClassCommand()
50        {
51            Type testClassType = typeof(CustomRunWithClass);
52            Type commandType = TypeUtility.GetRunWith(Reflector.Wrap(testClassType)).Type;
53
54            Assert.True(TypeUtility.ImplementsITestClassCommand(Reflector.Wrap(commandType)));
55        }
56
57        [Fact]
58        public void ClassHasRunWithAttributeWithITestClassCommand()
59        {
60            Type testClassType = typeof(CustomRunWithClass);
61            Assert.True(TypeUtility.HasRunWith(Reflector.Wrap(testClassType)));
62        }
63
64        [Fact]
65        public void BaseClassCanHaveRunWithAttribute()
66        {
67            Type testClassType = typeof(RunWithDerivedClass);
68
69            Type commandType = TypeUtility.GetRunWith(Reflector.Wrap(testClassType)).Type;
70
71            Assert.NotNull(commandType);
72        }
73
74        [Fact]
75        public void CanDetermineIfClassIsStatic()
76        {
77            Assert.False(TypeUtility.IsStatic(Reflector.Wrap(typeof(NonStaticClass))));
78            Assert.True(TypeUtility.IsStatic(Reflector.Wrap(typeof(StaticClass))));
79        }
80
81        class ClassWith2TestMethods
82        {
83            [Fact]
84            public void Method1() { }
85
86            [Fact]
87            public void Method2() { }
88        }
89
90        internal static class StaticClass { }
91
92        internal class NonStaticClass { }
93
94        internal class ClassWithNoTestMethods
95        {
96            public void NonTestMethod() { }
97        }
98
99        [RunWith(typeof(StubRunner))]
100        class CustomRunWithClass { }
101
102        [RunWith(typeof(string))]
103        class CustomRunWithInvalidClass { }
104
105        class RunWithDerivedClass : CustomRunWithClass { }
106
107        internal class StubRunner : ITestClassCommand
108        {
109            public int Count
110            {
111                get { return 0; }
112            }
113
114            public object ObjectUnderTest
115            {
116                get { return null; }
117            }
118
119            public ITypeInfo TypeUnderTest
120            {
121                get { return null; }
122                set { }
123            }
124
125            public int ChooseNextTest(ICollection<IMethodInfo> testsLeftToRun)
126            {
127                return 0;
128            }
129
130            public Exception ClassFinish()
131            {
132                return null;
133            }
134
135            public Exception ClassStart()
136            {
137                return null;
138            }
139
140            public IEnumerable<ITestCommand> EnumerateTestCommands(IMethodInfo testMethod)
141            {
142                return null;
143            }
144
145            public IEnumerable<IMethodInfo> EnumerateTestMethods()
146            {
147                return null;
148            }
149
150            public bool IsTestMethod(IMethodInfo testMethod)
151            {
152                return false;
153            }
154        }
155    }
156}

Source: TypeUtilityTests.cs

using System;
using System.Collections.Generic;
using Xunit;
using Xunit.Sdk;

namespace Xunit1
{
    public class TypeUtilityTests
    {
        [Fact]
        public void ClassContains2MethodsWithTestAttribute()
        {
            List<IMethodInfo> testMethods =
                new List<IMethodInfo>(TypeUtility.GetTestMethods(Reflector.Wrap(typeof(ClassWith2TestMethods))));

            Assert.Equal(2, testMethods.Count);
        }

        [Fact]
        public void ClassContainsNoMethodsWithTestAttribute()
        {
            List<IMethodInfo> testMethods =
                new List<IMethodInfo>(TypeUtility.GetTestMethods(Reflector.Wrap(typeof(ClassWithNoTestMethods))));

            Assert.Equal(0, testMethods.Count);
        }

        [Fact]
        public void ClassContainsTestMethods()
        {
            Assert.True(TypeUtility.ContainsTestMethods(Reflector.Wrap(typeof(ClassWith2TestMethods))));
        }

        [Fact]
        public void ClassDoesNotContainTestMethods()
        {
            Assert.False(TypeUtility.ContainsTestMethods(Reflector.Wrap(typeof(ClassWithNoTestMethods))));
        }

        [Fact]
        public void ClassHasRunWithAttributeReturnsTypeThatDoesNotImplementsITestClassCommand()
        {
            Type testClassType = typeof(CustomRunWithInvalidClass);

            Assert.Null(TypeUtility.GetRunWith(Reflector.Wrap(testClassType)));
        }

        [Fact]
        public void ClassHasRunWithAttributeReturnsTypeThatImplementsITestClassCommand()
        {
            Type testClassType = typeof(CustomRunWithClass);
            Type commandType = TypeUtility.GetRunWith(Reflector.Wrap(testClassType)).Type;

            Assert.True(TypeUtility.ImplementsITestClassCommand(Reflector.Wrap(commandType)));
        }

        [Fact]
        public void ClassHasRunWithAttributeWithITestClassCommand()
        {
            Type testClassType = typeof(CustomRunWithClass);
            Assert.True(TypeUtility.HasRunWith(Reflector.Wrap(testClassType)));
        }

        [Fact]
        public void BaseClassCanHaveRunWithAttribute()
        {
            Type testClassType = typeof(RunWithDerivedClass);

            Type commandType = TypeUtility.GetRunWith(Reflector.Wrap(testClassType)).Type;

            Assert.NotNull(commandType);
        }

        [Fact]
        public void CanDetermineIfClassIsStatic()
        {
            Assert.False(TypeUtility.IsStatic(Reflector.Wrap(typeof(NonStaticClass))));
            Assert.True(TypeUtility.IsStatic(Reflector.Wrap(typeof(StaticClass))));
        }

        class ClassWith2TestMethods
        {
            [Fact]
            public void Method1() { }

            [Fact]
            public void Method2() { }
        }

        internal static class StaticClass { }

        internal class NonStaticClass { }

        internal class ClassWithNoTestMethods
        {
            public void NonTestMethod() { }
        }

        [RunWith(typeof(StubRunner))]
        class CustomRunWithClass { }

        [RunWith(typeof(string))]
        class CustomRunWithInvalidClass { }

        class RunWithDerivedClass : CustomRunWithClass { }

        internal class StubRunner : ITestClassCommand
        {
            public int Count
            {
                get { return 0; }
            }

            public object ObjectUnderTest
            {
                get { return null; }
            }

            public ITypeInfo TypeUnderTest
            {
                get { return null; }
                set { }
            }

            public int ChooseNextTest(ICollection<IMethodInfo> testsLeftToRun)
            {
                return 0;
            }

            public Exception ClassFinish()
            {
                return null;
            }

            public Exception ClassStart()
            {
                return null;
            }

            public IEnumerable<ITestCommand> EnumerateTestCommands(IMethodInfo testMethod)
            {
                return null;
            }

            public IEnumerable<IMethodInfo> EnumerateTestMethods()
            {
                return null;
            }

            public bool IsTestMethod(IMethodInfo testMethod)
            {
                return false;
            }
        }
    }
}