Add code completion for events in IronPython.

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

@@ -194,7 +194,7 @@
     <Compile Include="Utils\Tests\MockAddInTreeTestFixture.cs" />
     <Compile Include="Utils\Tests\MockBuildOptionsTestFixture.cs" />
     <Compile Include="Utils\Tests\MockBuildProjectBeforeTestRunTestFixture.cs" />
-    <Compile Include="Utils\Tests\MockClassTestFixture.cs" />
+    <Compile Include="Utils\Tests\MockClassTests.cs" />
     <Compile Include="Utils\Tests\MockDebuggerServiceTestFixture.cs" />
     <Compile Include="Utils\Tests\MockFileServiceTestFixture.cs" />
     <Compile Include="Utils\Tests\MockMessageServiceTestFixture.cs" />

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

@@ -128,5 +128,25 @@ namespace UnitTesting.Tests.Utils
 			DefaultReturnType returnType = new DefaultReturnType(baseClass);
 			BaseTypes.Add(returnType);
 		}
+		
+		public DefaultProperty AddProperty(string name)
+		{
+			DefaultProperty property = new DefaultProperty(this, name);
+			Properties.Add(property);
+			return property;
+		}
+		
+		public void InsertPropertyAtStart(string name)
+		{
+			DefaultProperty property = new DefaultProperty(this, name);
+			Properties.Insert(0, property);
+		}
+		
+		public DefaultEvent AddEvent(string name)
+		{
+			DefaultEvent classEvent = new DefaultEvent(this, name);
+			Events.Add(classEvent);
+			return classEvent;
+		}
 	}
 }

src/AddIns/Analysis/UnitTesting/Test/Utils/Tests/MockClassTestFixture.cs

@@ -1,163 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using ICSharpCode.SharpDevelop.Dom;
-using ICSharpCode.SharpDevelop.Project;
-using NUnit.Framework;
-using UnitTesting.Tests.Utils;
-
-namespace UnitTesting.Tests.Utils.Tests
-{
-	[TestFixture]
-	public class MockClassTestFixture
-	{
-		MockClass outerClass;
-		MockClass innerClass;
-		
-		[Test]
-		public void ClassCreatedWithExpectedFullyQualifiedName()
-		{
-			string fullyQualifiedName = "MyNamespace.MyClass";
-			MockClass c = new MockClass(fullyQualifiedName);
-			Assert.AreEqual(fullyQualifiedName, c.FullyQualifiedName);
-		}
-		
-		[Test]
-		public void ClassCreatedWithFullyQualifiedNameHasMatchingDotNetName()
-		{
-			string fullyQualifiedName = "MyNamespace.MyClass";
-			MockClass c = new MockClass(fullyQualifiedName);
-			Assert.AreEqual(fullyQualifiedName, c.DotNetName);
-		}
-		
-		[Test]
-		public void ClassCreatedWithExpectedDotNetName()
-		{
-			string fullyQualifiedName = "MyNamespace.MyClass.InnerClass";
-			string dotNetName = "MyNamespace.MyClass+InnerClass";
-			MockClass c = new MockClass(fullyQualifiedName, dotNetName);
-			Assert.AreEqual(dotNetName, c.DotNetName);
-		}
-		
-		[Test]
-		public void ClassCreatedWithNamespaceTakenFromFullyQualifiedName()
-		{
-			string fullyQualifiedName = "MyNamespace.MySubNamespace.MyClass";
-			MockClass c = new MockClass(fullyQualifiedName);
-			string expectedNamespace = "MyNamespace.MySubNamespace";
-			Assert.AreEqual(expectedNamespace, c.Namespace);
-		}
-		
-		[Test]
-		public void ClassCreatedWithNameTakenFromFullyQualifiedName()
-		{
-			string fullyQualifiedName = "MyNamespace.MySubNamespace.MyClass";
-			MockClass c = new MockClass(fullyQualifiedName);
-			string expectedName = "MyClass";
-			Assert.AreEqual(expectedName, c.Name);
-		}
-		
-		[Test]
-		public void ClassCreatedWithNoNamespaceInFullyQualifiedNameHasNamespaceOfEmptyString()
-		{
-			string fullyQualifiedName = "MyClass";
-			MockClass c = new MockClass(fullyQualifiedName);
-			string expectedNamespace = String.Empty;
-			Assert.AreEqual(expectedNamespace, c.Namespace);
-		}
-		
-		[Test]
-		public void ClassHasCompilationUnit()
-		{
-			MockClass c = new MockClass();
-			Assert.IsNotNull(c.CompilationUnit);
-		}
-		
-		[Test]
-		public void ClassHasMockProjectContent()
-		{
-			MockClass c = new MockClass();
-			Assert.IsNotNull(c.ProjectContent as MockProjectContent);
-		}
-		
-		[Test]
-		public void CompoundClassIsClassItself()
-		{
-			MockClass c = new MockClass();
-			Assert.AreEqual(c, c.GetCompoundClass());
-		}
-		
-		[Test]
-		public void ClassDefaultReturnTypeGetUnderlyingClassMatchesOriginalMockClass()
-		{
-			MockClass c = new MockClass();
-			IReturnType returnType = c.DefaultReturnType;
-			Assert.AreEqual(c, returnType.GetUnderlyingClass());
-		}
-		
-		[Test]
-		public void ClassWithInnerClassHasDeclaringTypeAsOuterClass()
-		{
-			CreateClassWithInnerClass();
-			Assert.AreEqual(outerClass, innerClass.DeclaringType);
-		}
-		
-		void CreateClassWithInnerClass()
-		{
-			outerClass = new MockClass("MyTests.A");
-			innerClass = new MockClass("MyTests.A.InnerATest", "MyTests.A+InnerATest", outerClass);
-		}
-		
-		[Test]
-		public void InnerClassGetCompoundClassReturnsInnerClass()
-		{
-			CreateClassWithInnerClass();
-			Assert.AreEqual(innerClass, innerClass.GetCompoundClass());
-		}
-		
-		[Test]
-		public void InnerClassAddedToOuterClassInnerClassCollection()
-		{
-			CreateClassWithInnerClass();
-			Assert.AreEqual(innerClass, outerClass.InnerClasses[0]);
-		}
-		
-		[Test]
-		public void ClassAddedToBaseTypesBecomesBaseClass()
-		{
-			MockClass c = new MockClass();
-			MockClass baseClass = new MockClass();
-			DefaultReturnType returnType = new DefaultReturnType(baseClass);
-			c.BaseTypes.Add(returnType);
-			Assert.AreEqual(baseClass, c.BaseClass);
-		}
-		
-		[Test]
-		public void BaseClassPropertyReturnsClassAddedUsingAddBaseClassMethod()
-		{
-			MockClass c = new MockClass();
-			MockClass baseClass = new MockClass();
-			c.AddBaseClass(baseClass);
-			Assert.AreEqual(baseClass, c.BaseClass);
-		}
-		
-		[Test]
-		public void ClassWithProjectContentHasExpectedDotNetName()
-		{
-			MockProjectContent projectContent = new MockProjectContent();
-			string expectedName = "MyNamespace.MyTests";
-			MockClass c = new MockClass(projectContent, expectedName);
-			Assert.AreEqual(expectedName, c.DotNetName);
-		}
-		
-		[Test]
-		public void GetCompoundClassReturnsClassSetWithSetCompoundClass()
-		{
-			MockClass c = new MockClass();
-			MockClass compoundClass = new MockClass();
-			c.SetCompoundClass(compoundClass);
-			Assert.AreEqual(compoundClass, c.GetCompoundClass());
-		}
-	}
-}

src/AddIns/Analysis/UnitTesting/Test/Utils/Tests/MockClassTests.cs

@@ -0,0 +1,237 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.SharpDevelop.Project;
+using NUnit.Framework;
+using UnitTesting.Tests.Utils;
+
+namespace UnitTesting.Tests.Utils.Tests
+{
+	[TestFixture]
+	public class MockClassTests
+	{
+		MockClass outerClass;
+		MockClass innerClass;
+		
+		[Test]
+		public void FullyQualifiedName_NewInstanceCreatedWithFullyQualifiedName_ReturnsFullyQualifiedName()
+		{
+			string expectedFullyQualifiedName = "MyNamespace.MyClass";
+			MockClass c = new MockClass(expectedFullyQualifiedName);
+			string fullyQualifiedName = c.FullyQualifiedName;
+			Assert.AreEqual(expectedFullyQualifiedName, fullyQualifiedName);
+		}
+		
+		[Test]
+		public void DotNetName_NewInstanceCreatedWithFullyQualifiedName_ReturnsDotNetNameThatMatchesFullyQualifiedName()
+		{
+			string fullyQualifiedName = "MyNamespace.MyClass";
+			MockClass c = new MockClass(fullyQualifiedName);
+			string dotNetName = c.DotNetName;
+			Assert.AreEqual(fullyQualifiedName, dotNetName);
+		}
+		
+		[Test]
+		public void DotNetName_NewInstanceCreatedWithFullyQualifiedNameAndDotNetName_ReturnsExpectedDotNetName()
+		{
+			string fullyQualifiedName = "MyNamespace.MyClass.InnerClass";
+			string expectedDotNetName = "MyNamespace.MyClass+InnerClass";
+			MockClass c = new MockClass(fullyQualifiedName, expectedDotNetName);
+			string dotNetName = c.DotNetName;
+			Assert.AreEqual(expectedDotNetName, dotNetName);
+		}
+		
+		[Test]
+		public void Namespace_NewInstanceCreatedWithFullyQualifiedName_ReturnsNamespaceTakenFromFullyQualifiedName()
+		{
+			string fullyQualifiedName = "MyNamespace.MySubNamespace.MyClass";
+			MockClass c = new MockClass(fullyQualifiedName);
+			string expectedNamespace = "MyNamespace.MySubNamespace";
+			string actualNamespace = c.Namespace;
+			Assert.AreEqual(expectedNamespace, actualNamespace);
+		}
+		
+		[Test]
+		public void Name_NewInstanceCreatedWithFullyQualifiedName_ReturnsNameTakenFromFullyQualifiedName()
+		{
+			string fullyQualifiedName = "MyNamespace.MySubNamespace.MyClass";
+			MockClass c = new MockClass(fullyQualifiedName);
+			string expectedName = "MyClass";
+			string name = c.Name;
+			Assert.AreEqual(expectedName, name);
+		}
+		
+		[Test]
+		public void Namesapce_NewInstanceCreatedWithFullyQualifiedNameWithNoNamespace_ReturnsEmptyStringAsNamespace()
+		{
+			string fullyQualifiedName = "MyClass";
+			MockClass c = new MockClass(fullyQualifiedName);
+			string expectedNamespace = String.Empty;
+			string actualNamespace = c.Namespace;
+			Assert.AreEqual(expectedNamespace, actualNamespace);
+		}
+		
+		[Test]
+		public void CompilationUnit_NewInstanceCreated_ReturnsNonNullCompilationUnit()
+		{
+			MockClass c = new MockClass();
+			ICompilationUnit unit = c.CompilationUnit;
+			Assert.IsNotNull(unit);
+		}
+		
+		[Test]
+		public void ProjectContent_NewInstanceCreated_ReturnsMockProjectContent()
+		{
+			MockClass c = new MockClass();
+			MockProjectContent projectContent = c.ProjectContent as MockProjectContent;
+			Assert.IsNotNull(projectContent);
+		}
+		
+		[Test]
+		public void CompoundClass_NewInstance_ReturnsClassItself()
+		{
+			MockClass c = new MockClass();
+			IClass compoundClass = c.GetCompoundClass();
+			Assert.AreEqual(c, compoundClass);
+		}
+		
+		[Test]
+		public void DefaultReturnTypeGetUnderlyClass_NewInstance_ReturnsOriginalMockClass()
+		{
+			MockClass c = new MockClass();
+			IReturnType returnType = c.DefaultReturnType;
+			IClass underlyingClass = returnType.GetUnderlyingClass();
+			Assert.AreEqual(c, underlyingClass);
+		}
+		
+		[Test]
+		public void DeclaringType_NewInstanceWithInnerClass_InnerClassHasOuterClassAsDeclaringType()
+		{
+			CreateClassWithInnerClass();
+			IClass declaringType = innerClass.DeclaringType;
+			Assert.AreEqual(outerClass, declaringType);
+		}
+		
+		void CreateClassWithInnerClass()
+		{
+			outerClass = new MockClass("MyTests.A");
+			innerClass = new MockClass("MyTests.A.InnerATest", "MyTests.A+InnerATest", outerClass);
+		}
+		
+		[Test]
+		public void GetCompoundClass_NewInstanceWithInnerClass_InnerClassReturnsInnerClassAsCompoundClass()
+		{
+			CreateClassWithInnerClass();
+			IClass compoundClass = innerClass.GetCompoundClass();
+			Assert.AreEqual(innerClass, compoundClass);
+		}
+		
+		[Test]
+		public void InnerClasses_NewInstanceCreatedWithInnerClass_FirstClassInCollectionIsInnerClass()
+		{
+			CreateClassWithInnerClass();
+			IClass firstInnerClass = outerClass.InnerClasses[0];
+			Assert.AreEqual(innerClass, firstInnerClass);
+		}
+		
+		[Test]
+		public void BaseClass_ClassAddedToBaseTypes_ClassAddedToBaseTypesBecomesBaseClass()
+		{
+			MockClass c = new MockClass();
+			MockClass baseClass = new MockClass();
+			DefaultReturnType returnType = new DefaultReturnType(baseClass);
+			c.BaseTypes.Add(returnType);
+			IClass actualBaseClass = c.BaseClass;
+			Assert.AreEqual(baseClass, actualBaseClass);
+		}
+		
+		[Test]
+		public void BaseClass_AddBaseClassMethodCalled_ReturnsClassAddedUsingAddBaseClassMethod()
+		{
+			MockClass c = new MockClass();
+			MockClass baseClass = new MockClass();
+			c.AddBaseClass(baseClass);
+			IClass actualBaseClass = c.BaseClass;
+			Assert.AreEqual(baseClass, actualBaseClass);
+		}
+		
+		[Test]
+		public void DotNetName_NewInstanceCreatedWithProjectContent_ReturnsFullyQualifiedNameAsDotNetName()
+		{
+			MockProjectContent projectContent = new MockProjectContent();
+			string expectedName = "MyNamespace.MyTests";
+			MockClass c = new MockClass(projectContent, expectedName);
+			string dotNetName = c.DotNetName;
+			Assert.AreEqual(expectedName, dotNetName);
+		}
+		
+		[Test]
+		public void GetCompoundClass_SetCompoundClassMethodCalled_ReturnsClassPassedToSetCompoundClass()
+		{
+			MockClass c = new MockClass();
+			MockClass compoundClass = new MockClass();
+			c.SetCompoundClass(compoundClass);
+			IClass actualCompoundClass = c.GetCompoundClass();
+			Assert.AreEqual(compoundClass, actualCompoundClass);
+		}
+		
+		[Test]
+		public void AddProperty_PassedPropertyName_AddsPropertyToClass()
+		{
+			MockClass c = new MockClass();
+			c.AddProperty("MyProperty");
+			
+			IProperty property = c.Properties[0];
+			string name = property.Name;
+			
+			Assert.AreEqual("MyProperty", name);
+		}
+		
+		[Test]
+		public void InsertPropertyAtStart_PassedPropertyName_AddsPropertyAsFirstProperty()
+		{
+			MockClass c = new MockClass();
+			c.AddProperty("SecondProperty");
+			c.InsertPropertyAtStart("FirstProperty");
+			
+			IProperty property = c.Properties[0];
+			string name = property.Name;
+			
+			Assert.AreEqual("FirstProperty", name);			
+		}
+		
+		[Test]
+		public void AddProperty_PassedPropertyName_ReturnsPropertyWithExpectedName()
+		{
+			MockClass c = new MockClass();
+			IProperty property = c.AddProperty("MyProperty");			
+			string name = property.Name;
+			
+			Assert.AreEqual("MyProperty", name);
+		}
+		
+		[Test]
+		public void AddEvent_PassedEventName_AddsEventToClass()
+		{
+			MockClass c = new MockClass();
+			c.AddEvent("MyEvent");
+			
+			IEvent myEvent = c.Events[0];
+			string name = myEvent.Name;
+			
+			Assert.AreEqual("MyEvent", name);
+		}
+		
+		[Test]
+		public void AddEvent_PassedEventName_ReturnsEventWithExpectedName()
+		{
+			MockClass c = new MockClass();
+			IEvent myEvent = c.AddEvent("MyEvent");			
+			string name = myEvent.Name;
+			
+			Assert.AreEqual("MyEvent", name);
+		}
+	}
+}

src/AddIns/BackendBindings/Python/PythonBinding/Project/PythonBinding.csproj

@@ -101,13 +101,13 @@
     <Compile Include="Src\PythonFromImport.cs" />
     <Compile Include="Src\PythonImport.cs" />
     <Compile Include="Src\PythonLanguageBinding.cs" />
+    <Compile Include="Src\PythonMemberResolver.cs" />
     <Compile Include="Src\PythonMethodGroupResolveResult.cs" />
     <Compile Include="Src\PythonMethodResolver.cs" />
     <Compile Include="Src\PythonModuleCompletionItems.cs" />
     <Compile Include="Src\PythonModuleCompletionItemsFactory.cs" />
     <Compile Include="Src\PythonImportResolver.cs" />
     <Compile Include="Src\PythonNamespaceResolver.cs" />
-    <Compile Include="Src\PythonPropertyResolver.cs" />
     <Compile Include="Src\PythonResolverContext.cs" />
     <Compile Include="Src\PythonSelfResolver.cs" />
     <Compile Include="Src\PythonStandardLibraryPath.cs" />

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

@@ -0,0 +1,84 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using ICSharpCode.SharpDevelop.Dom;
+
+namespace ICSharpCode.PythonBinding
+{
+	/// <summary>
+	/// Resolves properties, events and fields.
+	/// </summary>
+	public class PythonMemberResolver : IPythonResolver
+	{
+		PythonClassResolver classResolver;
+		
+		public PythonMemberResolver(PythonClassResolver classResolver)
+		{
+			this.classResolver = classResolver;
+		}
+		
+		public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult)
+		{
+			IMember member = FindMember(resolverContext, expressionResult.Expression);
+			if (member != null) {
+				return CreateMemberResolveResult(member);
+			}
+			return null;
+		}
+		
+		IMember FindMember(PythonResolverContext resolverContext, string expression)
+		{
+			MemberName memberName = new MemberName(expression);
+			if (memberName.HasName) {
+				IClass c = resolverContext.GetClass(memberName.Type);
+				if (c != null) {
+					return FindMemberInClass(c, memberName.Name);
+				} else {
+					return FindMember(resolverContext, memberName);
+				}
+			}
+			return null;
+		}
+		
+		MemberResolveResult CreateMemberResolveResult(IMember member)
+		{
+			return new MemberResolveResult(null, null, member);
+		}
+		
+		IMember FindMemberInClass(IClass matchingClass, string memberName)
+		{
+			List<IMember> members = GetMembers(matchingClass);
+			foreach (IMember member in members) {
+				if (member.Name == memberName) {
+					return member;
+				}
+			}
+			return null;
+		}
+		
+		List<IMember> GetMembers(IClass c)
+		{
+			List<IMember> members = new List<IMember>();
+			members.AddRange(c.Events);
+			members.AddRange(c.Properties);
+			return members;
+		}
+		
+		IMember FindMember(PythonResolverContext resolverContext, MemberName memberName)
+		{
+			IMember parentMember = FindMember(resolverContext, memberName.Type);
+			if (parentMember != null) {
+				return FindMemberInParent(parentMember, memberName.Name);
+			}
+			return null;
+		}
+		
+		IMember FindMemberInParent(IMember parentMember, string propertyName)
+		{
+			IClass parentMemberClass = parentMember.ReturnType.GetUnderlyingClass();
+			return FindMemberInClass(parentMemberClass, propertyName);
+		}
+	}
+}

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

@@ -1,74 +0,0 @@
-// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
-// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
-
-using System;
-using ICSharpCode.SharpDevelop.Dom;
-
-namespace ICSharpCode.PythonBinding
-{
-	public class PythonPropertyResolver : IPythonResolver
-	{
-		PythonClassResolver classResolver;
-		
-		public PythonPropertyResolver(PythonClassResolver classResolver)
-		{
-			this.classResolver = classResolver;
-		}
-		
-		public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult)
-		{
-			IProperty property = FindProperty(resolverContext, expressionResult.Expression);
-			if (property != null) {
-				return CreateMemberResolveResult(property);
-			}
-			return null;
-		}
-		
-		IProperty FindProperty(PythonResolverContext resolverContext, string expression)
-		{
-			MemberName memberName = new MemberName(expression);
-			IClass matchingClass = FindClass(resolverContext, memberName.Type);
-			if (matchingClass != null) {
-				return FindPropertyInClass(matchingClass, memberName.Name);
-			} else if (memberName.HasName) {
-				return FindProperty(resolverContext, memberName);
-			}
-			return null;
-		}
-		
-		MemberResolveResult CreateMemberResolveResult(IProperty property)
-		{
-			return new MemberResolveResult(null, null, property);
-		}
-		
-		IClass FindClass(PythonResolverContext resolverContext, string typeName)
-		{
-			return classResolver.GetClass(resolverContext, typeName);
-		}
-		
-		IProperty FindPropertyInClass(IClass matchingClass, string memberName)
-		{
-			foreach (IProperty property in matchingClass.Properties) {
-				if (property.Name == memberName) {
-					return property;
-				}
-			}
-			return null;
-		}
-		
-		IProperty FindProperty(PythonResolverContext resolverContext, MemberName memberName)
-		{
-			IProperty parentProperty = FindProperty(resolverContext, memberName.Type);
-			if (parentProperty != null) {
-				return FindPropertyInProperty(parentProperty, memberName.Name);
-			}
-			return null;
-		}
-		
-		IProperty FindPropertyInProperty(IProperty parentProperty, string propertyName)
-		{
-			IClass parentPropertyClass = parentProperty.ReturnType.GetUnderlyingClass();
-			return FindPropertyInClass(parentPropertyClass, propertyName);
-		}
-	}
-}

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

@@ -19,19 +19,19 @@ namespace ICSharpCode.PythonBinding
 		PythonStandardModuleResolver standardModuleResolver = new PythonStandardModuleResolver();
 		PythonSelfResolver selfResolver = new PythonSelfResolver();
 		PythonMethodResolver methodResolver;
-		PythonPropertyResolver propertyResolver;
+		PythonMemberResolver memberResolver;
 		
 		List<IPythonResolver> resolvers = new List<IPythonResolver>();
 		
 		public PythonResolver()
 		{
 			methodResolver = new PythonMethodResolver(classResolver, standardModuleResolver);
-			propertyResolver = new PythonPropertyResolver(classResolver);
+			memberResolver = new PythonMemberResolver(classResolver);
 			
 			resolvers.Add(importResolver);
 			resolvers.Add(classResolver);
 			resolvers.Add(standardModuleResolver);
-			resolvers.Add(propertyResolver);
+			resolvers.Add(memberResolver);
 			resolvers.Add(methodResolver);
 			resolvers.Add(selfResolver);
 			resolvers.Add(namespaceResolver);

src/AddIns/BackendBindings/Python/PythonBinding/Test/Converter/ProjectHasStartupObjectTestFixture.cs

@@ -65,7 +65,7 @@ namespace PythonBinding.Tests.Converter
 			mockProjectContent = new ICSharpCode.Scripting.Tests.Utils.MockProjectContent();
 			MockClass mainClass = new MockClass(mockProjectContent, startupObject);
 			mainClass.CompilationUnit.FileName = @"d:\projects\test\src\Main2.cs";
-			mockProjectContent.ClassToReturnFromGetClass = mainClass;
+			mockProjectContent.SetClassToReturnFromGetClass(startupObject, mainClass);
 			
 			convertProjectCommand = new DerivedConvertProjectToPythonProjectCommand();
 			convertProjectCommand.ProjectContent = mockProjectContent;

src/AddIns/BackendBindings/Python/PythonBinding/Test/PythonBinding.Tests.csproj

@@ -350,6 +350,7 @@
     <Compile Include="Resolver\MemberNameTests.cs" />
     <Compile Include="Resolver\PythonSelfResolverTests.cs" />
     <Compile Include="Resolver\ResolveBuiltInRoundMethodTests.cs" />
+    <Compile Include="Resolver\ResolveClassEventTests.cs" />
     <Compile Include="Resolver\ResolveClassInstanceWithNamespaceTestFixture.cs" />
     <Compile Include="Resolver\ResolveClassPropertyTests.cs" />
     <Compile Include="Resolver\ResolveConsoleWriteLineTests.cs" />
@@ -425,6 +426,7 @@
     <Compile Include="Utils\PythonBindingAddInFile.cs" />
     <Compile Include="Utils\PythonCompletionItemsHelper.cs" />
     <Compile Include="Utils\PythonParserHelper.cs" />
+    <Compile Include="Utils\PythonResolverTestsHelper.cs" />
     <Compile Include="Utils\TestablePythonCodeCompletionBinding.cs" />
     <Compile Include="Utils\TestablePythonCodeCompletionItemProvider.cs" />
     <Compile Include="Utils\Tests\PythonCompletionItemsHelperTests.cs" />

src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveClassEventTests.cs

@@ -0,0 +1,78 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+using PythonBinding.Tests.Utils;
+using UnitTesting.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	/// <summary>
+	/// Tests resolving events for the following classes:
+	/// 
+	/// public class MyClass
+	/// {
+	/// 	public event EventHandler MyEvent;
+	/// }
+	/// 
+	/// </summary>
+	[TestFixture]
+	public class ResolveClassEventTests
+	{
+		PythonResolverTestsHelper resolverHelper;
+		IEvent myClassEvent;
+		MockClass myClass;
+		IProperty eventHandlerTargetProperty;
+		
+		void CreateClassWithOneEvent()
+		{
+			resolverHelper = new PythonResolverTestsHelper();
+			myClass = resolverHelper.CreateClass("MyClass");
+			myClassEvent = myClass.AddEvent("MyEvent");
+			
+			AddEventHandlerClass();
+			
+			resolverHelper.ProjectContent.SetClassToReturnFromGetClass("MyClass", myClass);
+		}
+		
+		void AddEventHandlerClass()
+		{
+			MockClass eventHandlerClass = resolverHelper.CreateClass("EventHandler");
+			eventHandlerTargetProperty = eventHandlerClass.AddProperty("Target");
+			myClassEvent.ReturnType = new DefaultReturnType(eventHandlerClass);
+		}
+		
+		[Test]
+		public void Resolve_ExpressionIsForEventOnClass_MemberResolveResultResolvedTypeIsClassEvent()
+		{
+			CreateClassWithOneEvent();
+			resolverHelper.Resolve("MyClass.MyEvent");
+			IMember resolvedMember = resolverHelper.MemberResultResult.ResolvedMember;
+			
+			Assert.AreEqual(myClassEvent, resolvedMember);
+		}
+		
+		[Test]
+		public void Resolve_ExpressionIsForSecondEventOnClass_MemberResolveResultResolvedTypeIsSecondEvent()
+		{
+			CreateClassWithOneEvent();
+			IEvent secondEvent = myClass.AddEvent("SecondEvent");
+			resolverHelper.Resolve("MyClass.SecondEvent");
+			IMember resolvedMember = resolverHelper.MemberResultResult.ResolvedMember;
+			
+			Assert.AreEqual(secondEvent, resolvedMember);
+		}
+		
+		[Test]
+		public void Resolve_ExpressionIsForEventHandlerTargetProperty_MemberResolveResultResolvedTypeIsEventHandlerTargetProperty()
+		{
+			CreateClassWithOneEvent();
+			resolverHelper.Resolve("MyClass.MyEvent.Target");
+			IMember resolvedMember = resolverHelper.MemberResultResult.ResolvedMember;
+			
+			Assert.AreEqual(eventHandlerTargetProperty, resolvedMember);
+		}
+	}
+}

src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveClassPropertyTests.cs

@@ -2,75 +2,59 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
-using ICSharpCode.PythonBinding;
-using ScriptingUtils = ICSharpCode.Scripting.Tests.Utils;
 using ICSharpCode.SharpDevelop.Dom;
 using NUnit.Framework;
+using PythonBinding.Tests.Utils;
 using UnitTesting.Tests.Utils;
 
 namespace PythonBinding.Tests.Resolver
 {
+	/// <summary>
+	/// Tests resolving properties for the following classes:
+	/// 
+	/// public class MyClass
+	/// {
+	/// 	public MyNestedPropertyClass MyProperty { get; set; }
+	/// }
+	/// 
+	/// public class MyNestedPropertyClass
+	/// {
+	/// 	public object MyNestedProperty { get; set; }
+	/// }
+	/// 
+	/// </summary>
 	[TestFixture]
 	public class ResolveClassPropertyTests
 	{
-		ResolveResult result;
+		PythonResolverTestsHelper resolverHelper;
-		ParseInformation parseInfo;
-		ScriptingUtils.MockProjectContent projectContent;
 		IProperty myClassProperty;
 		MockClass myClass;
 		IProperty nestedClassProperty;
 		
-		void ResolvePropertyExpression(string expression)
+		void CreateClassWithOneProperty()
 		{
-			PythonResolverContext context = new PythonResolverContext(parseInfo);
+			resolverHelper = new PythonResolverTestsHelper();
-			ExpressionResult expressionResult = new ExpressionResult(expression);
+			myClass = resolverHelper.CreateClass("MyClass");
+			myClassProperty = myClass.AddProperty("MyProperty");
 			
-			PythonResolver resolver = new PythonResolver();
+			AddNestedPropertyToExistingProperty();
-			result = resolver.Resolve(context, expressionResult);
-		}
-		
-		void CreateParseInfoWithOneClassWithOneProperty()
-		{
-			projectContent = new ScriptingUtils.MockProjectContent();
-			myClass = new MockClass(projectContent, "MyClass");
-			
-			myClassProperty = AddPropertyToClass("MyProperty", myClass);
-			
-			DefaultCompilationUnit unit = new DefaultCompilationUnit(projectContent);
-			parseInfo = new ParseInformation(unit);
 			
-			projectContent.SetClassToReturnFromGetClass("MyClass", myClass);
+			resolverHelper.ProjectContent.SetClassToReturnFromGetClass("MyClass", myClass);
 		}
 		
-		IProperty AddPropertyToClass(string propertyName, IClass c)
+		void AddNestedPropertyToExistingProperty()
-		{
-			IProperty property = CreateProperty(propertyName, c);
-			c.Properties.Add(property);
-			return property;
-		}
-		
-		IProperty CreateProperty(string propertyName, IClass c)
-		{
-			return new DefaultProperty(c, propertyName);
-		}
-		
-		[Test]
-		public void Resolve_ExpressionIsForPropertyOnClassWithOneProperty_ReturnsMemberResolveResult()
 		{
-			CreateParseInfoWithOneClassWithOneProperty();
+			MockClass nestedPropertyClass = resolverHelper.CreateClass("MyNestedPropertyClass");
-			ResolvePropertyExpression("MyClass.MyProperty");
+			nestedClassProperty = nestedPropertyClass.AddProperty("MyNestedProperty");
-			MemberResolveResult memberResolveResult = result as MemberResolveResult;
+			myClassProperty.ReturnType = new DefaultReturnType(nestedPropertyClass);
-			
-			Assert.IsNotNull(memberResolveResult);
 		}
 		
 		[Test]
 		public void Resolve_ExpressionIsForPropertyOnClassWithOneProperty_MemberResolveResultResolvedTypeIsMyClassProperty()
 		{
-			CreateParseInfoWithOneClassWithOneProperty();
+			CreateClassWithOneProperty();
-			ResolvePropertyExpression("MyClass.MyProperty");
+			resolverHelper.Resolve("MyClass.MyProperty");
-			MemberResolveResult memberResolveResult = result as MemberResolveResult;
+			IMember resolvedMember = resolverHelper.MemberResultResult.ResolvedMember;
-			IMember resolvedMember = memberResolveResult.ResolvedMember;
 			
 			Assert.AreEqual(myClassProperty, resolvedMember);
 		}
@@ -78,40 +62,23 @@ namespace PythonBinding.Tests.Resolver
 		[Test]
 		public void Resolve_ExpressionIsForSecondPropertyOnClassWithTwoProperties_MemberResolveResultResolvedTypeIsSecondClassProperty()
 		{
-			CreateParseInfoWithOneClassWithOneProperty();
+			CreateClassWithOneProperty();
-			InsertNewPropertyOnClassBeforeExistingProperty();
+			myClass.InsertPropertyAtStart("ExtraProperty");
-			ResolvePropertyExpression("MyClass.MyProperty");
+			resolverHelper.Resolve("MyClass.MyProperty");
-			
+			IMember resolvedMember = resolverHelper.MemberResultResult.ResolvedMember;
-			MemberResolveResult memberResolveResult = result as MemberResolveResult;
-			IMember resolvedMember = memberResolveResult.ResolvedMember;
 			
 			Assert.AreEqual(myClassProperty, resolvedMember);
 		}
 		
-		void InsertNewPropertyOnClassBeforeExistingProperty()
-		{
-			IProperty extraProperty = CreateProperty("ExtraProperty", myClass);
-			myClass.Properties.Insert(0, extraProperty);
-		}
-		
 		[Test]
 		public void Resolve_ExpressionRefersToNestedProperty_MemberResolveResultResolvedTypeIsNestedProperty()
 		{
-			CreateParseInfoWithOneClassWithOneProperty();
+			CreateClassWithOneProperty();
 			AddNestedPropertyToExistingProperty();
-			ResolvePropertyExpression("MyClass.MyProperty.MyNestedProperty");
+			resolverHelper.Resolve("MyClass.MyProperty.MyNestedProperty");
-			
+			IMember resolvedMember = resolverHelper.MemberResultResult.ResolvedMember;
-			MemberResolveResult memberResolveResult = result as MemberResolveResult;
-			IMember resolvedMember = memberResolveResult.ResolvedMember;
 			
 			Assert.AreEqual(nestedClassProperty, resolvedMember);
 		}
-		
-		void AddNestedPropertyToExistingProperty()
-		{
-			MockClass nestedPropertyClass = new MockClass(projectContent, "MyNestedPropertyClass");
-			nestedClassProperty = AddPropertyToClass("MyNestedProperty", nestedPropertyClass);
-			myClassProperty.ReturnType = new DefaultReturnType(nestedPropertyClass);
-		}
 	}
 }

src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSystemConsoleTests.cs

@@ -34,7 +34,7 @@ namespace PythonBinding.Tests.Resolver
 			mockProjectContent = new ICSharpCode.Scripting.Tests.Utils.MockProjectContent();
 			
 			systemConsoleClass = new MockClass(mockProjectContent, "System.Console");
-			mockProjectContent.ClassToReturnFromGetClass = systemConsoleClass;
+			mockProjectContent.SetClassToReturnFromGetClass("System.Console", systemConsoleClass);
 			
 			compilationUnit = CreateCompilationUnit(mockProjectContent);
 			ParseInformation parseInfo = new ParseInformation(compilationUnit);

src/AddIns/BackendBindings/Python/PythonBinding/Test/Utils/PythonResolverTestsHelper.cs

@@ -0,0 +1,47 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using UnitTesting.Tests.Utils;
+using ScriptingUtils = ICSharpCode.Scripting.Tests.Utils;
+
+namespace PythonBinding.Tests.Utils
+{
+	public class PythonResolverTestsHelper
+	{
+		public ScriptingUtils.MockProjectContent ProjectContent;
+		public	DefaultCompilationUnit CompilationUnit;
+		public ParseInformation ParseInfo;
+		public PythonResolverContext Context;
+		public PythonResolver Resolver;
+		public ResolveResult ResolveResult;
+		
+		public PythonResolverTestsHelper()
+		{
+			ProjectContent = new ScriptingUtils.MockProjectContent();
+			CompilationUnit = new DefaultCompilationUnit(ProjectContent);
+			ParseInfo = new ParseInformation(CompilationUnit);
+			Context = new PythonResolverContext(ParseInfo);
+			
+			Resolver = new PythonResolver();
+		}
+		
+		public ResolveResult Resolve(string expression)
+		{
+			ExpressionResult expressionResult = new ExpressionResult(expression);
+			ResolveResult = Resolver.Resolve(Context, expressionResult);
+			return ResolveResult;
+		}
+		
+		public MemberResolveResult MemberResultResult {
+			get { return ResolveResult as MemberResolveResult; }
+		}
+		
+		public MockClass CreateClass(string name)
+		{
+			return new MockClass(ProjectContent, name);
+		}
+	}
+}

src/AddIns/BackendBindings/Scripting/Test/Utils/MockProjectContent.cs

@@ -68,29 +68,10 @@ namespace ICSharpCode.Scripting.Tests.Utils
 			get { return searchTypeRequest; }
 		}
 		
-		/// <summary>
-		/// Gets or sets the class to return from the GetClass Method.
-		/// </summary>
-		public IClass ClassToReturnFromGetClass
-		{
-			get { return classToReturnFromGetClass; }
-			set { classToReturnFromGetClass = value; }
-		}
-		
-		/// <summary>
-		/// Gets or sets the class name that needs to match in order
-		/// for the GetClass call to return a class. If nothing is
-		/// specified then every class name matches. 
-		/// </summary>
-		public string ClassNameForGetClass {
-			get { return classNameForGetClass; }
-			set { classNameForGetClass = value; }
-		}
-		
 		public void SetClassToReturnFromGetClass(string className, IClass classToReturn)
 		{
-			ClassToReturnFromGetClass = classToReturn;
+			classToReturnFromGetClass = classToReturn;
-			ClassNameForGetClass = className;
+			classNameForGetClass = className;
 		}
 
 		/// <summary>

src/AddIns/BackendBindings/Scripting/Test/Utils/Tests/MockProjectContentTests.cs

@@ -162,16 +162,6 @@ namespace ICSharpCode.Scripting.Tests.Utils.Tests
 			Assert.AreEqual("abc", name);
 		}
 		
-		[Test]
-		public void GetClass_ClassNameDoesNotMatchAndNoClassNameForGetClassSpecified_ReturnsTestClassSinceNoClassNameRestrictionSpecified()
-		{
-			MockClass expectedClass = new MockClass(projectContent, "test");
-			projectContent.ClassToReturnFromGetClass = expectedClass;
-			IClass c = projectContent.GetClass("abcdef", 0);
-			
-			Assert.AreEqual(expectedClass, c);
-		}
-		
 		[Test]
 		public void GetClass_ClassNameDoesNotMatchClassNameForGetClassProperty_ReturnsNull()
 		{