From ca3838f9b3b346ebc10dc70fd5d4a02a23c92120 Mon Sep 17 00:00:00 2001 From: Daniel Grunwald Date: Tue, 3 Oct 2006 16:49:57 +0000 Subject: [PATCH] Re-enable resolver unit tests. git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@1872 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61 --- .../Boo/BooBinding/Test/ResolverTests.cs | 859 ++++---- .../CSharpBinding/Test/ExpressionFinder.cs | 4 +- .../Output/VBNet/CSharpToVBConverterTest.cs | 2 +- src/Main/Base/Test/GenericResolverTests.cs | 474 ++--- .../Base/Test/InnerClassesResolverTests.cs | 208 +- src/Main/Base/Test/NRefactoryResolverTests.cs | 1848 +++++++++-------- src/Main/Base/Test/OverloadFinding.cs | 124 +- src/Main/Base/Test/ReflectionLayerTests.cs | 281 +-- src/Main/Base/Test/SearchClassTests.cs | 248 +-- src/Main/Base/Test/SearchGenericClassTests.cs | 160 +- .../NavigationServiceTestFixture.cs | 1 - .../Src/ReflectionLayer/DomPersistence.cs | 2 +- 12 files changed, 2112 insertions(+), 2099 deletions(-) diff --git a/src/AddIns/BackendBindings/Boo/BooBinding/Test/ResolverTests.cs b/src/AddIns/BackendBindings/Boo/BooBinding/Test/ResolverTests.cs index 82680d4bfc..d59cc6c459 100644 --- a/src/AddIns/BackendBindings/Boo/BooBinding/Test/ResolverTests.cs +++ b/src/AddIns/BackendBindings/Boo/BooBinding/Test/ResolverTests.cs @@ -10,6 +10,7 @@ using System.Collections; using System.Reflection; using NUnit.Framework; using ICSharpCode.Core; +using ICSharpCode.SharpDevelop; using ICSharpCode.SharpDevelop.Dom; using ICSharpCode.SharpDevelop.Project; using Grunwald.BooBinding.CodeCompletion; @@ -19,434 +20,434 @@ namespace Grunwald.BooBinding.Tests [TestFixture] public class ResolverTests { -// #region Helper -// T Resolve(string code) where T : ResolveResult -// { -// return Resolve(code, "/*1*/"); -// } -// -// T Resolve(string code, string marker) where T : ResolveResult -// { -// return Resolve(normalProg, code, marker); -// } -// -// T Resolve(string prog, string code, string marker) where T : ResolveResult -// { -// ResolveResult rr = Resolve(prog, new ExpressionResult(code), marker); -// Assert.IsNotNull(rr, "Resolve must not return null"); -// Assert.IsInstanceOfType(typeof(T), rr, "Resolve must return instance of type " + typeof(T).Name); -// return (T)rr; -// } -// -// IProjectContent booLangPC; -// -// public ResolverTests() { -// booLangPC = new ReflectionProjectContent(Assembly.Load("Boo.Lang"), "Boo.Lang.dll"); -// booLangPC.ReferencedContents.Add(ProjectContentRegistry.Mscorlib); -// } -// -// const string fileName = "tempFile.boo"; -// DefaultProjectContent lastPC; -// -// void Register(string prog) -// { -// DefaultProjectContent pc = new DefaultProjectContent(); -// lastPC = pc; -// HostCallback.GetCurrentProjectContent = delegate { return pc; }; -// pc.ReferencedContents.Add(ProjectContentRegistry.Mscorlib); -// pc.ReferencedContents.Add(ProjectContentRegistry.GetProjectContentForReference("System.Windows.Forms", "System.Windows.Forms")); -// pc.ReferencedContents.Add(booLangPC); -// ICompilationUnit cu = new BooParser().Parse(pc, fileName, prog); -// ParserService.UpdateParseInformation(cu, fileName, false, false); -// cu.Classes.ForEach(pc.AddClassToNamespaceList); -// } -// -// void GetPos(string prog, string marker, out int line, out int column) -// { -// int index = prog.IndexOf(marker); -// line = 1; -// column = 0; -// for (int i = 0; i < index; i++) { -// column++; -// if (prog[i]=='\n') { -// line++; -// column = 0; -// } -// } -// } -// -// ResolveResult Resolve(string prog, ExpressionResult er, string marker) -// { -// Register(prog); -// int line, column; -// GetPos(prog, marker, out line, out column); -// -// BooResolver r = new BooResolver(); -// return r.Resolve(er, line, column, fileName, prog); -// } -// #endregion -// -// #region Basic tests -// const string normalProg = -// "import System\n" + -// "def MyMethod(arg as string):\n" + -// "\tlocalVar = arg\n" + -// "\t/*1*/\n" + -// "\tclosure = { e as string | arg.IndexOf(e) /*inClosure*/ }\n" + -// "\tindex = closure('.')\n" + -// "\t/*2*/\n" + -// "\tclosure2 = def(e as DateTime):\n" + -// "\t\treturn e.Year\n" + -// "\trecursiveClosure = def(myObject):/*inRecursiveClosure*/\n" + -// "\t\treturn recursiveClosure(myObject)\n" + -// "\t/*3*/\n"; -// -// [Test] -// public void MethodParameter() -// { -// LocalResolveResult rr = Resolve("arg"); -// Assert.IsTrue(rr.IsParameter); -// Assert.AreEqual("System.String", rr.ResolvedType.FullyQualifiedName); -// } -// -// [Test] -// public void LocalVariable() -// { -// LocalResolveResult rr = Resolve("localVar"); -// Assert.IsFalse(rr.IsParameter); -// Assert.AreEqual("System.String", rr.ResolvedType.FullyQualifiedName); -// } -// -// [Test] -// public void NullCoalescing() -// { -// ResolveResult rr = Resolve("localVar or arg"); -// Assert.AreEqual("System.String", rr.ResolvedType.FullyQualifiedName); -// } -// -// [Test] -// public void InnerClassEnum() -// { -// TypeResolveResult trr = Resolve("Environment.SpecialFolder"); -// Assert.AreEqual("System.Environment.SpecialFolder", trr.ResolvedClass.FullyQualifiedName); -// -// MemberResolveResult mrr = Resolve("Environment.SpecialFolder.Desktop"); -// Assert.AreEqual("System.Environment.SpecialFolder.Desktop", mrr.ResolvedMember.FullyQualifiedName); -// } -// -// [Test] -// public void ClosureParameter() -// { -// LocalResolveResult rr = Resolve("e", "/*inClosure*/"); -// Assert.AreEqual("System.String", rr.ResolvedType.FullyQualifiedName); -// -// Assert.IsNull(Resolve(normalProg, new ExpressionResult("e"), "/*1*/")); -// } -// -// [Test] -// public void ClosureCall() -// { -// LocalResolveResult rr = Resolve("closure('.')", "/*2*/"); -// Assert.IsFalse(rr.IsParameter); -// Assert.AreEqual("closure", rr.Field.Name); -// Assert.AreEqual("System.Int32", rr.ResolvedType.FullyQualifiedName); -// } -// -// [Test] -// public void ClosureCall2() -// { -// LocalResolveResult rr = Resolve("closure2(DateTime.Now)", "/*3*/"); -// Assert.IsFalse(rr.IsParameter); -// Assert.AreEqual("closure2", rr.Field.Name); -// Assert.AreEqual("System.Int32", rr.ResolvedType.FullyQualifiedName); -// } -// -// [Test] -// public void RecursiveClosure() -// { -// // Code-completion cannot work here, test if SharpDevelop is correctly -// // preventing the StackOverflow. -// LocalResolveResult rr = Resolve("recursiveClosure", "/*3*/"); -// Assert.IsFalse(rr.IsParameter); -// Assert.AreEqual("delegate(myObject:Object):?", rr.ResolvedType.FullyQualifiedName); -// } -// -// [Test] -// public void ClosureTypelessArgument() -// { -// LocalResolveResult rr = Resolve("myObject", "/*inRecursiveClosure*/"); -// Assert.AreEqual("System.Object", rr.ResolvedType.FullyQualifiedName); -// } -// -// [Test] -// public void EqualityOperator() -// { -// ResolveResult rr = Resolve("0 == 0"); -// Assert.AreEqual("System.Boolean", rr.ResolvedType.FullyQualifiedName); -// rr = Resolve("0 != 1"); -// Assert.AreEqual("System.Boolean", rr.ResolvedType.FullyQualifiedName); -// rr = Resolve("null is null"); -// Assert.AreEqual("System.Boolean", rr.ResolvedType.FullyQualifiedName); -// rr = Resolve("object() is not null"); -// Assert.AreEqual("System.Boolean", rr.ResolvedType.FullyQualifiedName); -// } -// -// [Test] -// public void ClassMethodAmbiguity() -// { -// string prog = -// "class Test:\n" + -// "\tdef constructor():\n" + -// "\t\tpass\n" + -// "class OtherClass:\n" + -// "\tdef Test():\n" + -// "\t\t/*mark*/\n" + -// "\t\tpass\n"; -// MemberResolveResult rr = Resolve(prog, "Test()", "/*mark*/"); -// Assert.AreEqual("OtherClass.Test", rr.ResolvedMember.FullyQualifiedName); -// } -// #endregion -// -// #region Regression -// const string regressionProg = -// "import System\n" + -// "import System.Reflection\n" + -// "def MyMethod(arg as string):\n" + -// "\tif true:\n" + -// "\t\tboo629 = 'hello'\n" + -// "\tfor boo640a in [1, 2, 3]:\n" + -// "\t\tif boo640b = boo640a as FieldInfo: /*640*/\n" + -// "\t\t\tprint boo640b\n" + -// "\t\n" + -// "\tprint 'end of method'\n" + -// "\t/*1*/\n"; -// -// [Test] -// public void MyMethodCompletion() -// { -// MethodResolveResult rr = Resolve(regressionProg, "MyMethod", "/*1*/"); -// ArrayList arr = rr.GetCompletionData(lastPC); -// Assert.IsNotNull(arr); -// bool beginInvoke = false; -// bool invoke = false; -// foreach (IMember m in arr) { -// if (m.Name == "BeginInvoke") beginInvoke = true; -// if (m.Name == "Invoke") invoke = true; -// } -// Assert.IsTrue(beginInvoke, "beginInvoke"); -// Assert.IsTrue(invoke, "invoke"); -// } -// -// [Test] -// public void Boo629VariableScope() -// { -// LocalResolveResult rr = Resolve(regressionProg, "boo629", "/*1*/"); -// Assert.AreEqual("System.String", rr.ResolvedType.FullyQualifiedName); -// } -// -// [Test] -// public void Boo640ConditionalAssignment() -// { -// LocalResolveResult rr = Resolve(regressionProg, "boo640b", "/*1*/"); -// Assert.AreEqual("System.Reflection.FieldInfo", rr.ResolvedType.FullyQualifiedName); -// rr = Resolve(regressionProg, "boo640a", "/*640*/"); -// Assert.AreEqual("System.Object", rr.ResolvedType.FullyQualifiedName); -// Assert.IsNull(Resolve(regressionProg, new ExpressionResult("boo640a"), "/*1*/")); -// } -// -// [Test] -// public void IndexerRecognition() -// { -// string prog = -// "class Foo:\n" + -// "\tself[index as int]:\n" + -// "\t\tget:\n" + -// "\t\t\treturn true\n" + -// "def example():\n" + -// "\tfoo = Foo()\n" + -// "\tmybool = foo[1] /*mark*/\n" + -// "\tprint mybool\n"; -// MemberResolveResult rr = Resolve(prog, "foo[1]", "/*mark*/"); -// Assert.IsTrue(((IProperty)rr.ResolvedMember).IsIndexer); -// Assert.AreEqual("System.Boolean", rr.ResolvedType.FullyQualifiedName); -// LocalResolveResult rr2 = Resolve(prog, "mybool", "/*mark*/"); -// Assert.AreEqual("System.Boolean", rr2.ResolvedType.FullyQualifiedName); -// } -// -// [Test] -// public void InfiniteRecursionGenerator() -// { -// string prog = -// "class Test:\n" + -// "\t_testList = []\n" + -// "\tTestProperty:\n" + -// "\t\tget:\n" + -// "\t\t\tfor testobj as Test in _testList:\n" + -// "\t\t\t\tyield testobj.TestProperty /*mark*/\n"; -// MemberResolveResult rr = Resolve(prog, "testobj.TestProperty", "/*mark*/"); -// Assert.AreEqual("Test.TestProperty", rr.ResolvedMember.FullyQualifiedName); -// Assert.AreEqual("System.Collections.Generic.IEnumerable", rr.ResolvedType.FullyQualifiedName); -// // prevent creating self-referring ConstructedReturnType -// Assert.AreEqual("?", rr.ResolvedType.CastToConstructedReturnType().TypeArguments[0].FullyQualifiedName); -// } -// #endregion -// -// #region Nested Classes -// const string nestedClassProg = -// "class Outer:\n" + -// "\tpublic static outerField = 1\n" + -// "\tpublic class Inner:\n/*inner*/" + -// "\t\tpublic innerField = 2\n" + -// "class Derived(Outer):\n/*derived*/" + -// "\tpublic static derivedField = 3\n" + -// "def Method():\n" + -// "\ti as Outer.Inner\n" + -// "\ti2 as Derived.Inner\n" + -// "\t/*1*/"; -// -// [Test] -// public void NestedClassTypeResolution() -// { -// TypeResolveResult trr; -// trr = Resolve(nestedClassProg, "Outer.Inner", "/*1*/"); -// Assert.AreEqual("Outer.Inner", trr.ResolvedClass.FullyQualifiedName); -// trr = Resolve(nestedClassProg, "Inner", "/*inner*/"); -// Assert.AreEqual("Outer.Inner", trr.ResolvedClass.FullyQualifiedName); -// trr = Resolve(nestedClassProg, "Inner", "/*derived*/"); -// Assert.AreEqual("Outer.Inner", trr.ResolvedClass.FullyQualifiedName); -// trr = Resolve(nestedClassProg, "Derived.Inner", "/*1*/"); -// Assert.AreEqual("Outer.Inner", trr.ResolvedClass.FullyQualifiedName); -// } -// -// [Test] -// public void NestedClassCtrlSpace() -// { -// CtrlSpace(nestedClassProg.Replace("/*inner*/", "/*mark*/"), "outerField", "innerField", "Inner", "Outer", "Derived"); -// CtrlSpace(nestedClassProg.Replace("/*derived*/", "/*mark*/"), "outerField", "derivedField", "Inner", "Outer", "Derived"); -// } -// -// [Test] -// public void NestedClassParentStaticField() -// { -// MemberResolveResult mrr = Resolve(nestedClassProg, "outerField", "/*inner*/"); -// Assert.AreEqual("Outer.outerField", mrr.ResolvedMember.FullyQualifiedName); -// } -// -// [Test] -// public void NestedClassCC() -// { -// LocalResolveResult rr = Resolve(nestedClassProg, "i", "/*1*/"); -// Assert.AreEqual("Outer.Inner", rr.ResolvedType.FullyQualifiedName); -// bool ok = false; -// foreach (object o in rr.GetCompletionData(lastPC)) { -// IMember m = o as IMember; -// if (m != null && m.Name == "innerField") -// ok = true; -// } -// Assert.IsTrue(ok); -// MemberResolveResult mrr = Resolve(nestedClassProg, "i.innerField", "/*1*/"); -// Assert.AreEqual("Outer.Inner.innerField", mrr.ResolvedMember.FullyQualifiedName); -// } -// -// [Test] -// public void NestedClassCC2() -// { -// LocalResolveResult rr = Resolve(nestedClassProg, "i2", "/*1*/"); -// Assert.AreEqual("Outer.Inner", rr.ResolvedType.FullyQualifiedName); -// bool ok = false; -// foreach (object o in rr.GetCompletionData(lastPC)) { -// IMember m = o as IMember; -// if (m != null && m.Name == "innerField") -// ok = true; -// } -// Assert.IsTrue(ok); -// MemberResolveResult mrr = Resolve(nestedClassProg, "i2.innerField", "/*1*/"); -// Assert.AreEqual("Outer.Inner.innerField", mrr.ResolvedMember.FullyQualifiedName); -// } -// #endregion -// -// #region CtrlSpace -// void CtrlSpace(string prog, params string[] expected) -// { -// CtrlSpace(new string[0], prog, expected); -// } -// -// void CtrlSpace(string[] unExpected, string prog, params string[] expected) -// { -// Register(prog); -// int line, column; -// GetPos(prog, "/*mark*/", out line, out column); -// BooResolver r = new BooResolver(); -// System.Collections.ArrayList ar; -// ar = r.CtrlSpace(line, column, fileName, prog, ExpressionContext.Default); -// foreach (string e in unExpected) { -// foreach (object o in ar) { -// if (e.Equals(o)) -// Assert.Fail("Didn't expect " + e); -// if (o is IMember && (o as IMember).Name == e) { -// Assert.Fail("Didn't expect " + e); -// } -// if (o is IClass && (o as IClass).Name == e) { -// Assert.Fail("Didn't expect " + e); -// } -// } -// } -// foreach (string e in expected) { -// bool ok = false; -// foreach (object o in ar) { -// if (e.Equals(o)) { -// if (ok) Assert.Fail("double entry " + e); -// ok = true; -// } -// if (o is IMember && (o as IMember).Name == e) { -// if (ok) Assert.Fail("double entry " + e); -// ok = true; -// } -// if (o is IClass && (o as IClass).Name == e) { -// if (ok) Assert.Fail("double entry " + e); -// ok = true; -// } -// } -// if (!ok) -// Assert.Fail("Expected " + e); -// } -// } -// -// [Test] -// public void CtrlSpaceScopeExtension() -// { -// string prog = -// "def Foo():\n" + -// "\tbar = def():\n" + -// "\t\tx = 0\n" + -// "\t\t/*mark*/\n"; -// CtrlSpace(prog, "bar", "x"); -// } -// -// [Test] -// public void DoubleEntryTest() -// { -// string prog = -// "class MyClass:\n" + -// "\t_myInt = 0\n" + -// "\tdef Foo():\n" + -// "\t\t_myInt = 5\n" + -// "\t\t/*mark*/\n"; -// CtrlSpace(prog, "_myInt"); -// } -// -// [Test] -// public void LoopInClosureTest() -// { -// string prog = -// "def Foo():\n" + -// "\tfor i in range(5):\n" + -// "\t\tbar = def():\n" + -// "\t\t\tx = 0\n" + -// "\t\t\t/*mark*/\n" + -// "\t\t\tprint x"; -// CtrlSpace(prog, "x", "bar", "i"); -// } -// #endregion + #region Helper + T Resolve(string code) where T : ResolveResult + { + return Resolve(code, "/*1*/"); + } + + T Resolve(string code, string marker) where T : ResolveResult + { + return Resolve(normalProg, code, marker); + } + + T Resolve(string prog, string code, string marker) where T : ResolveResult + { + ResolveResult rr = Resolve(prog, new ExpressionResult(code), marker); + Assert.IsNotNull(rr, "Resolve must not return null"); + Assert.IsInstanceOfType(typeof(T), rr, "Resolve must return instance of type " + typeof(T).Name); + return (T)rr; + } + + IProjectContent booLangPC; + + public ResolverTests() { + booLangPC = new ReflectionProjectContent(Assembly.Load("Boo.Lang"), "Boo.Lang.dll", ParserService.DefaultProjectContentRegistry); + booLangPC.ReferencedContents.Add(ParserService.DefaultProjectContentRegistry.Mscorlib); + } + + const string fileName = "tempFile.boo"; + DefaultProjectContent lastPC; + + void Register(string prog) + { + DefaultProjectContent pc = new DefaultProjectContent(); + lastPC = pc; + HostCallback.GetCurrentProjectContent = delegate { return pc; }; + pc.ReferencedContents.Add(ParserService.DefaultProjectContentRegistry.Mscorlib); + pc.ReferencedContents.Add(ParserService.DefaultProjectContentRegistry.GetProjectContentForReference("System.Windows.Forms", "System.Windows.Forms")); + pc.ReferencedContents.Add(booLangPC); + ICompilationUnit cu = new BooParser().Parse(pc, fileName, prog); + ParserService.UpdateParseInformation(cu, fileName, false, false); + cu.Classes.ForEach(pc.AddClassToNamespaceList); + } + + void GetPos(string prog, string marker, out int line, out int column) + { + int index = prog.IndexOf(marker); + line = 1; + column = 0; + for (int i = 0; i < index; i++) { + column++; + if (prog[i]=='\n') { + line++; + column = 0; + } + } + } + + ResolveResult Resolve(string prog, ExpressionResult er, string marker) + { + Register(prog); + int line, column; + GetPos(prog, marker, out line, out column); + + BooResolver r = new BooResolver(); + return r.Resolve(er, line, column, fileName, prog); + } + #endregion + + #region Basic tests + const string normalProg = + "import System\n" + + "def MyMethod(arg as string):\n" + + "\tlocalVar = arg\n" + + "\t/*1*/\n" + + "\tclosure = { e as string | arg.IndexOf(e) /*inClosure*/ }\n" + + "\tindex = closure('.')\n" + + "\t/*2*/\n" + + "\tclosure2 = def(e as DateTime):\n" + + "\t\treturn e.Year\n" + + "\trecursiveClosure = def(myObject):/*inRecursiveClosure*/\n" + + "\t\treturn recursiveClosure(myObject)\n" + + "\t/*3*/\n"; + + [Test] + public void MethodParameter() + { + LocalResolveResult rr = Resolve("arg"); + Assert.IsTrue(rr.IsParameter); + Assert.AreEqual("System.String", rr.ResolvedType.FullyQualifiedName); + } + + [Test] + public void LocalVariable() + { + LocalResolveResult rr = Resolve("localVar"); + Assert.IsFalse(rr.IsParameter); + Assert.AreEqual("System.String", rr.ResolvedType.FullyQualifiedName); + } + + [Test] + public void NullCoalescing() + { + ResolveResult rr = Resolve("localVar or arg"); + Assert.AreEqual("System.String", rr.ResolvedType.FullyQualifiedName); + } + + [Test] + public void InnerClassEnum() + { + TypeResolveResult trr = Resolve("Environment.SpecialFolder"); + Assert.AreEqual("System.Environment.SpecialFolder", trr.ResolvedClass.FullyQualifiedName); + + MemberResolveResult mrr = Resolve("Environment.SpecialFolder.Desktop"); + Assert.AreEqual("System.Environment.SpecialFolder.Desktop", mrr.ResolvedMember.FullyQualifiedName); + } + + [Test] + public void ClosureParameter() + { + LocalResolveResult rr = Resolve("e", "/*inClosure*/"); + Assert.AreEqual("System.String", rr.ResolvedType.FullyQualifiedName); + + Assert.IsNull(Resolve(normalProg, new ExpressionResult("e"), "/*1*/")); + } + + [Test] + public void ClosureCall() + { + LocalResolveResult rr = Resolve("closure('.')", "/*2*/"); + Assert.IsFalse(rr.IsParameter); + Assert.AreEqual("closure", rr.Field.Name); + Assert.AreEqual("System.Int32", rr.ResolvedType.FullyQualifiedName); + } + + [Test] + public void ClosureCall2() + { + LocalResolveResult rr = Resolve("closure2(DateTime.Now)", "/*3*/"); + Assert.IsFalse(rr.IsParameter); + Assert.AreEqual("closure2", rr.Field.Name); + Assert.AreEqual("System.Int32", rr.ResolvedType.FullyQualifiedName); + } + + [Test] + public void RecursiveClosure() + { + // Code-completion cannot work here, test if SharpDevelop is correctly + // preventing the StackOverflow. + LocalResolveResult rr = Resolve("recursiveClosure", "/*3*/"); + Assert.IsFalse(rr.IsParameter); + Assert.AreEqual("delegate(myObject:Object):?", rr.ResolvedType.FullyQualifiedName); + } + + [Test] + public void ClosureTypelessArgument() + { + LocalResolveResult rr = Resolve("myObject", "/*inRecursiveClosure*/"); + Assert.AreEqual("System.Object", rr.ResolvedType.FullyQualifiedName); + } + + [Test] + public void EqualityOperator() + { + ResolveResult rr = Resolve("0 == 0"); + Assert.AreEqual("System.Boolean", rr.ResolvedType.FullyQualifiedName); + rr = Resolve("0 != 1"); + Assert.AreEqual("System.Boolean", rr.ResolvedType.FullyQualifiedName); + rr = Resolve("null is null"); + Assert.AreEqual("System.Boolean", rr.ResolvedType.FullyQualifiedName); + rr = Resolve("object() is not null"); + Assert.AreEqual("System.Boolean", rr.ResolvedType.FullyQualifiedName); + } + + [Test] + public void ClassMethodAmbiguity() + { + string prog = + "class Test:\n" + + "\tdef constructor():\n" + + "\t\tpass\n" + + "class OtherClass:\n" + + "\tdef Test():\n" + + "\t\t/*mark*/\n" + + "\t\tpass\n"; + MemberResolveResult rr = Resolve(prog, "Test()", "/*mark*/"); + Assert.AreEqual("OtherClass.Test", rr.ResolvedMember.FullyQualifiedName); + } + #endregion + + #region Regression + const string regressionProg = + "import System\n" + + "import System.Reflection\n" + + "def MyMethod(arg as string):\n" + + "\tif true:\n" + + "\t\tboo629 = 'hello'\n" + + "\tfor boo640a in [1, 2, 3]:\n" + + "\t\tif boo640b = boo640a as FieldInfo: /*640*/\n" + + "\t\t\tprint boo640b\n" + + "\t\n" + + "\tprint 'end of method'\n" + + "\t/*1*/\n"; + + [Test] + public void MyMethodCompletion() + { + MethodResolveResult rr = Resolve(regressionProg, "MyMethod", "/*1*/"); + ArrayList arr = rr.GetCompletionData(lastPC); + Assert.IsNotNull(arr); + bool beginInvoke = false; + bool invoke = false; + foreach (IMember m in arr) { + if (m.Name == "BeginInvoke") beginInvoke = true; + if (m.Name == "Invoke") invoke = true; + } + Assert.IsTrue(beginInvoke, "beginInvoke"); + Assert.IsTrue(invoke, "invoke"); + } + + [Test] + public void Boo629VariableScope() + { + LocalResolveResult rr = Resolve(regressionProg, "boo629", "/*1*/"); + Assert.AreEqual("System.String", rr.ResolvedType.FullyQualifiedName); + } + + [Test] + public void Boo640ConditionalAssignment() + { + LocalResolveResult rr = Resolve(regressionProg, "boo640b", "/*1*/"); + Assert.AreEqual("System.Reflection.FieldInfo", rr.ResolvedType.FullyQualifiedName); + rr = Resolve(regressionProg, "boo640a", "/*640*/"); + Assert.AreEqual("System.Object", rr.ResolvedType.FullyQualifiedName); + Assert.IsNull(Resolve(regressionProg, new ExpressionResult("boo640a"), "/*1*/")); + } + + [Test] + public void IndexerRecognition() + { + string prog = + "class Foo:\n" + + "\tself[index as int]:\n" + + "\t\tget:\n" + + "\t\t\treturn true\n" + + "def example():\n" + + "\tfoo = Foo()\n" + + "\tmybool = foo[1] /*mark*/\n" + + "\tprint mybool\n"; + MemberResolveResult rr = Resolve(prog, "foo[1]", "/*mark*/"); + Assert.IsTrue(((IProperty)rr.ResolvedMember).IsIndexer); + Assert.AreEqual("System.Boolean", rr.ResolvedType.FullyQualifiedName); + LocalResolveResult rr2 = Resolve(prog, "mybool", "/*mark*/"); + Assert.AreEqual("System.Boolean", rr2.ResolvedType.FullyQualifiedName); + } + + [Test] + public void InfiniteRecursionGenerator() + { + string prog = + "class Test:\n" + + "\t_testList = []\n" + + "\tTestProperty:\n" + + "\t\tget:\n" + + "\t\t\tfor testobj as Test in _testList:\n" + + "\t\t\t\tyield testobj.TestProperty /*mark*/\n"; + MemberResolveResult rr = Resolve(prog, "testobj.TestProperty", "/*mark*/"); + Assert.AreEqual("Test.TestProperty", rr.ResolvedMember.FullyQualifiedName); + Assert.AreEqual("System.Collections.Generic.IEnumerable", rr.ResolvedType.FullyQualifiedName); + // prevent creating self-referring ConstructedReturnType + Assert.AreEqual("?", rr.ResolvedType.CastToConstructedReturnType().TypeArguments[0].FullyQualifiedName); + } + #endregion + + #region Nested Classes + const string nestedClassProg = + "class Outer:\n" + + "\tpublic static outerField = 1\n" + + "\tpublic class Inner:\n/*inner*/" + + "\t\tpublic innerField = 2\n" + + "class Derived(Outer):\n/*derived*/" + + "\tpublic static derivedField = 3\n" + + "def Method():\n" + + "\ti as Outer.Inner\n" + + "\ti2 as Derived.Inner\n" + + "\t/*1*/"; + + [Test] + public void NestedClassTypeResolution() + { + TypeResolveResult trr; + trr = Resolve(nestedClassProg, "Outer.Inner", "/*1*/"); + Assert.AreEqual("Outer.Inner", trr.ResolvedClass.FullyQualifiedName); + trr = Resolve(nestedClassProg, "Inner", "/*inner*/"); + Assert.AreEqual("Outer.Inner", trr.ResolvedClass.FullyQualifiedName); + trr = Resolve(nestedClassProg, "Inner", "/*derived*/"); + Assert.AreEqual("Outer.Inner", trr.ResolvedClass.FullyQualifiedName); + trr = Resolve(nestedClassProg, "Derived.Inner", "/*1*/"); + Assert.AreEqual("Outer.Inner", trr.ResolvedClass.FullyQualifiedName); + } + + [Test] + public void NestedClassCtrlSpace() + { + CtrlSpace(nestedClassProg.Replace("/*inner*/", "/*mark*/"), "outerField", "innerField", "Inner", "Outer", "Derived"); + CtrlSpace(nestedClassProg.Replace("/*derived*/", "/*mark*/"), "outerField", "derivedField", "Inner", "Outer", "Derived"); + } + + [Test] + public void NestedClassParentStaticField() + { + MemberResolveResult mrr = Resolve(nestedClassProg, "outerField", "/*inner*/"); + Assert.AreEqual("Outer.outerField", mrr.ResolvedMember.FullyQualifiedName); + } + + [Test] + public void NestedClassCC() + { + LocalResolveResult rr = Resolve(nestedClassProg, "i", "/*1*/"); + Assert.AreEqual("Outer.Inner", rr.ResolvedType.FullyQualifiedName); + bool ok = false; + foreach (object o in rr.GetCompletionData(lastPC)) { + IMember m = o as IMember; + if (m != null && m.Name == "innerField") + ok = true; + } + Assert.IsTrue(ok); + MemberResolveResult mrr = Resolve(nestedClassProg, "i.innerField", "/*1*/"); + Assert.AreEqual("Outer.Inner.innerField", mrr.ResolvedMember.FullyQualifiedName); + } + + [Test] + public void NestedClassCC2() + { + LocalResolveResult rr = Resolve(nestedClassProg, "i2", "/*1*/"); + Assert.AreEqual("Outer.Inner", rr.ResolvedType.FullyQualifiedName); + bool ok = false; + foreach (object o in rr.GetCompletionData(lastPC)) { + IMember m = o as IMember; + if (m != null && m.Name == "innerField") + ok = true; + } + Assert.IsTrue(ok); + MemberResolveResult mrr = Resolve(nestedClassProg, "i2.innerField", "/*1*/"); + Assert.AreEqual("Outer.Inner.innerField", mrr.ResolvedMember.FullyQualifiedName); + } + #endregion + + #region CtrlSpace + void CtrlSpace(string prog, params string[] expected) + { + CtrlSpace(new string[0], prog, expected); + } + + void CtrlSpace(string[] unExpected, string prog, params string[] expected) + { + Register(prog); + int line, column; + GetPos(prog, "/*mark*/", out line, out column); + BooResolver r = new BooResolver(); + System.Collections.ArrayList ar; + ar = r.CtrlSpace(line, column, fileName, prog, ExpressionContext.Default); + foreach (string e in unExpected) { + foreach (object o in ar) { + if (e.Equals(o)) + Assert.Fail("Didn't expect " + e); + if (o is IMember && (o as IMember).Name == e) { + Assert.Fail("Didn't expect " + e); + } + if (o is IClass && (o as IClass).Name == e) { + Assert.Fail("Didn't expect " + e); + } + } + } + foreach (string e in expected) { + bool ok = false; + foreach (object o in ar) { + if (e.Equals(o)) { + if (ok) Assert.Fail("double entry " + e); + ok = true; + } + if (o is IMember && (o as IMember).Name == e) { + if (ok) Assert.Fail("double entry " + e); + ok = true; + } + if (o is IClass && (o as IClass).Name == e) { + if (ok) Assert.Fail("double entry " + e); + ok = true; + } + } + if (!ok) + Assert.Fail("Expected " + e); + } + } + + [Test] + public void CtrlSpaceScopeExtension() + { + string prog = + "def Foo():\n" + + "\tbar = def():\n" + + "\t\tx = 0\n" + + "\t\t/*mark*/\n"; + CtrlSpace(prog, "bar", "x"); + } + + [Test] + public void DoubleEntryTest() + { + string prog = + "class MyClass:\n" + + "\t_myInt = 0\n" + + "\tdef Foo():\n" + + "\t\t_myInt = 5\n" + + "\t\t/*mark*/\n"; + CtrlSpace(prog, "_myInt"); + } + + [Test] + public void LoopInClosureTest() + { + string prog = + "def Foo():\n" + + "\tfor i in range(5):\n" + + "\t\tbar = def():\n" + + "\t\t\tx = 0\n" + + "\t\t\t/*mark*/\n" + + "\t\t\tprint x"; + CtrlSpace(prog, "x", "bar", "i"); + } + #endregion } } diff --git a/src/AddIns/BackendBindings/CSharpBinding/Test/ExpressionFinder.cs b/src/AddIns/BackendBindings/CSharpBinding/Test/ExpressionFinder.cs index bc72dc3c8b..62f9f25c22 100644 --- a/src/AddIns/BackendBindings/CSharpBinding/Test/ExpressionFinder.cs +++ b/src/AddIns/BackendBindings/CSharpBinding/Test/ExpressionFinder.cs @@ -9,6 +9,7 @@ using System; using System.Collections.Generic; using NUnit.Framework; using CSharpBinding.Parser; +using ICSharpCode.SharpDevelop; using ICSharpCode.SharpDevelop.Dom; namespace CSharpBinding.Tests @@ -130,10 +131,9 @@ class Main { } [Test] - [Ignore("Temporarily ignored - code no longer compiles")] public void NewException() { -// FindFull(program2, "otFoundException", "NotFoundException()", ExpressionContext.TypeDerivingFrom(ProjectContentRegistry.Mscorlib.GetClass("System.Exception"), true)); + FindFull(program2, "otFoundException", "NotFoundException()", ExpressionContext.TypeDerivingFrom(ParserService.DefaultProjectContentRegistry.Mscorlib.GetClass("System.Exception"), true)); } } } diff --git a/src/Libraries/NRefactory/Test/Output/VBNet/CSharpToVBConverterTest.cs b/src/Libraries/NRefactory/Test/Output/VBNet/CSharpToVBConverterTest.cs index 62e7adc5b9..f104b07a42 100644 --- a/src/Libraries/NRefactory/Test/Output/VBNet/CSharpToVBConverterTest.cs +++ b/src/Libraries/NRefactory/Test/Output/VBNet/CSharpToVBConverterTest.cs @@ -212,7 +212,7 @@ namespace ICSharpCode.NRefactory.Tests.PrettyPrinter "End Sub"); } - [Test, Ignore] + [Test, Ignore("NRefactory cannot guess the anonymous method's return type")] public void AnonymousMethodInVarDeclaration() { TestMember("void A() { Converter i = delegate(int argument) { return argument * 2; }; }", diff --git a/src/Main/Base/Test/GenericResolverTests.cs b/src/Main/Base/Test/GenericResolverTests.cs index 5a58ed08a3..244353d9c4 100644 --- a/src/Main/Base/Test/GenericResolverTests.cs +++ b/src/Main/Base/Test/GenericResolverTests.cs @@ -14,242 +14,242 @@ namespace ICSharpCode.SharpDevelop.Tests [TestFixture] public class GenericResolverTests { -// #region Test helper methods -// NRefactoryResolverTests nrrt = new NRefactoryResolverTests(); -// -// ResolveResult Resolve(string program, string expression, int line) -// { -// return nrrt.Resolve(program, expression, line); -// } -// -// ResolveResult ResolveVB(string program, string expression, int line) -// { -// return nrrt.ResolveVB(program, expression, line); -// } -// #endregion -// -// #region Generic references -// const string listProgram = @"using System.Collections.Generic; -//class TestClass { -// void Method() { -// List list = new List(); -// -// } -// -// T CloneIt(T source) where T : ICloneable { -// if (source == null) return new TestClass(); -// return source.Clone(); -// } -// -// public int PublicField; -//} -//"; -// -// [Test] -// public void ListAddTest() -// { -// ResolveResult result = Resolve(listProgram, "list.Add(new A())", 5); -// Assert.IsNotNull(result); -// Assert.IsTrue(result is MemberResolveResult); -// IMethod m = (IMethod)((MemberResolveResult)result).ResolvedMember; -// Assert.AreEqual(1, m.Parameters.Count); -// Assert.AreEqual("TestClass", m.Parameters[0].ReturnType.FullyQualifiedName); -// } -// -// [Test] -// public void ListAddRangeTest() -// { -// ResolveResult result = Resolve(listProgram, "list.AddRange(new A[0])", 5); -// Assert.IsNotNull(result); -// Assert.IsTrue(result is MemberResolveResult); -// IMethod m = (IMethod)((MemberResolveResult)result).ResolvedMember; -// Assert.AreEqual(1, m.Parameters.Count); -// Assert.IsTrue(m.Parameters[0].ReturnType is ConstructedReturnType); -// Assert.AreEqual("System.Collections.Generic.IEnumerable", m.Parameters[0].ReturnType.FullyQualifiedName); -// Assert.AreEqual("TestClass", ((ConstructedReturnType)m.Parameters[0].ReturnType).TypeArguments[0].FullyQualifiedName); -// } -// -// [Test] -// public void ListToArrayTest() -// { -// ResolveResult result = Resolve(listProgram, "list.ToArray()", 5); -// Assert.IsNotNull(result); -// Assert.IsTrue(result is MemberResolveResult); -// IMethod m = (IMethod)((MemberResolveResult)result).ResolvedMember; -// Assert.AreEqual("TestClass", m.ReturnType.FullyQualifiedName); -// Assert.AreEqual(1, m.ReturnType.CastToArrayReturnType().ArrayDimensions); -// } -// -// [Test] -// public void ClassReferenceTest() -// { -// ResolveResult result = Resolve(listProgram, "List", 5); -// Assert.IsNotNull(result); -// Assert.IsTrue(result is TypeResolveResult); -// Assert.AreEqual("System.Collections.Generic.List", ((TypeResolveResult)result).ResolvedClass.FullyQualifiedName); -// Assert.IsTrue(result.ResolvedType is ConstructedReturnType); -// Assert.AreEqual("System.String", ((ConstructedReturnType)result.ResolvedType).TypeArguments[0].FullyQualifiedName); -// } -// -// [Test] -// public void GenericMethodCallTest() -// { -// ResolveResult result = Resolve(listProgram, "CloneIt(null)", 5); -// Assert.IsNotNull(result); -// Assert.IsTrue(result is MemberResolveResult); -// Assert.AreEqual("TestClass", result.ResolvedType.FullyQualifiedName); -// MemberResolveResult mrr = (MemberResolveResult) result; -// Assert.AreEqual("TestClass.CloneIt", mrr.ResolvedMember.FullyQualifiedName); -// } -// -// [Test] -// public void FieldReferenceOnGenericMethodTest() -// { -// ResolveResult result = Resolve(listProgram, "CloneIt(null).PublicField", 5); -// Assert.IsNotNull(result); -// Assert.IsTrue(result is MemberResolveResult); -// Assert.AreEqual("System.Int32", result.ResolvedType.FullyQualifiedName); -// MemberResolveResult mrr = (MemberResolveResult) result; -// Assert.AreEqual("TestClass.PublicField", mrr.ResolvedMember.FullyQualifiedName); -// } -// -// [Test] -// public void TypeInferredGenericMethodCallTest() -// { -// ResolveResult result = Resolve(listProgram, "CloneIt(new TestClass())", 5); -// Assert.IsNotNull(result); -// Assert.IsTrue(result is MemberResolveResult); -// Assert.AreEqual("TestClass", result.ResolvedType.FullyQualifiedName); -// MemberResolveResult mrr = (MemberResolveResult) result; -// Assert.AreEqual("TestClass.CloneIt", mrr.ResolvedMember.FullyQualifiedName); -// } -// -// [Test] -// public void FieldReferenceOnTypeInferredGenericMethodCallTest() -// { -// ResolveResult result = Resolve(listProgram, "CloneIt(new TestClass()).PublicField", 5); -// Assert.IsNotNull(result); -// Assert.IsTrue(result is MemberResolveResult); -// Assert.AreEqual("System.Int32", result.ResolvedType.FullyQualifiedName); -// MemberResolveResult mrr = (MemberResolveResult) result; -// Assert.AreEqual("TestClass.PublicField", mrr.ResolvedMember.FullyQualifiedName); -// } -// -// [Test] -// public void ImportAliasClassResolveTest() -// { -// string program = @"using COL = System.Collections.Generic.List; -//class TestClass { -// void Test() { -// COL a = new COL(); -// -// } -//} -//"; -// TypeResolveResult rr = Resolve(program, "COL", 4) as TypeResolveResult; -// Assert.AreEqual("System.Collections.Generic.List", rr.ResolvedClass.FullyQualifiedName, "COL"); -// Assert.AreEqual("System.Collections.Generic.List{System.String}", rr.ResolvedType.DotNetName, "COL"); -// LocalResolveResult lr = Resolve(program, "a", 5) as LocalResolveResult; -// Assert.AreEqual("System.Collections.Generic.List{System.String}", lr.ResolvedType.DotNetName, "a"); -// } -// -// [Test] -// public void InheritFromGenericClass() -// { -// string program = @"using System; -//class BaseClass { -// public T value; -//} -//class DerivedClass : BaseClass { -// -//}"; -// MemberResolveResult rr = Resolve(program, "value", 6) as MemberResolveResult; -// Assert.AreEqual("System.String", rr.ResolvedType.FullyQualifiedName); -// } -// -// [Test] -// public void CrossTypeParametersInheritance() -// { -// string program = @"using System; -//class BaseClass { -// public A a; -// public B b; -//} -//class DerivedClass : BaseClass { -// -//}"; -// MemberResolveResult rr = Resolve(program, "a", 7) as MemberResolveResult; -// Assert.AreEqual("B", rr.ResolvedType.Name); -// rr = Resolve(program, "b", 7) as MemberResolveResult; -// Assert.AreEqual("A", rr.ResolvedType.Name); -// } -// #endregion -// -// #region CodeCompletion inside generic classes -// const string genericClass = @"using System; -//public class GenericClass where T : IDisposable -// void Method(T par1, G par2) where G : IConvertible, IFormattable { -// T var1; G var2; -// -// } -//} -//"; -// -// [Test] -// public void ClassTypeParameterResolveType() -// { -// ResolveResult rr = Resolve(genericClass, "T", 5); -// Assert.IsNotNull(rr); -// Assert.IsTrue(rr is TypeResolveResult); -// Assert.IsNull((rr as TypeResolveResult).ResolvedClass); -// Assert.IsTrue(rr.ResolvedType is GenericReturnType); -// } -// -// [Test] -// public void ClassTypeParameterResolveVariable() -// { -// ResolveResult rr = Resolve(genericClass, "var1", 5); -// Assert.IsNotNull(rr); -// Assert.IsTrue(rr is LocalResolveResult); -// Assert.IsTrue(rr.ResolvedType is GenericReturnType); -// } -// -// [Test] -// public void ClassTypeParameterResolveParameter() -// { -// ResolveResult rr = Resolve(genericClass, "par1", 5); -// Assert.IsNotNull(rr); -// Assert.IsTrue(rr is LocalResolveResult); -// Assert.IsTrue(rr.ResolvedType is GenericReturnType); -// } -// -// [Test] -// public void MethodTypeParameterResolveType() -// { -// ResolveResult rr = Resolve(genericClass, "G", 5); -// Assert.IsNotNull(rr); -// Assert.IsTrue(rr is TypeResolveResult); -// Assert.IsNull((rr as TypeResolveResult).ResolvedClass); -// Assert.IsTrue(rr.ResolvedType is GenericReturnType); -// } -// -// [Test] -// public void MethodTypeParameterResolveVariable() -// { -// ResolveResult rr = Resolve(genericClass, "var2", 5); -// Assert.IsNotNull(rr); -// Assert.IsTrue(rr is LocalResolveResult); -// Assert.IsTrue(rr.ResolvedType is GenericReturnType); -// } -// -// [Test] -// public void MethodTypeParameterResolveParameter() -// { -// ResolveResult rr = Resolve(genericClass, "par2", 5); -// Assert.IsNotNull(rr); -// Assert.IsTrue(rr is LocalResolveResult); -// Assert.IsTrue(rr.ResolvedType is GenericReturnType); -// } -// #endregion + #region Test helper methods + NRefactoryResolverTests nrrt = new NRefactoryResolverTests(); + + ResolveResult Resolve(string program, string expression, int line) + { + return nrrt.Resolve(program, expression, line); + } + + ResolveResult ResolveVB(string program, string expression, int line) + { + return nrrt.ResolveVB(program, expression, line); + } + #endregion + + #region Generic references + const string listProgram = @"using System.Collections.Generic; +class TestClass { + void Method() { + List list = new List(); + + } + + T CloneIt(T source) where T : ICloneable { + if (source == null) return new TestClass(); + return source.Clone(); + } + + public int PublicField; +} +"; + + [Test] + public void ListAddTest() + { + ResolveResult result = Resolve(listProgram, "list.Add(new A())", 5); + Assert.IsNotNull(result); + Assert.IsTrue(result is MemberResolveResult); + IMethod m = (IMethod)((MemberResolveResult)result).ResolvedMember; + Assert.AreEqual(1, m.Parameters.Count); + Assert.AreEqual("TestClass", m.Parameters[0].ReturnType.FullyQualifiedName); + } + + [Test] + public void ListAddRangeTest() + { + ResolveResult result = Resolve(listProgram, "list.AddRange(new A[0])", 5); + Assert.IsNotNull(result); + Assert.IsTrue(result is MemberResolveResult); + IMethod m = (IMethod)((MemberResolveResult)result).ResolvedMember; + Assert.AreEqual(1, m.Parameters.Count); + Assert.IsTrue(m.Parameters[0].ReturnType is ConstructedReturnType); + Assert.AreEqual("System.Collections.Generic.IEnumerable", m.Parameters[0].ReturnType.FullyQualifiedName); + Assert.AreEqual("TestClass", ((ConstructedReturnType)m.Parameters[0].ReturnType).TypeArguments[0].FullyQualifiedName); + } + + [Test] + public void ListToArrayTest() + { + ResolveResult result = Resolve(listProgram, "list.ToArray()", 5); + Assert.IsNotNull(result); + Assert.IsTrue(result is MemberResolveResult); + IMethod m = (IMethod)((MemberResolveResult)result).ResolvedMember; + Assert.AreEqual("TestClass", m.ReturnType.FullyQualifiedName); + Assert.AreEqual(1, m.ReturnType.CastToArrayReturnType().ArrayDimensions); + } + + [Test] + public void ClassReferenceTest() + { + ResolveResult result = Resolve(listProgram, "List", 5); + Assert.IsNotNull(result); + Assert.IsTrue(result is TypeResolveResult); + Assert.AreEqual("System.Collections.Generic.List", ((TypeResolveResult)result).ResolvedClass.FullyQualifiedName); + Assert.IsTrue(result.ResolvedType is ConstructedReturnType); + Assert.AreEqual("System.String", ((ConstructedReturnType)result.ResolvedType).TypeArguments[0].FullyQualifiedName); + } + + [Test] + public void GenericMethodCallTest() + { + ResolveResult result = Resolve(listProgram, "CloneIt(null)", 5); + Assert.IsNotNull(result); + Assert.IsTrue(result is MemberResolveResult); + Assert.AreEqual("TestClass", result.ResolvedType.FullyQualifiedName); + MemberResolveResult mrr = (MemberResolveResult) result; + Assert.AreEqual("TestClass.CloneIt", mrr.ResolvedMember.FullyQualifiedName); + } + + [Test] + public void FieldReferenceOnGenericMethodTest() + { + ResolveResult result = Resolve(listProgram, "CloneIt(null).PublicField", 5); + Assert.IsNotNull(result); + Assert.IsTrue(result is MemberResolveResult); + Assert.AreEqual("System.Int32", result.ResolvedType.FullyQualifiedName); + MemberResolveResult mrr = (MemberResolveResult) result; + Assert.AreEqual("TestClass.PublicField", mrr.ResolvedMember.FullyQualifiedName); + } + + [Test] + public void TypeInferredGenericMethodCallTest() + { + ResolveResult result = Resolve(listProgram, "CloneIt(new TestClass())", 5); + Assert.IsNotNull(result); + Assert.IsTrue(result is MemberResolveResult); + Assert.AreEqual("TestClass", result.ResolvedType.FullyQualifiedName); + MemberResolveResult mrr = (MemberResolveResult) result; + Assert.AreEqual("TestClass.CloneIt", mrr.ResolvedMember.FullyQualifiedName); + } + + [Test] + public void FieldReferenceOnTypeInferredGenericMethodCallTest() + { + ResolveResult result = Resolve(listProgram, "CloneIt(new TestClass()).PublicField", 5); + Assert.IsNotNull(result); + Assert.IsTrue(result is MemberResolveResult); + Assert.AreEqual("System.Int32", result.ResolvedType.FullyQualifiedName); + MemberResolveResult mrr = (MemberResolveResult) result; + Assert.AreEqual("TestClass.PublicField", mrr.ResolvedMember.FullyQualifiedName); + } + + [Test] + public void ImportAliasClassResolveTest() + { + string program = @"using COL = System.Collections.Generic.List; +class TestClass { + void Test() { + COL a = new COL(); + + } +} +"; + TypeResolveResult rr = Resolve(program, "COL", 4) as TypeResolveResult; + Assert.AreEqual("System.Collections.Generic.List", rr.ResolvedClass.FullyQualifiedName, "COL"); + Assert.AreEqual("System.Collections.Generic.List{System.String}", rr.ResolvedType.DotNetName, "COL"); + LocalResolveResult lr = Resolve(program, "a", 5) as LocalResolveResult; + Assert.AreEqual("System.Collections.Generic.List{System.String}", lr.ResolvedType.DotNetName, "a"); + } + + [Test] + public void InheritFromGenericClass() + { + string program = @"using System; +class BaseClass { + public T value; +} +class DerivedClass : BaseClass { + +}"; + MemberResolveResult rr = Resolve(program, "value", 6) as MemberResolveResult; + Assert.AreEqual("System.String", rr.ResolvedType.FullyQualifiedName); + } + + [Test] + public void CrossTypeParametersInheritance() + { + string program = @"using System; +class BaseClass { + public A a; + public B b; +} +class DerivedClass : BaseClass { + +}"; + MemberResolveResult rr = Resolve(program, "a", 7) as MemberResolveResult; + Assert.AreEqual("B", rr.ResolvedType.Name); + rr = Resolve(program, "b", 7) as MemberResolveResult; + Assert.AreEqual("A", rr.ResolvedType.Name); + } + #endregion + + #region CodeCompletion inside generic classes + const string genericClass = @"using System; +public class GenericClass where T : IDisposable + void Method(T par1, G par2) where G : IConvertible, IFormattable { + T var1; G var2; + + } +} +"; + + [Test] + public void ClassTypeParameterResolveType() + { + ResolveResult rr = Resolve(genericClass, "T", 5); + Assert.IsNotNull(rr); + Assert.IsTrue(rr is TypeResolveResult); + Assert.IsNull((rr as TypeResolveResult).ResolvedClass); + Assert.IsTrue(rr.ResolvedType is GenericReturnType); + } + + [Test] + public void ClassTypeParameterResolveVariable() + { + ResolveResult rr = Resolve(genericClass, "var1", 5); + Assert.IsNotNull(rr); + Assert.IsTrue(rr is LocalResolveResult); + Assert.IsTrue(rr.ResolvedType is GenericReturnType); + } + + [Test] + public void ClassTypeParameterResolveParameter() + { + ResolveResult rr = Resolve(genericClass, "par1", 5); + Assert.IsNotNull(rr); + Assert.IsTrue(rr is LocalResolveResult); + Assert.IsTrue(rr.ResolvedType is GenericReturnType); + } + + [Test] + public void MethodTypeParameterResolveType() + { + ResolveResult rr = Resolve(genericClass, "G", 5); + Assert.IsNotNull(rr); + Assert.IsTrue(rr is TypeResolveResult); + Assert.IsNull((rr as TypeResolveResult).ResolvedClass); + Assert.IsTrue(rr.ResolvedType is GenericReturnType); + } + + [Test] + public void MethodTypeParameterResolveVariable() + { + ResolveResult rr = Resolve(genericClass, "var2", 5); + Assert.IsNotNull(rr); + Assert.IsTrue(rr is LocalResolveResult); + Assert.IsTrue(rr.ResolvedType is GenericReturnType); + } + + [Test] + public void MethodTypeParameterResolveParameter() + { + ResolveResult rr = Resolve(genericClass, "par2", 5); + Assert.IsNotNull(rr); + Assert.IsTrue(rr is LocalResolveResult); + Assert.IsTrue(rr.ResolvedType is GenericReturnType); + } + #endregion } } diff --git a/src/Main/Base/Test/InnerClassesResolverTests.cs b/src/Main/Base/Test/InnerClassesResolverTests.cs index a6503c5ef6..9375d99273 100644 --- a/src/Main/Base/Test/InnerClassesResolverTests.cs +++ b/src/Main/Base/Test/InnerClassesResolverTests.cs @@ -15,109 +15,109 @@ namespace ICSharpCode.SharpDevelop.Tests [TestFixture] public class InnerClassesResolverTests { -// #region Test helper methods -// NRefactoryResolverTests nrrt = new NRefactoryResolverTests(); -// -// ResolveResult Resolve(string program, string expression, int line) -// { -// return nrrt.Resolve(program, expression, line); -// } -// -// ResolveResult ResolveVB(string program, string expression, int line) -// { -// return nrrt.ResolveVB(program, expression, line); -// } -// #endregion -// -// [Test] -// public void SimpleInnerClass() -// { -// string program = @"class A { -// void Test() { -// -// } -// class B { } -//} -//"; -// ResolveResult result = Resolve(program, "B", 3); -// Assert.IsTrue(result is TypeResolveResult); -// Assert.AreEqual("A.B", result.ResolvedType.FullyQualifiedName); -// } -// -// [Test] -// public void ReflectionInnerClass() -// { -// string program = @"using System; -//class A { -// void Test() { -// -// } -//} -//"; -// ResolveResult result = Resolve(program, "Environment.SpecialFolder", 3); -// Assert.IsTrue(result is TypeResolveResult); -// Assert.AreEqual("System.Environment.SpecialFolder", result.ResolvedType.FullyQualifiedName); -// } -// -// [Test] -// public void OuterclassPrivateFieldResolveTest() -// { -// string program = @"class A -//{ -// int myField; -// class B -// { -// void MyMethod(A a) -// { -// -// } -// } -//} -//"; -// ResolveResult result = Resolve(program, "a", 8); -// Assert.IsNotNull(result, "result"); -// Assert.IsTrue(result is LocalResolveResult, "result is LocalResolveResult"); -// ArrayList arr = result.GetCompletionData(nrrt.lastPC); -// Assert.IsNotNull(arr, "arr"); -// foreach (object o in arr) { -// if (o is IField) { -// Assert.AreEqual("myField", ((IField)o).Name); -// return; -// } -// } -// Assert.Fail("private field not visible from inner class"); -// } -// -// [Test] -// public void InheritedInnerClass() -// { -// string program = @"class A { -// class B { } -//} -//class C : A { -// void Main() { -// -// } -//} -//"; -// ResolveResult result = Resolve(program, "B", 6); -// Assert.IsTrue(result is TypeResolveResult); -// Assert.AreEqual("A.B", result.ResolvedType.FullyQualifiedName); -// -// result = Resolve(program, "C.B", 6); -// Assert.IsTrue(result is TypeResolveResult); -// Assert.AreEqual("A.B", result.ResolvedType.FullyQualifiedName); -// -// result = Resolve(program, "C", 6); -// Assert.IsTrue(result is TypeResolveResult); -// Assert.AreEqual("C", result.ResolvedType.FullyQualifiedName); -// foreach (object o in result.GetCompletionData(nrrt.lastPC)) { -// if (o is IClass) { -// Assert.AreEqual("A.B", ((IClass)o).FullyQualifiedName); -// return; -// } -// } -// Assert.Fail("Inherited inner class not visible."); -// } + #region Test helper methods + NRefactoryResolverTests nrrt = new NRefactoryResolverTests(); + + ResolveResult Resolve(string program, string expression, int line) + { + return nrrt.Resolve(program, expression, line); + } + + ResolveResult ResolveVB(string program, string expression, int line) + { + return nrrt.ResolveVB(program, expression, line); + } + #endregion + + [Test] + public void SimpleInnerClass() + { + string program = @"class A { + void Test() { + + } + class B { } +} +"; + ResolveResult result = Resolve(program, "B", 3); + Assert.IsTrue(result is TypeResolveResult); + Assert.AreEqual("A.B", result.ResolvedType.FullyQualifiedName); + } + + [Test] + public void ReflectionInnerClass() + { + string program = @"using System; +class A { + void Test() { + + } +} +"; + ResolveResult result = Resolve(program, "Environment.SpecialFolder", 3); + Assert.IsTrue(result is TypeResolveResult); + Assert.AreEqual("System.Environment.SpecialFolder", result.ResolvedType.FullyQualifiedName); + } + + [Test] + public void OuterclassPrivateFieldResolveTest() + { + string program = @"class A +{ + int myField; + class B + { + void MyMethod(A a) + { + + } + } +} +"; + ResolveResult result = Resolve(program, "a", 8); + Assert.IsNotNull(result, "result"); + Assert.IsTrue(result is LocalResolveResult, "result is LocalResolveResult"); + ArrayList arr = result.GetCompletionData(nrrt.lastPC); + Assert.IsNotNull(arr, "arr"); + foreach (object o in arr) { + if (o is IField) { + Assert.AreEqual("myField", ((IField)o).Name); + return; + } + } + Assert.Fail("private field not visible from inner class"); + } + + [Test] + public void InheritedInnerClass() + { + string program = @"class A { + class B { } +} +class C : A { + void Main() { + + } +} +"; + ResolveResult result = Resolve(program, "B", 6); + Assert.IsTrue(result is TypeResolveResult); + Assert.AreEqual("A.B", result.ResolvedType.FullyQualifiedName); + + result = Resolve(program, "C.B", 6); + Assert.IsTrue(result is TypeResolveResult); + Assert.AreEqual("A.B", result.ResolvedType.FullyQualifiedName); + + result = Resolve(program, "C", 6); + Assert.IsTrue(result is TypeResolveResult); + Assert.AreEqual("C", result.ResolvedType.FullyQualifiedName); + foreach (object o in result.GetCompletionData(nrrt.lastPC)) { + if (o is IClass) { + Assert.AreEqual("A.B", ((IClass)o).FullyQualifiedName); + return; + } + } + Assert.Fail("Inherited inner class not visible."); + } } } diff --git a/src/Main/Base/Test/NRefactoryResolverTests.cs b/src/Main/Base/Test/NRefactoryResolverTests.cs index c3aa739a86..94eed9ecca 100644 --- a/src/Main/Base/Test/NRefactoryResolverTests.cs +++ b/src/Main/Base/Test/NRefactoryResolverTests.cs @@ -20,928 +20,930 @@ namespace ICSharpCode.SharpDevelop.Tests [TestFixture] public class NRefactoryResolverTests { -// #region Test helper methods -// ICompilationUnit Parse(string fileName, string fileContent) -// { -// ICSharpCode.NRefactory.IParser p = ICSharpCode.NRefactory.ParserFactory.CreateParser(ICSharpCode.NRefactory.SupportedLanguage.CSharp, new StringReader(fileContent)); -// p.ParseMethodBodies = false; -// p.Parse(); -// DefaultProjectContent pc = new DefaultProjectContent(); -// pc.ReferencedContents.Add(ProjectContentRegistry.Mscorlib); -// pc.ReferencedContents.Add(ProjectContentRegistry.GetProjectContentForReference("System.Windows.Forms", "System.Windows.Forms")); -// HostCallback.GetCurrentProjectContent = delegate { -// return pc; -// }; -// lastPC = pc; -// NRefactoryASTConvertVisitor visitor = new NRefactoryASTConvertVisitor(pc); -// visitor.VisitCompilationUnit(p.CompilationUnit, null); -// visitor.Cu.FileName = fileName; -// visitor.Cu.ErrorsDuringCompile = p.Errors.Count > 0; -// foreach (IClass c in visitor.Cu.Classes) { -// pc.AddClassToNamespaceList(c); -// } -// -// return visitor.Cu; -// } -// -// public IProjectContent lastPC; -// -// ICompilationUnit ParseVB(string fileName, string fileContent) -// { -// ICSharpCode.NRefactory.IParser p = ICSharpCode.NRefactory.ParserFactory.CreateParser(ICSharpCode.NRefactory.SupportedLanguage.VBNet, new StringReader(fileContent)); -// p.ParseMethodBodies = false; -// p.Parse(); -// DefaultProjectContent pc = new DefaultProjectContent(); -// HostCallback.GetCurrentProjectContent = delegate { -// return pc; -// }; -// pc.ReferencedContents.Add(ProjectContentRegistry.Mscorlib); -// pc.ReferencedContents.Add(ProjectContentRegistry.GetProjectContentForReference("System.Windows.Forms", "System.Windows.Forms")); -// pc.Language = LanguageProperties.VBNet; -// lastPC = pc; -// NRefactoryASTConvertVisitor visitor = new NRefactoryASTConvertVisitor(pc); -// visitor.VisitCompilationUnit(p.CompilationUnit, null); -// visitor.Cu.FileName = fileName; -// visitor.Cu.ErrorsDuringCompile = p.Errors.Count > 0; -// foreach (IClass c in visitor.Cu.Classes) { -// pc.AddClassToNamespaceList(c); -// } -// -// return visitor.Cu; -// } -// -// void AddCompilationUnit(ICompilationUnit parserOutput, string fileName) -// { -// HostCallback.GetParseInformation = ParserService.GetParseInformation; -// ParserService.UpdateParseInformation(parserOutput, fileName, false, false); -// } -// -// public ResolveResult Resolve(string program, string expression, int line) -// { -// AddCompilationUnit(Parse("a.cs", program), "a.cs"); -// -// NRefactoryResolver resolver = new NRefactoryResolver(lastPC); -// return resolver.Resolve(new ExpressionResult(expression), -// line, 0, -// "a.cs", -// program); -// } -// -// public ResolveResult ResolveVB(string program, string expression, int line) -// { -// AddCompilationUnit(ParseVB("a.vb", program), "a.vb"); -// -// NRefactoryResolver resolver = new NRefactoryResolver(lastPC); -// return resolver.Resolve(new ExpressionResult(expression), -// line, 0, -// "a.vb", -// program); -// } -// -// public T Resolve(string program, string expression, int line) where T : ResolveResult -// { -// ResolveResult rr = Resolve(program, expression, line); -// Assert.IsNotNull(rr, "Resolve returned null"); -// Assert.IsTrue(rr is T, "result is " + typeof(T).Name); -// return (T)rr; -// } -// -// public T ResolveVB(string program, string expression, int line) where T : ResolveResult -// { -// ResolveResult rr = ResolveVB(program, expression, line); -// Assert.IsNotNull(rr, "Resolve returned null"); -// Assert.IsTrue(rr is T, "result is " + typeof(T).Name); -// return (T)rr; -// } -// #endregion -// -// #region Test for old issues (Fidalgo) -// // Issue SD-291 -// [Test] -// public void VBNetMultipleVariableDeclarationsTest() -// { -// string program = @"Class X -// Shared Sub Main -// Dim a, b As String -// -// End Sub -//End Class -//"; -// ResolveResult result = ResolveVB(program, "a", 4); -// Assert.AreEqual("System.String", result.ResolvedType.FullyQualifiedName); -// -// result = ResolveVB(program, "b", 4); -// Assert.AreEqual("System.String", result.ResolvedType.FullyQualifiedName); -// } -// -// // Issue SD-258 -// [Test] -// public void VBNetForeachLoopVariableTest() -// { -// string program = @"Class Test -// Shared Sub Main() -// For Each c As String In MyColl -// -// Next -// End Sub -//End Class -//"; -// ResolveResult result = ResolveVB(program, "c", 4); -// Assert.AreEqual("System.String", result.ResolvedType.FullyQualifiedName); -// } -// -// // Issue SD-265 -// [Test] -// public void VBNetStaticMembersOnInstanceTest() -// { -// string program = @"Class X -// Sub Z() -// Dim a As String -// -// End Sub -//End Class -//"; -// ResolveResult result = ResolveVB(program, "a", 4); -// Assert.IsNotNull(result, "result"); -// ArrayList arr = result.GetCompletionData(lastPC); -// Assert.IsNotNull(arr, "arr"); -// foreach (object o in arr) { -// if (o is IMember) { -// if (((IMember)o).FullyQualifiedName == "System.String.Empty") -// return; -// } -// } -// Assert.Fail("Static member empty not found on string instance!"); -// } -// -// // Issue SD-217 -// [Test] -// public void VBNetLocalArrayLookupTest() -// { -// string program = @"Module Main -// Sub Main() -// Dim t As String() -// -// End Sub -//End Module -//"; -// ResolveResult result = ResolveVB(program, "t", 4); -// -// ArrayList arr = result.GetCompletionData(lastPC); -// Assert.IsNotNull(arr, "arr"); -// foreach (object o in arr) { -// if (o is IMember) { -// if (((IMember)o).FullyQualifiedName == "System.Array.Length") -// return; -// } -// } -// Assert.Fail("Length not found on array instance (resolve result was " + result.ResolvedType.ToString() + ")"); -// } -// #endregion -// -// #region Simple Tests -// const string arrayListConflictProgram = @"using System.Collections; -//class A { -// void Test() { -// -// } -// -// ArrayList arrayList; -// public ArrayList ArrayList { -// get { -// return arrayList; -// } -// } -//} -//"; -// -// [Test] -// public void PropertyTypeConflictTest() -// { -// ResolveResult result = Resolve(arrayListConflictProgram, "arrayList", 4); -// Assert.AreEqual("System.Collections.ArrayList", result.ResolvedType.FullyQualifiedName); -// } -// -// [Test] -// public void PropertyTypeConflictCompletionResultTest() -// { -// ResolveResult result = Resolve(arrayListConflictProgram, "ArrayList", 4); -// // CC should offer both static and non-static results -// ArrayList list = result.GetCompletionData(lastPC); -// bool ok = false; -// foreach (object o in list) { -// IMethod method = o as IMethod; -// if (method != null && method.Name == "AddRange") -// ok = true; -// } -// Assert.IsTrue(ok, "AddRange should exist"); -// ok = false; -// foreach (object o in list) { -// IMethod method = o as IMethod; -// if (method != null && method.Name == "Adapter") -// ok = true; -// } -// Assert.IsTrue(ok, "Adapter should exist"); -// } -// -// [Test] -// public void InheritedInterfaceResolveTest() -// { -// string program = @"using System; -//class A { -// void Method(IInterface1 a) { -// -// } -//} -//interface IInterface1 : IInterface2, IDisposable { -// void Method1(); -//} -//interface IInterface2 { -// void Method2(); -//} -//"; -// ResolveResult result = Resolve(program, "a", 4); -// ArrayList arr = result.GetCompletionData(lastPC); -// Assert.IsNotNull(arr, "arr"); -// bool m1 = false; -// bool m2 = false; -// bool disp = false; -// bool getType = false; -// foreach (IMethod m in arr) { -// if (m.Name == "Method1") -// m1 = true; -// if (m.Name == "Method2") -// m2 = true; -// if (m.Name == "Dispose") -// disp = true; -// if (m.Name == "GetType") -// getType = true; -// } -// Assert.IsTrue(m1, "Method1 not found"); -// Assert.IsTrue(m2, "Method2 not found"); -// Assert.IsTrue(disp, "Dispose not found"); -// Assert.IsTrue(getType, "GetType not found"); -// } -// -// [Test] -// public void InvalidMethodCallTest() -// { -// string program = @"class A { -// void Method(string b) { -// -// } -//} -//"; -// ResolveResult result = Resolve(program, "b.ThisMethodDoesNotExistOnString()", 3); -// Assert.IsNull(result, "result"); -// } -// -// [Test] -// public void InvalidConstructorCallTest() -// { -// string program = @"class A { -// void Method() { -// -// } -//} -//"; -// ResolveResult result = Resolve(program, "new ThisClassDoesNotExist()", 3); -// Assert.IsNull(result); -// } -// -// [Test] -// public void MethodCallTest() -// { -// string program = @"class A { -// void Method() { -// -// } -// -// int TargetMethod() { -// return 3; -// } -//} -//"; -// ResolveResult result = Resolve(program, "TargetMethod()", 3); -// Assert.AreEqual("System.Int32", result.ResolvedType.FullyQualifiedName, "'TargetMethod()'"); -// } -// -// [Test] -// public void ThisMethodCallTest() -// { -// string program = @"class A { -// void Method() { -// -// } -// -// int TargetMethod() { -// return 3; -// } -//} -//"; -// ResolveResult result = Resolve(program, "this.TargetMethod()", 3); -// Assert.AreEqual("System.Int32", result.ResolvedType.FullyQualifiedName, "'this.TargetMethod()'"); -// } -// -// [Test] -// public void EventCallTest() -// { -// string program = @"using System; -//class A { -// void Method() { -// -// } -// -// public event EventHandler TestEvent; -//} -//"; -// MemberResolveResult result = Resolve(program, "TestEvent(this, EventArgs.Empty)", 4); -// Assert.AreEqual("A.TestEvent", result.ResolvedMember.FullyQualifiedName); -// } -// -// [Test] -// public void VoidTest() -// { -// string program = @"using System; -//class A { -// void TestMethod() { -// -// } -//} -//"; -// ResolveResult result = Resolve(program, "TestMethod()", 4); -// Assert.IsNotNull(result); -// Assert.AreSame(VoidReturnType.Instance, result.ResolvedType, result.ResolvedType.ToString()); -// Assert.AreEqual(0, result.GetCompletionData(lastPC).Count); -// } -// -// [Test] -// public void ThisEventCallTest() -// { -// string program = @"using System; -//class A { -// void Method() { -// -// } -// -// public event EventHandler TestEvent; -//} -//"; -// MemberResolveResult result = Resolve(program, "this.TestEvent(this, EventArgs.Empty)", 4); -// Assert.AreEqual("A.TestEvent", result.ResolvedMember.FullyQualifiedName); -// } -// -// [Test] -// public void DelegateCallTest() -// { -// string program = @"using System.Reflection; -//class A { -// void Method() { -// ModuleResolveEventHandler eh = SomeClass.SomeProperty; -// -// } -//} -//"; -// ResolveResult result = Resolve(program, "eh(this, new ResolveEventArgs())", 5); -// Assert.AreEqual("eh", (result as LocalResolveResult).Field.Name); -// -// result = Resolve(program, "eh(this, new ResolveEventArgs()).GetType(\"bla\")", 5); -// Assert.AreEqual("System.Reflection.Module.GetType", (result as MemberResolveResult).ResolvedMember.FullyQualifiedName); -// } -// -// [Test] -// public void OverloadLookupTest() -// { -// string program = @"class A { -// void Method() { -// -// } -// -// int Multiply(int a, int b) { return a * b; } -// double Multiply(double a, double b) { return a * b; } -//} -//"; -// ResolveResult result = Resolve(program, "Multiply(1, 1)", 3); -// Assert.AreEqual("System.Int32", result.ResolvedType.FullyQualifiedName, "'Multiply(1,1)'"); -// -// result = Resolve(program, "Multiply(1.0, 1.0)", 3); -// Assert.AreEqual("System.Double", result.ResolvedType.FullyQualifiedName, "'Multiply(1.0,1.0)'"); -// } -// -// [Test] -// public void CTorOverloadLookupTest() -// { -// string program = @"class A { -// void Method() { -// -// } -// -// static A() {} -// A() {} -// A(int intVal) {} -// A(double dblVal) {} -//} -//"; -// MemberResolveResult result = Resolve(program, "new A()", 3); -// IMethod m = (IMethod)result.ResolvedMember; -// Assert.IsFalse(m.IsStatic, "new A() is static"); -// Assert.AreEqual(0, m.Parameters.Count, "new A() parameter count"); -// -// result = Resolve(program, "new A(10)", 3); -// m = (IMethod)result.ResolvedMember; -// Assert.AreEqual(1, m.Parameters.Count, "new A(10) parameter count"); -// Assert.AreEqual("intVal", m.Parameters[0].Name, "new A(10) parameter"); -// -// result = Resolve(program, "new A(11.1)", 3); -// m = (IMethod)result.ResolvedMember; -// Assert.AreEqual(1, m.Parameters.Count, "new A(11.1) parameter count"); -// Assert.AreEqual("dblVal", m.Parameters[0].Name, "new A(11.1) parameter"); -// } -// -// [Test] -// public void DefaultCTorOverloadLookupTest() -// { -// string program = @"class A { -// void Method() { -// -// } -//} -//"; -// MemberResolveResult result = Resolve(program, "new A()", 3); -// IMethod m = (IMethod)result.ResolvedMember; -// Assert.IsNotNull(m); -// } -// -// [Test] -// public void ValueInsideSetterTest() -// { -// string program = @"class A { -// public string Property { -// set { -// -// } -// } -//} -//"; -// LocalResolveResult result = Resolve(program, "value", 4); -// Assert.AreEqual("System.String", result.ResolvedType.FullyQualifiedName); -// MemberResolveResult mrr = Resolve(program, "value.ToString()", 4); -// Assert.AreEqual("System.String.ToString", mrr.ResolvedMember.FullyQualifiedName); -// } -// -// [Test] -// public void AnonymousMethodParameters() -// { -// string program = @"using System; -//class A { -// void Method() { -// SomeEvent += delegate(object sender, EventArgs e) { -// -// }; -// } } -//"; -// ResolveResult result = Resolve(program, "e", 5); -// Assert.AreEqual("System.EventArgs", result.ResolvedType.FullyQualifiedName); -// } -// -// [Test] -// public void DefaultTypeCSharp() -// { -// string program = @"class A { -// void Method() { -// -// } } -//"; -// ResolveResult result = Resolve(program, "int", 3); -// Assert.AreEqual("System.Int32", result.ResolvedType.FullyQualifiedName); -// } -// -// [Test] -// public void DefaultTypeVB() -// { -// string program = @"Class A -// Sub Method() -// -// End Sub -//End Class -//"; -// ResolveResult result = ResolveVB(program, "inTeGer", 3); -// Assert.AreEqual("System.Int32", result.ResolvedType.FullyQualifiedName); -// } -// -// // PrimitiveTypeOutsideClass and OtherTypeOutsideClass -// // are necessary for delegate declarations and class inheritance -// // (because "outside" is everything before {, so the reference to the -// // base class is outside the class) -// [Test] -// public void PrimitiveTypeOutsideClass() -// { -// string program = @"class A { -// -//} -// -//class B { -// -//} -//"; -// ResolveResult result = Resolve(program, "int", 4); -// Assert.AreEqual("System.Int32", result.ResolvedType.FullyQualifiedName); -// } -// -// [Test] -// public void OtherTypeOutsideClass() -// { -// string program = @"using System; -//class A { -// -//} -// -//class B { -// -//} -//"; -// ResolveResult result = Resolve(program, "Activator", 5); -// Assert.AreEqual("System.Activator", result.ResolvedType.FullyQualifiedName); -// } -// -// [Test] -// public void FullyQualifiedTypeOutsideClass() -// { -// string program = @"class A { -// -//} -// -//class B { -// -//} -//"; -// ResolveResult result = Resolve(program, "System.Activator", 4); -// Assert.AreEqual("System.Activator", result.ResolvedType.FullyQualifiedName); -// } -// -// [Test] -// public void InnerClassTest() -// { -// string program = @"using System; -//class A { -// -//} -//"; -// ResolveResult result = Resolve(program, "Environment.SpecialFolder", 3); -// Assert.AreEqual("System.Environment.SpecialFolder", result.ResolvedType.FullyQualifiedName); -// } -// #endregion -// -// #region Import namespace tests -// [Test] -// public void NamespacePreferenceTest() -// { -// // Classes in the current namespace are preferred over classes from -// // imported namespaces -// string program = @"using System; -//namespace Testnamespace { -//class A { -// -//} -// -//class Activator { -// -//} -//} -//"; -// ResolveResult result = Resolve(program, "Activator", 4); -// Assert.AreEqual("Testnamespace.Activator", result.ResolvedType.FullyQualifiedName); -// } -// -// [Test] -// public void ParentNamespaceTypeLookup() -// { -// // Classes in the current namespace are preferred over classes from -// // imported namespaces -// string program = @"using System; -//namespace Root { -// class Alpha {} -//} -//namespace Root.Child { -// class Beta { -// -// } -//} -//"; -// ResolveResult result = Resolve(program, "Alpha", 7); -// Assert.AreEqual("Root.Alpha", result.ResolvedType.FullyQualifiedName); -// } -// -// [Test] -// public void ParentNamespaceCtrlSpace() -// { -// // Classes in the current namespace are preferred over classes from -// // imported namespaces -// string program = @"using System; -//namespace Root { -// class Alpha {} -//} -//namespace Root.Child { -// class Beta { -// -// } -//} -//"; -// AddCompilationUnit(Parse("a.cs", program), "a.cs"); -// -// NRefactoryResolver resolver = new NRefactoryResolver(lastPC); -// ArrayList m = resolver.CtrlSpace(7, 0, "a.cs", program, ExpressionContext.Default); -// Assert.IsTrue(TypeExists(m, "Beta"), "Meta must exist"); -// Assert.IsTrue(TypeExists(m, "Alpha"), "Alpha must exist"); -// } -// -// bool TypeExists(ArrayList m, string name) -// { -// foreach (object o in m) { -// IClass c = o as IClass; -// if (c != null && c.Name == name) -// return true; -// } -// return false; -// } -// -// [Test] -// public void ImportedSubnamespaceTestCSharp() -// { -// // using an import in this way is not possible in C# -// string program = @"using System; -//class TestClass { -// void Test() { -// Collections.ArrayList a; -// -// } -//} -//"; -// ResolveResult result = Resolve(program, "Collections.ArrayList", 4); -// Assert.IsNull(result, "Collections.ArrayList should not resolve"); -// LocalResolveResult local = Resolve(program, "a", 5); -// Assert.IsNull(local.ResolvedType, "the full type should not be resolved"); -// } -// -// [Test] -// public void ImportedSubnamespaceTestVBNet() -// { -// // using an import this way IS possible in VB.NET -// string program = @"Imports System -//Class TestClass -// Sub Test() -// Dim a As Collections.ArrayList -// -// End Sub -//End Class -//"; -// TypeResolveResult type = ResolveVB(program, "Collections.ArrayList", 4); -// Assert.AreEqual("System.Collections.ArrayList", type.ResolvedClass.FullyQualifiedName, "TypeResolveResult"); -// LocalResolveResult local = ResolveVB(program, "a", 5); -// Assert.AreEqual("System.Collections.ArrayList", local.ResolvedType.FullyQualifiedName, -// "the full type should be resolved"); -// } -// -// [Test] -// public void ImportAliasTest() -// { -// string program = @"using COL = System.Collections; -//class TestClass { -// void Test() { -// COL.ArrayList a; -// -// } -//} -//"; -// TypeResolveResult type = Resolve(program, "COL.ArrayList", 4); -// Assert.IsNotNull(type, "COL.ArrayList should resolve to a type"); -// Assert.AreEqual("System.Collections.ArrayList", type.ResolvedClass.FullyQualifiedName, "TypeResolveResult"); -// LocalResolveResult local = Resolve(program, "a", 5); -// Assert.AreEqual("System.Collections.ArrayList", local.ResolvedType.FullyQualifiedName, -// "the full type should be resolved"); -// } -// -// [Test] -// public void ImportAliasNamespaceResolveTest() -// { -// NamespaceResolveResult ns; -// string program = "using COL = System.Collections;\r\nclass A {\r\n\r\n}\r\n"; -// ns = Resolve(program, "COL", 3); -// Assert.AreEqual("System.Collections", ns.Name, "COL"); -// ns = Resolve(program, "COL.Generic", 3); -// Assert.AreEqual("System.Collections.Generic", ns.Name, "COL.Generic"); -// } -// -// [Test] -// public void ImportAliasClassResolveTest() -// { -// string program = @"using COL = System.Collections.ArrayList; -//class TestClass { -// void Test() { -// COL a = new COL(); -// -// } -//} -//"; -// TypeResolveResult rr = Resolve(program, "COL", 4); -// Assert.AreEqual("System.Collections.ArrayList", rr.ResolvedClass.FullyQualifiedName, "COL"); -// LocalResolveResult lr = Resolve(program, "a", 5); -// Assert.AreEqual("System.Collections.ArrayList", lr.ResolvedType.FullyQualifiedName, "a"); -// } -// #endregion -// -// #region Import class tests -// const string importClassProgram = @"Imports System -//Imports System.Math -// -//Class TestClass -// Sub Main() -// -// End Sub -//End Class -//"; -// -// [Test] -// public void TestImportClassMember() -// { -// MemberResolveResult mrr = ResolveVB(importClassProgram, "Pi", 6); -// Assert.AreEqual("System.Math.PI", mrr.ResolvedMember.FullyQualifiedName); -// mrr = ResolveVB(importClassProgram, "Pi.ToString()", 6); -// Assert.AreEqual("System.Double.ToString", mrr.ResolvedMember.FullyQualifiedName); -// } -// -// [Test] -// public void TestImportClassMethod() -// { -// MemberResolveResult mrr = ResolveVB(importClassProgram, "Sin(3)", 6); -// Assert.AreEqual("System.Math.Sin", mrr.ResolvedMember.FullyQualifiedName); -// mrr = ResolveVB(importClassProgram, "Sin(3).ToString()", 6); -// Assert.AreEqual("System.Double.ToString", mrr.ResolvedMember.FullyQualifiedName); -// } -// #endregion -// -// #region Visibility tests -// [Test] -// public void PrivateMemberTest() -// { -// string program = @"using System; -//class A { -// void TestMethod(B b) { -// -// } -//} -//class B { -// int member; -//} -//"; -// ResolveResult result = Resolve(program, "b", 4); -// Assert.IsNotNull(result); -// ArrayList cd = result.GetCompletionData(lastPC); -// Assert.IsFalse(MemberExists(cd, "member"), "member should not be in completion lookup"); -// result = Resolve(program, "b.member", 4); -// Assert.IsNotNull(result, "member should be found even though it is not visible!"); -// } -// -// [Test] -// public void ProtectedVisibleMemberTest() -// { -// string program = @"using System; -//class A : B { -// void TestMethod(B b) { -// -// } -//} -//class B { -// protected int member; -//} -//"; -// ResolveResult result = Resolve(program, "b", 4); -// Assert.IsNotNull(result); -// ArrayList cd = result.GetCompletionData(lastPC); -// Assert.IsTrue(MemberExists(cd, "member"), "member should be in completion lookup"); -// result = Resolve(program, "b.member", 4); -// Assert.IsNotNull(result, "member should be found!"); -// } -// -// [Test] -// public void ProtectedInvisibleMemberTest() -// { -// string program = @"using System; -//class A { -// void TestMethod(B b) { -// -// } -//} -//class B { -// protected int member; -//} -//"; -// ResolveResult result = Resolve(program, "b", 4); -// Assert.IsNotNull(result); -// ArrayList cd = result.GetCompletionData(lastPC); -// Assert.IsFalse(MemberExists(cd, "member"), "member should not be in completion lookup"); -// result = Resolve(program, "b.member", 4); -// Assert.IsNotNull(result, "member should be found even though it is not visible!"); -// } -// -// bool MemberExists(ArrayList members, string name) -// { -// foreach (object o in members) { -// IMember m = o as IMember; -// if (m.Name == name) return true; -// } -// return false; -// } -// -// [Test] -// public void OverriddenMemberVisibilityTest() -// { -// string program = @"using System; -// public abstract class GrandParent { -// protected abstract void OverrideMe(); -// } -// public class Parent: GrandParent { -// protected override void OverrideMe() { -// } -// } -// public class Child: Parent { -// } -//"; -// ResolveResult result = Resolve(program, "(Child)someVar", 6); -// Assert.AreEqual("Child", result.ResolvedType.FullyQualifiedName); -// int count = 0; -// foreach (IMethod m in result.ResolvedType.GetMethods()) { -// if (m.Name == "OverrideMe") -// count += 1; -// } -// Assert.AreEqual(1, count); -// count = 0; -// foreach (object o in result.GetCompletionData(lastPC)) { -// IMethod m = o as IMethod; -// if (m != null && m.Name == "OverrideMe") -// count += 1; -// } -// Assert.AreEqual(1, count); -// } -// #endregion -// -// #region MixedType tests -// const string mixedTypeTestProgram = @"using System; -//class A { -// void TestMethod() { -// -// } -// public Project Project { get { return new Project(); } } -// public Project OtherName { get { return new Project(); } } -//} -//class Project { -// public static string Static; -// public int Instance; -//} -//namespace OtherName { class Bla { } } -//"; -// -// [Test] -// public void MixedResolveResultTest() -// { -// ResolveResult result = Resolve(mixedTypeTestProgram, "Project", 4); -// Assert.IsInstanceOfType(typeof(MixedResolveResult), result); -// MixedResolveResult mrr = (MixedResolveResult)result; -// Assert.IsInstanceOfType(typeof(MemberResolveResult), mrr.PrimaryResult); -// Assert.AreEqual("Project", mrr.TypeResult.ResolvedClass.Name); -// } -// -// [Test] -// public void MixedStaticAccessTest() -// { -// ResolveResult result = Resolve(mixedTypeTestProgram, "Project.Static", 4); -// Assert.IsInstanceOfType(typeof(MemberResolveResult), result); -// Assert.AreEqual("Static", (result as MemberResolveResult).ResolvedMember.Name); -// } -// -// [Test] -// public void MixedInstanceAccessTest() -// { -// ResolveResult result = Resolve(mixedTypeTestProgram, "Project.Instance", 4); -// Assert.IsInstanceOfType(typeof(MemberResolveResult), result); -// Assert.AreEqual("Instance", (result as MemberResolveResult).ResolvedMember.Name); -// } -// -// [Test] -// public void NamespaceMixResolveResultTest() -// { -// ResolveResult result = Resolve(mixedTypeTestProgram, "OtherName", 4); -// Assert.IsInstanceOfType(typeof(MemberResolveResult), result); -// Assert.AreEqual("OtherName", (result as MemberResolveResult).ResolvedMember.Name); -// } -// -// [Test] -// public void NamespaceMixMemberAccessTest() -// { -// ResolveResult result = Resolve(mixedTypeTestProgram, "OtherName.Instance", 4); -// Assert.IsInstanceOfType(typeof(MemberResolveResult), result); -// Assert.AreEqual("Instance", (result as MemberResolveResult).ResolvedMember.Name); -// } -// #endregion + ProjectContentRegistry projectContentRegistry = ParserService.DefaultProjectContentRegistry; + + #region Test helper methods + ICompilationUnit Parse(string fileName, string fileContent) + { + ICSharpCode.NRefactory.IParser p = ICSharpCode.NRefactory.ParserFactory.CreateParser(ICSharpCode.NRefactory.SupportedLanguage.CSharp, new StringReader(fileContent)); + p.ParseMethodBodies = false; + p.Parse(); + DefaultProjectContent pc = new DefaultProjectContent(); + pc.ReferencedContents.Add(projectContentRegistry.Mscorlib); + pc.ReferencedContents.Add(projectContentRegistry.GetProjectContentForReference("System.Windows.Forms", "System.Windows.Forms")); + HostCallback.GetCurrentProjectContent = delegate { + return pc; + }; + lastPC = pc; + NRefactoryASTConvertVisitor visitor = new NRefactoryASTConvertVisitor(pc); + visitor.VisitCompilationUnit(p.CompilationUnit, null); + visitor.Cu.FileName = fileName; + visitor.Cu.ErrorsDuringCompile = p.Errors.Count > 0; + foreach (IClass c in visitor.Cu.Classes) { + pc.AddClassToNamespaceList(c); + } + + return visitor.Cu; + } + + public IProjectContent lastPC; + + ICompilationUnit ParseVB(string fileName, string fileContent) + { + ICSharpCode.NRefactory.IParser p = ICSharpCode.NRefactory.ParserFactory.CreateParser(ICSharpCode.NRefactory.SupportedLanguage.VBNet, new StringReader(fileContent)); + p.ParseMethodBodies = false; + p.Parse(); + DefaultProjectContent pc = new DefaultProjectContent(); + HostCallback.GetCurrentProjectContent = delegate { + return pc; + }; + pc.ReferencedContents.Add(projectContentRegistry.Mscorlib); + pc.ReferencedContents.Add(projectContentRegistry.GetProjectContentForReference("System.Windows.Forms", "System.Windows.Forms")); + pc.Language = LanguageProperties.VBNet; + lastPC = pc; + NRefactoryASTConvertVisitor visitor = new NRefactoryASTConvertVisitor(pc); + visitor.VisitCompilationUnit(p.CompilationUnit, null); + visitor.Cu.FileName = fileName; + visitor.Cu.ErrorsDuringCompile = p.Errors.Count > 0; + foreach (IClass c in visitor.Cu.Classes) { + pc.AddClassToNamespaceList(c); + } + + return visitor.Cu; + } + + void AddCompilationUnit(ICompilationUnit parserOutput, string fileName) + { + HostCallback.GetParseInformation = ParserService.GetParseInformation; + ParserService.UpdateParseInformation(parserOutput, fileName, false, false); + } + + public ResolveResult Resolve(string program, string expression, int line) + { + AddCompilationUnit(Parse("a.cs", program), "a.cs"); + + NRefactoryResolver resolver = new NRefactoryResolver(lastPC); + return resolver.Resolve(new ExpressionResult(expression), + line, 0, + "a.cs", + program); + } + + public ResolveResult ResolveVB(string program, string expression, int line) + { + AddCompilationUnit(ParseVB("a.vb", program), "a.vb"); + + NRefactoryResolver resolver = new NRefactoryResolver(lastPC); + return resolver.Resolve(new ExpressionResult(expression), + line, 0, + "a.vb", + program); + } + + public T Resolve(string program, string expression, int line) where T : ResolveResult + { + ResolveResult rr = Resolve(program, expression, line); + Assert.IsNotNull(rr, "Resolve returned null"); + Assert.IsTrue(rr is T, "result is " + typeof(T).Name); + return (T)rr; + } + + public T ResolveVB(string program, string expression, int line) where T : ResolveResult + { + ResolveResult rr = ResolveVB(program, expression, line); + Assert.IsNotNull(rr, "Resolve returned null"); + Assert.IsTrue(rr is T, "result is " + typeof(T).Name); + return (T)rr; + } + #endregion + + #region Test for old issues (Fidalgo) + // Issue SD-291 + [Test] + public void VBNetMultipleVariableDeclarationsTest() + { + string program = @"Class X + Shared Sub Main + Dim a, b As String + + End Sub +End Class +"; + ResolveResult result = ResolveVB(program, "a", 4); + Assert.AreEqual("System.String", result.ResolvedType.FullyQualifiedName); + + result = ResolveVB(program, "b", 4); + Assert.AreEqual("System.String", result.ResolvedType.FullyQualifiedName); + } + + // Issue SD-258 + [Test] + public void VBNetForeachLoopVariableTest() + { + string program = @"Class Test + Shared Sub Main() + For Each c As String In MyColl + + Next + End Sub +End Class +"; + ResolveResult result = ResolveVB(program, "c", 4); + Assert.AreEqual("System.String", result.ResolvedType.FullyQualifiedName); + } + + // Issue SD-265 + [Test] + public void VBNetStaticMembersOnInstanceTest() + { + string program = @"Class X + Sub Z() + Dim a As String + + End Sub +End Class +"; + ResolveResult result = ResolveVB(program, "a", 4); + Assert.IsNotNull(result, "result"); + ArrayList arr = result.GetCompletionData(lastPC); + Assert.IsNotNull(arr, "arr"); + foreach (object o in arr) { + if (o is IMember) { + if (((IMember)o).FullyQualifiedName == "System.String.Empty") + return; + } + } + Assert.Fail("Static member empty not found on string instance!"); + } + + // Issue SD-217 + [Test] + public void VBNetLocalArrayLookupTest() + { + string program = @"Module Main + Sub Main() + Dim t As String() + + End Sub +End Module +"; + ResolveResult result = ResolveVB(program, "t", 4); + + ArrayList arr = result.GetCompletionData(lastPC); + Assert.IsNotNull(arr, "arr"); + foreach (object o in arr) { + if (o is IMember) { + if (((IMember)o).FullyQualifiedName == "System.Array.Length") + return; + } + } + Assert.Fail("Length not found on array instance (resolve result was " + result.ResolvedType.ToString() + ")"); + } + #endregion + + #region Simple Tests + const string arrayListConflictProgram = @"using System.Collections; +class A { + void Test() { + + } + + ArrayList arrayList; + public ArrayList ArrayList { + get { + return arrayList; + } + } +} +"; + + [Test] + public void PropertyTypeConflictTest() + { + ResolveResult result = Resolve(arrayListConflictProgram, "arrayList", 4); + Assert.AreEqual("System.Collections.ArrayList", result.ResolvedType.FullyQualifiedName); + } + + [Test] + public void PropertyTypeConflictCompletionResultTest() + { + ResolveResult result = Resolve(arrayListConflictProgram, "ArrayList", 4); + // CC should offer both static and non-static results + ArrayList list = result.GetCompletionData(lastPC); + bool ok = false; + foreach (object o in list) { + IMethod method = o as IMethod; + if (method != null && method.Name == "AddRange") + ok = true; + } + Assert.IsTrue(ok, "AddRange should exist"); + ok = false; + foreach (object o in list) { + IMethod method = o as IMethod; + if (method != null && method.Name == "Adapter") + ok = true; + } + Assert.IsTrue(ok, "Adapter should exist"); + } + + [Test] + public void InheritedInterfaceResolveTest() + { + string program = @"using System; +class A { + void Method(IInterface1 a) { + + } +} +interface IInterface1 : IInterface2, IDisposable { + void Method1(); +} +interface IInterface2 { + void Method2(); +} +"; + ResolveResult result = Resolve(program, "a", 4); + ArrayList arr = result.GetCompletionData(lastPC); + Assert.IsNotNull(arr, "arr"); + bool m1 = false; + bool m2 = false; + bool disp = false; + bool getType = false; + foreach (IMethod m in arr) { + if (m.Name == "Method1") + m1 = true; + if (m.Name == "Method2") + m2 = true; + if (m.Name == "Dispose") + disp = true; + if (m.Name == "GetType") + getType = true; + } + Assert.IsTrue(m1, "Method1 not found"); + Assert.IsTrue(m2, "Method2 not found"); + Assert.IsTrue(disp, "Dispose not found"); + Assert.IsTrue(getType, "GetType not found"); + } + + [Test] + public void InvalidMethodCallTest() + { + string program = @"class A { + void Method(string b) { + + } +} +"; + ResolveResult result = Resolve(program, "b.ThisMethodDoesNotExistOnString()", 3); + Assert.IsNull(result, "result"); + } + + [Test] + public void InvalidConstructorCallTest() + { + string program = @"class A { + void Method() { + + } +} +"; + ResolveResult result = Resolve(program, "new ThisClassDoesNotExist()", 3); + Assert.IsNull(result); + } + + [Test] + public void MethodCallTest() + { + string program = @"class A { + void Method() { + + } + + int TargetMethod() { + return 3; + } +} +"; + ResolveResult result = Resolve(program, "TargetMethod()", 3); + Assert.AreEqual("System.Int32", result.ResolvedType.FullyQualifiedName, "'TargetMethod()'"); + } + + [Test] + public void ThisMethodCallTest() + { + string program = @"class A { + void Method() { + + } + + int TargetMethod() { + return 3; + } +} +"; + ResolveResult result = Resolve(program, "this.TargetMethod()", 3); + Assert.AreEqual("System.Int32", result.ResolvedType.FullyQualifiedName, "'this.TargetMethod()'"); + } + + [Test] + public void EventCallTest() + { + string program = @"using System; +class A { + void Method() { + + } + + public event EventHandler TestEvent; +} +"; + MemberResolveResult result = Resolve(program, "TestEvent(this, EventArgs.Empty)", 4); + Assert.AreEqual("A.TestEvent", result.ResolvedMember.FullyQualifiedName); + } + + [Test] + public void VoidTest() + { + string program = @"using System; +class A { + void TestMethod() { + + } +} +"; + ResolveResult result = Resolve(program, "TestMethod()", 4); + Assert.IsNotNull(result); + Assert.AreSame(VoidReturnType.Instance, result.ResolvedType, result.ResolvedType.ToString()); + Assert.AreEqual(0, result.GetCompletionData(lastPC).Count); + } + + [Test] + public void ThisEventCallTest() + { + string program = @"using System; +class A { + void Method() { + + } + + public event EventHandler TestEvent; +} +"; + MemberResolveResult result = Resolve(program, "this.TestEvent(this, EventArgs.Empty)", 4); + Assert.AreEqual("A.TestEvent", result.ResolvedMember.FullyQualifiedName); + } + + [Test] + public void DelegateCallTest() + { + string program = @"using System.Reflection; +class A { + void Method() { + ModuleResolveEventHandler eh = SomeClass.SomeProperty; + + } +} +"; + ResolveResult result = Resolve(program, "eh(this, new ResolveEventArgs())", 5); + Assert.AreEqual("eh", (result as LocalResolveResult).Field.Name); + + result = Resolve(program, "eh(this, new ResolveEventArgs()).GetType(\"bla\")", 5); + Assert.AreEqual("System.Reflection.Module.GetType", (result as MemberResolveResult).ResolvedMember.FullyQualifiedName); + } + + [Test] + public void OverloadLookupTest() + { + string program = @"class A { + void Method() { + + } + + int Multiply(int a, int b) { return a * b; } + double Multiply(double a, double b) { return a * b; } +} +"; + ResolveResult result = Resolve(program, "Multiply(1, 1)", 3); + Assert.AreEqual("System.Int32", result.ResolvedType.FullyQualifiedName, "'Multiply(1,1)'"); + + result = Resolve(program, "Multiply(1.0, 1.0)", 3); + Assert.AreEqual("System.Double", result.ResolvedType.FullyQualifiedName, "'Multiply(1.0,1.0)'"); + } + + [Test] + public void CTorOverloadLookupTest() + { + string program = @"class A { + void Method() { + + } + + static A() {} + A() {} + A(int intVal) {} + A(double dblVal) {} +} +"; + MemberResolveResult result = Resolve(program, "new A()", 3); + IMethod m = (IMethod)result.ResolvedMember; + Assert.IsFalse(m.IsStatic, "new A() is static"); + Assert.AreEqual(0, m.Parameters.Count, "new A() parameter count"); + + result = Resolve(program, "new A(10)", 3); + m = (IMethod)result.ResolvedMember; + Assert.AreEqual(1, m.Parameters.Count, "new A(10) parameter count"); + Assert.AreEqual("intVal", m.Parameters[0].Name, "new A(10) parameter"); + + result = Resolve(program, "new A(11.1)", 3); + m = (IMethod)result.ResolvedMember; + Assert.AreEqual(1, m.Parameters.Count, "new A(11.1) parameter count"); + Assert.AreEqual("dblVal", m.Parameters[0].Name, "new A(11.1) parameter"); + } + + [Test] + public void DefaultCTorOverloadLookupTest() + { + string program = @"class A { + void Method() { + + } +} +"; + MemberResolveResult result = Resolve(program, "new A()", 3); + IMethod m = (IMethod)result.ResolvedMember; + Assert.IsNotNull(m); + } + + [Test] + public void ValueInsideSetterTest() + { + string program = @"class A { + public string Property { + set { + + } + } +} +"; + LocalResolveResult result = Resolve(program, "value", 4); + Assert.AreEqual("System.String", result.ResolvedType.FullyQualifiedName); + MemberResolveResult mrr = Resolve(program, "value.ToString()", 4); + Assert.AreEqual("System.String.ToString", mrr.ResolvedMember.FullyQualifiedName); + } + + [Test] + public void AnonymousMethodParameters() + { + string program = @"using System; +class A { + void Method() { + SomeEvent += delegate(object sender, EventArgs e) { + + }; + } } +"; + ResolveResult result = Resolve(program, "e", 5); + Assert.AreEqual("System.EventArgs", result.ResolvedType.FullyQualifiedName); + } + + [Test] + public void DefaultTypeCSharp() + { + string program = @"class A { + void Method() { + + } } +"; + ResolveResult result = Resolve(program, "int", 3); + Assert.AreEqual("System.Int32", result.ResolvedType.FullyQualifiedName); + } + + [Test] + public void DefaultTypeVB() + { + string program = @"Class A + Sub Method() + + End Sub +End Class +"; + ResolveResult result = ResolveVB(program, "inTeGer", 3); + Assert.AreEqual("System.Int32", result.ResolvedType.FullyQualifiedName); + } + + // PrimitiveTypeOutsideClass and OtherTypeOutsideClass + // are necessary for delegate declarations and class inheritance + // (because "outside" is everything before {, so the reference to the + // base class is outside the class) + [Test] + public void PrimitiveTypeOutsideClass() + { + string program = @"class A { + +} + +class B { + +} +"; + ResolveResult result = Resolve(program, "int", 4); + Assert.AreEqual("System.Int32", result.ResolvedType.FullyQualifiedName); + } + + [Test] + public void OtherTypeOutsideClass() + { + string program = @"using System; +class A { + +} + +class B { + +} +"; + ResolveResult result = Resolve(program, "Activator", 5); + Assert.AreEqual("System.Activator", result.ResolvedType.FullyQualifiedName); + } + + [Test] + public void FullyQualifiedTypeOutsideClass() + { + string program = @"class A { + +} + +class B { + +} +"; + ResolveResult result = Resolve(program, "System.Activator", 4); + Assert.AreEqual("System.Activator", result.ResolvedType.FullyQualifiedName); + } + + [Test] + public void InnerClassTest() + { + string program = @"using System; +class A { + +} +"; + ResolveResult result = Resolve(program, "Environment.SpecialFolder", 3); + Assert.AreEqual("System.Environment.SpecialFolder", result.ResolvedType.FullyQualifiedName); + } + #endregion + + #region Import namespace tests + [Test] + public void NamespacePreferenceTest() + { + // Classes in the current namespace are preferred over classes from + // imported namespaces + string program = @"using System; +namespace Testnamespace { +class A { + +} + +class Activator { + +} +} +"; + ResolveResult result = Resolve(program, "Activator", 4); + Assert.AreEqual("Testnamespace.Activator", result.ResolvedType.FullyQualifiedName); + } + + [Test] + public void ParentNamespaceTypeLookup() + { + // Classes in the current namespace are preferred over classes from + // imported namespaces + string program = @"using System; +namespace Root { + class Alpha {} +} +namespace Root.Child { + class Beta { + + } +} +"; + ResolveResult result = Resolve(program, "Alpha", 7); + Assert.AreEqual("Root.Alpha", result.ResolvedType.FullyQualifiedName); + } + + [Test] + public void ParentNamespaceCtrlSpace() + { + // Classes in the current namespace are preferred over classes from + // imported namespaces + string program = @"using System; +namespace Root { + class Alpha {} +} +namespace Root.Child { + class Beta { + + } +} +"; + AddCompilationUnit(Parse("a.cs", program), "a.cs"); + + NRefactoryResolver resolver = new NRefactoryResolver(lastPC); + ArrayList m = resolver.CtrlSpace(7, 0, "a.cs", program, ExpressionContext.Default); + Assert.IsTrue(TypeExists(m, "Beta"), "Meta must exist"); + Assert.IsTrue(TypeExists(m, "Alpha"), "Alpha must exist"); + } + + bool TypeExists(ArrayList m, string name) + { + foreach (object o in m) { + IClass c = o as IClass; + if (c != null && c.Name == name) + return true; + } + return false; + } + + [Test] + public void ImportedSubnamespaceTestCSharp() + { + // using an import in this way is not possible in C# + string program = @"using System; +class TestClass { + void Test() { + Collections.ArrayList a; + + } +} +"; + ResolveResult result = Resolve(program, "Collections.ArrayList", 4); + Assert.IsNull(result, "Collections.ArrayList should not resolve"); + LocalResolveResult local = Resolve(program, "a", 5); + Assert.IsNull(local.ResolvedType, "the full type should not be resolved"); + } + + [Test] + public void ImportedSubnamespaceTestVBNet() + { + // using an import this way IS possible in VB.NET + string program = @"Imports System +Class TestClass + Sub Test() + Dim a As Collections.ArrayList + + End Sub +End Class +"; + TypeResolveResult type = ResolveVB(program, "Collections.ArrayList", 4); + Assert.AreEqual("System.Collections.ArrayList", type.ResolvedClass.FullyQualifiedName, "TypeResolveResult"); + LocalResolveResult local = ResolveVB(program, "a", 5); + Assert.AreEqual("System.Collections.ArrayList", local.ResolvedType.FullyQualifiedName, + "the full type should be resolved"); + } + + [Test] + public void ImportAliasTest() + { + string program = @"using COL = System.Collections; +class TestClass { + void Test() { + COL.ArrayList a; + + } +} +"; + TypeResolveResult type = Resolve(program, "COL.ArrayList", 4); + Assert.IsNotNull(type, "COL.ArrayList should resolve to a type"); + Assert.AreEqual("System.Collections.ArrayList", type.ResolvedClass.FullyQualifiedName, "TypeResolveResult"); + LocalResolveResult local = Resolve(program, "a", 5); + Assert.AreEqual("System.Collections.ArrayList", local.ResolvedType.FullyQualifiedName, + "the full type should be resolved"); + } + + [Test] + public void ImportAliasNamespaceResolveTest() + { + NamespaceResolveResult ns; + string program = "using COL = System.Collections;\r\nclass A {\r\n\r\n}\r\n"; + ns = Resolve(program, "COL", 3); + Assert.AreEqual("System.Collections", ns.Name, "COL"); + ns = Resolve(program, "COL.Generic", 3); + Assert.AreEqual("System.Collections.Generic", ns.Name, "COL.Generic"); + } + + [Test] + public void ImportAliasClassResolveTest() + { + string program = @"using COL = System.Collections.ArrayList; +class TestClass { + void Test() { + COL a = new COL(); + + } +} +"; + TypeResolveResult rr = Resolve(program, "COL", 4); + Assert.AreEqual("System.Collections.ArrayList", rr.ResolvedClass.FullyQualifiedName, "COL"); + LocalResolveResult lr = Resolve(program, "a", 5); + Assert.AreEqual("System.Collections.ArrayList", lr.ResolvedType.FullyQualifiedName, "a"); + } + #endregion + + #region Import class tests + const string importClassProgram = @"Imports System +Imports System.Math + +Class TestClass + Sub Main() + + End Sub +End Class +"; + + [Test] + public void TestImportClassMember() + { + MemberResolveResult mrr = ResolveVB(importClassProgram, "Pi", 6); + Assert.AreEqual("System.Math.PI", mrr.ResolvedMember.FullyQualifiedName); + mrr = ResolveVB(importClassProgram, "Pi.ToString()", 6); + Assert.AreEqual("System.Double.ToString", mrr.ResolvedMember.FullyQualifiedName); + } + + [Test] + public void TestImportClassMethod() + { + MemberResolveResult mrr = ResolveVB(importClassProgram, "Sin(3)", 6); + Assert.AreEqual("System.Math.Sin", mrr.ResolvedMember.FullyQualifiedName); + mrr = ResolveVB(importClassProgram, "Sin(3).ToString()", 6); + Assert.AreEqual("System.Double.ToString", mrr.ResolvedMember.FullyQualifiedName); + } + #endregion + + #region Visibility tests + [Test] + public void PrivateMemberTest() + { + string program = @"using System; +class A { + void TestMethod(B b) { + + } +} +class B { + int member; +} +"; + ResolveResult result = Resolve(program, "b", 4); + Assert.IsNotNull(result); + ArrayList cd = result.GetCompletionData(lastPC); + Assert.IsFalse(MemberExists(cd, "member"), "member should not be in completion lookup"); + result = Resolve(program, "b.member", 4); + Assert.IsNotNull(result, "member should be found even though it is not visible!"); + } + + [Test] + public void ProtectedVisibleMemberTest() + { + string program = @"using System; +class A : B { + void TestMethod(B b) { + + } +} +class B { + protected int member; +} +"; + ResolveResult result = Resolve(program, "b", 4); + Assert.IsNotNull(result); + ArrayList cd = result.GetCompletionData(lastPC); + Assert.IsTrue(MemberExists(cd, "member"), "member should be in completion lookup"); + result = Resolve(program, "b.member", 4); + Assert.IsNotNull(result, "member should be found!"); + } + + [Test] + public void ProtectedInvisibleMemberTest() + { + string program = @"using System; +class A { + void TestMethod(B b) { + + } +} +class B { + protected int member; +} +"; + ResolveResult result = Resolve(program, "b", 4); + Assert.IsNotNull(result); + ArrayList cd = result.GetCompletionData(lastPC); + Assert.IsFalse(MemberExists(cd, "member"), "member should not be in completion lookup"); + result = Resolve(program, "b.member", 4); + Assert.IsNotNull(result, "member should be found even though it is not visible!"); + } + + bool MemberExists(ArrayList members, string name) + { + foreach (object o in members) { + IMember m = o as IMember; + if (m.Name == name) return true; + } + return false; + } + + [Test] + public void OverriddenMemberVisibilityTest() + { + string program = @"using System; + public abstract class GrandParent { + protected abstract void OverrideMe(); + } + public class Parent: GrandParent { + protected override void OverrideMe() { + } + } + public class Child: Parent { + } +"; + ResolveResult result = Resolve(program, "(Child)someVar", 6); + Assert.AreEqual("Child", result.ResolvedType.FullyQualifiedName); + int count = 0; + foreach (IMethod m in result.ResolvedType.GetMethods()) { + if (m.Name == "OverrideMe") + count += 1; + } + Assert.AreEqual(1, count); + count = 0; + foreach (object o in result.GetCompletionData(lastPC)) { + IMethod m = o as IMethod; + if (m != null && m.Name == "OverrideMe") + count += 1; + } + Assert.AreEqual(1, count); + } + #endregion + + #region MixedType tests + const string mixedTypeTestProgram = @"using System; +class A { + void TestMethod() { + + } + public Project Project { get { return new Project(); } } + public Project OtherName { get { return new Project(); } } +} +class Project { + public static string Static; + public int Instance; +} +namespace OtherName { class Bla { } } +"; + + [Test] + public void MixedResolveResultTest() + { + ResolveResult result = Resolve(mixedTypeTestProgram, "Project", 4); + Assert.IsInstanceOfType(typeof(MixedResolveResult), result); + MixedResolveResult mrr = (MixedResolveResult)result; + Assert.IsInstanceOfType(typeof(MemberResolveResult), mrr.PrimaryResult); + Assert.AreEqual("Project", mrr.TypeResult.ResolvedClass.Name); + } + + [Test] + public void MixedStaticAccessTest() + { + ResolveResult result = Resolve(mixedTypeTestProgram, "Project.Static", 4); + Assert.IsInstanceOfType(typeof(MemberResolveResult), result); + Assert.AreEqual("Static", (result as MemberResolveResult).ResolvedMember.Name); + } + + [Test] + public void MixedInstanceAccessTest() + { + ResolveResult result = Resolve(mixedTypeTestProgram, "Project.Instance", 4); + Assert.IsInstanceOfType(typeof(MemberResolveResult), result); + Assert.AreEqual("Instance", (result as MemberResolveResult).ResolvedMember.Name); + } + + [Test] + public void NamespaceMixResolveResultTest() + { + ResolveResult result = Resolve(mixedTypeTestProgram, "OtherName", 4); + Assert.IsInstanceOfType(typeof(MemberResolveResult), result); + Assert.AreEqual("OtherName", (result as MemberResolveResult).ResolvedMember.Name); + } + + [Test] + public void NamespaceMixMemberAccessTest() + { + ResolveResult result = Resolve(mixedTypeTestProgram, "OtherName.Instance", 4); + Assert.IsInstanceOfType(typeof(MemberResolveResult), result); + Assert.AreEqual("Instance", (result as MemberResolveResult).ResolvedMember.Name); + } + #endregion } } diff --git a/src/Main/Base/Test/OverloadFinding.cs b/src/Main/Base/Test/OverloadFinding.cs index 383e834f2d..cef9e5890b 100644 --- a/src/Main/Base/Test/OverloadFinding.cs +++ b/src/Main/Base/Test/OverloadFinding.cs @@ -15,67 +15,67 @@ namespace ICSharpCode.SharpDevelop.Tests [TestFixture] public class OverloadFinding { -// [Test] public void Simple() -// { -// Test("(\"Hallo\")", 0, "(string a)", "(int b)"); -// Test("(2)", 1, "(string a)", "(int b)"); -// } -// -// [Test] public void WinForms() -// { -// string[] overloads = {"(object a)", "(TextBoxBase a)", "(Control a)", "(RichTextBox a)"}; -// Test("(new RichTextBox())", 3, overloads); -// Test("(new Control())", 2, overloads); -// Test("(new TextBox())", 1, overloads); -// Test("(new Button())", 2, overloads); -// Test("(3)", 0, overloads); -// } -// -// [Test] public void Params() -// { -// string[] overloads = {"(params int[] a)", "(int a, params int[] b)"}; -// Test("()", 0, overloads); -// Test("(1)", 1, overloads); -// Test("(1, 2)", 1, overloads); -// } -// -// [Test] public void IntegerConversion() -// { -// string[] overloads = {"(T a)", "(int a)"}; -// Test("(1)", 1, overloads); -// Test("(short.MaxValue)", 1, overloads); -// Test("(long.MaxValue)", 0, overloads); -// } -// -// NRefactoryResolverTests nrrt = new NRefactoryResolverTests(); -// -// void Test(string callExpr, int num, params string[] signatures) -// { -// StringBuilder b = new StringBuilder(); -// int lineNumber = 0; -// ++lineNumber; b.AppendLine("using System;"); -// ++lineNumber; b.AppendLine("using System.Windows.Forms;"); -// ++lineNumber; b.AppendLine("class TestClass {"); -// ++lineNumber; b.AppendLine(" void callingMethod() {"); -// ++lineNumber; b.AppendLine(" "); -// int callPosition = lineNumber; -// ++lineNumber; b.AppendLine(" }"); -// int[] positions = new int[signatures.Length]; -// for (int i = 0; i < signatures.Length; i++) { -// b.Append(" void Method"); -// b.Append(signatures[i]); -// ++lineNumber; b.AppendLine(" {"); -// positions[i] = lineNumber; -// ++lineNumber; b.AppendLine(" }"); -// } -// b.AppendLine("}"); -// MemberResolveResult mrr = nrrt.Resolve(b.ToString(), "Method" + callExpr, callPosition); -// string msg = "wrong overload: "; -// for (int i = 0; i < positions.Length; i++) { -// if (positions[i] == mrr.ResolvedMember.Region.BeginLine) -// msg += signatures[i]; -// } -// Assert.AreEqual(positions[num], mrr.ResolvedMember.Region.BeginLine, msg); -// } + [Test] public void Simple() + { + Test("(\"Hallo\")", 0, "(string a)", "(int b)"); + Test("(2)", 1, "(string a)", "(int b)"); + } + + [Test] public void WinForms() + { + string[] overloads = {"(object a)", "(TextBoxBase a)", "(Control a)", "(RichTextBox a)"}; + Test("(new RichTextBox())", 3, overloads); + Test("(new Control())", 2, overloads); + Test("(new TextBox())", 1, overloads); + Test("(new Button())", 2, overloads); + Test("(3)", 0, overloads); + } + + [Test] public void Params() + { + string[] overloads = {"(params int[] a)", "(int a, params int[] b)"}; + Test("()", 0, overloads); + Test("(1)", 1, overloads); + Test("(1, 2)", 1, overloads); + } + + [Test] public void IntegerConversion() + { + string[] overloads = {"(T a)", "(int a)"}; + Test("(1)", 1, overloads); + Test("(short.MaxValue)", 1, overloads); + Test("(long.MaxValue)", 0, overloads); + } + + NRefactoryResolverTests nrrt = new NRefactoryResolverTests(); + + void Test(string callExpr, int num, params string[] signatures) + { + StringBuilder b = new StringBuilder(); + int lineNumber = 0; + ++lineNumber; b.AppendLine("using System;"); + ++lineNumber; b.AppendLine("using System.Windows.Forms;"); + ++lineNumber; b.AppendLine("class TestClass {"); + ++lineNumber; b.AppendLine(" void callingMethod() {"); + ++lineNumber; b.AppendLine(" "); + int callPosition = lineNumber; + ++lineNumber; b.AppendLine(" }"); + int[] positions = new int[signatures.Length]; + for (int i = 0; i < signatures.Length; i++) { + b.Append(" void Method"); + b.Append(signatures[i]); + ++lineNumber; b.AppendLine(" {"); + positions[i] = lineNumber; + ++lineNumber; b.AppendLine(" }"); + } + b.AppendLine("}"); + MemberResolveResult mrr = nrrt.Resolve(b.ToString(), "Method" + callExpr, callPosition); + string msg = "wrong overload: "; + for (int i = 0; i < positions.Length; i++) { + if (positions[i] == mrr.ResolvedMember.Region.BeginLine) + msg += signatures[i]; + } + Assert.AreEqual(positions[num], mrr.ResolvedMember.Region.BeginLine, msg); + } } } diff --git a/src/Main/Base/Test/ReflectionLayerTests.cs b/src/Main/Base/Test/ReflectionLayerTests.cs index 6bcbd426ed..19b049b2d0 100644 --- a/src/Main/Base/Test/ReflectionLayerTests.cs +++ b/src/Main/Base/Test/ReflectionLayerTests.cs @@ -20,142 +20,149 @@ namespace ICSharpCode.SharpDevelop.Tests [TestFixture] public class ReflectionLayerTests { -// IProjectContent pc = ProjectContentRegistry.Mscorlib; -// -// [Test] -// public void InheritanceTest() -// { -// IClass c = pc.GetClass("System.SystemException"); -// IClass c2 = pc.GetClass("System.Exception"); -// Assert.IsNotNull(c, "c is null"); -// Assert.IsNotNull(c2, "c2 is null"); -// Assert.AreEqual(3, c.BaseTypes.Count); // 2 interfaces -// Assert.AreEqual("System.Exception", c.BaseTypes[0].FullyQualifiedName); -// Assert.AreSame(c2, c.BaseClass); -// -// List subClasses = new List(); -// foreach (IClass subClass in c.ClassInheritanceTree) { -// subClasses.Add(subClass); -// } -// Assert.AreEqual(5, subClasses.Count, "ClassInheritanceTree length"); -// Assert.AreEqual("System.SystemException", subClasses[0].FullyQualifiedName); -// Assert.AreEqual("System.Exception", subClasses[1].FullyQualifiedName); -// Assert.AreEqual("System.Runtime.Serialization.ISerializable", subClasses[2].FullyQualifiedName); -// Assert.AreEqual("System.Runtime.InteropServices._Exception", subClasses[3].FullyQualifiedName); -// Assert.AreEqual("System.Object", subClasses[4].FullyQualifiedName); -// } -// -// [Test] -// public void ParameterComparisonTest() -// { -// DefaultParameter p1 = new DefaultParameter("a", pc.GetClass("System.String").DefaultReturnType, DomRegion.Empty); -// DefaultParameter p2 = new DefaultParameter("b", new GetClassReturnType(pc, "System.String", 0), DomRegion.Empty); -// IList a1 = new List(); -// IList a2 = new List(); -// a1.Add(p1); -// a2.Add(p2); -// Assert.AreEqual(0, DiffUtility.Compare(a1, a2)); -// } -// -// DefaultMethod GetMethod(IClass c, string name) { -// IMethod result = c.Methods.Find(delegate(IMethod m) { return m.Name == name; }); -// Assert.IsNotNull(result, "Method " + name + " not found"); -// return (DefaultMethod)result; -// } -// -// [Test] -// public void GenericDocumentationTagNamesTest() -// { -// DefaultClass c = (DefaultClass)pc.GetClass("System.Collections.Generic.List"); -// Assert.AreEqual("T:System.Collections.Generic.List`1", -// c.DocumentationTag); -// Assert.AreEqual("M:System.Collections.Generic.List`1.Add(`0)", -// GetMethod(c, "Add").DocumentationTag); -// Assert.AreEqual("M:System.Collections.Generic.List`1.AddRange(System.Collections.Generic.IEnumerable{`0})", -// GetMethod(c, "AddRange").DocumentationTag); -// Assert.AreEqual("M:System.Collections.Generic.List`1.ConvertAll``1(System.Converter{`0,``0})", -// GetMethod(c, "ConvertAll").DocumentationTag); -// } -// -// [Test] -// public void InnerClassReferenceTest() -// { -// IClass c = pc.GetClass("System.Environment"); -// Assert.IsNotNull(c, "System.Environment not found"); -// IReturnType rt = GetMethod(c, "GetFolderPath").Parameters[0].ReturnType; -// Assert.IsNotNull(rt, "ReturnType is null"); -// Assert.AreEqual("System.Environment.SpecialFolder", rt.FullyQualifiedName); -// IClass inner = rt.GetUnderlyingClass(); -// Assert.IsNotNull(inner, "UnderlyingClass"); -// Assert.AreEqual("System.Environment.SpecialFolder", inner.FullyQualifiedName); -// } -// -// [Test] -// public void InnerClassesTest() -// { -// IClass c = pc.GetClass("System.Environment.SpecialFolder"); -// Assert.IsNotNull(c, "c is null"); -// Assert.AreEqual("System.Environment.SpecialFolder", c.FullyQualifiedName); -// } -// -// [Test] -// public void VoidTest() -// { -// IClass c = pc.GetClass("System.Void"); -// Assert.IsNotNull(c, "System.Void not found"); -// Assert.AreSame(c.DefaultReturnType, VoidReturnType.Instance, "VoidReturnType.Instance is c.DefaultReturnType"); -// } -// -// class TestClass where A : B { -// public void TestMethod(string param) where V: K where K: IComparable {} -// -// public void GetIndex(T element) where T: IEquatable {} -// } -// -// [Test] -// public void ReflectionParserTest() -// { -// ICompilationUnit cu = new ReflectionProjectContent("TestName", "testlocation", new AssemblyName[0]).AssemblyCompilationUnit; -// IClass c = new ReflectionClass(cu, typeof(TestClass<,>), typeof(TestClass<,>).FullName, null); -// cu.ProjectContent.AddClassToNamespaceList(c); -// -// CheckClass(c); -// MemoryStream memory = new MemoryStream(); -// DomPersistence.WriteProjectContent((ReflectionProjectContent)cu.ProjectContent, memory); -// -// memory.Position = 0; -// foreach (IClass c2 in DomPersistence.LoadProjectContent(memory).Classes) { -// CheckClass(c2); -// } -// } -// -// void CheckClass(IClass c) -// { -// Assert.AreSame(c, c.TypeParameters[0].Class); -// Assert.AreSame(c, c.TypeParameters[1].Class); -// Assert.AreSame(c.TypeParameters[1], ((GenericReturnType)c.TypeParameters[0].Constraints[0]).TypeParameter); -// -// IMethod m = c.Methods.Find(delegate(IMethod me) { return me.Name == "TestMethod"; }); -// Assert.IsNotNull(m); -// Assert.AreEqual("K", m.TypeParameters[0].Name); -// Assert.AreEqual("V", m.TypeParameters[1].Name); -// Assert.AreSame(m, m.TypeParameters[0].Method); -// Assert.AreSame(m, m.TypeParameters[1].Method); -// -// Assert.AreEqual("IComparable", m.TypeParameters[0].Constraints[0].Name); -// GenericReturnType kConst = (GenericReturnType)m.TypeParameters[1].Constraints[0]; -// Assert.AreSame(m.TypeParameters[0], kConst.TypeParameter); -// -// m = c.Methods.Find(delegate(IMethod me) { return me.Name == "GetIndex"; }); -// Assert.IsNotNull(m); -// Assert.AreEqual("T", m.TypeParameters[0].Name); -// Assert.AreSame(m, m.TypeParameters[0].Method); -// -// Assert.AreEqual("IEquatable", m.TypeParameters[0].Constraints[0].Name); -// Assert.AreEqual(1, m.TypeParameters[0].Constraints[0].TypeParameterCount); -// Assert.AreEqual(1, m.TypeParameters[0].Constraints[0].CastToConstructedReturnType().TypeArguments.Count); -// GenericReturnType grt = (GenericReturnType)m.TypeParameters[0].Constraints[0].CastToConstructedReturnType().TypeArguments[0]; -// Assert.AreSame(m.TypeParameters[0], grt.TypeParameter); -// } + IProjectContent pc = ParserService.DefaultProjectContentRegistry.Mscorlib; + + [Test] + public void InheritanceTest() + { + IClass c = pc.GetClass("System.SystemException"); + IClass c2 = pc.GetClass("System.Exception"); + Assert.IsNotNull(c, "c is null"); + Assert.IsNotNull(c2, "c2 is null"); + //Assert.AreEqual(3, c.BaseTypes.Count); // Inherited interfaces are not reported by Cecil + // which matches the behaviour of our C#/VB parsers + Assert.AreEqual("System.Exception", c.BaseTypes[0].FullyQualifiedName); + Assert.AreSame(c2, c.BaseClass); + + List subClasses = new List(); + foreach (IClass subClass in c.ClassInheritanceTree) { + subClasses.Add(subClass); + } + Assert.AreEqual(5, subClasses.Count, "ClassInheritanceTree length"); + Assert.AreEqual("System.SystemException", subClasses[0].FullyQualifiedName); + Assert.AreEqual("System.Exception", subClasses[1].FullyQualifiedName); + if (subClasses[2].FullyQualifiedName == "System.Object") { + Assert.AreEqual("System.Object", subClasses[2].FullyQualifiedName); + Assert.AreEqual("System.Runtime.Serialization.ISerializable", subClasses[3].FullyQualifiedName); + Assert.AreEqual("System.Runtime.InteropServices._Exception", subClasses[4].FullyQualifiedName); + } else { + Assert.AreEqual("System.Runtime.Serialization.ISerializable", subClasses[2].FullyQualifiedName); + Assert.AreEqual("System.Runtime.InteropServices._Exception", subClasses[3].FullyQualifiedName); + Assert.AreEqual("System.Object", subClasses[4].FullyQualifiedName); + } + } + + [Test] + public void ParameterComparisonTest() + { + DefaultParameter p1 = new DefaultParameter("a", pc.GetClass("System.String").DefaultReturnType, DomRegion.Empty); + DefaultParameter p2 = new DefaultParameter("b", new GetClassReturnType(pc, "System.String", 0), DomRegion.Empty); + IList a1 = new List(); + IList a2 = new List(); + a1.Add(p1); + a2.Add(p2); + Assert.AreEqual(0, DiffUtility.Compare(a1, a2)); + } + + DefaultMethod GetMethod(IClass c, string name) { + IMethod result = c.Methods.Find(delegate(IMethod m) { return m.Name == name; }); + Assert.IsNotNull(result, "Method " + name + " not found"); + return (DefaultMethod)result; + } + + [Test] + public void GenericDocumentationTagNamesTest() + { + DefaultClass c = (DefaultClass)pc.GetClass("System.Collections.Generic.List"); + Assert.AreEqual("T:System.Collections.Generic.List`1", + c.DocumentationTag); + Assert.AreEqual("M:System.Collections.Generic.List`1.Add(`0)", + GetMethod(c, "Add").DocumentationTag); + Assert.AreEqual("M:System.Collections.Generic.List`1.AddRange(System.Collections.Generic.IEnumerable{`0})", + GetMethod(c, "AddRange").DocumentationTag); + Assert.AreEqual("M:System.Collections.Generic.List`1.ConvertAll``1(System.Converter{`0,``0})", + GetMethod(c, "ConvertAll").DocumentationTag); + } + + [Test] + public void InnerClassReferenceTest() + { + IClass c = pc.GetClass("System.Environment"); + Assert.IsNotNull(c, "System.Environment not found"); + IReturnType rt = GetMethod(c, "GetFolderPath").Parameters[0].ReturnType; + Assert.IsNotNull(rt, "ReturnType is null"); + Assert.AreEqual("System.Environment.SpecialFolder", rt.FullyQualifiedName); + IClass inner = rt.GetUnderlyingClass(); + Assert.IsNotNull(inner, "UnderlyingClass"); + Assert.AreEqual("System.Environment.SpecialFolder", inner.FullyQualifiedName); + } + + [Test] + public void InnerClassesTest() + { + IClass c = pc.GetClass("System.Environment.SpecialFolder"); + Assert.IsNotNull(c, "c is null"); + Assert.AreEqual("System.Environment.SpecialFolder", c.FullyQualifiedName); + } + + [Test] + public void VoidTest() + { + IClass c = pc.GetClass("System.Void"); + Assert.IsNotNull(c, "System.Void not found"); + Assert.AreSame(c.DefaultReturnType, VoidReturnType.Instance, "VoidReturnType.Instance is c.DefaultReturnType"); + } + + class TestClass where A : B { + public void TestMethod(string param) where V: K where K: IComparable {} + + public void GetIndex(T element) where T: IEquatable {} + } + + [Test] + public void ReflectionParserTest() + { + ICompilationUnit cu = new ReflectionProjectContent("TestName", "testlocation", new AssemblyName[0], ParserService.DefaultProjectContentRegistry).AssemblyCompilationUnit; + IClass c = new ReflectionClass(cu, typeof(TestClass<,>), typeof(TestClass<,>).FullName, null); + cu.ProjectContent.AddClassToNamespaceList(c); + + CheckClass(c); + MemoryStream memory = new MemoryStream(); + DomPersistence.WriteProjectContent((ReflectionProjectContent)cu.ProjectContent, memory); + + memory.Position = 0; + foreach (IClass c2 in DomPersistence.LoadProjectContent(memory, ParserService.DefaultProjectContentRegistry).Classes) { + CheckClass(c2); + } + } + + void CheckClass(IClass c) + { + Assert.AreSame(c, c.TypeParameters[0].Class); + Assert.AreSame(c, c.TypeParameters[1].Class); + Assert.AreSame(c.TypeParameters[1], ((GenericReturnType)c.TypeParameters[0].Constraints[0]).TypeParameter); + + IMethod m = c.Methods.Find(delegate(IMethod me) { return me.Name == "TestMethod"; }); + Assert.IsNotNull(m); + Assert.AreEqual("K", m.TypeParameters[0].Name); + Assert.AreEqual("V", m.TypeParameters[1].Name); + Assert.AreSame(m, m.TypeParameters[0].Method); + Assert.AreSame(m, m.TypeParameters[1].Method); + + Assert.AreEqual("IComparable", m.TypeParameters[0].Constraints[0].Name); + GenericReturnType kConst = (GenericReturnType)m.TypeParameters[1].Constraints[0]; + Assert.AreSame(m.TypeParameters[0], kConst.TypeParameter); + + m = c.Methods.Find(delegate(IMethod me) { return me.Name == "GetIndex"; }); + Assert.IsNotNull(m); + Assert.AreEqual("T", m.TypeParameters[0].Name); + Assert.AreSame(m, m.TypeParameters[0].Method); + + Assert.AreEqual("IEquatable", m.TypeParameters[0].Constraints[0].Name); + Assert.AreEqual(1, m.TypeParameters[0].Constraints[0].TypeParameterCount); + Assert.AreEqual(1, m.TypeParameters[0].Constraints[0].CastToConstructedReturnType().TypeArguments.Count); + GenericReturnType grt = (GenericReturnType)m.TypeParameters[0].Constraints[0].CastToConstructedReturnType().TypeArguments[0]; + Assert.AreSame(m.TypeParameters[0], grt.TypeParameter); + } } } diff --git a/src/Main/Base/Test/SearchClassTests.cs b/src/Main/Base/Test/SearchClassTests.cs index 0ab89c3620..83eda73d92 100644 --- a/src/Main/Base/Test/SearchClassTests.cs +++ b/src/Main/Base/Test/SearchClassTests.cs @@ -15,128 +15,130 @@ namespace ICSharpCode.SharpDevelop.Tests [TestFixture] public class SearchClassTests { -// #region Helper methods -// ICompilationUnit Prepare(LanguageProperties language) -// { -// DefaultProjectContent pc = new DefaultProjectContent(); -// pc.ReferencedContents.Add(ProjectContentRegistry.Mscorlib); -// pc.Language = language; -// DefaultCompilationUnit cu = new DefaultCompilationUnit(pc); -// if (language == LanguageProperties.VBNet) -// cu.Usings.Add(CreateUsing(pc, "syStEm")); -// else -// cu.Usings.Add(CreateUsing(pc, "System")); -// return cu; -// } -// -// IUsing CreateUsing(IProjectContent pc, string @namespace) -// { -// DefaultUsing @using = new DefaultUsing(pc); -// @using.Usings.Add(@namespace); -// return @using; -// } -// -// IReturnType SearchType(string type) -// { -// ICompilationUnit cu = Prepare(LanguageProperties.CSharp); -// IReturnType c = cu.ProjectContent.SearchType(new SearchTypeRequest(type, 0, null, cu, 1, 1)).Result; -// Assert.IsNotNull(c, type + "not found"); -// return c; -// } -// -// IReturnType SearchTypeVB(string type) -// { -// ICompilationUnit cu = Prepare(LanguageProperties.VBNet); -// IReturnType c = cu.ProjectContent.SearchType(new SearchTypeRequest(type, 0, null, cu, 1, 1)).Result; -// Assert.IsNotNull(c, type + "not found"); -// return c; -// } -// -// void CheckNamespace(string @namespace, string className) -// { -// CheckNamespace(@namespace, className, LanguageProperties.CSharp); -// } -// -// void CheckNamespaceVB(string @namespace, string className) -// { -// CheckNamespace(@namespace, className, LanguageProperties.VBNet); -// } -// -// void CheckNamespace(string @namespace, string className, LanguageProperties language) -// { -// ICompilationUnit cu = Prepare(language); -// string ns = cu.ProjectContent.SearchNamespace(@namespace, null, cu, 1, 1); -// Assert.IsNotNull(ns, @namespace + " not found"); -// foreach (object o in cu.ProjectContent.GetNamespaceContents(ns)) { -// IClass c = o as IClass; -// if (c != null && c.Name == className) -// return; -// } -// } -// #endregion -// -// [Test] -// public void SearchFullyQualifiedClass() -// { -// Assert.AreEqual("System.Reflection.Assembly", SearchType("System.Reflection.Assembly").FullyQualifiedName); -// } -// -// [Test] -// public void SearchFullyQualifiedClassVB() -// { -// Assert.AreEqual("System.Reflection.Assembly", SearchTypeVB("SYStem.RefleCtion.asSembly").FullyQualifiedName); -// } -// -// [Test] -// public void SearchFullyQualifiedNamespace() -// { -// CheckNamespace("System.Collections.Generic", "KeyNotFoundException"); -// } -// -// [Test] -// public void SearchFullyQualifiedNamespaceVB() -// { -// CheckNamespaceVB("SyStem.COllEctions.GeNEric", "KeyNotFoundException"); -// } -// -// [Test] -// public void SearchEnvironment() -// { -// Assert.AreEqual("System.Environment", SearchType("Environment").FullyQualifiedName); -// } -// -// [Test] -// public void SearchEnvironmentVB() -// { -// Assert.AreEqual("System.Environment", SearchTypeVB("EnVIroNmEnt").FullyQualifiedName); -// } -// -// [Test] -// public void SearchArrayList() -// { -// ICompilationUnit cu = Prepare(LanguageProperties.CSharp); -// IReturnType c = cu.ProjectContent.SearchType(new SearchTypeRequest("Collections.ArrayList", 0, null, cu, 1, 1)).Result; -// Assert.IsNull(c, "Namespaces should not be imported in C#"); -// } -// -// [Test] -// public void SearchArrayListVB() -// { -// Assert.AreEqual("System.Collections.ArrayList", SearchTypeVB("CoLLections.ArrAyLiSt").FullyQualifiedName); -// } -// -// [Test] -// public void SearchNestedNamespace() -// { -// ICompilationUnit cu = Prepare(LanguageProperties.CSharp); -// string ns = cu.ProjectContent.SearchNamespace("Collections.Generic", null, cu, 1, 1); -// Assert.IsNull(ns, "Nested namespaces should not be found in C#"); -// } -// -// [Test] -// public void SearchNestedNamespaceVB() -// { -// CheckNamespaceVB("COllEctions.GeNEric", "KeyNotFoundException"); -// } + ProjectContentRegistry projectContentRegistry = ParserService.DefaultProjectContentRegistry; + + #region Helper methods + ICompilationUnit Prepare(LanguageProperties language) + { + DefaultProjectContent pc = new DefaultProjectContent(); + pc.ReferencedContents.Add(projectContentRegistry.Mscorlib); + pc.Language = language; + DefaultCompilationUnit cu = new DefaultCompilationUnit(pc); + if (language == LanguageProperties.VBNet) + cu.Usings.Add(CreateUsing(pc, "syStEm")); + else + cu.Usings.Add(CreateUsing(pc, "System")); + return cu; + } + + IUsing CreateUsing(IProjectContent pc, string @namespace) + { + DefaultUsing @using = new DefaultUsing(pc); + @using.Usings.Add(@namespace); + return @using; + } + + IReturnType SearchType(string type) + { + ICompilationUnit cu = Prepare(LanguageProperties.CSharp); + IReturnType c = cu.ProjectContent.SearchType(new SearchTypeRequest(type, 0, null, cu, 1, 1)).Result; + Assert.IsNotNull(c, type + "not found"); + return c; + } + + IReturnType SearchTypeVB(string type) + { + ICompilationUnit cu = Prepare(LanguageProperties.VBNet); + IReturnType c = cu.ProjectContent.SearchType(new SearchTypeRequest(type, 0, null, cu, 1, 1)).Result; + Assert.IsNotNull(c, type + "not found"); + return c; + } + + void CheckNamespace(string @namespace, string className) + { + CheckNamespace(@namespace, className, LanguageProperties.CSharp); + } + + void CheckNamespaceVB(string @namespace, string className) + { + CheckNamespace(@namespace, className, LanguageProperties.VBNet); + } + + void CheckNamespace(string @namespace, string className, LanguageProperties language) + { + ICompilationUnit cu = Prepare(language); + string ns = cu.ProjectContent.SearchNamespace(@namespace, null, cu, 1, 1); + Assert.IsNotNull(ns, @namespace + " not found"); + foreach (object o in cu.ProjectContent.GetNamespaceContents(ns)) { + IClass c = o as IClass; + if (c != null && c.Name == className) + return; + } + } + #endregion + + [Test] + public void SearchFullyQualifiedClass() + { + Assert.AreEqual("System.Reflection.Assembly", SearchType("System.Reflection.Assembly").FullyQualifiedName); + } + + [Test] + public void SearchFullyQualifiedClassVB() + { + Assert.AreEqual("System.Reflection.Assembly", SearchTypeVB("SYStem.RefleCtion.asSembly").FullyQualifiedName); + } + + [Test] + public void SearchFullyQualifiedNamespace() + { + CheckNamespace("System.Collections.Generic", "KeyNotFoundException"); + } + + [Test] + public void SearchFullyQualifiedNamespaceVB() + { + CheckNamespaceVB("SyStem.COllEctions.GeNEric", "KeyNotFoundException"); + } + + [Test] + public void SearchEnvironment() + { + Assert.AreEqual("System.Environment", SearchType("Environment").FullyQualifiedName); + } + + [Test] + public void SearchEnvironmentVB() + { + Assert.AreEqual("System.Environment", SearchTypeVB("EnVIroNmEnt").FullyQualifiedName); + } + + [Test] + public void SearchArrayList() + { + ICompilationUnit cu = Prepare(LanguageProperties.CSharp); + IReturnType c = cu.ProjectContent.SearchType(new SearchTypeRequest("Collections.ArrayList", 0, null, cu, 1, 1)).Result; + Assert.IsNull(c, "Namespaces should not be imported in C#"); + } + + [Test] + public void SearchArrayListVB() + { + Assert.AreEqual("System.Collections.ArrayList", SearchTypeVB("CoLLections.ArrAyLiSt").FullyQualifiedName); + } + + [Test] + public void SearchNestedNamespace() + { + ICompilationUnit cu = Prepare(LanguageProperties.CSharp); + string ns = cu.ProjectContent.SearchNamespace("Collections.Generic", null, cu, 1, 1); + Assert.IsNull(ns, "Nested namespaces should not be found in C#"); + } + + [Test] + public void SearchNestedNamespaceVB() + { + CheckNamespaceVB("COllEctions.GeNEric", "KeyNotFoundException"); + } } } diff --git a/src/Main/Base/Test/SearchGenericClassTests.cs b/src/Main/Base/Test/SearchGenericClassTests.cs index db3e631c0a..5c6b4d8ac4 100644 --- a/src/Main/Base/Test/SearchGenericClassTests.cs +++ b/src/Main/Base/Test/SearchGenericClassTests.cs @@ -16,84 +16,86 @@ namespace ICSharpCode.SharpDevelop.Tests [TestFixture] public class SearchGenericClassTests { -// #region Helper methods -// ICompilationUnit Prepare(LanguageProperties language) -// { -// DefaultProjectContent pc = new DefaultProjectContent(); -// pc.ReferencedContents.Add(ProjectContentRegistry.Mscorlib); -// pc.Language = language; -// DefaultCompilationUnit cu = new DefaultCompilationUnit(pc); -// if (language == LanguageProperties.VBNet) { -// cu.Usings.Add(CreateUsing(pc, "syStEm.coLLectIons")); -// pc.DefaultImports = new DefaultUsing(pc); -// pc.DefaultImports.Usings.Add("syStEm"); -// pc.DefaultImports.Usings.Add("syStEm.coLLEctionS.GeNeRic"); -// } else { -// cu.Usings.Add(CreateUsing(pc, "System")); -// cu.Usings.Add(CreateUsing(pc, "System.Collections")); -// cu.Usings.Add(CreateUsing(pc, "System.Collections.Generic")); -// } -// return cu; -// } -// -// IUsing CreateUsing(IProjectContent pc, string @namespace) -// { -// DefaultUsing @using = new DefaultUsing(pc); -// @using.Usings.Add(@namespace); -// return @using; -// } -// -// IReturnType SearchType(string type, int typeParameterCount) -// { -// ICompilationUnit cu = Prepare(LanguageProperties.CSharp); -// IReturnType c = cu.ProjectContent.SearchType(new SearchTypeRequest(type, typeParameterCount, null, cu, 1, 1)).Result; -// Assert.IsNotNull(c, type + "not found"); -// return c; -// } -// -// IReturnType SearchTypeVB(string type, int typeParameterCount) -// { -// ICompilationUnit cu = Prepare(LanguageProperties.VBNet); -// IReturnType c = cu.ProjectContent.SearchType(new SearchTypeRequest(type, typeParameterCount, null, cu, 1, 1)).Result; -// Assert.IsNotNull(c, type + "not found"); -// return c; -// } -// -// void CheckType(string shortName, string vbShortName, string fullType, int typeParameterCount) -// { -// IReturnType type = SearchType(shortName, typeParameterCount); -// Assert.AreEqual(fullType, type.FullyQualifiedName); -// Assert.AreEqual(typeParameterCount, type.TypeParameterCount); -// type = SearchTypeVB(vbShortName, typeParameterCount); -// Assert.AreEqual(fullType, type.FullyQualifiedName); -// Assert.AreEqual(typeParameterCount, type.TypeParameterCount); -// } -// #endregion -// -// // EventHandler vs. EventHandler -// // both mscorlib, both namespace System -// [Test] public void FindEventHandler() { -// CheckType("EventHandler", "EvEnThAndler", "System.EventHandler", 0); -// } -// [Test] public void FindGenericEventHandler() { -// CheckType("EventHandler", "EvEnThAndler", "System.EventHandler", 1); -// } -// -// -// [Test] public void FindNullableClass() { -// CheckType("Nullable", "NuLLable", "System.Nullable", 0); -// } -// [Test] public void FindNullableStruct() { -// CheckType("Nullable", "NuLLable", "System.Nullable", 1); -// } -// -// // ICollection vs. ICollection -// // both mscorlib, different namespaces -// [Test] public void FindCollection() { -// CheckType("ICollection", "IColLEction", "System.Collections.ICollection", 0); -// } -// [Test] public void FindGenericCollection() { -// CheckType("ICollection", "IColLEction", "System.Collections.Generic.ICollection", 1); -// } + ProjectContentRegistry projectContentRegistry = ParserService.DefaultProjectContentRegistry; + + #region Helper methods + ICompilationUnit Prepare(LanguageProperties language) + { + DefaultProjectContent pc = new DefaultProjectContent(); + pc.ReferencedContents.Add(projectContentRegistry.Mscorlib); + pc.Language = language; + DefaultCompilationUnit cu = new DefaultCompilationUnit(pc); + if (language == LanguageProperties.VBNet) { + cu.Usings.Add(CreateUsing(pc, "syStEm.coLLectIons")); + pc.DefaultImports = new DefaultUsing(pc); + pc.DefaultImports.Usings.Add("syStEm"); + pc.DefaultImports.Usings.Add("syStEm.coLLEctionS.GeNeRic"); + } else { + cu.Usings.Add(CreateUsing(pc, "System")); + cu.Usings.Add(CreateUsing(pc, "System.Collections")); + cu.Usings.Add(CreateUsing(pc, "System.Collections.Generic")); + } + return cu; + } + + IUsing CreateUsing(IProjectContent pc, string @namespace) + { + DefaultUsing @using = new DefaultUsing(pc); + @using.Usings.Add(@namespace); + return @using; + } + + IReturnType SearchType(string type, int typeParameterCount) + { + ICompilationUnit cu = Prepare(LanguageProperties.CSharp); + IReturnType c = cu.ProjectContent.SearchType(new SearchTypeRequest(type, typeParameterCount, null, cu, 1, 1)).Result; + Assert.IsNotNull(c, type + "not found"); + return c; + } + + IReturnType SearchTypeVB(string type, int typeParameterCount) + { + ICompilationUnit cu = Prepare(LanguageProperties.VBNet); + IReturnType c = cu.ProjectContent.SearchType(new SearchTypeRequest(type, typeParameterCount, null, cu, 1, 1)).Result; + Assert.IsNotNull(c, type + "not found"); + return c; + } + + void CheckType(string shortName, string vbShortName, string fullType, int typeParameterCount) + { + IReturnType type = SearchType(shortName, typeParameterCount); + Assert.AreEqual(fullType, type.FullyQualifiedName); + Assert.AreEqual(typeParameterCount, type.TypeParameterCount); + type = SearchTypeVB(vbShortName, typeParameterCount); + Assert.AreEqual(fullType, type.FullyQualifiedName); + Assert.AreEqual(typeParameterCount, type.TypeParameterCount); + } + #endregion + + // EventHandler vs. EventHandler + // both mscorlib, both namespace System + [Test] public void FindEventHandler() { + CheckType("EventHandler", "EvEnThAndler", "System.EventHandler", 0); + } + [Test] public void FindGenericEventHandler() { + CheckType("EventHandler", "EvEnThAndler", "System.EventHandler", 1); + } + + + [Test] public void FindNullableClass() { + CheckType("Nullable", "NuLLable", "System.Nullable", 0); + } + [Test] public void FindNullableStruct() { + CheckType("Nullable", "NuLLable", "System.Nullable", 1); + } + + // ICollection vs. ICollection + // both mscorlib, different namespaces + [Test] public void FindCollection() { + CheckType("ICollection", "IColLEction", "System.Collections.ICollection", 0); + } + [Test] public void FindGenericCollection() { + CheckType("ICollection", "IColLEction", "System.Collections.Generic.ICollection", 1); + } } } diff --git a/src/Main/Base/Test/Services_Navigation/NavigationServiceTestFixture.cs b/src/Main/Base/Test/Services_Navigation/NavigationServiceTestFixture.cs index 6b5ef094c9..7c46192130 100644 --- a/src/Main/Base/Test/Services_Navigation/NavigationServiceTestFixture.cs +++ b/src/Main/Base/Test/Services_Navigation/NavigationServiceTestFixture.cs @@ -477,7 +477,6 @@ namespace NavigationServiceTests } [Test] - [Ignore("System.NullReferenceException: Object reference not set to an instance of an object.")] /// /// The must /// expose a method to generate an diff --git a/src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/ReflectionLayer/DomPersistence.cs b/src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/ReflectionLayer/DomPersistence.cs index 1eb520b4f6..59722abeeb 100644 --- a/src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/ReflectionLayer/DomPersistence.cs +++ b/src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/ReflectionLayer/DomPersistence.cs @@ -171,7 +171,7 @@ namespace ICSharpCode.SharpDevelop.Dom return LoadProjectContent(stream, registry); } - internal static ReflectionProjectContent LoadProjectContent(Stream stream, ProjectContentRegistry registry) + public static ReflectionProjectContent LoadProjectContent(Stream stream, ProjectContentRegistry registry) { ReflectionProjectContent pc; BinaryReader reader = new BinaryReader(stream);