Add support for IronPython code completion on properties to any level.

src/AddIns/BackendBindings/Python/PythonBinding.sln

@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 11.00
 # Visual Studio 2010
-# SharpDevelop 4.0.0.6611
+# SharpDevelop 4.0.0.6676
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PythonBinding", "PythonBinding\Project\PythonBinding.csproj", "{8D732610-8FC6-43BA-94C9-7126FD7FE361}"
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PythonBinding.Tests", "PythonBinding\Test\PythonBinding.Tests.csproj", "{23B517C9-1ECC-4419-A13F-0B7136D085CB}"

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

@@ -17,19 +17,21 @@ namespace ICSharpCode.PythonBinding
 		
 		public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult)
 		{
-			IProperty property = FindProperty(resolverContext, expressionResult);
+			IProperty property = FindProperty(resolverContext, expressionResult.Expression);
 			if (property != null) {
 				return CreateMemberResolveResult(property);
 			}
 			return null;
 		}
 		
-		IProperty FindProperty(PythonResolverContext resolverContext, ExpressionResult expressionResult)
+		IProperty FindProperty(PythonResolverContext resolverContext, string expression)
 		{
-			MemberName memberName = new MemberName(expressionResult.Expression);
+			MemberName memberName = new MemberName(expression);
 			IClass matchingClass = FindClass(resolverContext, memberName.Type);
 			if (matchingClass != null) {
-				return FindProperty(matchingClass, memberName.Name);
+				return FindPropertyInClass(matchingClass, memberName.Name);
+			} else if (memberName.HasName) {
+				return FindProperty(resolverContext, memberName);
 			}
 			return null;
 		}
@@ -44,7 +46,7 @@ namespace ICSharpCode.PythonBinding
 			return classResolver.GetClass(resolverContext, typeName);
 		}
 		
-		IProperty FindProperty(IClass matchingClass, string memberName)
+		IProperty FindPropertyInClass(IClass matchingClass, string memberName)
 		{
 			foreach (IProperty property in matchingClass.Properties) {
 				if (property.Name == memberName) {
@@ -53,5 +55,20 @@ namespace ICSharpCode.PythonBinding
 			}
 			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/Test/Completion/NamespaceContentsAddedToCtrlSpaceTestFixture.cs

@@ -36,7 +36,7 @@ namespace PythonBinding.Tests.Resolver
 			namespaceItems.Add(myTestClass);
 			mockProjectContent.AddExistingNamespaceContents("MyNamespace", namespaceItems);
 			
-			DefaultCompilationUnit cu = new DefaultCompilationUnit(mockProjectContent) { ErrorsDuringCompile = true };
+			DefaultCompilationUnit cu = new DefaultCompilationUnit(mockProjectContent);
 			
 			// Add usings.
 			DefaultUsing newUsing = new DefaultUsing(cu.ProjectContent);

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

@@ -349,22 +349,21 @@
     <Compile Include="Resolver\InvalidResolveInputsTestFixture.cs" />
     <Compile Include="Resolver\MemberNameTests.cs" />
     <Compile Include="Resolver\PythonSelfResolverTests.cs" />
-    <Compile Include="Resolver\ResolveBuiltInRoundMethodTestFixture.cs" />
+    <Compile Include="Resolver\ResolveBuiltInRoundMethodTests.cs" />
     <Compile Include="Resolver\ResolveClassInstanceWithNamespaceTestFixture.cs" />
     <Compile Include="Resolver\ResolveClassPropertyTests.cs" />
-    <Compile Include="Resolver\ResolveConsoleWriteLineTestFixture.cs" />
+    <Compile Include="Resolver\ResolveConsoleWriteLineTests.cs" />
-    <Compile Include="Resolver\ResolveExitMethodFromSysImportExitAsMyExitTestFixture.cs" />
+    <Compile Include="Resolver\ResolveExitMethodFromSysImportExitAsMyExitTests.cs" />
     <Compile Include="Resolver\ResolveExitMethodFromSysImportExitTestFixture.cs" />
-    <Compile Include="Resolver\ResolveFooTextBoxFromSystemWindowsFormsImportedAsFooTestFixture.cs" />
+    <Compile Include="Resolver\ResolveFooWindowsWithImportSystemAsFooTests.cs" />
-    <Compile Include="Resolver\ResolveFooWindowsWithImportSystemAsFooTestFixture.cs" />
+    <Compile Include="Resolver\ResolveFromImportTests.cs" />
-    <Compile Include="Resolver\ResolveFromImportTestFixture.cs" />
+    <Compile Include="Resolver\ResolveFromMathImportedMathModuleCompletionItemsTests.cs" />
-    <Compile Include="Resolver\ResolveFromMathImportedMathModuleCompletionItemsTestFixture.cs" />
+    <Compile Include="Resolver\ResolveFromSystemImportEverythingTests.cs" />
-    <Compile Include="Resolver\ResolveConsoleFromSystemImportEverythingFixture.cs" />
     <Compile Include="Resolver\ResolveImportsTestFixture.cs" />
-    <Compile Include="Resolver\ResolveLocalClassInstanceTestFixture.cs" />
+    <Compile Include="Resolver\ResolveLocalClassInstanceTests.cs" />
-    <Compile Include="Resolver\ResolveMethodFromUnknownImportAllTestFixture.cs" />
+    <Compile Include="Resolver\ResolveMethodFromUnknownImportAllTests.cs" />
-    <Compile Include="Resolver\ResolveMethodWhenFromImportIsUnknownTestFixture.cs" />
+    <Compile Include="Resolver\ResolveMethodWhenFromImportIsUnknownTests.cs" />
-    <Compile Include="Resolver\ResolveMethodWhenImportIsUnknownTestFixture.cs" />
+    <Compile Include="Resolver\ResolveMethodWhenImportIsUnknownTests.cs" />
     <Compile Include="Resolver\ResolveNullCtrlSpaceParseInfoTestFixture.cs" />
     <Compile Include="Resolver\ResolverContextDottedImportedNameMatchTests.cs" />
     <Compile Include="Resolver\ResolverContextGetModulesThatImportEverythingTests.cs" />
@@ -374,26 +373,27 @@
     <Compile Include="Resolver\ResolverContextPartialNamespaceExistsTests.cs" />
     <Compile Include="Resolver\ResolverContextUnaliasImportedModuleNameTestFixture.cs" />
     <Compile Include="Resolver\ResolveSelfTests.cs" />
-    <Compile Include="Resolver\ResolveSysModuleExitMethodTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSysModuleExitMethodTests.cs" />
-    <Compile Include="Resolver\ResolveSysModuleImportedAsMySysTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSysModuleImportedAsMySysTests.cs" />
     <Compile Include="Resolver\ResolveSysModuleTestFixture.cs">
     </Compile>
-    <Compile Include="Resolver\ResolveSysModuleUnknownMethodTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSysModuleUnknownMethodTests.cs" />
     <Compile Include="Resolver\ResolveSystemConsoleOutsideClassTestFixture.cs" />
-    <Compile Include="Resolver\ResolveSystemConsoleTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSystemConsoleTests.cs" />
-    <Compile Include="Resolver\ResolveSystemImportedAsMySystemTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSystemImportedAsMySystemTests.cs" />
-    <Compile Include="Resolver\ResolveSystemImportTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSystemImportTests.cs" />
-    <Compile Include="Resolver\ResolveSystemNamespaceTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSystemNamespaceTests.cs" />
-    <Compile Include="Resolver\ResolveSystemNamespaceWithMissingImportTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSystemNamespaceWithMissingImportTests.cs" />
-    <Compile Include="Resolver\ResolveSystemWindowsFormsWithImportSystemTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSystemWindowsFormsWithImportSystemTests.cs" />
-    <Compile Include="Resolver\ResolveSystemWindowsWithImportSystemTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSystemWindowsWithImportSystemTests.cs" />
-    <Compile Include="Resolver\ResolveSystemWithImportSystemWindowsTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSystemWithImportSystemWindowsTests.cs" />
-    <Compile Include="Resolver\ResolveTanMethodFromMathImportAllTestFixture.cs" />
+    <Compile Include="Resolver\ResolveTanMethodFromMathImportAllTests.cs" />
-    <Compile Include="Resolver\ResolveTanMethodFromMathImportCosAndTanTestFixture.cs" />
+    <Compile Include="Resolver\ResolveTanMethodFromMathImportCosAndTanTests.cs" />
-    <Compile Include="Resolver\ResolveTestFixtureBase.cs" />
+    <Compile Include="Resolver\ResolveTestsBase.cs" />
-    <Compile Include="Resolver\ResolveTextBoxFromSystemWindowsFormsImportedAsMyTextBoxTestFixture.cs" />
+    <Compile Include="Resolver\ResolveTextBoxFromSystemWindowsFormsImportedAsFooTests.cs" />
-    <Compile Include="Resolver\ResolveTextBoxFromSystemWindowsFormsImportTextBoxTestFixture.cs" />
+    <Compile Include="Resolver\ResolveTextBoxFromSystemWindowsFormsImportedAsMyTextBoxTests.cs" />
-    <Compile Include="Resolver\ResolveUnknownNamespaceTestFixture.cs" />
+    <Compile Include="Resolver\ResolveTextBoxFromSystemWindowsFormsImportTextBoxTests.cs" />
+    <Compile Include="Resolver\ResolveUnknownNamespaceTests.cs" />
     <Compile Include="Testing\CreatePythonTestRunnerTestFixture.cs" />
     <Compile Include="Testing\PythonConsoleApplicationTestFixture.cs" />
     <Compile Include="Testing\PythonStandardLibraryPathTests.cs" />

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

@@ -0,0 +1,117 @@
+// 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;
+using System.Collections.Generic;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.SharpDevelop.Dom.CSharp;
+using NUnit.Framework;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveBuiltInRoundMethodTestFixture : ResolveTestsBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			return new ExpressionResult("round", ExpressionContext.Default);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return 
+				"round\r\n" +
+				"\r\n";
+		}
+			
+		[Test]
+		public void ResolveResultIsMethodGroupResolveResult()
+		{
+			Assert.IsTrue(resolveResult is MethodGroupResolveResult);
+		}
+		
+		[Test]
+		public void ResolveResultMethodNameIsRound()
+		{
+			Assert.AreEqual("round", MethodResolveResult.Name);
+		}
+		
+		MethodGroupResolveResult MethodResolveResult {
+			get { return (MethodGroupResolveResult)resolveResult; }
+		}
+		
+		[Test]
+		public void ResolveResultContainingTypeHasTwoRoundMethods()
+		{
+			List<IMethod> exitMethods = GetRoundMethods();
+			Assert.AreEqual(2, exitMethods.Count);
+		}
+		
+		List<IMethod> GetRoundMethods()
+		{
+			return GetRoundMethods(-1);
+		}
+		
+		List<IMethod> GetRoundMethods(int parameterCount)
+		{
+			List<IMethod> methods = MethodResolveResult.ContainingType.GetMethods();
+			return PythonCompletionItemsHelper.FindAllMethodsFromCollection("round", parameterCount, methods.ToArray());
+		}
+		
+		[Test]
+		public void BothRoundMethodsArePublic()
+		{
+			foreach (IMethod method in GetRoundMethods()) {
+				Assert.IsTrue(method.IsPublic);
+			}
+		}
+		
+		[Test]
+		public void BothRoundMethodsHaveClassWithNameOfSys()
+		{
+			foreach (IMethod method in GetRoundMethods()) {
+				Assert.AreEqual("__builtin__", method.DeclaringType.Name);
+			}
+		}
+		
+		[Test]
+		public void OneRoundMethodHasTwoParameters()
+		{
+			int parameterCount = 2;
+			Assert.AreEqual(1, GetRoundMethods(parameterCount).Count);
+		}
+		
+		[Test]
+		public void RoundMethodParameterNameIsNumber()
+		{
+			IParameter parameter = GetFirstRoundMethodParameter();
+			Assert.AreEqual("number", parameter.Name);
+		}
+		
+		IParameter GetFirstRoundMethodParameter()
+		{
+			int parameterCount = 1;
+			List<IMethod> methods = GetRoundMethods(parameterCount);
+			IMethod method = methods[0];
+			return method.Parameters[0];
+		}
+		
+		[Test]
+		public void RoundMethodParameterReturnTypeIsDouble()
+		{
+			IParameter parameter = GetFirstRoundMethodParameter();
+			Assert.AreEqual("Double", parameter.ReturnType.Name);
+		}
+		
+		[Test]
+		public void RoundMethodParameterConvertedToStringUsingAmbienceReturnsDoubleNumberString()
+		{
+			IAmbience ambience = new CSharpAmbience();
+			string text = ambience.Convert(GetFirstRoundMethodParameter());
+			Assert.AreEqual("double number", text);
+		}
+	}
+}

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

@@ -15,53 +15,60 @@ namespace PythonBinding.Tests.Resolver
 	{
 		ResolveResult result;
 		ParseInformation parseInfo;
+		ScriptingUtils.MockProjectContent projectContent;
 		IProperty myClassProperty;
 		MockClass myClass;
+		IProperty nestedClassProperty;
 		
-		void ResolveClassProperty()
+		void ResolvePropertyExpression(string expression)
 		{
 			PythonResolverContext context = new PythonResolverContext(parseInfo);
-			ExpressionResult expression = new ExpressionResult("MyClass.MyProperty");
+			ExpressionResult expressionResult = new ExpressionResult(expression);
 			
 			PythonResolver resolver = new PythonResolver();
-			result = resolver.Resolve(context, expression);
+			result = resolver.Resolve(context, expressionResult);
 		}
 		
-		void CreateParseInfoWithOneClass()
+		void CreateParseInfoWithOneClassWithOneProperty()
 		{
-			ScriptingUtils.MockProjectContent projectContent = new ScriptingUtils.MockProjectContent();
+			projectContent = new ScriptingUtils.MockProjectContent();
 			myClass = new MockClass(projectContent, "MyClass");
 			
-			projectContent.ClassToReturnFromGetClass = myClass;
+			myClassProperty = AddPropertyToClass("MyProperty", myClass);
-			projectContent.ClassNameForGetClass = "MyClass";
-			
-			myClassProperty = CreateProperty(myClass);
-			myClass.Properties.Add(myClassProperty);
 			
 			DefaultCompilationUnit unit = new DefaultCompilationUnit(projectContent);
 			parseInfo = new ParseInformation(unit);
+			
+			projectContent.SetClassToReturnFromGetClass("MyClass", myClass);
+		}
+		
+		IProperty AddPropertyToClass(string propertyName, IClass c)
+		{
+			IProperty property = CreateProperty(propertyName, c);
+			c.Properties.Add(property);
+			return property;
 		}
 		
-		IProperty CreateProperty(IClass c)
+		IProperty CreateProperty(string propertyName, IClass c)
 		{
-			return new DefaultProperty(c, "MyProperty");
+			return new DefaultProperty(c, propertyName);
 		}
 		
 		[Test]
-		public void Resolve_ClassHasOneProperty_ReturnsMemberResolveResult()
+		public void Resolve_ExpressionIsForPropertyOnClassWithOneProperty_ReturnsMemberResolveResult()
 		{
-			CreateParseInfoWithOneClass();
+			CreateParseInfoWithOneClassWithOneProperty();
-			ResolveClassProperty();
+			ResolvePropertyExpression("MyClass.MyProperty");
 			MemberResolveResult memberResolveResult = result as MemberResolveResult;
 			
 			Assert.IsNotNull(memberResolveResult);
 		}
 		
 		[Test]
-		public void Resolve_ClassHasOneProperty_MemberResolveResultResolvedTypeIsMyClassProperty()
+		public void Resolve_ExpressionIsForPropertyOnClassWithOneProperty_MemberResolveResultResolvedTypeIsMyClassProperty()
 		{
-			CreateParseInfoWithOneClass();
+			CreateParseInfoWithOneClassWithOneProperty();
-			ResolveClassProperty();
+			ResolvePropertyExpression("MyClass.MyProperty");
 			MemberResolveResult memberResolveResult = result as MemberResolveResult;
 			IMember resolvedMember = memberResolveResult.ResolvedMember;
 			
@@ -69,17 +76,42 @@ namespace PythonBinding.Tests.Resolver
 		}
 		
 		[Test]
-		public void Resolve_ClassHasTwoProperties_MemberResolveResultResolvedTypeIsSecondClassProperty()
+		public void Resolve_ExpressionIsForSecondPropertyOnClassWithTwoProperties_MemberResolveResultResolvedTypeIsSecondClassProperty()
 		{
-			CreateParseInfoWithOneClass();
+			CreateParseInfoWithOneClassWithOneProperty();
-			DefaultProperty extraProperty = new DefaultProperty(myClass, "ExtraProperty");
+			InsertNewPropertyOnClassBeforeExistingProperty();
-			myClass.Properties.Insert(0, extraProperty);
+			ResolvePropertyExpression("MyClass.MyProperty");
-			ResolveClassProperty();
 			
 			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();
+			AddNestedPropertyToExistingProperty();
+			ResolvePropertyExpression("MyClass.MyProperty.MyNestedProperty");
+			
+			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/ResolveConsoleWriteLineTests.cs

@@ -0,0 +1,60 @@
+// 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;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+using PythonBinding.Tests;
+using PythonBinding.Tests.Utils;
+using UnitTesting.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	/// <summary>
+	/// Tests that the expression "Console.WriteLine" is correctly
+	/// resolved.
+	/// </summary>
+	[TestFixture]
+	public class ResolveConsoleWriteLineTests : ResolveTestsBase
+	{
+		MockClass systemConsoleClass;
+		
+		protected override ExpressionResult GetExpressionResult()
+		{
+			systemConsoleClass = new MockClass(projectContent, "System.Console");
+			projectContent.SetClassToReturnFromGetClass("Console", systemConsoleClass);
+			return new ExpressionResult("Console.WriteLine", new DomRegion(2, 2), null, null);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return 
+				"import System\r\n" +
+				"Console.WriteLine\r\n";
+		}
+		
+		[Test]
+		public void ResolveResultExists()
+		{
+			Assert.IsNotNull(resolveResult);
+		}
+		
+		/// <summary>
+		/// Gets the class name used in IProjectContent.GetClass call.
+		/// </summary>
+		[Test]
+		public void GetClassName()
+		{
+			Assert.AreEqual("Console", projectContent.GetClassName);
+		}
+				
+		[Test]
+		public void MethodNameResolveIsWriteLine()
+		{
+			MethodGroupResolveResult methodResolveResult = (MethodGroupResolveResult)resolveResult;
+			Assert.AreEqual("WriteLine", methodResolveResult.Name);
+		}
+	}
+}

src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveExitMethodFromSysImportExitAsMyExitTests.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 System.Collections;
+using System.Collections.Generic;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.SharpDevelop.Dom.CSharp;
+using NUnit.Framework;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveExitMethodFromSysImportExitAsMyExitTestFixture : ResolveTestsBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			return new ExpressionResult("myexit", ExpressionContext.Default);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return 
+				"from sys import exit as myexit\r\n" +
+				"myexit\r\n" +
+				"\r\n";
+		}
+			
+		[Test]
+		public void ResolveResultIsMethodGroupResolveResult()
+		{
+			Assert.IsTrue(resolveResult is MethodGroupResolveResult);
+		}
+		
+		[Test]
+		public void ResolveResultMethodNameIsExit()
+		{
+			Assert.AreEqual("exit", MethodResolveResult.Name);
+		}
+		
+		MethodGroupResolveResult MethodResolveResult {
+			get { return (MethodGroupResolveResult)resolveResult; }
+		}
+	}
+}

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

@@ -13,7 +13,7 @@ using PythonBinding.Tests.Utils;
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolveExitMethodFromSysImportExitTestFixture : ResolveTestFixtureBase
+	public class ResolveExitMethodFromSysImportExitTestFixture : ResolveTestsBase
 	{
 		protected override ExpressionResult GetExpressionResult()
 		{

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

@@ -0,0 +1,45 @@
+// 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.PythonBinding;
+using ICSharpCode.Scripting.Tests.Utils;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+using PythonBinding.Tests;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveFooWindowsWithImportSystemAsFooTestFixture : ResolveTestsBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			MockProjectContent referencedContent = new MockProjectContent();
+			List<ICompletionEntry> namespaceItems = new List<ICompletionEntry>();
+			referencedContent.AddExistingNamespaceContents("System.Windows.Forms", namespaceItems);
+			projectContent.ReferencedContents.Add(referencedContent);
+			
+			return new ExpressionResult("Foo.Windows");
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return
+				"import System as Foo\r\n" +
+				"Foo.Windows\r\n";
+		}
+		
+		NamespaceResolveResult NamespaceResolveResult {
+			get { return resolveResult as NamespaceResolveResult; }
+		}
+		
+		[Test]
+		public void NamespaceResolveResultHasSystemWindowsNamespace()
+		{
+			Assert.AreEqual("System.Windows", NamespaceResolveResult.Name);
+		}
+	}
+}

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

@@ -0,0 +1,54 @@
+// 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;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.Scripting.Tests.Utils;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+using PythonBinding.Tests;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	/// <summary>
+	/// Tests that the PythonResolver resolves "from System" to 
+	/// a namespace.
+	/// </summary>
+	[TestFixture]
+	public class ResolveFromImportTestFixture
+	{
+		PythonResolver resolver;
+		MockProjectContent mockProjectContent;
+		PythonImportModuleResolveResult resolveResult;
+		
+		[TestFixtureSetUp]
+		public void SetUpFixture()
+		{
+			resolver = new PythonResolver();
+			
+			mockProjectContent = new MockProjectContent();
+			DefaultCompilationUnit cu = new DefaultCompilationUnit(mockProjectContent);
+			cu.FileName = @"C:\Projects\Test\test.py";
+			ParseInformation parseInfo = new ParseInformation(cu);
+					
+			string python = "from System";
+			PythonExpressionFinder finder = new PythonExpressionFinder();
+			ExpressionResult expressionResult = finder.FindExpression(python, python.Length);
+			resolveResult = resolver.Resolve(expressionResult, parseInfo, python) as PythonImportModuleResolveResult;
+		}
+		
+		[Test]
+		public void NamespaceResolveResultFound()
+		{
+			Assert.IsNotNull(resolveResult);
+		}
+		
+		[Test]
+		public void NamespaceName()
+		{
+			Assert.AreEqual("System", resolveResult.Name);
+		}
+	}
+}

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

@@ -0,0 +1,55 @@
+// 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;
+using System.Collections.Generic;
+
+using ICSharpCode.PythonBinding;
+using ICSharpCode.Scripting.Tests.Utils;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+using PythonBinding.Tests;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveFromMathImportedMathModuleCompletionItemsTestFixture : ResolveTestsBase
+	{
+		List<ICompletionEntry> GetCompletionResults()
+		{
+			return resolveResult.GetCompletionData(projectContent);
+		}
+		
+		protected override ExpressionResult GetExpressionResult()
+		{
+			string code = GetPythonScript();
+			PythonExpressionFinder finder = new PythonExpressionFinder();
+			return finder.FindExpression(code, code.Length);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return "from math import";
+		}
+		
+		[Test]
+		public void CompletionResultsContainCosMethodFromMathModule()
+		{
+			IMethod method = PythonCompletionItemsHelper.FindMethodFromCollection("cos", GetCompletionResults());
+			Assert.IsNotNull(method);
+		}
+		
+		[Test]
+		public void ExpressionResultContextShowItemReturnsTrueForIMethod()
+		{
+			MockProjectContent projectContent = new MockProjectContent();
+			DefaultCompilationUnit unit = new DefaultCompilationUnit(projectContent);
+			DefaultClass c = new DefaultClass(unit, "MyClass");
+			DefaultMethod method = new DefaultMethod(c, "Test");
+			
+			Assert.IsTrue(expressionResult.Context.ShowEntry(method));
+		}
+	}
+}

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

@@ -0,0 +1,56 @@
+// 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;
+using System.Collections.Generic;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.SharpDevelop.Dom.CSharp;
+using NUnit.Framework;
+using PythonBinding.Tests.Utils;
+using UnitTesting.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveFromSystemImportEverythingTests : ResolveTestsBase
+	{
+		MockClass consoleClass;
+		
+		protected override ExpressionResult GetExpressionResult()
+		{
+			consoleClass = new MockClass(projectContent, "System.Console");
+			projectContent.SetClassToReturnFromGetClass("System.Console", consoleClass);
+			
+			List<ICompletionEntry> namespaceItems = new List<ICompletionEntry>();
+			projectContent.AddExistingNamespaceContents("System", namespaceItems);
+			
+			return new ExpressionResult("Console", ExpressionContext.Default);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return 
+				"from System import *\r\n" +
+				"Console\r\n" +
+				"\r\n";
+		}
+		
+		[Test]
+		public void ResolveResultResolvedClassIsConsoleClass()
+		{
+			Assert.AreEqual(consoleClass, TypeResolveResult.ResolvedClass);
+		}
+		
+		TypeResolveResult TypeResolveResult {
+			get { return (TypeResolveResult)resolveResult; }
+		}
+		
+		[Test]
+		public void ProjectContentNamespaceExistsReturnsTrueForSystem()
+		{
+			Assert.IsTrue(projectContent.NamespaceExists("System"));
+		}
+	}
+}

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

@@ -0,0 +1,101 @@
+// 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;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+using PythonBinding.Tests;
+using PythonBinding.Tests.Utils;
+using UnitTesting.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	/// <summary>
+	/// Given code:
+	/// 
+	/// a = Class1()
+	/// 
+	/// Check that the type of "a" can be obtained by the resolver.
+	/// </summary>
+	[TestFixture]
+	[Ignore("Disabled local variable resolution for SD 3.0")]
+	public class ResolveLocalClassInstanceTests
+	{
+		PythonResolver resolver;
+		ICSharpCode.Scripting.Tests.Utils.MockProjectContent mockProjectContent;
+		LocalResolveResult resolveResult;
+		MockClass testClass;
+		ICompilationUnit compilationUnit;
+		
+		[TestFixtureSetUp]
+		public void SetUpFixture()
+		{
+			resolver = new PythonResolver();
+			
+			mockProjectContent = new ICSharpCode.Scripting.Tests.Utils.MockProjectContent();
+			testClass = new MockClass(mockProjectContent, "Test.Test1");
+			mockProjectContent.ClassesInProjectContent.Add(testClass);			
+			mockProjectContent.SetClassToReturnFromGetClass("Test.Test1", testClass);
+
+			compilationUnit = new DefaultCompilationUnit(mockProjectContent);
+			compilationUnit.FileName = @"C:\Projects\Test\test.py";
+			ParseInformation parseInfo = new ParseInformation(compilationUnit);
+
+			string python =
+				"a = Test1()\r\n" +
+				"a";
+			ExpressionResult expressionResult = new ExpressionResult("a", new DomRegion(2, 1), null, null);
+			resolveResult = resolver.Resolve(expressionResult, parseInfo, python) as LocalResolveResult;			
+		}		
+		
+		[Test]
+		public void GetTypeOfInstance()
+		{
+			string code = "a = Class1()";
+			PythonVariableResolver resolver = new PythonVariableResolver();
+			Assert.AreEqual("Class1", resolver.Resolve("a", @"C:\Projects\Test\Test.py", code));
+		}
+
+		/// <summary>
+		/// Tests that the NameExpression in the resolver is reset so the second assignment
+		/// does not override the first.
+		/// </summary>
+		[Test]
+		public void DifferentTypeCreatedLast()
+		{
+			string code = "a = Class1()\r\n" +
+						"b = Class2()";
+			PythonVariableResolver resolver = new PythonVariableResolver();
+			Assert.AreEqual("Class1", resolver.Resolve("a", @"C:\Projects\Test\Test.py", code));
+		}
+		
+		[Test]
+		public void StringAssignmentShouldNotResolve()
+		{
+			string code = "a = \"test\"";
+			PythonVariableResolver resolver = new PythonVariableResolver();
+			Assert.AreEqual(null, resolver.Resolve("a", @"C:\Projects\Test\Test.py", code));
+		}
+		
+		[Test]
+		public void NullCodeShouldNotResolve()
+		{
+			PythonVariableResolver resolver = new PythonVariableResolver();
+			Assert.AreEqual(null, resolver.Resolve("a", @"C:\Projects\Test\Test.py", null));
+		}			
+		
+		[Test]
+		public void ResolveResultIsLocalResolveResult()
+		{
+			Assert.IsNotNull(resolveResult);
+		}
+
+		[Test]
+		public void ResolveResultVariableName()
+		{
+			Assert.AreEqual(resolveResult.VariableName, "a");
+		}
+	}
+}

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

@@ -0,0 +1,37 @@
+// 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;
+using System.Collections.Generic;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.SharpDevelop.Dom.CSharp;
+using NUnit.Framework;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveMethodFromUnknownImportAllTestFixture : ResolveTestsBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			return new ExpressionResult("methodcall", ExpressionContext.Default);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return 
+				"from unknown import *\r\n" +
+				"methodcall\r\n" +
+				"\r\n";
+		}
+		
+		[Test]
+		public void ResolveResultIsNull()
+		{
+			Assert.IsNull(resolveResult);
+		}
+	}
+}

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

@@ -0,0 +1,36 @@
+// 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;
+using System.Collections.Generic;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveMethodWhenFromImportIsUnknownTestFixture : ResolveTestsBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			return new ExpressionResult("methodcall", ExpressionContext.Default);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return 
+				"from unknown import methodcall\r\n" +
+				"methodcall\r\n" +
+				"\r\n";
+		}
+		
+		[Test]
+		public void ResolveResultIsNull()
+		{
+			Assert.IsNull(resolveResult);
+		}
+	}
+}

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

@@ -0,0 +1,36 @@
+// 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;
+using System.Collections.Generic;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveMethodWhenImportIsUnknownTestFixture : ResolveTestsBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			return new ExpressionResult("unknown.methodcall", ExpressionContext.Default);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return 
+				"from unknown import methodcall\r\n" +
+				"unknown.methodcall\r\n" +
+				"\r\n";
+		}
+		
+		[Test]
+		public void ResolveResultIsNull()
+		{
+			Assert.IsNull(resolveResult);
+		}
+	}
+}

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

@@ -9,7 +9,7 @@ using UnitTesting.Tests.Utils;
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolveSelfTests : ResolveTestFixtureBase
+	public class ResolveSelfTests : ResolveTestsBase
 	{
 		IClass fooClass;
 		

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

@@ -0,0 +1,136 @@
+// 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;
+using System.Collections.Generic;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.SharpDevelop.Dom.CSharp;
+using NUnit.Framework;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveSysModuleExitMethodTestFixture : ResolveTestsBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			return new ExpressionResult("sys.exit", ExpressionContext.Default);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return 
+				"import sys\r\n" +
+				"sys.exit\r\n" +
+				"\r\n";
+		}
+			
+		[Test]
+		public void ResolveResultIsMethodGroupResolveResult()
+		{
+			Assert.IsTrue(resolveResult is MethodGroupResolveResult);
+		}
+		
+		[Test]
+		public void ResolveResultMethodNameIsExit()
+		{
+			Assert.AreEqual("exit", MethodResolveResult.Name);
+		}
+		
+		MethodGroupResolveResult MethodResolveResult {
+			get { return (MethodGroupResolveResult)resolveResult; }
+		}
+		
+		[Test]
+		public void ResolveResultContainingTypeHasTwoExitMethods()
+		{
+			List<IMethod> exitMethods = GetExitMethods();
+			Assert.AreEqual(2, exitMethods.Count);
+		}
+		
+		List<IMethod> GetExitMethods()
+		{
+			return GetExitMethods(-1);
+		}
+		
+		List<IMethod> GetExitMethods(int parameterCount)
+		{
+			List<IMethod> methods = MethodResolveResult.ContainingType.GetMethods();
+			return PythonCompletionItemsHelper.FindAllMethodsFromCollection("exit", parameterCount, methods.ToArray());
+		}
+		
+		[Test]
+		public void BothExitMethodsArePublic()
+		{
+			foreach (IMethod method in GetExitMethods()) {
+				Assert.IsTrue(method.IsPublic);
+			}
+		}
+		
+		[Test]
+		public void BothExitMethodsHaveClassWithNameOfSys()
+		{
+			foreach (IMethod method in GetExitMethods()) {
+				Assert.AreEqual("sys", method.DeclaringType.Name);
+			}
+		}
+		
+		[Test]
+		public void OneExitMethodHasOneParameter()
+		{
+			int parameterCount = 1;
+			Assert.AreEqual(1, GetExitMethods(parameterCount).Count);
+		}
+		
+		[Test]
+		public void ExitMethodParameterNameIsCode()
+		{
+			IParameter parameter = GetFirstExitMethodParameter();
+			Assert.AreEqual("code", parameter.Name);
+		}
+		
+		IParameter GetFirstExitMethodParameter()
+		{
+			int parameterCount = 1;
+			List<IMethod> methods = GetExitMethods(parameterCount);
+			IMethod method = methods[0];
+			return method.Parameters[0];
+		}
+		
+		[Test]
+		public void ExitMethodParameterReturnTypeIsObject()
+		{
+			IParameter parameter = GetFirstExitMethodParameter();
+			Assert.AreEqual("Object", parameter.ReturnType.Name);
+		}
+		
+		[Test]
+		public void ExitMethodParameterConvertedToStringUsingAmbienceReturnsObjectCodeString()
+		{
+			IAmbience ambience = new CSharpAmbience();
+			string text = ambience.Convert(GetFirstExitMethodParameter());
+			Assert.AreEqual("object code", text);
+		}
+		
+		[Test]
+		public void ExitMethodReturnTypeConvertedToStringUsingAmbienceReturnsVoid()
+		{
+			IAmbience ambience = new CSharpAmbience();
+			List<IMethod> methods = GetExitMethods();
+			IReturnType returnType = methods[0].ReturnType;
+			string text = ambience.Convert(returnType);
+			Assert.AreEqual("void", text);
+		}
+		
+		[Test]
+		public void MethodGroupContainingTypeHasTwoExitMethods()
+		{
+			IReturnType returnType = MethodResolveResult.ContainingType;
+			List<IMethod> methods = PythonCompletionItemsHelper.FindAllMethodsFromCollection("exit", returnType.GetMethods());
+			Assert.AreEqual(2, methods.Count);
+		}
+	}
+}

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

@@ -0,0 +1,42 @@
+// 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.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveSysModuleImportedAsMySysTestFixture : ResolveTestsBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			return new ExpressionResult("mysys", ExpressionContext.Default);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return 
+				"import sys as mysys\r\n" +
+				"mysys\r\n" +
+				"\r\n";
+		}
+		
+		[Test]
+		public void ResolveResultContainsExitMethod()
+		{
+			List<ICompletionEntry> items = GetCompletionItems();
+			IMethod method = PythonCompletionItemsHelper.FindMethodFromCollection("exit", items);
+			Assert.IsNotNull(method);
+		}
+		
+		List<ICompletionEntry> GetCompletionItems()
+		{
+			return resolveResult.GetCompletionData(projectContent);
+		}
+	}
+}

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

@@ -11,7 +11,7 @@ using PythonBinding.Tests.Utils;
 namespace PythonBinding.Tests.Resolver
 {
 	[TestFixture]
-	public class ResolveSysModuleTestFixture : ResolveTestFixtureBase
+	public class ResolveSysModuleTestFixture : ResolveTestsBase
 	{
 		protected override ExpressionResult GetExpressionResult()
 		{

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

@@ -0,0 +1,36 @@
+// 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;
+using System.Collections.Generic;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveSysModuleUnknownMethodTestFixture : ResolveTestsBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			return new ExpressionResult("sys.unknown", ExpressionContext.Default);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return 
+				"import sys\r\n" +
+				"sys.unknown\r\n" +
+				"\r\n";
+		}
+			
+		[Test]
+		public void ResolveResultIsNull()
+		{
+			Assert.IsNull(resolveResult);
+		}
+	}
+}

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

@@ -0,0 +1,105 @@
+// 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;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+using PythonBinding.Tests;
+using PythonBinding.Tests.Utils;
+using UnitTesting.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	/// <summary>
+	/// Tests the PythonResolver correctly resolves the expression:
+	/// "System.Console"
+	/// </summary>
+	[TestFixture]
+	public class ResolveSystemConsoleTestFixture
+	{
+		PythonResolver resolver;
+		ICSharpCode.Scripting.Tests.Utils.MockProjectContent mockProjectContent;
+		ResolveResult resolveResult;
+		MockClass testClass;
+		ICompilationUnit compilationUnit;
+		MockClass systemConsoleClass;
+		ResolveResult invalidMostRecentCompilationUnitResolveResult;
+		
+		[TestFixtureSetUp]
+		public void SetUpFixture()
+		{
+			resolver = new PythonResolver();
+			mockProjectContent = new ICSharpCode.Scripting.Tests.Utils.MockProjectContent();
+			
+			systemConsoleClass = new MockClass(mockProjectContent, "System.Console");
+			mockProjectContent.ClassToReturnFromGetClass = systemConsoleClass;
+			
+			compilationUnit = CreateCompilationUnit(mockProjectContent);
+			ParseInformation parseInfo = new ParseInformation(compilationUnit);
+			
+			string python = GetPythonScript();
+			ExpressionResult expressionResult = new ExpressionResult("System.Console", new DomRegion(3, 2), null, null);
+			resolveResult = resolver.Resolve(expressionResult, parseInfo, python);
+			
+			// Check that the best compilation unit is used and the resolve
+			// still works.
+			invalidMostRecentCompilationUnitResolveResult = resolver.Resolve(expressionResult, parseInfo, python);
+		}
+		
+		[Test]
+		public void ResolveResultExists()
+		{
+			Assert.IsNotNull(resolveResult);
+		}
+		
+		[Test]
+		public void IsTypeResolveResult()
+		{
+			Assert.IsInstanceOf(typeof(TypeResolveResult), resolveResult);
+		}
+		
+		[Test]
+		public void ResolvedClass()
+		{
+			TypeResolveResult typeResolveResult = resolveResult as TypeResolveResult;
+			Assert.AreEqual(systemConsoleClass, typeResolveResult.ResolvedClass);
+		}
+		
+		[Test]
+		public void GetClassName()
+		{
+			Assert.AreEqual("System.Console", mockProjectContent.GetClassName);
+		}
+		
+		[Test]
+		public void ResolvedClassWithInvalidMostRecentCompilationUnit()
+		{
+			TypeResolveResult typeResolveResult = invalidMostRecentCompilationUnitResolveResult as TypeResolveResult;
+			Assert.AreEqual(systemConsoleClass, typeResolveResult.ResolvedClass);
+		}
+		
+		/// <summary>
+		/// Returns the Python script that will be used for testing.
+		/// </summary>
+		protected virtual string GetPythonScript()
+		{
+			return "import System\r\n" +
+					"class Test:\r\n" +
+					"\tdef __init__(self):\r\n" +
+					"\t\tSystem.Console\r\n";
+		}
+
+		/// <summary>
+		/// Creates a compilation unit with one class called Test.
+		/// </summary>
+		protected virtual ICompilationUnit CreateCompilationUnit(IProjectContent projectContent)
+		{
+			ICompilationUnit compilationUnit = new DefaultCompilationUnit(projectContent);
+			testClass = new MockClass(projectContent, "Test");
+			compilationUnit.Classes.Add(testClass);
+			return compilationUnit;
+		}
+	}
+}

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

@@ -0,0 +1,59 @@
+// 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;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+using PythonBinding.Tests;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	/// <summary>
+	/// Tests that the PythonResolver resolves "import System" to 
+	/// a namespace.
+	/// </summary>
+	[TestFixture]
+	public class ResolveSystemImportTestFixture : ResolveTestsBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			string code = GetPythonScript();
+			PythonExpressionFinder finder = new PythonExpressionFinder();
+			return finder.FindExpression(code, code.Length);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return "import System";
+		}
+		
+		[Test]
+		public void NamespaceResolveResultFound()
+		{
+			Assert.IsNotNull(resolveResult);
+		}
+		
+		[Test]
+		public void NamespaceName()
+		{
+			PythonImportModuleResolveResult importResolveResult = (PythonImportModuleResolveResult)resolveResult;
+			Assert.AreEqual("System", importResolveResult.Name);
+		}
+		
+		[Test]
+		public void ExpressionResultContextShowItemReturnsTrueForNamespaceEntry()
+		{
+			NamespaceEntry entry = new NamespaceEntry("abc");
+			Assert.IsTrue(expressionResult.Context.ShowEntry(entry));
+		}
+		
+		[Test]
+		public void ExpressionResultContextShowItemReturnsFalseForNull()
+		{
+			Assert.IsFalse(expressionResult.Context.ShowEntry(null));
+		}
+	}
+}

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

@@ -0,0 +1,68 @@
+// 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.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveSystemImportedAsMySystemTestFixture : ResolveTestsBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			List<ICompletionEntry> namespaceItems = new List<ICompletionEntry>();
+			DefaultClass consoleClass = new DefaultClass(compilationUnit, "System.Console");
+			namespaceItems.Add(consoleClass);
+			projectContent.AddExistingNamespaceContents("System", namespaceItems);
+			
+			return new ExpressionResult("MySystem", ExpressionContext.Default);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return 
+				"import System as MySystem\r\n" +
+				"MySystem.\r\n" +
+				"\r\n";
+		}
+				
+		[Test]
+		public void ResolveResultContainsConsoleClass()
+		{
+			List<ICompletionEntry> items = GetCompletionItems();
+			IClass consoleClass = PythonCompletionItemsHelper.FindClassFromCollection("Console", items);
+			Assert.IsNotNull(consoleClass);
+		}
+		
+		List<ICompletionEntry> GetCompletionItems()
+		{
+			return resolveResult.GetCompletionData(projectContent);
+		}
+		
+		[Test]
+		public void NamespaceResolveResultNameIsSystem()
+		{
+			NamespaceResolveResult namespaceResolveResult = resolveResult as NamespaceResolveResult;
+			Assert.AreEqual("System", namespaceResolveResult.Name);
+		}
+		
+		[Test]
+		public void MockProjectContentSystemNamespaceContentsIncludesConsoleClass()
+		{
+			List<ICompletionEntry> items = projectContent.GetNamespaceContents("System");
+			IClass consoleClass = PythonCompletionItemsHelper.FindClassFromCollection("Console", items);
+			Assert.IsNotNull(consoleClass);
+		}
+		
+		[Test]
+		public void MockProjectContentNamespaceExistsReturnsTrueForSystem()
+		{
+			Assert.IsTrue(projectContent.NamespaceExists("System"));
+		}
+	}
+}

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

@@ -0,0 +1,66 @@
+// 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.PythonBinding;
+using ICSharpCode.Scripting.Tests.Utils;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+using PythonBinding.Tests;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	/// <summary>
+	/// Tests the PythonResolver correctly resolves the expression:
+	/// "System"
+	/// </summary>
+	[TestFixture]
+	public class ResolveSystemNamespaceTestFixture
+	{
+		PythonResolver resolver;
+		MockProjectContent mockProjectContent;
+		NamespaceResolveResult resolveResult;
+		
+		[TestFixtureSetUp]
+		public void SetUpFixture()
+		{
+			resolver = new PythonResolver();
+			mockProjectContent = new MockProjectContent();
+			mockProjectContent.AddExistingNamespaceContents("System", new List<ICompletionEntry>());
+			
+			string python =
+				"import System\r\n" +
+				"class Test:\r\n" +
+				"    def __init__(self):\r\n" +
+				"        System.\r\n";
+			
+			PythonParser parser = new PythonParser();
+			string fileName = @"C:\Projects\Test\test.py";
+			DefaultCompilationUnit cu = parser.Parse(mockProjectContent, fileName, python) as DefaultCompilationUnit;
+			ParseInformation parseInfo = new ParseInformation(cu);
+			
+			ExpressionResult expressionResult = new ExpressionResult("System", new DomRegion(4, 2), null, null);
+			resolveResult = resolver.Resolve(expressionResult, parseInfo, python) as NamespaceResolveResult;
+		}
+		
+		[Test]
+		public void NamespaceExistsCalled()
+		{
+			Assert.IsTrue(mockProjectContent.NamespaceExistsCalled);
+		}
+		
+		[Test]
+		public void NamespaceSearchedFor()
+		{
+			Assert.AreEqual("System", mockProjectContent.NamespacePassedToNamespaceExistsMethod);
+		}
+				
+		[Test]
+		public void NamespaceResolveResultHasSystemNamespace()
+		{
+			Assert.AreEqual("System", resolveResult.Name);
+		}
+	}
+}

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

@@ -0,0 +1,44 @@
+// 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.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+using PythonBinding.Tests.Utils;
+using UnitTesting.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveSystemNamespaceWithMissingImportTestFixture : ResolveTestsBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			MockClass systemConsoleClass = new MockClass(projectContent, "System.Console");
+			List<ICompletionEntry> namespaceItems = new List<ICompletionEntry>();
+			namespaceItems.Add(systemConsoleClass);
+			projectContent.AddExistingNamespaceContents("System", namespaceItems);
+
+			return new ExpressionResult("System", ExpressionContext.Default);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return "System\r\n";
+		}
+		
+		[Test]
+		public void ResolveResultIsNullSinceSystemNamespaceIsNotImported()
+		{
+			Assert.IsNull(resolveResult);
+		}
+		
+		[Test]
+		public void ProjectContentNamespaceExistsReturnsTrueForSystemNamespace()
+		{
+			Assert.IsTrue(projectContent.NamespaceExists("System"));
+		}
+	}
+}

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

@@ -0,0 +1,45 @@
+// 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.PythonBinding;
+using ICSharpCode.Scripting.Tests.Utils;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+using PythonBinding.Tests;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveSystemWindowsFormsWithImportSystemTestFixture : ResolveTestsBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			MockProjectContent referencedContent = new MockProjectContent();
+			List<ICompletionEntry> namespaceItems = new List<ICompletionEntry>();
+			referencedContent.AddExistingNamespaceContents("System.Windows.Forms", namespaceItems);
+			projectContent.ReferencedContents.Add(referencedContent);
+			
+			return new ExpressionResult("System.Windows.Forms");
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return
+				"import System\r\n" +
+				"System.Windows.Forms\r\n";
+		}
+		
+		NamespaceResolveResult NamespaceResolveResult {
+			get { return resolveResult as NamespaceResolveResult; }
+		}
+		
+		[Test]
+		public void NamespaceResolveResultHasSystemNamespace()
+		{
+			Assert.AreEqual("System.Windows.Forms", NamespaceResolveResult.Name);
+		}
+	}
+}

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

@@ -0,0 +1,45 @@
+// 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.PythonBinding;
+using ICSharpCode.Scripting.Tests.Utils;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+using PythonBinding.Tests;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveSystemWindowsWithImportSystemTestFixture : ResolveTestsBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			MockProjectContent referencedContent = new MockProjectContent();
+			List<ICompletionEntry> namespaceItems = new List<ICompletionEntry>();
+			referencedContent.AddExistingNamespaceContents("System.Windows.Forms", namespaceItems);
+			projectContent.ReferencedContents.Add(referencedContent);
+			
+			return new ExpressionResult("System.Windows");
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return
+				"import System\r\n" +
+				"System.Windows\r\n";
+		}
+		
+		NamespaceResolveResult NamespaceResolveResult {
+			get { return resolveResult as NamespaceResolveResult; }
+		}
+		
+		[Test]
+		public void NamespaceResolveResultHasSystemWindowsNamespace()
+		{
+			Assert.AreEqual("System.Windows", NamespaceResolveResult.Name);
+		}
+	}
+}

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

@@ -0,0 +1,39 @@
+// 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;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+using PythonBinding.Tests;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveSystemWithImportSystemWindowsTestFixture : ResolveTestsBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			return new ExpressionResult("System");
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return
+				"import System.Windows\r\n" +
+				"System\r\n";
+		}
+		
+		NamespaceResolveResult NamespaceResolveResult {
+			get { return resolveResult as NamespaceResolveResult; }
+		}
+		
+		[Test]
+		public void NamespaceResolveResultHasSystemNamespace()
+		{
+			Assert.AreEqual("System", NamespaceResolveResult.Name);
+		}
+	}
+}

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

@@ -0,0 +1,63 @@
+// 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;
+using System.Collections.Generic;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.SharpDevelop.Dom.CSharp;
+using NUnit.Framework;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveTanMethodFromMathImportAllTestFixture : ResolveTestsBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			return new ExpressionResult("tan", ExpressionContext.Default);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return
+				"from sys import *\r\n" +
+				"from math import *\r\n" +
+				"from socket import *\r\n" +
+				"\r\n" +
+				"tan\r\n" +
+				"\r\n";
+		}
+		
+		[Test]
+		public void ResolveResultIsMethodGroupResolveResult()
+		{
+			Assert.IsTrue(resolveResult is MethodGroupResolveResult);
+		}
+		
+		[Test]
+		public void ResolveResultMethodNameIsTan()
+		{
+			Assert.AreEqual("tan", MethodResolveResult.Name);
+		}
+		
+		MethodGroupResolveResult MethodResolveResult {
+			get { return (MethodGroupResolveResult)resolveResult; }
+		}
+		
+		[Test]
+		public void ResolveResultContainingTypeHasOneTanMethods()
+		{
+			List<IMethod> tanMethods = GetTanMethods();
+			Assert.AreEqual(1, tanMethods.Count);
+		}
+		
+		List<IMethod> GetTanMethods()
+		{
+			List<IMethod> methods = MethodResolveResult.ContainingType.GetMethods();
+			return PythonCompletionItemsHelper.FindAllMethodsFromCollection("tan", -1, methods.ToArray());
+		}
+	}
+}

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

@@ -0,0 +1,60 @@
+// 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;
+using System.Collections.Generic;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.SharpDevelop.Dom.CSharp;
+using NUnit.Framework;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveTanMethodFromMathImportCosAndTanTestFixture : ResolveTestsBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			return new ExpressionResult("tan", ExpressionContext.Default);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return 
+				"from math import cos, tan\r\n" +
+				"tan\r\n" +
+				"\r\n";
+		}
+			
+		[Test]
+		public void ResolveResultIsMethodGroupResolveResult()
+		{
+			Assert.IsTrue(resolveResult is MethodGroupResolveResult);
+		}
+		
+		[Test]
+		public void ResolveResultMethodNameIsTan()
+		{
+			Assert.AreEqual("tan", MethodResolveResult.Name);
+		}
+		
+		MethodGroupResolveResult MethodResolveResult {
+			get { return (MethodGroupResolveResult)resolveResult; }
+		}
+		
+		[Test]
+		public void ResolveResultContainingTypeHasOneTanMethods()
+		{
+			List<IMethod> tanMethods = GetTanMethods();
+			Assert.AreEqual(1, tanMethods.Count);
+		}
+		
+		List<IMethod> GetTanMethods()
+		{
+			List<IMethod> methods = MethodResolveResult.ContainingType.GetMethods();
+			return PythonCompletionItemsHelper.FindAllMethodsFromCollection("tan", -1, methods.ToArray());
+		}
+	}
+}

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

@@ -0,0 +1,41 @@
+// 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.Scripting.Tests.Utils;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	public abstract class ResolveTestsBase
+	{
+		protected ICompilationUnit compilationUnit;
+		protected MockProjectContent projectContent;
+		protected PythonResolver resolver;
+		protected ResolveResult resolveResult;
+		protected ParseInformation parseInfo;
+		protected ExpressionResult expressionResult;
+		
+		[SetUp]
+		public void InitBase()
+		{
+			projectContent = new MockProjectContent();
+			PythonParser parser = new PythonParser();
+			string fileName = @"C:\projects\test\test.py";
+			compilationUnit = parser.Parse(projectContent, fileName, GetPythonScript());
+			parseInfo = new ParseInformation(compilationUnit);
+			
+			resolver = new PythonResolver();
+			
+			expressionResult = GetExpressionResult();
+			resolveResult = resolver.Resolve(expressionResult, parseInfo, GetPythonScript());
+		}
+		
+		protected abstract ExpressionResult GetExpressionResult();
+		
+		protected abstract string GetPythonScript();
+	}
+}

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

@@ -0,0 +1,51 @@
+// 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;
+using System.Collections.Generic;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.SharpDevelop.Dom.CSharp;
+using NUnit.Framework;
+using PythonBinding.Tests.Utils;
+using UnitTesting.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveTextBoxFromSystemWindowsFormsImportTextBoxTests : ResolveTestsBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			MockClass textBoxClass = new MockClass(projectContent, "System.Windows.Forms.TextBox");
+			projectContent.SetClassToReturnFromGetClass("System.Windows.Forms.TextBox", textBoxClass);
+			
+			return new ExpressionResult("TextBox", ExpressionContext.Default);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return 
+				"from System.Windows.Forms import TextBox\r\n" +
+				"TextBox\r\n" +
+				"\r\n";
+		}
+			
+		[Test]
+		public void ResolveResultIsTypeResolveResult()
+		{
+			Assert.IsTrue(resolveResult is TypeResolveResult);
+		}
+		
+		[Test]
+		public void ResolveResultResolveClassNameIsTextBox()
+		{
+			Assert.AreEqual("TextBox", TypeResolveResult.ResolvedClass.Name);
+		}
+		
+		TypeResolveResult TypeResolveResult {
+			get { return (TypeResolveResult)resolveResult; }
+		}
+	}
+}

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

@@ -0,0 +1,51 @@
+// 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;
+using System.Collections.Generic;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.SharpDevelop.Dom.CSharp;
+using NUnit.Framework;
+using PythonBinding.Tests.Utils;
+using UnitTesting.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveTextBoxFromSystemWindowsFormsImportedAsFooTests : ResolveTestsBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			MockClass textBoxClass = new MockClass(projectContent, "System.Windows.Forms.TextBox");
+			projectContent.SetClassToReturnFromGetClass("System.Windows.Forms.TextBox", textBoxClass);
+			
+			return new ExpressionResult("Foo.TextBox", ExpressionContext.Default);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return 
+				"import System.Windows.Forms as Foo\r\n" +
+				"Foo.TextBox\r\n" +
+				"\r\n";
+		}
+		
+		[Test]
+		public void ResolveResultIsTypeResolveResult()
+		{
+			Assert.IsTrue(resolveResult is TypeResolveResult);
+		}
+		
+		[Test]
+		public void ResolveResultResolveClassNameIsTextBox()
+		{
+			Assert.AreEqual("TextBox", TypeResolveResult.ResolvedClass.Name);
+		}
+		
+		TypeResolveResult TypeResolveResult {
+			get { return (TypeResolveResult)resolveResult; }
+		}
+	}
+}

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

@@ -0,0 +1,51 @@
+// 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;
+using System.Collections.Generic;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.SharpDevelop.Dom.CSharp;
+using NUnit.Framework;
+using PythonBinding.Tests.Utils;
+using UnitTesting.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolveTextBoxFromSystemWindowsFormsImportedAsMyTextBoxTests : ResolveTestsBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			MockClass textBoxClass = new MockClass(projectContent, "System.Windows.Forms.TextBox");
+			projectContent.SetClassToReturnFromGetClass("System.Windows.Forms.TextBox", textBoxClass);
+			
+			return new ExpressionResult("MyTextBox", ExpressionContext.Default);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return 
+				"from System.Windows.Forms import TextBox as MyTextBox\r\n" +
+				"MyTextBox\r\n" +
+				"\r\n";
+		}
+			
+		[Test]
+		public void ResolveResultIsTypeResolveResult()
+		{
+			Assert.IsTrue(resolveResult is TypeResolveResult);
+		}
+		
+		[Test]
+		public void ResolveResultResolveClassNameIsTextBox()
+		{
+			Assert.AreEqual("TextBox", TypeResolveResult.ResolvedClass.Name);
+		}
+		
+		TypeResolveResult TypeResolveResult {
+			get { return (TypeResolveResult)resolveResult; }
+		}
+	}
+}

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

@@ -0,0 +1,43 @@
+// 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.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+using PythonBinding.Tests;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	/// <summary>
+	/// Tests the PythonResolver does not return a namespace resolve result for
+	/// an unknown namespace.
+	/// </summary>
+	[TestFixture]
+	public class ResolveUnknownNamespaceTestFixture : ResolveTestsBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			projectContent.AddExistingNamespaceContents("System", new List<ICompletionEntry>());
+			
+			return new ExpressionResult("Unknown", new DomRegion(3, 2), null, null);
+		}
+		
+		protected override string GetPythonScript()
+		{
+			return
+				"import System\r\n" +
+				"class Test:\r\n" +
+				"    def __init__(self):\r\n" +
+				"        Unknown\r\n";
+		}
+		
+		[Test]
+		public void ResolveResultDoesNotExist()
+		{
+			Assert.IsNull(resolveResult);
+		}
+	}
+}

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

@@ -16,7 +16,6 @@ namespace ICSharpCode.Scripting.Tests.Utils
 		bool searchTypeCalled;
 		SearchTypeRequest searchTypeRequest;
 		IClass classToReturnFromGetClass;
-		bool getClassCalled;
 		string getClassName;
 		List<IClass> classesInProjectContent = new List<IClass>();
 		string namespacePassedToGetNamespaceContentsMethod;
@@ -26,10 +25,6 @@ namespace ICSharpCode.Scripting.Tests.Utils
 		Dictionary<string, List<ICompletionEntry>> namespaceContents = new Dictionary<string, List<ICompletionEntry>>();
 		LanguageProperties language = LanguageProperties.CSharp;
 		List<IProjectContent> referencedContents = new List<IProjectContent>();
-		
-		public MockProjectContent()
-		{
-		}
 			
 		/// <summary>
 		/// Gets the namespaces that will be added when the
@@ -91,12 +86,11 @@ namespace ICSharpCode.Scripting.Tests.Utils
 			get { return classNameForGetClass; }
 			set { classNameForGetClass = value; }
 		}
-
+		
-		/// <summary>
+		public void SetClassToReturnFromGetClass(string className, IClass classToReturn)
-		/// Gets whether the GetClass method was called.
+		{
-		/// </summary>
+			ClassToReturnFromGetClass = classToReturn;
-		public bool GetClassCalled {
+			ClassNameForGetClass = className;
-			get { return getClassCalled; }
 		}
 
 		/// <summary>
@@ -187,7 +181,6 @@ namespace ICSharpCode.Scripting.Tests.Utils
 		public IClass GetClass(string typeName, int typeParameterCount)
 		{
 			getClassName = typeName;
-			getClassCalled = true;
 			
 			// If a class name is specified then only return a class
 			// if we have a match.
@@ -258,9 +251,6 @@ namespace ICSharpCode.Scripting.Tests.Utils
 		
 		public string SearchNamespace(string name, IClass curType, ICompilationUnit unit, int caretLine, int caretColumn)
 		{
-//			searchNamespaceCalled = true;
-//			namespaceSearchedFor = name;
-//			return searchNamespace;
 			throw new NotImplementedException();
 		}
 		
@@ -290,21 +280,13 @@ namespace ICSharpCode.Scripting.Tests.Utils
 		{
 			throw new NotImplementedException();
 		}
-		#endregion
-
-		protected virtual void OnReferencedContentsChanged(EventArgs e)
-		{
-			if (ReferencedContentsChanged != null) {
-				ReferencedContentsChanged(this, e);
-			}
-		}
 		
 		public bool InternalsVisibleTo(IProjectContent otherProjectContent)
 		{
 			throw new NotImplementedException();
 		}
 		
-			public string AssemblyName {
+		public string AssemblyName {
 			get {
 				throw new NotImplementedException();
 			}
@@ -319,5 +301,13 @@ namespace ICSharpCode.Scripting.Tests.Utils
 		{
 			throw new NotImplementedException();
 		}
+		#endregion
+
+		protected virtual void OnReferencedContentsChanged(EventArgs e)
+		{
+			if (ReferencedContentsChanged != null) {
+				ReferencedContentsChanged(this, e);
+			}
+		}
 	}
 }

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

@@ -24,7 +24,7 @@ namespace ICSharpCode.Scripting.Tests.Utils.Tests
 		}
 		
 		[Test]
-		public void AddNamespaceContentsAddsNamespaces()
+		public void AddNamespaceContents_NamespacesSetToBeAdded_AddsNamespacesToList()
 		{
 			projectContent.NamespacesToAdd.Add("test");
 			projectContent.AddNamespaceContents(items, String.Empty, null, false);
@@ -36,7 +36,7 @@ namespace ICSharpCode.Scripting.Tests.Utils.Tests
 		}
 			
 		[Test]
-		public void AddNamespaceContentsAddsClasses()
+		public void AddNamespaceContents_OneClassInProjectContent_AddsClassToList()
 		{
 			MockClass c = new MockClass(new MockProjectContent(), "TestClass");
 			projectContent.ClassesInProjectContent.Add(c);
@@ -49,20 +49,22 @@ namespace ICSharpCode.Scripting.Tests.Utils.Tests
 		}
 
 		[Test]
-		public void NamespaceContentsSearchedIsNullByDefault()
+		public void NamespacePassedToGetNamespaceContentsMethod_GetNamespaceContentsNotCalled_ReturnsNull()
 		{
-			Assert.IsNull(projectContent.NamespacePassedToGetNamespaceContentsMethod);
+			string name = projectContent.NamespacePassedToGetNamespaceContentsMethod;
+			Assert.IsNull(name);
 		}
 		
 		[Test]
-		public void NamespacePassedToGetNamespaceMethodIsSaved()
+		public void NamespacePassedToGetNamespaceMethod_GetNamespaceContentsCalled_ReturnsNamespacePassedMethod()
 		{
 			projectContent.GetNamespaceContents("abc");
-			Assert.AreEqual("abc", projectContent.NamespacePassedToGetNamespaceContentsMethod);
+			string name = projectContent.NamespacePassedToGetNamespaceContentsMethod;
+			Assert.AreEqual("abc", name);
 		}
 		
 		[Test]
-		public void GetNamespaceContentsReturnsExpectedItems()
+		public void GetNamespaceContents_EmptyNamespacePassed_ReturnsExpectedItemsForEmptyNamespace()
 		{
 			List<ICompletionEntry> namespaceItems = new List<ICompletionEntry>();
 			namespaceItems.Add(new NamespaceEntry("test"));
@@ -76,25 +78,26 @@ namespace ICSharpCode.Scripting.Tests.Utils.Tests
 		}
 		
 		[Test]
-		public void NamespaceExistsReturnsTrueForAddedExistingNamespace()
+		public void NamespaceExists_NamespaceAddedToExistingNamespaceContents_ReturnsTrue()
 		{
 			List<ICompletionEntry> items = new List<ICompletionEntry>();
 			projectContent.AddExistingNamespaceContents("System", items);
-
+			bool result = projectContent.NamespaceExists("System");
-			Assert.IsTrue(projectContent.NamespaceExists("System"));
+			
+			Assert.IsTrue(result);
 		}
 		
 		[Test]
-		public void NamespaceExistsReturnsFalseForUnknownNamespace()
+		public void NamespaceExists_UnknownNamespace_ReturnsFalse()
 		{
 			List<ICompletionEntry> items = new List<ICompletionEntry>();
 			projectContent.AddExistingNamespaceContents("System", items);
-			
+			bool result = projectContent.NamespaceExists("Unknown");
-			Assert.IsFalse(projectContent.NamespaceExists("Unknown"));
+			Assert.IsFalse(result);
 		}
 		
 		[Test]
-		public void GetNamespaceContentsReturnsItemsForAddedExistingNamespace()
+		public void GetNamespaceContents_AddExistingNamespaceContentsCalledWithCompletionItemsForTwoNamespaces_ReturnsItemsForSystemNamespace()
 		{
 			List<ICompletionEntry> items = new List<ICompletionEntry>();
 			items.Add(new NamespaceEntry("test"));
@@ -102,22 +105,25 @@ namespace ICSharpCode.Scripting.Tests.Utils.Tests
 			projectContent.AddExistingNamespaceContents("Math", new List<ICompletionEntry>());
 			projectContent.AddExistingNamespaceContents("System", items);
 			
+			List<ICompletionEntry> actualItems = projectContent.GetNamespaceContents("System");
+			
 			List<ICompletionEntry> expectedItems = new List<ICompletionEntry>();
 			expectedItems.Add(new NamespaceEntry("test"));
 			
-			Assert.AreEqual(expectedItems, projectContent.GetNamespaceContents("System"));
+			Assert.AreEqual(expectedItems, actualItems);
 		}
 		
 		[Test]
-		public void GetNamespaceContentsReturnsEmptyArrayListForUnknownNamespace()
+		public void GetNamespaceContents_UnknownNamespace_ReturnsEmptyArrayListF()
 		{
 			List<ICompletionEntry> items = new List<ICompletionEntry>();
 			items.Add(new NamespaceEntry("test"));
 			projectContent.AddExistingNamespaceContents("System", items);
 			
+			List<ICompletionEntry> actualItems = projectContent.GetNamespaceContents("Unknown");
 			List<ICompletionEntry> expectedItems = new List<ICompletionEntry>();
 			
-			Assert.AreEqual(expectedItems, projectContent.GetNamespaceContents("Unknown"));
+			Assert.AreEqual(expectedItems, actualItems);
 		}
 		
 		[Test]
@@ -128,88 +134,90 @@ namespace ICSharpCode.Scripting.Tests.Utils.Tests
 		}
 		
 		[Test]
-		public void NamespaceExistsCalledIsFalseInitially()
+		public void NamespaceExistsCalled_NamespaceExistsMethodNotCalled_ReturnsFalse()
 		{
 			Assert.IsFalse(projectContent.NamespaceExistsCalled);
 		}
 		
 		[Test]
-		public void NamespaceExistsCalledReturnsTrueAfterMethodCall()
+		public void NamespaceExistsCalled_NamespaceExistsMethodCalled_ReturnsTrue()
 		{
 			projectContent.NamespaceExists("System");
-			Assert.IsTrue(projectContent.NamespaceExistsCalled);
+			bool result = projectContent.NamespaceExistsCalled;
+			Assert.IsTrue(result);
 		}
 		
 		[Test]
-		public void GetClassReturnsNullByDefault()
+		public void GetClass_NewInstance_ReturnsNullByDefault()
 		{
-			Assert.IsNull(projectContent.GetClass("test", 0));
+			IClass c = projectContent.GetClass("test", 0);
+			Assert.IsNull(c);
 		}
 		
 		[Test]
-		public void GetClassNameReturnsClassNamePassedToGetClassMethod()
+		public void GetClassName_GetClassCalledWithClassName_ReturnsClassNamePassedToGetClassMethod()
 		{
 			projectContent.GetClass("abc", 0);
-			Assert.AreEqual("abc", projectContent.GetClassName);
+			string name = projectContent.GetClassName;
+			Assert.AreEqual("abc", name);
 		}
 		
 		[Test]
-		public void GetClassCalledIsFalseByDefault()
+		public void GetClass_ClassNameDoesNotMatchAndNoClassNameForGetClassSpecified_ReturnsTestClassSinceNoClassNameRestrictionSpecified()
 		{
-			Assert.IsFalse(projectContent.GetClassCalled);
+			MockClass expectedClass = new MockClass(projectContent, "test");
-		}
+			projectContent.ClassToReturnFromGetClass = expectedClass;
-		
+			IClass c = projectContent.GetClass("abcdef", 0);
-		[Test]
+			
-		public void GetClassCalledIsTrueAfterGetClassCalled()
+			Assert.AreEqual(expectedClass, c);
-		{
-			projectContent.GetClass("abc", 0);
-			Assert.IsTrue(projectContent.GetClassCalled);
 		}
 		
 		[Test]
-		public void GetClassReturnsClassEvenIfClassNameDoesNotMatchAndNoClassNameForGetClassSpecified()
+		public void GetClass_ClassNameDoesNotMatchClassNameForGetClassProperty_ReturnsNull()
 		{
 			MockClass c = new MockClass(projectContent, "test");
-			projectContent.ClassToReturnFromGetClass = c;
+			projectContent.SetClassToReturnFromGetClass("test", c);
 			
-			Assert.AreEqual(c, projectContent.GetClass("abcdef", 0));
+			Assert.IsNull(projectContent.GetClass("abcdef", 0));
 		}
 		
 		[Test]
-		public void GetClassReturnsNullIfClassNameDoesNotMatchClassNameForGetClassProperty()
+		public void GetClass_ClassNameMatchesClassNameForGetClassProperty_ReturnsTestClass()
 		{
-			MockClass c = new MockClass(projectContent, "test");
+			MockClass expectedClass = new MockClass(projectContent, "test");
-			projectContent.ClassToReturnFromGetClass = c;
+			projectContent.SetClassToReturnFromGetClass("test", expectedClass);
-			projectContent.ClassNameForGetClass = "test";
 			
-			Assert.IsNull(projectContent.GetClass("abcdef", 0));
+			IClass c = projectContent.GetClass("test", 0);
+			
+			Assert.AreEqual(expectedClass, c);
 		}
 		
 		[Test]
-		public void GetClassReturnsClassIfClassNameMatchesClassNameForGetClassProperty()
+		public void ReferencedContents_NewInstance_HasNoItemsByDefault()
 		{
-			MockClass c = new MockClass(projectContent, "test");
+			int count = projectContent.ReferencedContents.Count;
-			projectContent.ClassToReturnFromGetClass = c;
+			Assert.AreEqual(0, count);
-			projectContent.ClassNameForGetClass = "test";
-			
-			Assert.AreEqual(c, projectContent.GetClass("test", 0));
 		}
 		
 		[Test]
-		public void NamespaceNamesHasNoItemsByDefault()
+		public void NamespaceNames_NewInstance_HasNoItemsByDefault()
 		{
-			Assert.AreEqual(0, projectContent.ReferencedContents.Count);
+			int count = projectContent.NamespaceNames.Count;
+			Assert.AreEqual(0, count);
 		}
 		
 		[Test]
-		public void NamespaceNamesContainingsNamespaceAddedToExistingNamespaces()
+		public void NamespaceNames_NamespaceAddedToExistingNamespaces_NamespaceIncludedInReturnedCollection()
 		{
 			List<ICompletionEntry> namespaceItems = new List<ICompletionEntry>();
 			projectContent.AddExistingNamespaceContents("System", namespaceItems);
+			
+			ICollection<string> names = projectContent.NamespaceNames;
+			
 			List<string> expectedNames = new List<string>();
 			expectedNames.Add("System");
 			
-			Assert.AreEqual(expectedNames, projectContent.NamespaceNames);
+			Assert.AreEqual(expectedNames, names);
 		}
 	}
 }