public void ExecuteMethodThrowsException() {
    var fixture = new TestFixture(typeof(Foo));
    var tm = new TestMethod(fixture, typeof(Foo).GetMethod("MethodWithException"));
    tm.Execute(_listener);
    Assert.Equals(" MethodWithException", _sequence);
    Assert.StartsWith(" TS:MethodWithException TE:MethodWithException ", SimpleTestListener.Messages);
 }

        public TestRepository(ILdapManager ldapManagerObj, TestUserRepository testUserRepository)
        {
            _testImplementation = new TestImplementation.TestImplementation(testUserRepository, ldapManagerObj);

            TestList = new Dictionary<TestType, TestMethod>
            {
                {TestType.TestAdminConnection, _testImplementation.TestAdminConnect},
                {TestType.TestCreateUser, _testImplementation.TestCreateUser},
                {TestType.TestDeleteUser, _testImplementation.TestDeleteUser},
                {TestType.TestInitLibrary, _testImplementation.TestCompleteInitLibrary},
                {TestType.TestInitLibraryNoAdmin, _testImplementation.TestStardardInitLibraryNoAdmin},
                {TestType.TestModifyUserDescription, _testImplementation.TestModifyUserAttribute},
                {TestType.TestSearchUsers, _testImplementation.TestSearchUser},
                {TestType.TestStandardInitLibraryNoAdmin, _testImplementation.TestStardardInitLibraryNoAdmin},
                {TestType.TestUserChangePassword, _testImplementation.TestChangeUserPassword},
                {
                    TestType.TestConnectUser, () =>
                    {
                        var testMethod = new TestMethod(_testImplementation.TestUserConnectWithoutWritePermissions);
                        if (_writePermission) testMethod = _testImplementation.TestUserConnect;
                        return testMethod();
                    }
                },
                {
                    TestType.TestSearchUserAndConnect, () =>
                    {
                        var testMethod =
                            new TestMethod(_testImplementation.TestSearchUserAndConnectWithoutWritePermissions);
                        if (_writePermission) testMethod = _testImplementation.TestSearchUserAndConnect;
                        return testMethod();
                    }
                }
            };
        }

        public void ShouldNotIgnoreMethodNotMarkedIgnore()
        {
            MethodInfo methodInfo = typeof(TestMethodTest).GetMethod("MethodNotMarkedIgnore");
            var testMethod = new TestMethod(methodInfo);

            Assert.IsFalse(testMethod.Ignore);
        }

 /// <summary>
 /// Initializes a new <see cref="MSTestAutomation"/>.
 /// </summary>
 public MSTestAutomation(TestMethod testMethod)
 {
     Name = String.Format("{0}.{1}", testMethod.FullClassName, testMethod.Name);
     Identifier = _identifierFactory.CreateIdentifier(Name);
     Storage = Path.GetFileName(testMethod.AssemblyName);
     TestType = "Unit Test";
 }

        /// <summary>
        /// Creates a test command for use in running this test.
        /// </summary>
        /// <returns></returns>
        public static TestCommand MakeTestCommand(TestMethod test)
        {
            // Command to execute test
            TestCommand command = new TestMethodCommand(test);

            // Add any wrappers to the TestMethodCommand
            foreach (IWrapTestMethod wrapper in test.Method.GetCustomAttributes(typeof(IWrapTestMethod), true))
                command = wrapper.Wrap(command);

            // Wrap in TestActionCommand
            command = new TestActionCommand(command);

            // Wrap in SetUpTearDownCommand
            command = new SetUpTearDownCommand(command);

            // Add wrappers that apply before setup and after teardown
            foreach (ICommandWrapper decorator in test.Method.GetCustomAttributes(typeof(IWrapSetUpTearDown), true))
                command = decorator.Wrap(command);

            // Add command to set up context using attributes that implement IApplyToContext
            IApplyToContext[] changes = (IApplyToContext[])test.Method.GetCustomAttributes(typeof(IApplyToContext), true);
            if (changes.Length > 0)
                command = new ApplyChangesToContextCommand(command, changes);

            return command;
        }

 public void ExecuteMethod() {
    var fixture = new TestFixture(typeof(Foo));
    var tm = new TestMethod(fixture, typeof(Foo).GetMethod("AMethod"));
    tm.Execute( _listener);
    Assert.Equals(" AMethod", _sequence);
    Assert.Equals(" TS:AMethod TP:AMethod", SimpleTestListener.Messages);
 }

        public static void DoTimedRun(TestMethod testMethod, int reps)
        {
            System.GC.Collect();

            long rigging_time = 0;
            long start;
            long finish;

            //			start = System.DateTime.Now.Ticks;
            //			for (int i = 1; i <= reps; i++)
            //			{
            //				new TestMethod(DoNothingTestMethod)();
            //			}
            //			finish = System.DateTime.Now.Ticks;
            //			rigging_time = (finish - start);

            Console.Out.Write("TIME: {0}", testMethod.Method.Name);
            start = System.DateTime.Now.Ticks;
            for (int i = 1; i <= reps; i++)
            {
                testMethod();
            }
            finish = System.DateTime.Now.Ticks;
            long millis = ((finish - start) - rigging_time) / TimeSpan.TicksPerMillisecond;

            Console.Out.WriteLine("; repeats = {0} {1}ms ({2} millisec/eval)", reps, millis, (millis/reps));
        }

        public void SetUp()
        {
            _test = new TestMethod(new MethodWrapper(typeof(DummySuite), "DummyMethod"));
            _testResult = _test.MakeTestResult();

            _suite = new TestSuite(typeof(DummySuite));
            _suiteResult = (TestSuiteResult)_suite.MakeTestResult();
        }

 public void OneNameCriterion() {
    ITestMethod tm =
       new TestMethod(new TestFixture(typeof(SampleTestFixture)),
                      typeof(SampleTestFixture).GetMethod("Foo"));
    var nameCriterion = new NameCriterion(typeof(SampleTestFixture).FullName + ".Foo");
    var selection = new TestRun(nameCriterion);
    Assert.True(selection.Contains(tm));
 }

        public void SetsTestClassOnTestMethods()
        {
            TestMethod testMethod = new TestMethod(null, null, null);

            var testClass = new TestClass("typeName", new[] { testMethod });

            Assert.Same(testClass, testMethod.TestClass);
        }

 static void Main(string[] args)
 {
     Program program = new Program();
     TestMethod testMethod = new TestMethod(program.SearchShopbyFood);
     //program.OptimisticConcurrencyTest();
     testMethod += program.SearchShopbyFood3;
     testMethod();
 }

 public void DoTest(IWin32Window owner, TestMethod method, object data)
 {
     _alarming = true;
     _method = method;
     _data = data;
     MakePrompt();
     ShowDialog(owner);
 }

 protected override void TestSkipped(TestMethod method, TestSkippedResult result)
 {
     Console.WriteLine(
         "##teamcity[testIgnored name='{0}' message='{1}']",
         Escape(method.DisplayName),
         Escape(result.Reason)
     );
 }

 public void OneTestConfigured() {
    var testSpec = new TestSpec();
    var testMethod1 = new TestMethod(new TestFixture(typeof(Foo)), typeof(Foo).GetMethod("Bar"));
    var testMethod2 = new TestMethod(new TestFixture(typeof(Foo)), typeof(Foo).GetMethod("Nope"));
    testSpec.AddTest(testMethod1);
    Assert.True(testSpec.Contains(testMethod1));
    Assert.False(testSpec.Contains(testMethod2));
 }

 public static void RunTest(TestMethod r)
 {
     try
     {
         r();
     }
     catch (TestFailedException) { }
 }

    public void MethodWithAllPassingResultsIsInPassedRunState()
    {
        TestMethod method = new TestMethod("methdName", "displayname", null);

        method.RunResults.Add(new TestPassedResult(0.0, "displayname", null));
        method.RunResults.Add(new TestPassedResult(1.2, "displayname", null));

        Assert.Equal(TestStatus.Passed, method.RunStatus);
    }

        public void CreateWorkItems()
        {
            IMethodInfo method = new MethodWrapper(typeof(DummyFixture), "DummyTest");
            ITest test = new TestMethod(method);
            _workItem = WorkItem.CreateWorkItem(test, TestFilter.Empty);

            _context = new TestExecutionContext();
            _workItem.InitializeContext(_context);
        }

        public override bool TestStart(TestMethod method)
        {
            Console.WriteLine(
                "##teamcity[testStarted name='{0}']",
                Escape(method.DisplayName)
            );

            return true;
        }

 public void DoNap(IWin32Window owner, TimeSpan length, TimeSpan cooldown,
     TestMethod testMethod, object testData)
 {
     _testMethod = testMethod;
     _testData = testData;
     _engine.BeginNap(length, cooldown);
     ShowDialog(owner);
     PseudoDispose();
 }

        public void EmptyFiltersListAlwaysPasses()
        {
            var filters = new XunitFilters();
            var method = new TestMethod("method1", "Display Name 1", traits: null);

            bool result = filters.Filter(method);

            Assert.True(result);
        }