diff --git a/src/AddIns/Misc/UnitTesting/Src/RemovedClasses.cs b/src/AddIns/Misc/UnitTesting/Src/RemovedClasses.cs new file mode 100644 index 0000000000..6a93a6d086 --- /dev/null +++ b/src/AddIns/Misc/UnitTesting/Src/RemovedClasses.cs @@ -0,0 +1,56 @@ +// +// +// +// +// $Revision$ +// + +using System; +using System.Collections.Generic; +using ICSharpCode.SharpDevelop.Dom; + +namespace ICSharpCode.UnitTesting +{ + /// + /// Used to determine which classes have been removed by the user in the project. + /// + public class RemovedClasses + { + Dictionary classDictionary = new Dictionary(); + + public RemovedClasses() + { + } + + public void Add(IList classes) + { + foreach (IClass c in classes) { + classDictionary[c.DotNetName] = c; + foreach (IClass innerClass in c.InnerClasses) { + classDictionary[innerClass.DotNetName] = innerClass; + } + } + } + + /// + /// + /// + /// + public void Remove(IClass c) + { + classDictionary.Remove(c.DotNetName); + foreach (IClass innerClass in c.InnerClasses) { + classDictionary.Remove(innerClass.DotNetName); + } + } + + public IList GetMissingClasses() + { + List missingClasses = new List(); + foreach (IClass c in classDictionary.Values) { + missingClasses.Add(c); + } + return missingClasses; + } + } +} diff --git a/src/AddIns/Misc/UnitTesting/Src/TestClass.cs b/src/AddIns/Misc/UnitTesting/Src/TestClass.cs index 7b77cda9c6..4bff9a706a 100644 --- a/src/AddIns/Misc/UnitTesting/Src/TestClass.cs +++ b/src/AddIns/Misc/UnitTesting/Src/TestClass.cs @@ -37,9 +37,7 @@ namespace ICSharpCode.UnitTesting /// Gets the underlying IClass for this test class. /// public IClass Class { - get { - return c; - } + get { return c; } } /// @@ -132,7 +130,10 @@ namespace ICSharpCode.UnitTesting /// Gets the name of the class. /// public string Name { - get { + get { + if (c.DeclaringType != null) { + return String.Concat(c.DeclaringType.Name, "+", c.Name); + } return c.Name; } } @@ -141,16 +142,17 @@ namespace ICSharpCode.UnitTesting /// Gets the fully qualified name of the class. /// public string QualifiedName { - get { - return c.FullyQualifiedName; - } + get { return c.DotNetName; } } /// /// Gets the namespace of this class. /// public string Namespace { - get { + get { + if (c.DeclaringType != null) { + return c.DeclaringType.Namespace; + } return c.Namespace; } } @@ -159,18 +161,14 @@ namespace ICSharpCode.UnitTesting /// Gets the root namespace for this class. /// public string RootNamespace { - get { - return GetRootNamespace(c.Namespace); - } + get { return GetRootNamespace(c.Namespace); } } /// /// Gets the test result for this class. /// public TestResultType Result { - get { - return testResultType; - } + get { return testResultType; } set { TestResultType previousTestResultType = testResultType; testResultType = value; diff --git a/src/AddIns/Misc/UnitTesting/Src/TestClassCollection.cs b/src/AddIns/Misc/UnitTesting/Src/TestClassCollection.cs index 464e131b88..504c09a324 100644 --- a/src/AddIns/Misc/UnitTesting/Src/TestClassCollection.cs +++ b/src/AddIns/Misc/UnitTesting/Src/TestClassCollection.cs @@ -100,7 +100,7 @@ namespace ICSharpCode.UnitTesting protected override string GetKeyForItem(TestClass item) { - return item.Class.FullyQualifiedName; + return item.QualifiedName; } protected override void InsertItem(int index, TestClass item) diff --git a/src/AddIns/Misc/UnitTesting/Src/TestProject.cs b/src/AddIns/Misc/UnitTesting/Src/TestProject.cs index c8eb3427c4..54d85fb763 100644 --- a/src/AddIns/Misc/UnitTesting/Src/TestProject.cs +++ b/src/AddIns/Misc/UnitTesting/Src/TestProject.cs @@ -34,9 +34,7 @@ namespace ICSharpCode.UnitTesting /// Returns the underlying project. /// public IProject Project { - get { - return project; - } + get { return project; } } /// @@ -114,9 +112,7 @@ namespace ICSharpCode.UnitTesting /// Gets the project's name. /// public string Name { - get { - return project.Name; - } + get { return project.Name; } } /// @@ -152,8 +148,7 @@ namespace ICSharpCode.UnitTesting } /// - /// Updates the classes and methods based on the new parse - /// information. + /// Updates the classes and methods based on the new parse information. /// /// The old compiliation unit /// (ParseInformationEventArgs.ParseInformation.BestCompilationUnit as ICompilationUnit) @@ -165,28 +160,25 @@ namespace ICSharpCode.UnitTesting return; } - Dictionary classDictionary = new Dictionary(); - Dictionary wasUpdatedDictionary = new Dictionary(); + RemovedClasses removedClasses = new RemovedClasses(); if (oldUnit != null) { - foreach (IClass c in oldUnit.Classes) { - classDictionary[c.FullyQualifiedName] = c; - wasUpdatedDictionary[c.FullyQualifiedName] = false; - } + removedClasses.Add(oldUnit.Classes); } if (newUnit != null) { foreach (IClass c in newUnit.Classes) { UpdateTestClass(c); - wasUpdatedDictionary[c.FullyQualifiedName] = true; + foreach (IClass innerClass in c.InnerClasses) { + UpdateTestClass(innerClass); + removedClasses.Remove(innerClass); + } + removedClasses.Remove(c); } } // Remove missing classes. - foreach (KeyValuePair entry in wasUpdatedDictionary) { - if (!entry.Value) { - IClass c = classDictionary[entry.Key]; - TestClasses.Remove(c.FullyQualifiedName); - } + foreach (IClass c in removedClasses.GetMissingClasses()) { + TestClasses.Remove(c.DotNetName); } } @@ -224,14 +216,14 @@ namespace ICSharpCode.UnitTesting /// void UpdateTestClass(IClass c) { - if (TestClasses.Contains(c.FullyQualifiedName)) { + if (TestClasses.Contains(c.DotNetName)) { if (TestClass.IsTestClass(c)) { - TestClass testClass = TestClasses[c.FullyQualifiedName]; + TestClass testClass = TestClasses[c.DotNetName]; testClass.UpdateClass(c); } else { // TestFixture attribute has been removed so // remove the class from the set of TestClasses. - TestClasses.Remove(c.FullyQualifiedName); + TestClasses.Remove(c.DotNetName); } } else { // TestFixture attribute may have been recently added to @@ -239,7 +231,7 @@ namespace ICSharpCode.UnitTesting // check if the class is actually a test class since // AddNewTestClass does this anyway. AddNewTestClass(c); - } + } } void GetTestClasses() @@ -251,6 +243,13 @@ namespace ICSharpCode.UnitTesting testClasses.Add(new TestClass(c)); } } + foreach (IClass innerClass in c.InnerClasses) { + if (TestClass.IsTestClass(innerClass)) { + if (!testClasses.Contains(innerClass.DotNetName)) { + testClasses.Add(new TestClass(innerClass)); + } + } + } } } @@ -263,6 +262,6 @@ namespace ICSharpCode.UnitTesting rootNamespaces.Add(rootNamespace); } } - } + } } } diff --git a/src/AddIns/Misc/UnitTesting/Src/UnitTestApplicationStartHelper.cs b/src/AddIns/Misc/UnitTesting/Src/UnitTestApplicationStartHelper.cs index 65250b7a3e..5156e7a679 100644 --- a/src/AddIns/Misc/UnitTesting/Src/UnitTestApplicationStartHelper.cs +++ b/src/AddIns/Misc/UnitTesting/Src/UnitTestApplicationStartHelper.cs @@ -119,7 +119,7 @@ namespace ICSharpCode.UnitTesting NamespaceFilter = namespaceFilter; } if (fixture != null) { - Fixture = fixture.FullyQualifiedName; + Fixture = fixture.DotNetName; if (test != null) { Test = test.Name; } diff --git a/src/AddIns/Misc/UnitTesting/Test/Project/InnerClassMethodRenamedTestFixture.cs b/src/AddIns/Misc/UnitTesting/Test/Project/InnerClassMethodRenamedTestFixture.cs new file mode 100644 index 0000000000..92a772e053 --- /dev/null +++ b/src/AddIns/Misc/UnitTesting/Test/Project/InnerClassMethodRenamedTestFixture.cs @@ -0,0 +1,73 @@ +// +// +// +// +// $Revision$ +// + +using System; +using ICSharpCode.SharpDevelop.Dom; +using ICSharpCode.UnitTesting; +using NUnit.Framework; +using UnitTesting.Tests.Utils; + +namespace UnitTesting.Tests.Project +{ + /// + /// Tests what happens when a test method is renamed inside an inner class. + /// + [TestFixture] + public class InnerClassMethodRemovedTestFixture : InnerClassTestFixtureBase + { + TestClass innerTestClass; + + [SetUp] + public void Init() + { + base.InitBase(); + + DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent); + oldUnit.Classes.Add(outerClass); + + // Create new compilation unit with inner class that has its method renamed. + DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent); + MockClass newOuterClass = new MockClass("MyTests.A"); + newOuterClass.ProjectContent = projectContent; + projectContent.Classes.Add(newOuterClass); + newOuterClass.SetCompoundClass(newOuterClass); + newUnit.Classes.Add(newOuterClass); + + // Create the inner test class. + MockClass newInnerClass = new MockClass("MyTests.A.InnerATest", "MyTests.A+InnerATest"); + newInnerClass.Attributes.Add(new MockAttribute("TestFixture")); + newInnerClass.ProjectContent = projectContent; + newInnerClass.DeclaringType = outerClass; // Declaring type is outer class. + newInnerClass.SetCompoundClass(newInnerClass); + newOuterClass.InnerClasses.Add(newInnerClass); + + MockMethod method = new MockMethod("FooBarRenamed"); + method.Attributes.Add(new MockAttribute("Test")); + method.DeclaringType = newInnerClass; + newInnerClass.Methods.Add(method); + outerClass.InnerClasses.Add(newInnerClass); + + // Update TestProject's parse info. + testProject.UpdateParseInfo(oldUnit, newUnit); + + innerTestClass = testProject.TestClasses["MyTests.A+InnerATest"]; + } + + [Test] + public void NewTestMethodExists() + { + TestMethod method = innerTestClass.TestMethods[0]; + Assert.AreEqual("FooBarRenamed", method.Name); + } + + [Test] + public void OldTestMethodRemoved() + { + Assert.AreEqual(1, innerTestClass.TestMethods.Count); + } + } +} diff --git a/src/AddIns/Misc/UnitTesting/Test/Project/InnerClassNameChangesTestFixture.cs b/src/AddIns/Misc/UnitTesting/Test/Project/InnerClassNameChangesTestFixture.cs new file mode 100644 index 0000000000..fe25ec2d67 --- /dev/null +++ b/src/AddIns/Misc/UnitTesting/Test/Project/InnerClassNameChangesTestFixture.cs @@ -0,0 +1,69 @@ +// +// +// +// +// $Revision$ +// + +using System; +using ICSharpCode.SharpDevelop.Dom; +using ICSharpCode.SharpDevelop.Project; +using ICSharpCode.UnitTesting; +using NUnit.Framework; +using UnitTesting.Tests.Utils; + +namespace UnitTesting.Tests.Project +{ + /// + /// Tests that the TestProject is correctly updated after the inner class name changes. + /// + [TestFixture] + public class InnerClassNameChangesTestFixture : InnerClassTestFixtureBase + { + [SetUp] + public void Init() + { + base.InitBase(); + + DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent); + oldUnit.Classes.Add(outerClass); + + // Create new compilation unit with extra class. + DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent); + MockClass newOuterClass = new MockClass("MyTests.A"); + newOuterClass.ProjectContent = projectContent; + projectContent.Classes.Add(newOuterClass); + newOuterClass.SetCompoundClass(newOuterClass); + newUnit.Classes.Add(newOuterClass); + + // Create the inner test class. + // Note the use of the DotNetName "MyTests.A+InnerTest". + MockClass newInnerClass = new MockClass("MyTests.A.InnerATestMod", "MyTests.A+InnerATestMod"); + newInnerClass.Attributes.Add(new MockAttribute("TestFixture")); + newInnerClass.ProjectContent = projectContent; + newInnerClass.DeclaringType = outerClass; // Declaring type is outer class. + newOuterClass.InnerClasses.Add(newInnerClass); + + // Update TestProject's parse info. + testProject.UpdateParseInfo(oldUnit, newUnit); + } + + [Test] + public void NewInnerClassAdded() + { + Assert.IsTrue(testProject.TestClasses.Contains("MyTests.A+InnerATestMod")); + } + + [Test] + public void OldInnerClassRemoved() + { + Assert.IsFalse(testProject.TestClasses.Contains("MyTests.A+InnerATest")); + } + + [Test] + public void OneTestClassRemain() + { + Assert.AreEqual(1, testProject.TestClasses.Count); + } + } +} diff --git a/src/AddIns/Misc/UnitTesting/Test/Project/InnerClassTestFixture.cs b/src/AddIns/Misc/UnitTesting/Test/Project/InnerClassTestFixture.cs new file mode 100644 index 0000000000..dec18f4aa4 --- /dev/null +++ b/src/AddIns/Misc/UnitTesting/Test/Project/InnerClassTestFixture.cs @@ -0,0 +1,79 @@ +// +// +// +// +// $Revision$ +// + +using System; +using ICSharpCode.SharpDevelop.Dom; +using ICSharpCode.SharpDevelop.Project; +using ICSharpCode.UnitTesting; +using NUnit.Framework; +using UnitTesting.Tests.Utils; + +namespace UnitTesting.Tests.Project +{ + /// + /// Tests that a class with an inner test fixture is recognised, for example: + /// + /// public class A + /// { + /// [TestFixture] + /// public class InnerATest + /// { + /// [Test] + /// public void FooBar() + /// { + /// } + /// } + /// } + /// + /// In this case the FooBar test is identified via: "A+InnerATest.FooBar". + /// + [TestFixture] + public class InnerClassTestFixture : InnerClassTestFixtureBase + { + [SetUp] + public void Init() + { + base.InitBase(); + } + + [Test] + public void OneTestClassFound() + { + Assert.AreEqual(1, testProject.TestClasses.Count); + } + + [Test] + public void TestClassQualifiedName() + { + Assert.AreEqual("MyTests.A+InnerATest", testClass.QualifiedName); + } + + [Test] + public void TestClassName() + { + Assert.AreEqual("A+InnerATest", testClass.Name); + } + + [Test] + public void NoTestClassesForNamespaceMyTestsA() + { + Assert.AreEqual(0, testProject.GetTestClasses("MyTests.A").Length); + } + + [Test] + public void OneTestClassForNamespaceMyTests() + { + Assert.AreEqual(1, testProject.GetTestClasses("MyTests").Length); + } + + [Test] + public void NamespaceForInnerClassIsDeclaringTypesNamespace() + { + Assert.AreEqual("MyTests", testClass.Namespace); + } + } +} diff --git a/src/AddIns/Misc/UnitTesting/Test/Project/InnerClassTestFixtureAttributeRemovedTestFixture.cs b/src/AddIns/Misc/UnitTesting/Test/Project/InnerClassTestFixtureAttributeRemovedTestFixture.cs new file mode 100644 index 0000000000..fbb6d94d95 --- /dev/null +++ b/src/AddIns/Misc/UnitTesting/Test/Project/InnerClassTestFixtureAttributeRemovedTestFixture.cs @@ -0,0 +1,61 @@ +// +// +// +// +// $Revision$ +// + +using System; +using ICSharpCode.SharpDevelop.Dom; +using ICSharpCode.UnitTesting; +using NUnit.Framework; +using UnitTesting.Tests.Utils; + +namespace UnitTesting.Tests.Project +{ + /// + /// Tests that the inner test class is removed when its TestFixture attribute is removed. + /// + [TestFixture] + public class InnerClassTestFixtureAttributeRemovedTestFixture : InnerClassTestFixtureBase + { + [SetUp] + public void Init() + { + base.InitBase(); + + DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent); + oldUnit.Classes.Add(outerClass); + + // Create new compilation unit with inner class that no longer has the TestFixture attribute. + DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent); + MockClass newOuterClass = new MockClass("MyTests.A"); + newOuterClass.ProjectContent = projectContent; + projectContent.Classes.Add(newOuterClass); + newOuterClass.SetCompoundClass(newOuterClass); + newUnit.Classes.Add(newOuterClass); + + // Create the inner test class. + MockClass newInnerClass = new MockClass("MyTests.A.InnerATest", "MyTests.A+InnerATest"); + newInnerClass.ProjectContent = projectContent; + newInnerClass.DeclaringType = outerClass; // Declaring type is outer class. + newInnerClass.SetCompoundClass(newInnerClass); + newOuterClass.InnerClasses.Add(newInnerClass); + + // Update TestProject's parse info. + testProject.UpdateParseInfo(oldUnit, newUnit); + } + + [Test] + public void NoTestClasses() + { + Assert.AreEqual(0, testProject.TestClasses.Count); + } + + [Test] + public void InnerTestClassRemoved() + { + Assert.IsFalse(testProject.TestClasses.Contains("MyTests.A+InnerATest")); + } + } +} diff --git a/src/AddIns/Misc/UnitTesting/Test/Project/InnerClassTestFixtureBase.cs b/src/AddIns/Misc/UnitTesting/Test/Project/InnerClassTestFixtureBase.cs new file mode 100644 index 0000000000..ea82c73f54 --- /dev/null +++ b/src/AddIns/Misc/UnitTesting/Test/Project/InnerClassTestFixtureBase.cs @@ -0,0 +1,70 @@ +// +// +// +// +// $Revision$ +// + +using System; +using ICSharpCode.SharpDevelop.Dom; +using ICSharpCode.SharpDevelop.Project; +using ICSharpCode.UnitTesting; +using UnitTesting.Tests.Utils; + +namespace UnitTesting.Tests.Project +{ + /// + /// Base class for testing inner classes with TestFixture information. + /// + public class InnerClassTestFixtureBase + { + protected TestClass testClass; + protected MockClass innerClass; + protected TestProject testProject; + protected MockProjectContent projectContent; + protected MockClass outerClass; + + protected void InitBase() + { + projectContent = new MockProjectContent(); + projectContent.Language = LanguageProperties.None; + + // Create the base test class. + outerClass = new MockClass("MyTests.A"); + outerClass.ProjectContent = projectContent; + projectContent.Classes.Add(outerClass); + + // Create the inner test class. + // Note the use of the DotNetName "MyTests.A+InnerTest". + innerClass = new MockClass("MyTests.A.InnerATest", "MyTests.A+InnerATest"); + innerClass.Attributes.Add(new MockAttribute("TestFixture")); + innerClass.ProjectContent = projectContent; + innerClass.DeclaringType = outerClass; // Declaring type is outer class. + + MockMethod method = new MockMethod("FooBar"); + method.Attributes.Add(new MockAttribute("Test")); + method.DeclaringType = innerClass; + innerClass.Methods.Add(method); + outerClass.InnerClasses.Add(innerClass); + + // Add another inner class that is not a test class. + MockClass nonTestInnerClass = new MockClass("MyTests.A.InnerBClass"); + nonTestInnerClass.ProjectContent = projectContent; + nonTestInnerClass.DeclaringType = outerClass; // Declaring type is outer class. + outerClass.InnerClasses.Add(nonTestInnerClass); + + // Add another inner class with the same name as the InnerATest. + // This makes sure duplicate classes are not added. + MockClass duplicateInnerClass = new MockClass("MyTests.A.InnerATest", "MyTests.A+InnerATest"); + duplicateInnerClass.Attributes.Add(new MockAttribute("TestFixture")); + duplicateInnerClass.ProjectContent = projectContent; + duplicateInnerClass.DeclaringType = outerClass; // Declaring type is outer class. + outerClass.InnerClasses.Add(duplicateInnerClass); + + testProject = new TestProject(null, projectContent); + if (testProject.TestClasses.Count > 0) { + testClass = testProject.TestClasses[0]; + } + } + } +} diff --git a/src/AddIns/Misc/UnitTesting/Test/Project/RemovedClassesTestFixture.cs b/src/AddIns/Misc/UnitTesting/Test/Project/RemovedClassesTestFixture.cs new file mode 100644 index 0000000000..c616251244 --- /dev/null +++ b/src/AddIns/Misc/UnitTesting/Test/Project/RemovedClassesTestFixture.cs @@ -0,0 +1,111 @@ +// +// +// +// +// $Revision$ +// + +using System; +using System.Collections.Generic; +using System.Text; +using ICSharpCode.SharpDevelop.Dom; +using ICSharpCode.UnitTesting; +using NUnit.Framework; +using UnitTesting.Tests.Utils; + +namespace UnitTesting.Tests.Project +{ + [TestFixture] + public class RemovedClassesTestFixture + { + RemovedClasses removedClasses; + MockClass myClass; + MockClass anotherClass; + MockClass innerClass; + + [SetUp] + public void Init() + { + myClass = new MockClass("MyTests.MyClass"); + innerClass = new MockClass("MyTests.MyClass.InnerClass", "MyTests.MyClass+InnerClass"); + myClass.InnerClasses.Add(innerClass); + + anotherClass = new MockClass("MyTests.AnotherClass"); + + List classes = new List(); + classes.Add(myClass); + classes.Add(anotherClass); + + removedClasses = new RemovedClasses(); + removedClasses.Add(classes); + } + + [Test] + public void InnerClassesIncludedInMissingClasses() + { + List expectedClasses = new List(); + expectedClasses.Add(myClass); + expectedClasses.Add(innerClass); + expectedClasses.Add(anotherClass); + + AssertContains(expectedClasses, removedClasses.GetMissingClasses()); + } + + /// + /// Should remove inner class too. + /// + [Test] + public void RemoveMyClass() + { + removedClasses.Remove(myClass); + + List expectedClasses = new List(); + expectedClasses.Add(anotherClass); + + AssertContains(expectedClasses, removedClasses.GetMissingClasses()); + } + + [Test] + public void RemoveInnerClass() + { + removedClasses.Remove(innerClass); + + List expectedClasses = new List(); + expectedClasses.Add(myClass); + expectedClasses.Add(anotherClass); + + AssertContains(expectedClasses, removedClasses.GetMissingClasses()); + } + + [Test] + public void DotNetNameUsedWhenAddingClasses() + { + MockClass c = new MockClass("MyTests.MyClass.InnerClass", "MyTests.MyClass+InnerClass"); + List classes = new List(); + classes.Add(c); + + RemovedClasses removedClasses = new RemovedClasses(); + removedClasses.Add(classes); + removedClasses.Remove(c); + + Assert.AreEqual(0, removedClasses.GetMissingClasses().Count); + } + + void AssertContains(IList expectedClasses, IList actualClasses) + { + foreach (IClass c in expectedClasses) { + Assert.IsTrue(actualClasses.Contains(c), "Class missing: " + c.FullyQualifiedName + " Actual:\r\n" + GetClassNames(actualClasses)); + } + Assert.AreEqual(expectedClasses.Count, actualClasses.Count, "Actual:\r\n" + GetClassNames(actualClasses)); + } + + string GetClassNames(IList classes) + { + StringBuilder names = new StringBuilder(); + foreach (IClass c in classes) { + names.AppendLine(c.FullyQualifiedName); + } + return names.ToString(); + } + } +} diff --git a/src/AddIns/Misc/UnitTesting/Test/UnitTestCommandLineTests.cs b/src/AddIns/Misc/UnitTesting/Test/UnitTestCommandLineTests.cs index 406ae603af..a371b60fb7 100644 --- a/src/AddIns/Misc/UnitTesting/Test/UnitTestCommandLineTests.cs +++ b/src/AddIns/Misc/UnitTesting/Test/UnitTestCommandLineTests.cs @@ -209,6 +209,18 @@ namespace UnitTesting.Tests { helper.Initialize(project, null, null); Assert.AreSame(project, helper.Project); + } + + [Test] + public void TestInnerClassSpecifiedInInitialize() + { + MockClass testFixture = new MockClass("MyTests.TestFixture.InnerTest", "MyTests.TestFixture+InnerTest"); + helper.Initialize(project, testFixture, null); + helper.NoLogo = false; + helper.ShadowCopy = true; + + string expectedCommandLine = "\"C:\\Projects\\MyTests\\MyTests.dll\" /run=\"MyTests.TestFixture+InnerTest\""; + Assert.AreEqual(expectedCommandLine, helper.GetArguments()); } } } diff --git a/src/AddIns/Misc/UnitTesting/Test/UnitTesting.Tests.csproj b/src/AddIns/Misc/UnitTesting/Test/UnitTesting.Tests.csproj index 4ad35683e7..eb555c53b2 100644 --- a/src/AddIns/Misc/UnitTesting/Test/UnitTesting.Tests.csproj +++ b/src/AddIns/Misc/UnitTesting/Test/UnitTesting.Tests.csproj @@ -62,6 +62,12 @@ + + + + + + diff --git a/src/AddIns/Misc/UnitTesting/Test/Utils/MockClass.cs b/src/AddIns/Misc/UnitTesting/Test/Utils/MockClass.cs index e3b5c6fe5a..a6c03d2b25 100644 --- a/src/AddIns/Misc/UnitTesting/Test/Utils/MockClass.cs +++ b/src/AddIns/Misc/UnitTesting/Test/Utils/MockClass.cs @@ -17,25 +17,36 @@ namespace UnitTesting.Tests.Utils DomRegion region = DomRegion.Empty; IList attributes = new List(); IList methods = new List(); + IList innerClasses = new List(); string fullyQualifiedName = String.Empty; string name = String.Empty; string ns = String.Empty; IClass compoundClass; IClass baseClass; + string dotNetName = String.Empty; + IClass declaringType; public MockClass() { } - public MockClass(string fullyQualifiedName) + public MockClass(string fullyQualifiedName) : this(fullyQualifiedName, fullyQualifiedName) + { + } + + public MockClass(string fullyQualifiedName, string dotNetName) { FullyQualifiedName = fullyQualifiedName; + this.dotNetName = dotNetName; + } + + public override string ToString() + { + return dotNetName; } public string FullyQualifiedName { - get { - return fullyQualifiedName; - } + get { return fullyQualifiedName; } set { fullyQualifiedName = value; int index = fullyQualifiedName.LastIndexOf('.'); @@ -49,74 +60,45 @@ namespace UnitTesting.Tests.Utils } public string Name { - get { - return name; - } - set { - name = value; - } + get { return name; } + set { name = value; } } public string Namespace { - get { - return ns; - } - set { - ns = value; - } + get { return ns; } + set { ns = value; } } public ClassType ClassType { - get { - return ClassType.Class; - } + get { return ClassType.Class; } } public IProjectContent ProjectContent { - get { - return projectContent; - } - set { - projectContent = value; - } + get { return projectContent; } + set { projectContent = value; } } public DomRegion Region { - get { - return region; - } - set { - region = value; - } + get { return region; } + set { region = value; } } public IList Methods { - get { - return methods; - } + get { return methods; } } public IClass BaseClass { - get { - return baseClass; - } - set { - baseClass = value; - } + get { return baseClass; } + set { baseClass = value; } } public ModifierEnum Modifiers { - get { - return ModifierEnum.None; - } - set { - } + get { return ModifierEnum.None; } + set { } } public IList Attributes { - get { - return attributes; - } + get { return attributes; } } public IClass GetCompoundClass() @@ -136,9 +118,7 @@ namespace UnitTesting.Tests.Utils } public string DotNetName { - get { - throw new NotImplementedException(); - } + get { return dotNetName; } } public ICompilationUnit CompilationUnit { @@ -160,9 +140,7 @@ namespace UnitTesting.Tests.Utils } public IList InnerClasses { - get { - throw new NotImplementedException(); - } + get { return innerClasses; } } public IList Fields { @@ -223,9 +201,8 @@ namespace UnitTesting.Tests.Utils } public IClass DeclaringType { - get { - throw new NotImplementedException(); - } + get { return declaringType; } + set { declaringType = value; } } public string Documentation { diff --git a/src/AddIns/Misc/UnitTesting/UnitTesting.csproj b/src/AddIns/Misc/UnitTesting/UnitTesting.csproj index 182deb1ead..de3907f52c 100644 --- a/src/AddIns/Misc/UnitTesting/UnitTesting.csproj +++ b/src/AddIns/Misc/UnitTesting/UnitTesting.csproj @@ -62,6 +62,7 @@ +