Test pad refresh when base test class is changed in the editor.

src/AddIns/Analysis/MachineSpecifications/MachineSpecifications.Tests/Src/MSpecTestFrameworkTests.cs

@@ -156,7 +156,7 @@ namespace ICSharpCode.MachineSpecifications.Tests
 		static IField otherField;
 		static IField behavesLikeField;
 
-		static IEnumerable<IMember> result;
+		static IEnumerable<TestMember> result;
 
 		const string BehaviorClassName = "Test.Behavior";
 
@@ -182,12 +182,12 @@ namespace ICSharpCode.MachineSpecifications.Tests
 		Because of = () => result = sut.GetTestMembersFor(testClass);
 
 		It should_contain_field_with_it_return_type = () =>
-			result.ShouldContain(testSpecification);
+			result.Select(m => m.Member).ShouldContain(testSpecification);
 
 		It should_not_contain_field_with_arbitrary_return_type = () =>
-			result.ShouldNotContain(otherField);
+			result.Select(m => m.Member).ShouldNotContain(otherField);
 
 		It should_contain_imported_field_from_behavior = () =>
-			result.ShouldContain(member => member.FullyQualifiedName == "TestClass.testSpecificationInBehavior");
+			result.Select(m => m.Member).ShouldContain(member => member.FullyQualifiedName == "TestClass.testSpecificationInBehavior");
 	}
 }

src/AddIns/Analysis/MachineSpecifications/MachineSpecifications/MachineSpecifications.csproj

@@ -58,6 +58,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Configuration\AssemblyInfo.cs" />
+    <Compile Include="src\BehaviorImportedTestMember.cs" />
     <Compile Include="src\ClassFilterBuilder.cs" />
     <Compile Include="src\MSpecApplication.cs" />
     <Compile Include="src\MSpecTestDebugger.cs" />

src/AddIns/Analysis/MachineSpecifications/MachineSpecifications/src/BehaviorImportedTestMember.cs

@@ -0,0 +1,25 @@
+/*
+ * Created by SharpDevelop.
+ * User: trecio
+ * Date: 2011-10-24
+ * Time: 23:11
+ * 
+ * To change this template use Tools | Options | Coding | Edit Standard Headers.
+ */
+using System;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.UnitTesting;
+
+namespace ICSharpCode.MachineSpecifications
+{
+	/// <summary>
+	/// Description of BehaviorImportedClass.
+	/// </summary>
+	public class BehaviorImportedTestMember : BaseTestMember
+	{
+		public BehaviorImportedTestMember(IClass testClass, IMember behaviorMember)
+			: base(testClass, behaviorMember, behaviorMember.Name)
+		{
+		}
+	}
+}

src/AddIns/Analysis/MachineSpecifications/MachineSpecifications/src/MSpecTestFramework.cs

@@ -30,20 +30,21 @@ namespace ICSharpCode.MachineSpecifications
 			return HasSpecificationMembers(c) && !HasBehaviorAttribute(c);
 		}
 		
-		public IEnumerable<IMember> GetTestMembersFor(IClass @class) {
+		public IEnumerable<TestMember> GetTestMembersFor(IClass @class) {
 			return GetTestMembers(@class, @class.Fields);
 		}
 
-		private IEnumerable<IMember> GetTestMembers(IClass testClass, IList<IField> fields)
+		private IEnumerable<TestMember> GetTestMembers(IClass testClass, IList<IField> fields)
 		{
-			var result = fields.Where(HasItReturnType).Cast<IMember>().ToList();
+			var result = fields.Where(HasItReturnType).Select(field => new TestMember(field)).ToList();
 			foreach (var field in fields)
 				if (HasBehavesLikeReturnType(field))
 				{
 					var behaviorFields = ResolveBehaviorFieldsOf(field);
-					var behaviorTestMembers = GetTestMembers(testClass, behaviorFields);
+					var behaviorMembers = GetTestMembers(testClass, behaviorFields);
-					var decoratedTestMembers = behaviorTestMembers.Select(f => new BaseTestMember(testClass, f)).Cast<IMember>();
+					var testMembersFromBehavior = behaviorMembers.Select(member => 
-					result.AddRange(decoratedTestMembers);
+						new TestMember(member.DeclaringType, new BehaviorImportedTestMember(testClass, member.Member)));
+					result.AddRange(testMembersFromBehavior);
 				}
 			return result;
 		}

src/AddIns/Analysis/UnitTesting/Src/BaseTestMember.cs

@@ -27,7 +27,12 @@ namespace ICSharpCode.UnitTesting
 		/// the class where the method is actually defined.</param>
 		/// <param name="method">The base class's test member.</param>
 		public BaseTestMember(IClass derivedClass, IMember member)
-			: base(derivedClass, member.Name)
+			: this(derivedClass, member, member.DeclaringType.Name + "." + member.Name)
+		{
+		}
+
+		protected BaseTestMember(IClass derivedClass, IMember member, string name)
+			: base(derivedClass, name)
 		{
 			this.member = member;
 			this.ReturnType = member.ReturnType;
@@ -57,7 +62,7 @@ namespace ICSharpCode.UnitTesting
 		}
 		
 		public override string Documentation {get;set;}
-		
+
 		public override IMember Clone()
 		{
 			return new BaseTestMember(DeclaringType, Member);

src/AddIns/Analysis/UnitTesting/Src/IRegisteredTestFrameworks.cs

@@ -18,7 +18,7 @@ namespace ICSharpCode.UnitTesting
 		bool IsTestClass(IClass c);
 		bool IsTestProject(IProject project);
 		
-		IEnumerable<IMember> GetTestMembersFor(IClass @class);
+		IEnumerable<TestMember> GetTestMembersFor(IClass @class);
 
 		bool IsBuildNeededBeforeTestRunForProject(IProject project);		
 	}

src/AddIns/Analysis/UnitTesting/Src/NUnitTestFramework.cs

@@ -86,8 +86,8 @@ namespace ICSharpCode.UnitTesting
 			return false;
 		}
 		
-		public IEnumerable<IMember> GetTestMembersFor(IClass @class) {
+		public IEnumerable<TestMember> GetTestMembersFor(IClass @class) {
-			return @class.Methods.Where(IsTestMethod);
+			return @class.Methods.Where(IsTestMethod).Select(member => new TestMember(member));
 		}
 		
 		static bool IsTestMethod(IMethod method)

src/AddIns/Analysis/UnitTesting/Src/RegisteredTestFrameworks.cs

@@ -39,11 +39,11 @@ namespace ICSharpCode.UnitTesting
 			return false;
 		}
 		
-		public IEnumerable<IMember> GetTestMembersFor(IClass @class) {
+		public IEnumerable<TestMember> GetTestMembersFor(IClass @class) {
 			ITestFramework testFramework = GetTestFramework(@class);
 			if (testFramework != null)
 				return testFramework.GetTestMembersFor(@class);
-			return new IMember[0];
+			return new TestMember[0];
 		}
 		
 		ITestFramework GetTestFramework(IMember member)

src/AddIns/Analysis/UnitTesting/Src/TestClass.cs

@@ -2,6 +2,7 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
+using System.Linq;
 using System.Collections.Generic;
 using ICSharpCode.Core;
 using ICSharpCode.SharpDevelop.Dom;
@@ -35,6 +36,11 @@ namespace ICSharpCode.UnitTesting
 		public IClass Class {
 			get { return c; }
 		}
+
+		/// <summary>
+		/// Gets the list of other (e.g. base types) classes where from which test members included in this test class come from.
+		/// </summary>
+		private readonly ICollection<string> baseClassesFQNames = new List<string>();
 		
 		/// <summary>
 		/// Gets the test classes that exist in the specified namespace.
@@ -282,18 +288,19 @@ namespace ICSharpCode.UnitTesting
 			TestMemberCollection testMembers = new TestMemberCollection();
 			foreach (var member in testFrameworks.GetTestMembersFor(c))
 				if (!testMembers.Contains(member.Name)) {
-					testMembers.Add(new TestMember(member));
+					testMembers.Add(member);
 				}
 			
 			// Add base class test members.
 			IClass declaringType = c;
-			while (c.BaseClass != null) {
+			while (c.BaseClass != null)
-				foreach (var method in testFrameworks.GetTestMembersFor(c.BaseClass)) {
+			{
-					BaseTestMember baseTestMethod = new BaseTestMember(declaringType, method);
+				foreach (var testMember in testFrameworks.GetTestMembersFor(c.BaseClass)) {
-					TestMember testMethod = new TestMember(c.BaseClass.Name, baseTestMethod);
+					BaseTestMember baseTestMethod = new BaseTestMember(declaringType, testMember.Member);
-					if (method.IsVirtual) {
+					TestMember testMethod = new TestMember(c, baseTestMethod);
-						if (!testMembers.Contains(method.Name)) {
+					if (testMember.Member.IsVirtual) {
-							testMembers.Add(testMethod);	
+						if (!testMembers.Contains(testMember.Name)) {
+							testMembers.Add(testMethod);
 						}
 					} else {
 						if (!testMembers.Contains(testMethod.Name)) {
@@ -303,6 +310,11 @@ namespace ICSharpCode.UnitTesting
 				}
 				c = c.BaseClass;
 			}
+
+			baseClassesFQNames.Clear();
+			foreach (var memberDeclaringClass in testMembers.Select(member => member.DeclaringType).Distinct())
+				if (memberDeclaringClass != declaringType)
+					baseClassesFQNames.Add(memberDeclaringClass.FullyQualifiedName);
 			return testMembers;
 		}
 		
@@ -361,5 +373,10 @@ namespace ICSharpCode.UnitTesting
 			}
 			return null;
 		}
+
+		public bool IsDerivedFrom(IClass c)
+		{
+			return baseClassesFQNames.Contains(c.FullyQualifiedName);
+		}
 	}
 }

src/AddIns/Analysis/UnitTesting/Src/TestFramework.cs

@@ -14,7 +14,7 @@ namespace ICSharpCode.UnitTesting
 		bool IsTestClass(IClass c);
 		bool IsTestProject(IProject project);
 		
-		IEnumerable<IMember> GetTestMembersFor(IClass @class);
+		IEnumerable<TestMember> GetTestMembersFor(IClass @class);
 		
 		ITestRunner CreateTestRunner();
 		ITestRunner CreateTestDebugger();

src/AddIns/Analysis/UnitTesting/Src/TestMember.cs

@@ -11,20 +11,24 @@ namespace ICSharpCode.UnitTesting
 	/// </summary>
 	public class TestMember
 	{
+#if unused
 		string prefix = String.Empty;
+#endif
 		IMember member;
 		TestResultType testResultType = TestResultType.None;
 		
 		/// <summary>
 		/// Raised when the test result has changed.
 		/// </summary>
-		public event EventHandler ResultChanged;
+		public event EventHandler ResultChanged;		
 		
 		public TestMember(IMember member)
 		{
 			this.member = member;
+			this.DeclaringType = member.DeclaringType;
 		}
 		
+#if unused
 		/// <summary>
 		/// Creates a new TestMember instance.
 		/// </summary>
@@ -46,6 +50,13 @@ namespace ICSharpCode.UnitTesting
 			this.member = member;
 			this.prefix = prefix;
 		}
+#endif
+
+		public TestMember(IClass testClass, IMember member)
+		{
+			this.DeclaringType = testClass;
+			this.member = member;
+		}
 		
 		/// <summary>
 		/// Gets the underlying IMember for this TestMember.
@@ -53,6 +64,12 @@ namespace ICSharpCode.UnitTesting
 		public IMember Member {
 			get { return member; }
 		}
+
+		/// <summary>
+		/// Gets the class where the test member is actually declared.
+		/// In case of test member from base class it will be the base class not the 
+		/// </summary>
+		public IClass DeclaringType { get; private set; }
 		
 		/// <summary>
 		/// Updates the test member based on new information 
@@ -82,9 +99,11 @@ namespace ICSharpCode.UnitTesting
 		/// </summary>
 		public string Name {
 			get {
+#if unused
 				if (prefix.Length > 0) {
 					return String.Concat(prefix, ".", member.Name);
 				}
+#endif
 				return member.Name;
 			}
 		}

src/AddIns/Analysis/UnitTesting/Src/TestProject.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using ICSharpCode.Core;
 using ICSharpCode.SharpDevelop.Dom;
 using ICSharpCode.SharpDevelop.Project;
@@ -188,21 +189,50 @@ namespace ICSharpCode.UnitTesting
 		/// </summary>
 		void UpdateTestClass(IClass c)
 		{
-			if (TestClasses.Contains(c.DotNetName)) {
+			if (TestClasses.Contains(c.DotNetName))
-				if (IsTestClass(c)) {
+			{
+				if (IsTestClass(c))
+				{
 					TestClass testClass = TestClasses[c.DotNetName];
 					testClass.UpdateClass(c);
-				} else {
+				}
+				else
+				{
 					// TestFixture attribute has been removed so
 					// remove the class from the set of TestClasses.
 					TestClasses.Remove(c.DotNetName);
 				}
-			} else {
+			}
-				// TestFixture attribute may have been recently added to
+			else
-				// this class so call AddNewTestClass. No need to
+			{
-				// check if the class is actually a test class since
+					// TestFixture attribute may have been recently added to
-				// AddNewTestClass does this anyway.
+					// this class so call AddNewTestClass. No need to
-				AddNewTestClass(c);
+					// check if the class is actually a test class since
+					// AddNewTestClass does this anyway.
+					AddNewTestClass(c);
+			}
+
+			var derivedTestClasses = GetTestClassesDerivedFrom(c);
+			if (derivedTestClasses.Any())
+				UpdateClassesFromProjectContent(derivedTestClasses);
+
+		}
+
+		private IEnumerable<IClass> GetTestClassesDerivedFrom(IClass c)
+		{
+			return TestClasses
+				.Where(testClass => testClass.IsDerivedFrom(c))
+				.Select(testClass => testClass.Class)
+				.ToArray();
+		}
+
+		private void UpdateClassesFromProjectContent(IEnumerable<IClass> classes)
+		{
+			foreach (var c in classes)
+			{
+				var classInProjectContent = projectContent.GetClass(c.FullyQualifiedName, c.TypeParameters.Count);
+				if (classInProjectContent != null)
+					UpdateTestClass(classInProjectContent);
 			}
 		}
 		

src/AddIns/Analysis/UnitTesting/Test/Project/BaseTestMethodTestFixture.cs

@@ -45,7 +45,7 @@ namespace UnitTesting.Tests.Project
 		[Test]
 		public void MethodName()
 		{
-			Assert.AreEqual("MyMethod", baseTestMethod.Name);
+			Assert.AreEqual("MyTestFixture.MyMethod", baseTestMethod.Name);
 		}
 		
 		[Test]

src/AddIns/Analysis/UnitTesting/Test/Project/DoubleNestedTestClassWithBaseType.cs

@@ -0,0 +1,74 @@
+/*
+ * Created by SharpDevelop.
+ * User: trecio
+ * Date: 2011-10-23
+ * Time: 16:15
+ * 
+ * To change this template use Tools | Options | Coding | Edit Standard Headers.
+ */
+using System;
+using System.Linq;
+using ICSharpCode.UnitTesting;
+using NUnit.Framework;
+using UnitTesting.Tests.Utils;
+
+namespace UnitTesting.Tests.Project
+{
+	/// <summary>
+	/// Tests that a class with base type nested inside test fixture is recognized, e.g.
+	/// 
+	/// public abstract class BaseClass {
+	/// 	[Test]
+	/// 	public void BaseFoo() {
+	/// 	}
+	/// }
+	/// 
+	/// [TestFixture]
+	/// public class A
+	/// {	
+	/// 	public class InnerATest
+	/// 	{
+	/// 		[Test]
+	/// 		public void FooBar()
+	/// 		{
+	/// 		}
+	/// 
+	/// 		public class InnerTestLevel2 : BaseClass {
+	/// 		}
+	/// 	}
+	/// }
+	/// </summary>
+	[TestFixture]
+	public class DoubleNestedTestClassWithBaseType : InnerClassTestFixtureBase
+	{
+		MockClass classNestedInInnerClass;
+		MockClass baseClass;
+		MockMethod testMethodInBaseClass;
+		
+		[SetUp]
+		public void SetUp() {
+			base.InitBase();
+			
+			baseClass = new MockClass(projectContent, "MyTests.BaseClass");
+			testMethodInBaseClass = new MockMethod(baseClass, "BaseFoo");
+			testMethodInBaseClass.Attributes.Add(new MockAttribute("Test"));
+			baseClass.Methods.Add(testMethodInBaseClass);
+
+			//Add TestFixture attribute to outer class
+			outerClass.Attributes.Add(new MockAttribute("TestFixture"));
+
+			//Add inner class nested in test class
+			classNestedInInnerClass = new MockClass(projectContent, "MyTests.A.InnerATest.InnerTestLevel2", "MyTests.A+InnerATest+InnerTestLevel2", innerClass);
+			innerClass.InnerClasses.Add(classNestedInInnerClass);
+			classNestedInInnerClass.AddBaseClass(baseClass);
+			
+			testProject = new TestProject(null, projectContent, testFrameworks);
+		}
+		
+		[Test]
+		public void DoubleNestedClassShouldHaveTestMemberImportedFromBaseClass() {
+			var nestedClass = testProject.TestClasses.Single(c => c.Class == classNestedInInnerClass);
+			Assert.AreEqual("BaseClass.BaseFoo", nestedClass.TestMembers.Single().Name);
+		}
+	}
+}

src/AddIns/Analysis/UnitTesting/Test/Project/DuplicateMethodNameTestFixture.cs

@@ -65,7 +65,7 @@ namespace UnitTesting.Tests.Project
 		[Test]
 		public void TestMethodName()
 		{
-			Assert.AreEqual("MyTest", testClass.TestMembers[0].Name);
+			Assert.AreEqual("MyTestFixtureBase.MyTest", testClass.TestMembers[0].Name);
 		}
 		
 		[Test]

src/AddIns/Analysis/UnitTesting/Test/Project/InnerClassInTestFixtureTests.cs

@@ -22,6 +22,9 @@ namespace UnitTesting.Tests.Project
 	/// 		public void FooBar()
 	/// 		{
 	/// 		}
+	/// 
+	/// 		public class InnerTestLevel2 {
+	/// 		}
 	/// 	}
 	/// }
 	///
@@ -69,28 +72,28 @@ namespace UnitTesting.Tests.Project
 			AssertTestResultContainsClass(classNestedInInnerClass);
 		}
 
-        [Test]
+		[Test]
-        public void TestClassNameShouldBeDotNetNameOfTheDoubleNestedClass()
+		public void TestClassNameShouldBeDotNetNameOfTheDoubleNestedClass()
-        {
+		{
-            Assert.AreEqual("A+InnerATest+InnerTestLevel2", TestClassRelatedTo(classNestedInInnerClass).Name);
+			Assert.AreEqual("A+InnerATest+InnerTestLevel2", TestClassRelatedTo(classNestedInInnerClass).Name);
-        }
+		}
 
-        [Test]
+		[Test]
-        public void TestClassNamespaceShouldBeValid()
+		public void TestClassNamespaceShouldBeValid()
-        {
+		{
-            Assert.AreEqual("MyTests", TestClassRelatedTo(classNestedInInnerClass).Namespace);
+			Assert.AreEqual("MyTests", TestClassRelatedTo(classNestedInInnerClass).Namespace);
-        }
+		}
 
 		void AssertTestResultContainsClass(IClass clazz)
 		{
-		    var testClazz = TestClassRelatedTo(clazz);
+			var testClazz = TestClassRelatedTo(clazz);
 			if (testClazz == null)
 				throw new AssertionException(string.Format("Test result should contain class {0}.", clazz.FullyQualifiedName));
 		}
 
-        TestClass TestClassRelatedTo(IClass clazz)
+		TestClass TestClassRelatedTo(IClass clazz)
-        {
+		{
-            return testProject.TestClasses.SingleOrDefault(c => c.Class == clazz);
+			return testProject.TestClasses.SingleOrDefault(c => c.Class == clazz);
-        }
+		}
 	}
 }

src/AddIns/Analysis/UnitTesting/Test/UnitTesting.Tests.csproj

@@ -81,6 +81,7 @@
     <Compile Include="Frameworks\UnitTestingOptionsTestFixture.cs" />
     <Compile Include="Project\AbstractBaseClassWithTestMethodsTestFixture.cs" />
     <Compile Include="Project\BaseTestMethodTestFixture.cs" />
+    <Compile Include="Project\DoubleNestedTestClassWithBaseType.cs" />
     <Compile Include="Project\InnerClassInTestFixtureTests.cs" />
     <Compile Include="Project\DuplicateClassNameChangedTestFixture.cs" />
     <Compile Include="Project\InnerClassMethodRenamedTestFixture.cs" />

src/AddIns/Analysis/UnitTesting/Test/Utils/MockNUnitTestFramework.cs

@@ -54,7 +54,7 @@ namespace UnitTesting.Tests.Utils
 			throw new NotImplementedException();
 		}
 		
-		public IEnumerable<IMember> GetTestMembersFor(IClass @class) {
+		public IEnumerable<TestMember> GetTestMembersFor(IClass @class) {
 			throw new NotImplementedException();
 		}
 		

src/AddIns/Analysis/UnitTesting/Test/Utils/MockTestFramework.cs

@@ -32,8 +32,8 @@ namespace UnitTesting.Tests.Utils
 			return testMembers.Contains(member);
 		}
 		
-		public IEnumerable<IMember> GetTestMembersFor(IClass @class) {
+		public IEnumerable<TestMember> GetTestMembersFor(IClass @class) {
-			return testMembers.Where(member => member.DeclaringType == @class);
+			return testMembers.Where(member => member.DeclaringType == @class).Select(member => new TestMember(member));
 		}
 		
 		public IMember IsTestMemberParameterUsed {

src/AddIns/BackendBindings/Python/PythonBinding/Project/Src/PythonTestFramework.cs

@@ -21,8 +21,8 @@ namespace ICSharpCode.PythonBinding
 			return false;
 		}
 		
-		public IEnumerable<IMember> GetTestMembersFor(IClass @class) {
+		public IEnumerable<TestMember> GetTestMembersFor(IClass @class) {
-			return @class.Methods.Where(IsTestMethod);
+			return @class.Methods.Where(IsTestMethod).Select(method => new TestMember(method));
 		}
 
 		static bool IsTestMethod(IMethod method) {

src/AddIns/BackendBindings/Ruby/RubyBinding/Project/Src/RubyTestFramework.cs

@@ -16,13 +16,13 @@ namespace ICSharpCode.RubyBinding
 		public bool IsTestMember(IMember member)
 		{
 			var method = member as IMethod;
-			if (method != null)				
+			if (method != null)
-				return IsTestMethod(method);			
+				return IsTestMethod(method);
 			return false;
 		}
 		
-		public IEnumerable<IMember> GetTestMembersFor(IClass @class) {
+		public IEnumerable<TestMember> GetTestMembersFor(IClass @class) {
-			return @class.Methods.Where(IsTestMethod);
+			return @class.Methods.Where(IsTestMethod).Select(method => new TestMember(method));
 		}
 
 		bool IsTestMethod(IMethod method)