← Back to branch summary

~halega/+junk/sharpdevelop

« back to all changes in this revision

Viewing changes to src/AddIns/Analysis/UnitTesting/Test/Utils/Tests/MockNUnitTestFrameworkTestFixture.cs

  • Committer: sk
  • Date: 2011-09-10 05:17:57 UTC
  • Revision ID: halega@halega.com-20110910051757-qfouz1llya9m6boy
4.1.0.7915 Release Candidate 1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/AddIns/Analysis/UnitTesting/Test/Utils/Tests/MockNUnitTestFrameworkTestFixture.cs
 
1
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
 
2
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
3
 
 
4
using System;
 
5
using System.Collections.Generic;
 
6
using ICSharpCode.UnitTesting;
 
7
using NUnit.Framework;
 
8
using UnitTesting.Tests.Utils;
 
9
 
 
10
namespace UnitTesting.Tests.Utils.Tests
 
11
{
 
12
        [TestFixture]
 
13
        public class MockNUnitTestFrameworkTestFixture
 
14
        {
 
15
                MockRunTestCommandContext context;
 
16
                MockProcessRunner processRunner;
 
17
                MockNUnitTestFramework testFramework;
 
18
                NUnitTestRunner testRunner;
 
19
                NUnitTestDebugger testDebugger;
 
20
                MockDebuggerService debuggerService;
 
21
                
 
22
                [SetUp]
 
23
                public void Init()
 
24
                {
 
25
                        context = new MockRunTestCommandContext();
 
26
                        processRunner = new MockProcessRunner();
 
27
                        debuggerService = new MockDebuggerService();
 
28
                        
 
29
                        testFramework = new MockNUnitTestFramework(debuggerService,
 
30
                                processRunner,
 
31
                                context.MockTestResultsMonitor,
 
32
                                context.UnitTestingOptions,
 
33
                                context.MessageService);
 
34
                        
 
35
                        testRunner = testFramework.CreateTestRunner() as NUnitTestRunner;
 
36
                        testDebugger = testFramework.CreateTestDebugger() as NUnitTestDebugger;
 
37
                }
 
38
                
 
39
                [Test]
 
40
                public void CreateTestRunnerCreatesNUnitTestRunner()
 
41
                {
 
42
                        Assert.IsNotNull(testRunner);
 
43
                }
 
44
                
 
45
                [Test]
 
46
                public void NUnitTestRunnerAddedToTestRunnersCreatedList()
 
47
                {
 
48
                        List<NUnitTestRunner> expectedRunners = new List<NUnitTestRunner>();
 
49
                        expectedRunners.Add(testRunner);
 
50
                        
 
51
                        Assert.AreEqual(expectedRunners.ToArray(), testFramework.NUnitTestRunnersCreated.ToArray());
 
52
                }
 
53
                
 
54
                [Test]
 
55
                public void NUnitTestRunnerCreatedWithMockProcessRunnerAndUnitTestingOptions()
 
56
                {
 
57
                        MockCSharpProject project = new MockCSharpProject();
 
58
                        SelectedTests tests = new SelectedTests(project);
 
59
                        testRunner.Start(tests);
 
60
                        
 
61
                        NUnitConsoleApplication app = new NUnitConsoleApplication(tests, context.UnitTestingOptions);
 
62
                        string expectedArguments = app.GetArguments();
 
63
                        Assert.AreEqual(expectedArguments, processRunner.CommandArgumentsPassedToStartMethod);
 
64
                }
 
65
                
 
66
                [Test]
 
67
                public void NUnitTestRunnerCreatedWithMockTestResultsMonitor()
 
68
                {
 
69
                        MockCSharpProject project = new MockCSharpProject();
 
70
                        SelectedTests tests = new SelectedTests(project);
 
71
                        testRunner.Start(tests);
 
72
                        
 
73
                        Assert.IsTrue(context.MockTestResultsMonitor.IsStartMethodCalled);
 
74
                }
 
75
                
 
76
                [Test]
 
77
                public void NUnitTestDebuggerCreated()
 
78
                {
 
79
                        Assert.IsNotNull(testDebugger);
 
80
                }
 
81
                
 
82
                [Test]
 
83
                public void NUnitTestDebuggerAddedToTestDebuggersCreatedList()
 
84
                {
 
85
                        List<NUnitTestDebugger> expectedDebuggers = new List<NUnitTestDebugger>();
 
86
                        expectedDebuggers.Add(testDebugger);
 
87
                        
 
88
                        Assert.AreEqual(expectedDebuggers.ToArray(), testFramework.NUnitTestDebuggersCreated.ToArray());
 
89
                }
 
90
                
 
91
                [Test]
 
92
                public void NUnitTestDebuggerCreatedWithMockTestResultsMonitor()
 
93
                {
 
94
                        MockCSharpProject project = new MockCSharpProject();
 
95
                        SelectedTests tests = new SelectedTests(project);
 
96
                        testDebugger.Start(tests);
 
97
                        
 
98
                        Assert.IsTrue(context.MockTestResultsMonitor.IsStartMethodCalled);
 
99
                }
 
100
                
 
101
                [Test]
 
102
                public void NUnitTestDebuggerCreatedWithDebuggerService()
 
103
                {
 
104
                        context.UnitTestingOptions.NoShadow = true;
 
105
                        
 
106
                        MockCSharpProject project = new MockCSharpProject();
 
107
                        SelectedTests tests = new SelectedTests(project);
 
108
                        testDebugger.Start(tests);
 
109
                        
 
110
                        NUnitConsoleApplication app = new NUnitConsoleApplication(tests, context.UnitTestingOptions);
 
111
                        string expectedArguments = app.GetArguments();
 
112
                        Assert.AreEqual(expectedArguments, debuggerService.MockDebugger.ProcessStartInfo.Arguments);
 
113
                }
 
114
                
 
115
                [Test]
 
116
                public void NUnitTestDebuggerCreatedWithMessageService()
 
117
                {
 
118
                        context.MockMessageService.AskQuestionReturnValue = true;
 
119
                        debuggerService.IsDebuggerLoaded = true;
 
120
                        debuggerService.MockDebugger.IsDebugging = true;
 
121
                        
 
122
                        MockCSharpProject project = new MockCSharpProject();
 
123
                        SelectedTests tests = new SelectedTests(project);
 
124
                        testDebugger.Start(tests);
 
125
                        
 
126
                        Assert.IsNotNull(context.MockMessageService.QuestionPassedToAskQuestion);
 
127
                }
 
128
                
 
129
                [Test]
 
130
                public void IsBuildNeededBeforeTestRunReturnsTrue()
 
131
                {
 
132
                        Assert.IsTrue(testFramework.IsBuildNeededBeforeTestRun);
 
133
                }
 
134
        }
 
135
}