Added constructor insight for python and further improved completion for imported .NET libraries.

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/branches/3.0@5476 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61

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

@@ -12,40 +12,45 @@ namespace ICSharpCode.PythonBinding
 {
 	public class PythonClassResolver : IPythonResolver
 	{
+		PythonResolverContext resolverContext;
+		
 		public PythonClassResolver()
 		{
 		}
 		
-		public ResolveResult Resolve(PythonResolverContext context, ExpressionResult expressionResult)
+		public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult)
 		{
-			IClass matchingClass = GetClass(context, expressionResult.Expression);
+			IClass matchingClass = GetClass(resolverContext, expressionResult.Expression);
 			if (matchingClass != null) {
 				return CreateTypeResolveResult(matchingClass);
 			}
 			return null;
 		}
 		
-		public IClass GetClass(PythonResolverContext context, string name)
+		public IClass GetClass(PythonResolverContext resolverContext, string name)
 		{
+			this.resolverContext = resolverContext;
+			
 			if (String.IsNullOrEmpty(name)) {
 				return null;
 			}
 			
-			IClass matchedClass = context.GetClass(name);
+			IClass matchedClass = resolverContext.GetClass(name);
 			if (matchedClass != null) {
 				return matchedClass;
 			}
 			
-			matchedClass = GetClassFromImportedNames(context, name);
+			matchedClass = GetClassFromImportedNames(name);
 			if (matchedClass != null) {
 				return matchedClass;
 			}
 			
-			matchedClass = GetClassFromNamespaceThatImportsEverything(context, name);
+			matchedClass = GetClassFromNamespaceThatImportsEverything(name);
 			if (matchedClass != null) {
 				return matchedClass;
 			}
-			return null;
+			
+			return GetClassFromDottedImport(name);
 		}
 		
 		TypeResolveResult CreateTypeResolveResult(IClass c)
@@ -53,13 +58,13 @@ namespace ICSharpCode.PythonBinding
 			return new TypeResolveResult(null, null, c);
 		}
 		
-		IClass GetClassFromImportedNames(PythonResolverContext context, string name)
+		IClass GetClassFromImportedNames(string name)
 		{
-			string moduleName = context.GetModuleForImportedName(name);
+			string moduleName = resolverContext.GetModuleForImportedName(name);
 			if (moduleName != null) {
-				name = context.UnaliasImportedName(name);
+				name = resolverContext.UnaliasImportedName(name);
 				string fullyQualifiedName = GetQualifiedClassName(moduleName, name);
-				return context.GetClass(fullyQualifiedName);
+				return resolverContext.GetClass(fullyQualifiedName);
 			}
 			return null;
 		}
@@ -69,16 +74,33 @@ namespace ICSharpCode.PythonBinding
 			return namespacePrefix + "." + className;
 		}
 		
-		IClass GetClassFromNamespaceThatImportsEverything(PythonResolverContext context, string name)
+		IClass GetClassFromNamespaceThatImportsEverything(string name)
 		{
-			foreach (string moduleName in context.GetModulesThatImportEverything()) {
+			foreach (string moduleName in resolverContext.GetModulesThatImportEverything()) {
 				string fullyQualifiedName = GetQualifiedClassName(moduleName, name);
-				IClass matchedClass = context.GetClass(fullyQualifiedName);
+				IClass matchedClass = resolverContext.GetClass(fullyQualifiedName);
 				if (matchedClass != null) {
 					return matchedClass;
 				}
 			}
 			return null;
 		}
+		
+		IClass GetClassFromDottedImport(string name)
+		{
+			string moduleName = resolverContext.FindStartOfDottedModuleNameInImports(name);
+			if (moduleName != null) {
+				string fullyQualifiedName = UnaliasClassName(moduleName, name);
+				return resolverContext.GetClass(fullyQualifiedName);
+			}
+			return null;
+		}
+		
+		string UnaliasClassName(string moduleName, string fullClassName)
+		{
+			string actualModuleName = resolverContext.UnaliasImportedModuleName(moduleName);
+			string lastPartOfClassName = fullClassName.Substring(moduleName.Length + 1);
+			return GetQualifiedClassName(actualModuleName, lastPartOfClassName);
+		}
 	}
 }

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

@@ -27,5 +27,9 @@ namespace ICSharpCode.PythonBinding
 		public override CodeDomProvider CodeDomProvider {
 			get { return new CSharpCodeProvider(); }
 		}
+		
+		public override bool AllowObjectConstructionOutsideContext {
+			get { return true; }
+		}
 	}
 }

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

@@ -12,26 +12,61 @@ namespace ICSharpCode.PythonBinding
 {
 	public class PythonNamespaceResolver : IPythonResolver
 	{
+		PythonResolverContext resolverContext;
+		ExpressionResult expressionResult;
+		
 		public PythonNamespaceResolver()
 		{
 		}
 		
 		public ResolveResult Resolve(PythonResolverContext resolverContext, ExpressionResult expressionResult)
 		{
-			if (!resolverContext.HasImport(expressionResult.Expression)) {
-				return null;
+			this.resolverContext = resolverContext;
+			this.expressionResult = expressionResult;
+			
+			if (resolverContext.HasImport(expressionResult.Expression)) {
+				return ResolveFullNamespace();
 			}
+			return ResolvePartialNamespaceMatch();
+		}
 			
+		ResolveResult ResolveFullNamespace()
+		{
 			string actualNamespace = resolverContext.UnaliasImportedModuleName(expressionResult.Expression);
-			return CreateNamespaceResolveResultIfNamespaceExists(resolverContext, actualNamespace);
+			return ResolveIfNamespaceExistsInProjectReferences(actualNamespace);
+		}	
+		
+		ResolveResult ResolvePartialNamespaceMatch()
+		{
+			string fullNamespace = expressionResult.Expression;
+			if (resolverContext.IsStartOfDottedModuleNameImported(fullNamespace)) {
+				return ResolveIfPartialNamespaceExistsInProjectReferences(fullNamespace);
+			} else if (resolverContext.HasDottedImportNameThatStartsWith(fullNamespace)) {
+				return CreateNamespaceResolveResult(fullNamespace);
+			}
+			return null;
 		}
 		
-		ResolveResult CreateNamespaceResolveResultIfNamespaceExists(PythonResolverContext resolverContext, string namespaceName)
+		ResolveResult ResolveIfNamespaceExistsInProjectReferences(string namespaceName)
 		{
 			if (resolverContext.NamespaceExistsInProjectReferences(namespaceName)) {
-				return new NamespaceResolveResult(null, null, namespaceName);
+				return CreateNamespaceResolveResult(namespaceName);
 			}
 			return null;
 		}
+		
+		ResolveResult ResolveIfPartialNamespaceExistsInProjectReferences(string namespaceName)
+		{
+			string actualNamespace = resolverContext.UnaliasStartOfDottedImportedModuleName(namespaceName);
+			if (resolverContext.PartialNamespaceExistsInProjectReferences(actualNamespace)) {
+				return CreateNamespaceResolveResult(actualNamespace);
+			}
+			return null;
+		}
+		
+		ResolveResult CreateNamespaceResolveResult(string namespaceName)
+		{
+			return new NamespaceResolveResult(null, null, namespaceName);
+		}
 	}
 }

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

@@ -59,6 +59,26 @@ namespace ICSharpCode.PythonBinding
 			return projectContent.NamespaceExists(name);
 		}
 		
+		public bool PartialNamespaceExistsInProjectReferences(string name)
+		{
+			foreach (IProjectContent referencedContent in projectContent.ReferencedContents) {
+				if (PartialNamespaceExists(referencedContent, name)) {
+					return true;
+				}
+			}
+			return false;
+		}
+		
+		bool PartialNamespaceExists(IProjectContent projectContent, string name)
+		{
+			foreach (string namespaceReference in projectContent.NamespaceNames) {
+				if (namespaceReference.StartsWith(name)) {
+					return true;
+				}
+			}
+			return false;
+		}
+		
 		/// <summary>
 		/// Determines the class and member at the specified
 		/// line and column in the specified file.
@@ -238,5 +258,51 @@ namespace ICSharpCode.PythonBinding
 			}
 			return modules.ToArray();
 		}
+		
+		public bool IsStartOfDottedModuleNameImported(string fullDottedModuleName)
+		{
+			return FindStartOfDottedModuleNameInImports(fullDottedModuleName) != null;
+		}
+		
+		public string FindStartOfDottedModuleNameInImports(string fullDottedModuleName)
+		{
+			MemberName memberName = new MemberName(fullDottedModuleName);
+			while (memberName.HasName) {
+				string partialNamespace = memberName.Type;
+				if (HasImport(partialNamespace)) {
+					return partialNamespace;
+				}
+				memberName = new MemberName(partialNamespace);
+			}
+			return null;
+		}
+		
+		public string UnaliasStartOfDottedImportedModuleName(string fullDottedModuleName)
+		{
+			string startOfModuleName = FindStartOfDottedModuleNameInImports(fullDottedModuleName);
+			if (startOfModuleName != null) {
+				return UnaliasStartOfDottedImportedModuleName(startOfModuleName, fullDottedModuleName);
+			}
+			return fullDottedModuleName;
+		}
+		
+		string UnaliasStartOfDottedImportedModuleName(string startOfModuleName, string fullModuleName)
+		{
+			string unaliasedStartOfModuleName = UnaliasImportedModuleName(startOfModuleName);
+			return unaliasedStartOfModuleName + fullModuleName.Substring(startOfModuleName.Length);
+		}
+		
+		public bool HasDottedImportNameThatStartsWith(string importName)
+		{
+			string dottedImportNameStartsWith = importName + ".";
+			foreach (IUsing u in mostRecentCompilationUnit.UsingScope.Usings) {
+				foreach (string ns in u.Usings) {
+					if (ns.StartsWith(dottedImportNameStartsWith)) {
+						return true;
+					}
+				}
+			}
+			return false;
+		}
 	}
 }

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

@@ -364,6 +364,8 @@
     <Compile Include="Resolver\ResolveConsoleWriteLineTestFixture.cs" />
     <Compile Include="Resolver\ResolveExitMethodFromSysImportExitAsMyExitTestFixture.cs" />
     <Compile Include="Resolver\ResolveExitMethodFromSysImportExitTestFixture.cs" />
+    <Compile Include="Resolver\ResolveFooTextBoxFromSystemWindowsFormsImportedAsFooTestFixture.cs" />
+    <Compile Include="Resolver\ResolveFooWindowsWithImportSystemAsFooTestFixture.cs" />
     <Compile Include="Resolver\ResolveFromImportTestFixture.cs" />
     <Compile Include="Resolver\ResolveFromMathImportedMathModuleCompletionItemsTestFixture.cs" />
     <Compile Include="Resolver\ResolveConsoleFromSystemImportEverythingFixture.cs" />
@@ -374,10 +376,12 @@
     <Compile Include="Resolver\ResolveMethodWhenImportIsUnknownTestFixture.cs" />
     <Compile Include="Resolver\ResolveNullCtrlSpaceCompilationUnitTestFixture.cs" />
     <Compile Include="Resolver\ResolveNullCtrlSpaceParseInfoTestFixture.cs" />
+    <Compile Include="Resolver\ResolverContextDottedImportedNameMatchTests.cs" />
     <Compile Include="Resolver\ResolverContextGetModulesThatImportEverythingTests.cs" />
     <Compile Include="Resolver\ResolverContextGetModuleForNameImportedAsDifferentNameTestFixture.cs" />
     <Compile Include="Resolver\ResolverContextGetModuleForImportedNameTests.cs" />
     <Compile Include="Resolver\ResolverContextHasImportTests.cs" />
+    <Compile Include="Resolver\ResolverContextPartialNamespaceExistsTests.cs" />
     <Compile Include="Resolver\ResolverContextUnaliasImportedModuleNameTestFixture.cs" />
     <Compile Include="Resolver\ResolveSysModuleExitMethodTestFixture.cs" />
     <Compile Include="Resolver\ResolveSysModuleImportedAsMySysTestFixture.cs" />
@@ -390,6 +394,9 @@
     <Compile Include="Resolver\ResolveSystemImportTestFixture.cs" />
     <Compile Include="Resolver\ResolveSystemNamespaceTestFixture.cs" />
     <Compile Include="Resolver\ResolveSystemNamespaceWithMissingImportTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSystemWindowsFormsWithImportSystemTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSystemWindowsWithImportSystemTestFixture.cs" />
+    <Compile Include="Resolver\ResolveSystemWithImportSystemWindowsTestFixture.cs" />
     <Compile Include="Resolver\ResolveTanMethodFromMathImportAllTestFixture.cs" />
     <Compile Include="Resolver\ResolveTanMethodFromMathImportCosAndTanTestFixture.cs" />
     <Compile Include="Resolver\ResolveTestFixtureBase.cs" />

src/AddIns/BackendBindings/Python/PythonBinding/Test/PythonLanguagePropertiesTests.cs

@@ -20,5 +20,11 @@ namespace PythonBinding.Tests
 		{
 			Assert.IsNotNull(PythonLanguageProperties.Default.CodeDomProvider);
 		}
+		
+		[Test]
+		public void AllowObjectConstructionOutsideContextReturnsTrueToEnableMethodInsightForConstructors()
+		{
+			Assert.IsTrue(PythonLanguageProperties.Default.AllowObjectConstructionOutsideContext);
+		}
 	}
 }

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

@@ -0,0 +1,55 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+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 ResolveTextBoxFromSystemWindowsFormsImportedAsFooTestFixture : ResolveTestFixtureBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			MockClass textBoxClass = new MockClass(projectContent, "System.Windows.Forms.TextBox");
+			projectContent.ClassToReturnFromGetClass = textBoxClass;
+			projectContent.ClassNameForGetClass = "System.Windows.Forms.TextBox";
+			
+			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/ResolveFooWindowsWithImportSystemAsFooTestFixture.cs

@@ -0,0 +1,47 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+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 ResolveFooWindowsWithImportSystemAsFooTestFixture : ResolveTestFixtureBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			MockProjectContent referencedContent = new MockProjectContent();
+			referencedContent.AddExistingNamespaceContents("System.Windows.Forms", new ArrayList());
+			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/ResolveSystemWindowsFormsWithImportSystemTestFixture.cs

@@ -0,0 +1,47 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+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 ResolveSystemWindowsFormsWithImportSystemTestFixture : ResolveTestFixtureBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			MockProjectContent referencedContent = new MockProjectContent();
+			referencedContent.AddExistingNamespaceContents("System.Windows.Forms", new ArrayList());
+			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/ResolveSystemWindowsWithImportSystemTestFixture.cs

@@ -0,0 +1,47 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+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 ResolveSystemWindowsWithImportSystemTestFixture : ResolveTestFixtureBase
+	{
+		protected override ExpressionResult GetExpressionResult()
+		{
+			MockProjectContent referencedContent = new MockProjectContent();
+			referencedContent.AddExistingNamespaceContents("System.Windows.Forms", new ArrayList());
+			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/ResolveSystemWithImportSystemWindowsTestFixture.cs

@@ -0,0 +1,43 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+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 : ResolveTestFixtureBase
+	{
+		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/ResolverContextDottedImportedNameMatchTests.cs

@@ -0,0 +1,39 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.PythonBinding;
+using NUnit.Framework;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolverContextDottedImportedNameMatchTests
+	{
+		[Test]
+		public void HasDottedImportNameReturnsTrueForSystemWithSystemWindowsFormsImported()
+		{
+			string code = "import System.Windows.Forms";
+			ParseInformation parseInfo = PythonParserHelper.CreateParseInfo(code);
+			
+			PythonResolverContext resolverContext = new PythonResolverContext(parseInfo);
+			Assert.IsTrue(resolverContext.HasDottedImportNameThatStartsWith("System"));
+		}
+		
+		[Test]
+		public void HasDottedImportNameReturnsFalseForMyNamespaceWithMyNamespaceTestImportedWithoutDtso()
+		{
+			string code = "import MyNamespaceTest";
+			ParseInformation parseInfo = PythonParserHelper.CreateParseInfo(code);
+			
+			PythonResolverContext resolverContext = new PythonResolverContext(parseInfo);
+			Assert.IsFalse(resolverContext.HasDottedImportNameThatStartsWith("MyNamespace"));
+		}
+	}
+}

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

@@ -0,0 +1,57 @@
+// <file>
+//     <copyright see="prj:///doc/copyright.txt"/>
+//     <license see="prj:///doc/license.txt"/>
+//     <owner name="Matthew Ward" email="mrward@users.sourceforge.net"/>
+//     <version>$Revision$</version>
+// </file>
+
+using System;
+using System.Collections;
+using ICSharpCode.PythonBinding;
+using ICSharpCode.SharpDevelop.Dom;
+using NUnit.Framework;
+using PythonBinding.Tests.Utils;
+
+namespace PythonBinding.Tests.Resolver
+{
+	[TestFixture]
+	public class ResolverContextPartialNamespaceExistsTests
+	{
+		ParseInformation parseInfo;
+		PythonResolverContext resolverContext;
+		
+		[SetUp]
+		public void Init()
+		{
+			MockProjectContent projectContent = new MockProjectContent();
+			MockProjectContent winFormsReferenceProjectContent = new MockProjectContent();
+			winFormsReferenceProjectContent.AddExistingNamespaceContents("System.Windows.Forms", new ArrayList());
+			projectContent.ReferencedContents.Add(winFormsReferenceProjectContent);
+			DefaultCompilationUnit unit = new DefaultCompilationUnit(projectContent);
+			parseInfo = new ParseInformation(unit);
+			
+			resolverContext = new PythonResolverContext(parseInfo);
+		}
+		
+		[Test]
+		public void PartialNamespaceExistsReturnsFalseForUnknownNamespace()
+		{
+			string ns = "unknown";
+			Assert.IsFalse(resolverContext.PartialNamespaceExistsInProjectReferences(ns));
+		}
+		
+		[Test]
+		public void PartialNamespaceExistsReturnsTrueForCompleteSystemWinFormsNamespaceMatch()
+		{
+			string ns = "System.Windows.Forms";
+			Assert.IsTrue(resolverContext.PartialNamespaceExistsInProjectReferences(ns));
+		}
+		
+		[Test]
+		public void PartialNamespaceExistsReturnsTrueForSystemWindowsNamespace()
+		{
+			string ns = "System.Windows";
+			Assert.IsTrue(resolverContext.PartialNamespaceExistsInProjectReferences(ns));
+		}
+	}
+}

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

@@ -32,6 +32,7 @@ namespace PythonBinding.Tests.Utils
 		object project;
 		Dictionary<string, ArrayList> namespaceContents = new Dictionary<string, ArrayList>();
 		LanguageProperties language = LanguageProperties.CSharp;
+		List<IProjectContent> referencedContents = new List<IProjectContent>();
 		
 		public MockProjectContent()
 		{
@@ -143,14 +144,16 @@ namespace PythonBinding.Tests.Utils
 		
 		public ICollection<string> NamespaceNames {
 			get {
-				throw new NotImplementedException();
+				List<string> names = new List<string>();
+				foreach (string existingNamespace in namespaceContents.Keys) {
+					names.Add(existingNamespace);
+				}
+				return names;
 			}
 		}
 		
 		public ICollection<IProjectContent> ReferencedContents {
-			get {
-				throw new NotImplementedException();
-			}
+			get { return this.referencedContents; }
 		}
 		
 		public IUsing DefaultImports {

src/AddIns/BackendBindings/Python/PythonBinding/Test/Utils/Tests/MockProjectContentTests.cs

@@ -7,6 +7,7 @@
 
 using System;
 using System.Collections;
+using System.Collections.Generic;
 using ICSharpCode.PythonBinding;
 using NUnit.Framework;
 using PythonBinding.Tests.Utils;
@@ -197,5 +198,21 @@ namespace PythonBinding.Tests.Utils.Tests
 			
 			Assert.AreEqual(c, projectContent.GetClass("test", 0));
 		}
+		
+		[Test]
+		public void NamespaceNamesHasNoItemsByDefault()
+		{
+			Assert.AreEqual(0, projectContent.ReferencedContents.Count);
+		}
+		
+		[Test]
+		public void NamespaceNamesContainingsNamespaceAddedToExistingNamespaces()
+		{
+			projectContent.AddExistingNamespaceContents("System", new ArrayList());
+			List<string> expectedNames = new List<string>();
+			expectedNames.Add("System");
+			
+			Assert.AreEqual(expectedNames, projectContent.NamespaceNames);
+		}
 	}
 }