diff --git a/src/AddIns/BackendBindings/Python/PythonBinding.sln b/src/AddIns/BackendBindings/Python/PythonBinding.sln index fb15eb87e0..7676dba062 100644 --- a/src/AddIns/BackendBindings/Python/PythonBinding.sln +++ b/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}" diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Project/Src/PythonPropertyResolver.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Project/Src/PythonPropertyResolver.cs index 7d4d93c20f..9900b4bcc2 100644 --- a/src/AddIns/BackendBindings/Python/PythonBinding/Project/Src/PythonPropertyResolver.cs +++ b/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); + } } } diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Completion/NamespaceContentsAddedToCtrlSpaceTestFixture.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Completion/NamespaceContentsAddedToCtrlSpaceTestFixture.cs index d9dbe58fe6..e230f1e49b 100644 --- a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Completion/NamespaceContentsAddedToCtrlSpaceTestFixture.cs +++ b/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); diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/PythonBinding.Tests.csproj b/src/AddIns/BackendBindings/Python/PythonBinding/Test/PythonBinding.Tests.csproj index 4c49b36df8..45b300c7e4 100644 --- a/src/AddIns/BackendBindings/Python/PythonBinding/Test/PythonBinding.Tests.csproj +++ b/src/AddIns/BackendBindings/Python/PythonBinding/Test/PythonBinding.Tests.csproj @@ -349,22 +349,21 @@ - + - - + + - - - - - + + + + - - - - + + + + @@ -374,26 +373,27 @@ - - + + - + - - - - - - - - - - - - - - + + + + + + + + + + + + + + + diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveBuiltInRoundMethodTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveBuiltInRoundMethodTests.cs new file mode 100644 index 0000000000..b63f7e7d72 --- /dev/null +++ b/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 exitMethods = GetRoundMethods(); + Assert.AreEqual(2, exitMethods.Count); + } + + List GetRoundMethods() + { + return GetRoundMethods(-1); + } + + List GetRoundMethods(int parameterCount) + { + List 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 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); + } + } +} diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveClassPropertyTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveClassPropertyTests.cs index 4524ba60bc..f7cc9c3de4 100644 --- a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveClassPropertyTests.cs +++ b/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; - projectContent.ClassNameForGetClass = "MyClass"; - - myClassProperty = CreateProperty(myClass); - myClass.Properties.Add(myClassProperty); + myClassProperty = AddPropertyToClass("MyProperty", myClass); 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(); - ResolveClassProperty(); + CreateParseInfoWithOneClassWithOneProperty(); + ResolvePropertyExpression("MyClass.MyProperty"); MemberResolveResult memberResolveResult = result as MemberResolveResult; Assert.IsNotNull(memberResolveResult); } [Test] - public void Resolve_ClassHasOneProperty_MemberResolveResultResolvedTypeIsMyClassProperty() + public void Resolve_ExpressionIsForPropertyOnClassWithOneProperty_MemberResolveResultResolvedTypeIsMyClassProperty() { - CreateParseInfoWithOneClass(); - ResolveClassProperty(); + CreateParseInfoWithOneClassWithOneProperty(); + 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(); - DefaultProperty extraProperty = new DefaultProperty(myClass, "ExtraProperty"); - myClass.Properties.Insert(0, extraProperty); - ResolveClassProperty(); + CreateParseInfoWithOneClassWithOneProperty(); + InsertNewPropertyOnClassBeforeExistingProperty(); + ResolvePropertyExpression("MyClass.MyProperty"); 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); + } } } diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveConsoleWriteLineTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveConsoleWriteLineTests.cs new file mode 100644 index 0000000000..ef116d3c5b --- /dev/null +++ b/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 +{ + /// + /// Tests that the expression "Console.WriteLine" is correctly + /// resolved. + /// + [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); + } + + /// + /// Gets the class name used in IProjectContent.GetClass call. + /// + [Test] + public void GetClassName() + { + Assert.AreEqual("Console", projectContent.GetClassName); + } + + [Test] + public void MethodNameResolveIsWriteLine() + { + MethodGroupResolveResult methodResolveResult = (MethodGroupResolveResult)resolveResult; + Assert.AreEqual("WriteLine", methodResolveResult.Name); + } + } +} diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveExitMethodFromSysImportExitAsMyExitTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveExitMethodFromSysImportExitAsMyExitTests.cs new file mode 100644 index 0000000000..fb02caa42c --- /dev/null +++ b/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; } + } + } +} diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveExitMethodFromSysImportExitTestFixture.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveExitMethodFromSysImportExitTestFixture.cs index 12a5615c07..3b2c7d84d2 100644 --- a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveExitMethodFromSysImportExitTestFixture.cs +++ b/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() { diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveFooWindowsWithImportSystemAsFooTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveFooWindowsWithImportSystemAsFooTests.cs new file mode 100644 index 0000000000..2fb77b6da1 --- /dev/null +++ b/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 namespaceItems = new List(); + 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); + } + } +} diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveFromImportTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveFromImportTests.cs new file mode 100644 index 0000000000..8da8066b20 --- /dev/null +++ b/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 +{ + /// + /// Tests that the PythonResolver resolves "from System" to + /// a namespace. + /// + [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); + } + } +} diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveFromMathImportedMathModuleCompletionItemsTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveFromMathImportedMathModuleCompletionItemsTests.cs new file mode 100644 index 0000000000..22c71efd40 --- /dev/null +++ b/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 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)); + } + } +} diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveFromSystemImportEverythingTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveFromSystemImportEverythingTests.cs new file mode 100644 index 0000000000..83914ef3ba --- /dev/null +++ b/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 namespaceItems = new List(); + 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")); + } + } +} diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveLocalClassInstanceTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveLocalClassInstanceTests.cs new file mode 100644 index 0000000000..3f5a115f94 --- /dev/null +++ b/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 +{ + /// + /// Given code: + /// + /// a = Class1() + /// + /// Check that the type of "a" can be obtained by the resolver. + /// + [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)); + } + + /// + /// Tests that the NameExpression in the resolver is reset so the second assignment + /// does not override the first. + /// + [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"); + } + } +} diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveMethodFromUnknownImportAllTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveMethodFromUnknownImportAllTests.cs new file mode 100644 index 0000000000..84f4d94562 --- /dev/null +++ b/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); + } + } +} diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveMethodWhenFromImportIsUnknownTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveMethodWhenFromImportIsUnknownTests.cs new file mode 100644 index 0000000000..f516e6aad2 --- /dev/null +++ b/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); + } + } +} diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveMethodWhenImportIsUnknownTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveMethodWhenImportIsUnknownTests.cs new file mode 100644 index 0000000000..318bd614ee --- /dev/null +++ b/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); + } + } +} diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSelfTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSelfTests.cs index d49716f4bd..faf47d545f 100644 --- a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSelfTests.cs +++ b/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; diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSysModuleExitMethodTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSysModuleExitMethodTests.cs new file mode 100644 index 0000000000..bee6c2dc42 --- /dev/null +++ b/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 exitMethods = GetExitMethods(); + Assert.AreEqual(2, exitMethods.Count); + } + + List GetExitMethods() + { + return GetExitMethods(-1); + } + + List GetExitMethods(int parameterCount) + { + List 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 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 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 methods = PythonCompletionItemsHelper.FindAllMethodsFromCollection("exit", returnType.GetMethods()); + Assert.AreEqual(2, methods.Count); + } + } +} diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSysModuleImportedAsMySysTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSysModuleImportedAsMySysTests.cs new file mode 100644 index 0000000000..a4433f0a6c --- /dev/null +++ b/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 items = GetCompletionItems(); + IMethod method = PythonCompletionItemsHelper.FindMethodFromCollection("exit", items); + Assert.IsNotNull(method); + } + + List GetCompletionItems() + { + return resolveResult.GetCompletionData(projectContent); + } + } +} diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSysModuleTestFixture.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSysModuleTestFixture.cs index 16270ad8db..74d1627bf0 100644 --- a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSysModuleTestFixture.cs +++ b/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() { diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSysModuleUnknownMethodTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSysModuleUnknownMethodTests.cs new file mode 100644 index 0000000000..e11708f5dc --- /dev/null +++ b/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); + } + } +} diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSystemConsoleTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSystemConsoleTests.cs new file mode 100644 index 0000000000..ca2f758605 --- /dev/null +++ b/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 +{ + /// + /// Tests the PythonResolver correctly resolves the expression: + /// "System.Console" + /// + [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); + } + + /// + /// Returns the Python script that will be used for testing. + /// + protected virtual string GetPythonScript() + { + return "import System\r\n" + + "class Test:\r\n" + + "\tdef __init__(self):\r\n" + + "\t\tSystem.Console\r\n"; + } + + /// + /// Creates a compilation unit with one class called Test. + /// + protected virtual ICompilationUnit CreateCompilationUnit(IProjectContent projectContent) + { + ICompilationUnit compilationUnit = new DefaultCompilationUnit(projectContent); + testClass = new MockClass(projectContent, "Test"); + compilationUnit.Classes.Add(testClass); + return compilationUnit; + } + } +} diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSystemImportTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSystemImportTests.cs new file mode 100644 index 0000000000..ab9763978c --- /dev/null +++ b/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 +{ + /// + /// Tests that the PythonResolver resolves "import System" to + /// a namespace. + /// + [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)); + } + } +} diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSystemImportedAsMySystemTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSystemImportedAsMySystemTests.cs new file mode 100644 index 0000000000..ddf060fe6a --- /dev/null +++ b/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 namespaceItems = new List(); + 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 items = GetCompletionItems(); + IClass consoleClass = PythonCompletionItemsHelper.FindClassFromCollection("Console", items); + Assert.IsNotNull(consoleClass); + } + + List GetCompletionItems() + { + return resolveResult.GetCompletionData(projectContent); + } + + [Test] + public void NamespaceResolveResultNameIsSystem() + { + NamespaceResolveResult namespaceResolveResult = resolveResult as NamespaceResolveResult; + Assert.AreEqual("System", namespaceResolveResult.Name); + } + + [Test] + public void MockProjectContentSystemNamespaceContentsIncludesConsoleClass() + { + List items = projectContent.GetNamespaceContents("System"); + IClass consoleClass = PythonCompletionItemsHelper.FindClassFromCollection("Console", items); + Assert.IsNotNull(consoleClass); + } + + [Test] + public void MockProjectContentNamespaceExistsReturnsTrueForSystem() + { + Assert.IsTrue(projectContent.NamespaceExists("System")); + } + } +} diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSystemNamespaceTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSystemNamespaceTests.cs new file mode 100644 index 0000000000..4839b50539 --- /dev/null +++ b/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 +{ + /// + /// Tests the PythonResolver correctly resolves the expression: + /// "System" + /// + [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()); + + 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); + } + } +} diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSystemNamespaceWithMissingImportTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSystemNamespaceWithMissingImportTests.cs new file mode 100644 index 0000000000..fdbf46a106 --- /dev/null +++ b/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 namespaceItems = new List(); + 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")); + } + } +} diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSystemWindowsFormsWithImportSystemTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSystemWindowsFormsWithImportSystemTests.cs new file mode 100644 index 0000000000..61370450bb --- /dev/null +++ b/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 namespaceItems = new List(); + 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); + } + } +} diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSystemWindowsWithImportSystemTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSystemWindowsWithImportSystemTests.cs new file mode 100644 index 0000000000..243834c576 --- /dev/null +++ b/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 namespaceItems = new List(); + 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); + } + } +} diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSystemWithImportSystemWindowsTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveSystemWithImportSystemWindowsTests.cs new file mode 100644 index 0000000000..afb599f2af --- /dev/null +++ b/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); + } + } +} diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveTanMethodFromMathImportAllTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveTanMethodFromMathImportAllTests.cs new file mode 100644 index 0000000000..30f21bd74b --- /dev/null +++ b/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 tanMethods = GetTanMethods(); + Assert.AreEqual(1, tanMethods.Count); + } + + List GetTanMethods() + { + List methods = MethodResolveResult.ContainingType.GetMethods(); + return PythonCompletionItemsHelper.FindAllMethodsFromCollection("tan", -1, methods.ToArray()); + } + } +} diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveTanMethodFromMathImportCosAndTanTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveTanMethodFromMathImportCosAndTanTests.cs new file mode 100644 index 0000000000..6e3c9493d6 --- /dev/null +++ b/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 tanMethods = GetTanMethods(); + Assert.AreEqual(1, tanMethods.Count); + } + + List GetTanMethods() + { + List methods = MethodResolveResult.ContainingType.GetMethods(); + return PythonCompletionItemsHelper.FindAllMethodsFromCollection("tan", -1, methods.ToArray()); + } + } +} diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveTestsBase.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveTestsBase.cs new file mode 100644 index 0000000000..02b610e59b --- /dev/null +++ b/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(); + } +} diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveTextBoxFromSystemWindowsFormsImportTextBoxTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveTextBoxFromSystemWindowsFormsImportTextBoxTests.cs new file mode 100644 index 0000000000..8473accf28 --- /dev/null +++ b/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; } + } + } +} diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveTextBoxFromSystemWindowsFormsImportedAsFooTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveTextBoxFromSystemWindowsFormsImportedAsFooTests.cs new file mode 100644 index 0000000000..97de48bb17 --- /dev/null +++ b/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; } + } + } +} diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveTextBoxFromSystemWindowsFormsImportedAsMyTextBoxTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveTextBoxFromSystemWindowsFormsImportedAsMyTextBoxTests.cs new file mode 100644 index 0000000000..4f12aaa48a --- /dev/null +++ b/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; } + } + } +} diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveUnknownNamespaceTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveUnknownNamespaceTests.cs new file mode 100644 index 0000000000..bcbfb84a71 --- /dev/null +++ b/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 +{ + /// + /// Tests the PythonResolver does not return a namespace resolve result for + /// an unknown namespace. + /// + [TestFixture] + public class ResolveUnknownNamespaceTestFixture : ResolveTestsBase + { + protected override ExpressionResult GetExpressionResult() + { + projectContent.AddExistingNamespaceContents("System", new List()); + + 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); + } + } +} diff --git a/src/AddIns/BackendBindings/Scripting/Test/Utils/MockProjectContent.cs b/src/AddIns/BackendBindings/Scripting/Test/Utils/MockProjectContent.cs index 163be0bddd..b2d887860a 100644 --- a/src/AddIns/BackendBindings/Scripting/Test/Utils/MockProjectContent.cs +++ b/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 classesInProjectContent = new List(); string namespacePassedToGetNamespaceContentsMethod; @@ -26,10 +25,6 @@ namespace ICSharpCode.Scripting.Tests.Utils Dictionary> namespaceContents = new Dictionary>(); LanguageProperties language = LanguageProperties.CSharp; List referencedContents = new List(); - - public MockProjectContent() - { - } /// /// Gets the namespaces that will be added when the @@ -91,12 +86,11 @@ namespace ICSharpCode.Scripting.Tests.Utils get { return classNameForGetClass; } set { classNameForGetClass = value; } } - - /// - /// Gets whether the GetClass method was called. - /// - public bool GetClassCalled { - get { return getClassCalled; } + + public void SetClassToReturnFromGetClass(string className, IClass classToReturn) + { + ClassToReturnFromGetClass = classToReturn; + ClassNameForGetClass = className; } /// @@ -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); + } + } } } diff --git a/src/AddIns/BackendBindings/Scripting/Test/Utils/Tests/MockProjectContentTests.cs b/src/AddIns/BackendBindings/Scripting/Test/Utils/Tests/MockProjectContentTests.cs index f192dac3b6..63402f1dfe 100644 --- a/src/AddIns/BackendBindings/Scripting/Test/Utils/Tests/MockProjectContentTests.cs +++ b/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 namespaceItems = new List(); 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 items = new List(); projectContent.AddExistingNamespaceContents("System", items); - - Assert.IsTrue(projectContent.NamespaceExists("System")); + bool result = projectContent.NamespaceExists("System"); + + Assert.IsTrue(result); } [Test] - public void NamespaceExistsReturnsFalseForUnknownNamespace() + public void NamespaceExists_UnknownNamespace_ReturnsFalse() { List items = new List(); projectContent.AddExistingNamespaceContents("System", items); - - Assert.IsFalse(projectContent.NamespaceExists("Unknown")); + bool result = projectContent.NamespaceExists("Unknown"); + Assert.IsFalse(result); } [Test] - public void GetNamespaceContentsReturnsItemsForAddedExistingNamespace() + public void GetNamespaceContents_AddExistingNamespaceContentsCalledWithCompletionItemsForTwoNamespaces_ReturnsItemsForSystemNamespace() { List items = new List(); items.Add(new NamespaceEntry("test")); @@ -102,22 +105,25 @@ namespace ICSharpCode.Scripting.Tests.Utils.Tests projectContent.AddExistingNamespaceContents("Math", new List()); projectContent.AddExistingNamespaceContents("System", items); + List actualItems = projectContent.GetNamespaceContents("System"); + List expectedItems = new List(); 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 items = new List(); items.Add(new NamespaceEntry("test")); projectContent.AddExistingNamespaceContents("System", items); + List actualItems = projectContent.GetNamespaceContents("Unknown"); List expectedItems = new List(); - 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); - } - - [Test] - public void GetClassCalledIsTrueAfterGetClassCalled() - { - projectContent.GetClass("abc", 0); - Assert.IsTrue(projectContent.GetClassCalled); + MockClass expectedClass = new MockClass(projectContent, "test"); + projectContent.ClassToReturnFromGetClass = expectedClass; + IClass c = projectContent.GetClass("abcdef", 0); + + Assert.AreEqual(expectedClass, c); } [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"); - projectContent.ClassToReturnFromGetClass = c; - projectContent.ClassNameForGetClass = "test"; + MockClass expectedClass = new MockClass(projectContent, "test"); + projectContent.SetClassToReturnFromGetClass("test", expectedClass); - 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"); - projectContent.ClassToReturnFromGetClass = c; - projectContent.ClassNameForGetClass = "test"; - - Assert.AreEqual(c, projectContent.GetClass("test", 0)); + int count = projectContent.ReferencedContents.Count; + Assert.AreEqual(0, count); } [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 namespaceItems = new List(); projectContent.AddExistingNamespaceContents("System", namespaceItems); + + ICollection names = projectContent.NamespaceNames; + List expectedNames = new List(); expectedNames.Add("System"); - Assert.AreEqual(expectedNames, projectContent.NamespaceNames); + Assert.AreEqual(expectedNames, names); } } }