← Back to branch summary

~halega/+junk/sharpdevelop

« back to all changes in this revision

Viewing changes to src/AddIns/Analysis/UnitTesting/Test/Project/TestProjectWithOneClassTestFixture.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/Project/TestProjectWithOneClassTestFixture.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.SharpDevelop.Dom;
 
7
using ICSharpCode.SharpDevelop.Project;
 
8
using ICSharpCode.UnitTesting;
 
9
using NUnit.Framework;
 
10
using UnitTesting.Tests.Utils;
 
11
 
 
12
namespace UnitTesting.Tests.Project
 
13
{
 
14
        /// <summary>
 
15
        /// Creates a TestProject that has one test class.
 
16
        /// </summary>
 
17
        [TestFixture]
 
18
        public class TestProjectWithOneClassTestFixture
 
19
        {
 
20
                TestProject testProject;
 
21
                TestClass testClass;
 
22
                MSBuildBasedProject project;
 
23
                bool resultChangedCalled;
 
24
                MockProjectContent projectContent;
 
25
                List<TestClass> classesAdded;
 
26
                List<TestClass> classesRemoved;
 
27
                MockTestFrameworksWithNUnitFrameworkSupport testFrameworks;
 
28
                
 
29
                [SetUp]
 
30
                public void Init()
 
31
                {
 
32
                        resultChangedCalled = false;
 
33
                        classesAdded = new List<TestClass>();
 
34
                        classesRemoved = new List<TestClass>();
 
35
                        
 
36
                        // Create a project.
 
37
                        project = new MockCSharpProject();
 
38
                        project.Name = "TestProject";
 
39
                        ReferenceProjectItem nunitFrameworkReferenceItem = new ReferenceProjectItem(project);
 
40
                        nunitFrameworkReferenceItem.Include = "NUnit.Framework";
 
41
                        ProjectService.AddProjectItem(project, nunitFrameworkReferenceItem);
 
42
                        
 
43
                        // Add a test class with a TestFixture attributes.
 
44
                        projectContent = new MockProjectContent();
 
45
                        projectContent.Language = LanguageProperties.None;
 
46
                        MockClass c = new MockClass(projectContent, "RootNamespace.MyTestFixture");
 
47
                        c.SetCompoundClass(c);
 
48
                        c.Attributes.Add(new MockAttribute("TestFixture"));
 
49
                        projectContent.Classes.Add(c);
 
50
                        
 
51
                        // Add a second class that has no test fixture attribute.
 
52
                        MockClass nonTestClass = new MockClass(projectContent);
 
53
                        projectContent.Classes.Add(nonTestClass);
 
54
                        
 
55
                        testFrameworks = new MockTestFrameworksWithNUnitFrameworkSupport();
 
56
                        testProject = new TestProject(project, projectContent, testFrameworks);
 
57
                        testProject.TestClasses.TestClassAdded += TestClassAdded;
 
58
                        testProject.TestClasses.TestClassRemoved += TestClassRemoved;
 
59
                        
 
60
                        testClass = testProject.TestClasses[0];
 
61
                }
 
62
                
 
63
                [Test]
 
64
                public void OneTestClass()
 
65
                {
 
66
                        Assert.AreEqual(1, testProject.TestClasses.Count);
 
67
                }
 
68
                
 
69
                [Test]
 
70
                public void TestProjectName()
 
71
                {
 
72
                        Assert.AreEqual("TestProject", testProject.Name);
 
73
                }
 
74
                
 
75
                [Test]
 
76
                public void TestClassName()
 
77
                {
 
78
                        Assert.AreEqual("MyTestFixture", testClass.Name);
 
79
                }
 
80
                
 
81
                [Test]
 
82
                public void TestClassQualifiedName()
 
83
                {
 
84
                        Assert.AreEqual("RootNamespace.MyTestFixture", testClass.QualifiedName);
 
85
                }
 
86
                
 
87
                [Test]
 
88
                public void OneRootNamespace()
 
89
                {
 
90
                        Assert.AreEqual(1, testProject.RootNamespaces.Count);
 
91
                }
 
92
                
 
93
                [Test]
 
94
                public void ProjectProperty()
 
95
                {
 
96
                        Assert.AreSame(project, testProject.Project);
 
97
                }
 
98
                
 
99
                [Test]
 
100
                public void FindTestClass()
 
101
                {
 
102
                        Assert.AreSame(testClass, testProject.TestClasses["RootNamespace.MyTestFixture"]);
 
103
                }
 
104
                
 
105
                [Test]
 
106
                public void NoMatchingTestClass()
 
107
                {
 
108
                        Assert.IsFalse(testProject.TestClasses.Contains("NoSuchClass.MyTestFixture"));
 
109
                }
 
110
                
 
111
                [Test]
 
112
                public void TestClassResultChanged()
 
113
                {
 
114
                        try {
 
115
                                testClass.ResultChanged += ResultChanged;
 
116
                                testClass.Result = TestResultType.Success;
 
117
                        } finally {
 
118
                                testClass.ResultChanged -= ResultChanged;
 
119
                        }
 
120
                        
 
121
                        Assert.IsTrue(resultChangedCalled);
 
122
                }
 
123
                
 
124
                /// <summary>
 
125
                /// Tests that a new class is added to the TestProject
 
126
                /// from the parse info.
 
127
                /// </summary>
 
128
                [Test]
 
129
                public void NewClassInParserInfo()
 
130
                {
 
131
                        // Create old compilation unit.
 
132
                        DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);
 
133
                        MockClass mockClass = (MockClass)testClass.Class;
 
134
                        mockClass.SetCompoundClass(mockClass);
 
135
                        oldUnit.Classes.Add(testClass.Class);
 
136
                        
 
137
                        // Create new compilation unit with extra class.
 
138
                        DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
 
139
                        newUnit.Classes.Add(testClass.Class);
 
140
                        MockClass newClass = new MockClass(projectContent, "RootNamespace.MyNewTestFixture");
 
141
                        newClass.Attributes.Add(new MockAttribute("TestFixture"));
 
142
                        newClass.SetCompoundClass(newClass);
 
143
                        newUnit.Classes.Add(newClass);
 
144
                        
 
145
                        // Update TestProject's parse info.
 
146
                        testProject.UpdateParseInfo(oldUnit, newUnit);
 
147
                        
 
148
                        Assert.IsTrue(testProject.TestClasses.Contains("RootNamespace.MyNewTestFixture"));
 
149
                        Assert.AreEqual(1, classesAdded.Count);
 
150
                        Assert.AreSame(newClass, classesAdded[0].Class);
 
151
                }
 
152
                
 
153
                /// <summary>
 
154
                /// Tests that the TestProject.UpdateParseInfo handles the
 
155
                /// case when the old compilation unit does not have a
 
156
                /// test class, the new compilation unit does have the
 
157
                /// test class, but the test class has already been
 
158
                /// added to our TestProject.
 
159
                /// </summary>
 
160
                [Test]
 
161
                public void TestClassInNewCompilationUnitOnly()
 
162
                {
 
163
                        // Create old compilation unit.
 
164
                        projectContent.Classes.Clear();
 
165
                        DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);
 
166
                        
 
167
                        // Create new compilation unit with class that 
 
168
                        // already exists in the project.
 
169
                        DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
 
170
                        newUnit.Classes.Add(testClass.Class);
 
171
                        MockClass c = new MockClass(projectContent, "RootNamespace.MyTestFixture");
 
172
                        c.Attributes.Add(new MockAttribute("TestFixture"));
 
173
                        c.SetCompoundClass(c);
 
174
                        newUnit.Classes.Add(c);
 
175
                        
 
176
                        // Update TestProject's parse info.
 
177
                        testProject.UpdateParseInfo(oldUnit, newUnit);
 
178
                        
 
179
                        Assert.IsTrue(testProject.TestClasses.Contains("RootNamespace.MyTestFixture"));
 
180
                        Assert.AreEqual(0, classesAdded.Count);
 
181
                }
 
182
                
 
183
                /// <summary>
 
184
                /// New class without a test fixture attribute should not
 
185
                /// be added to the list of test classes.
 
186
                /// </summary>
 
187
                [Test]
 
188
                public void NewClassInParserInfoWithoutTestFixtureAttribute()
 
189
                {
 
190
                        // Create old compilation unit.
 
191
                        DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);
 
192
                        MockClass mockClass = (MockClass)testClass.Class;
 
193
                        mockClass.SetCompoundClass(mockClass);
 
194
                        oldUnit.Classes.Add(testClass.Class);
 
195
                        
 
196
                        // Create new compilation unit with extra class.
 
197
                        DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
 
198
                        newUnit.Classes.Add(testClass.Class);
 
199
                        MockClass newClass = new MockClass(projectContent, "RootNamespace.MyNewTestFixture");
 
200
                        newClass.SetCompoundClass(newClass);
 
201
                        newUnit.Classes.Add(newClass);
 
202
                        
 
203
                        // Update TestProject's parse info.
 
204
                        testProject.UpdateParseInfo(oldUnit, newUnit);
 
205
                        
 
206
                        Assert.IsFalse(testProject.TestClasses.Contains("RootNamespace.MyNewTestFixture"));
 
207
                }
 
208
                
 
209
                [Test]
 
210
                public void TestClassRemovedInParserInfo()
 
211
                {
 
212
                        // Create old compilation unit.
 
213
                        projectContent.Classes.Clear();
 
214
                        DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);
 
215
                        MockClass mockClass = (MockClass)testClass.Class;
 
216
                        mockClass.SetCompoundClass(mockClass);
 
217
                        oldUnit.Classes.Add(testClass.Class);
 
218
                        
 
219
                        // Create new compilation unit with the original test class
 
220
                        // removed.
 
221
                        DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
 
222
                        
 
223
                        // Update TestProject's parse info.
 
224
                        testProject.UpdateParseInfo(oldUnit, newUnit);
 
225
                        
 
226
                        Assert.AreEqual(0, testProject.TestClasses.Count);
 
227
                        Assert.AreEqual(1, classesRemoved.Count);
 
228
                        Assert.AreSame(testClass, classesRemoved[0]);
 
229
                }
 
230
                
 
231
                [Test]
 
232
                public void NewCompilationUnitNull()
 
233
                {
 
234
                        // Create old compilation unit.
 
235
                        projectContent.Classes.Clear();
 
236
                        DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);
 
237
                        MockClass mockClass = (MockClass)testClass.Class;
 
238
                        mockClass.SetCompoundClass(mockClass);
 
239
                        oldUnit.Classes.Add(testClass.Class);
 
240
                        
 
241
                        // Update TestProject's parse info.
 
242
                        testProject.UpdateParseInfo(oldUnit, null);
 
243
                        
 
244
                        Assert.AreEqual(0, testProject.TestClasses.Count);
 
245
                        Assert.AreEqual(1, classesRemoved.Count);
 
246
                        Assert.AreSame(testClass, classesRemoved[0]);
 
247
                }
 
248
                
 
249
                /// <summary>
 
250
                /// Tests that a new method is added to the TestClass
 
251
                /// from the parse info. Also checks that the test method is 
 
252
                /// taken from the CompoundClass via IClass.GetCompoundClass. 
 
253
                /// A CompoundClass combines partial classes into one class so
 
254
                /// we do not get any duplicate classes with the same name.
 
255
                /// </summary>
 
256
                [Test]
 
257
                public void NewMethodInParserInfo()
 
258
                {
 
259
                        // Create old compilation unit.
 
260
                        DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);
 
261
                        oldUnit.Classes.Add(testClass.Class);
 
262
                        
 
263
                        // Create new compilation unit.
 
264
                        DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
 
265
                        newUnit.Classes.Add(testClass.Class);
 
266
                        
 
267
                        // Add a new method to a new compound class.
 
268
                        MockClass compoundClass = new MockClass(projectContent, "RootNamespace.MyTestFixture");
 
269
                        compoundClass.Attributes.Add(new MockAttribute("TestFixture"));
 
270
                        MockMethod method = new MockMethod(testClass.Class, "NewMethod");
 
271
                        method.Attributes.Add(new MockAttribute("Test"));
 
272
                        compoundClass.Methods.Add(method);
 
273
                        MockClass mockClass = (MockClass)testClass.Class;
 
274
                        mockClass.SetCompoundClass(compoundClass);
 
275
                        
 
276
                        // Monitor test methods added.
 
277
                        List<TestMethod> methodsAdded = new List<TestMethod>();
 
278
                        testClass.TestMethods.TestMethodAdded += delegate(Object source, TestMethodEventArgs e)
 
279
                                { methodsAdded.Add(e.TestMethod); };
 
280
 
 
281
                        // Update TestProject's parse info.
 
282
                        testProject.UpdateParseInfo(oldUnit, newUnit);
 
283
        
 
284
                        Assert.IsTrue(testClass.TestMethods.Contains("NewMethod"));
 
285
                        Assert.AreEqual(1, methodsAdded.Count);
 
286
                        Assert.AreSame(method, methodsAdded[0].Method);
 
287
                }
 
288
                
 
289
                [Test]
 
290
                public void ParserInfoForDifferentProject()
 
291
                {
 
292
                        // Create old compilation unit.
 
293
                        MockProjectContent differentProjectContent = new MockProjectContent();
 
294
                        DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(differentProjectContent);
 
295
                        MockClass mockClass = (MockClass)testClass.Class;
 
296
                        mockClass.SetCompoundClass(mockClass);
 
297
                        oldUnit.Classes.Add(testClass.Class);
 
298
                        
 
299
                        // Create new compilation unit with the original test class
 
300
                        // removed.
 
301
                        DefaultCompilationUnit newUnit = new DefaultCompilationUnit(differentProjectContent);
 
302
                        
 
303
                        // Update TestProject's parse info.
 
304
                        testProject.UpdateParseInfo(oldUnit, newUnit);
 
305
                        
 
306
                        Assert.AreEqual(1, testProject.TestClasses.Count);
 
307
                        Assert.AreEqual(0, classesRemoved.Count);
 
308
                        Assert.AreEqual(0, classesAdded.Count);
 
309
                }
 
310
                
 
311
                [Test]
 
312
                public void ParserInfoForThisProjectOldCompilationUnitNull()
 
313
                {
 
314
                        DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
 
315
                        Assert.IsTrue(testProject.IsParseInfoForThisProject(null, newUnit));
 
316
                }
 
317
                
 
318
                [Test]
 
319
                public void ParserInfoForDifferentProjectOldCompilationUnitNull()
 
320
                {
 
321
                        MockProjectContent differentProjectContent = new MockProjectContent();
 
322
                        DefaultCompilationUnit newUnit = new DefaultCompilationUnit(differentProjectContent);
 
323
                        
 
324
                        Assert.IsFalse(testProject.IsParseInfoForThisProject(null, newUnit));
 
325
                }
 
326
                
 
327
                [Test]
 
328
                public void ParseInfoForThisProjectWhenBothCompilationUnitsNull()
 
329
                {
 
330
                        Assert.IsFalse(testProject.IsParseInfoForThisProject(null, null));
 
331
                }
 
332
                
 
333
                void ResultChanged(object source, EventArgs e)
 
334
                {
 
335
                        resultChangedCalled = true;
 
336
                }
 
337
                
 
338
                void TestClassAdded(object source, TestClassEventArgs e)
 
339
                {
 
340
                        classesAdded.Add(e.TestClass);
 
341
                }
 
342
                
 
343
                void TestClassRemoved(object source, TestClassEventArgs e)
 
344
                {
 
345
                        classesRemoved.Add(e.TestClass);
 
346
                }
 
347
        }
 
348
}