pimhwang
/
SharpDevelop
mirror of https://github.com/icsharpcode/SharpDevelop.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Re-enable resolver unit tests. 

git-svn-id: svn://svn.sharpdevelop.net/sharpdevelop/trunk@1872 1ccf3a8d-04fe-1044-b7c0-cef0b8235c61
shortcuts
Daniel Grunwald 20 years ago
parent
d637ec546e
commit
ca3838f9b3
12 changed files with 2112 additions and 2099 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 859
      src/AddIns/BackendBindings/Boo/BooBinding/Test/ResolverTests.cs
  2. 4
      src/AddIns/BackendBindings/CSharpBinding/Test/ExpressionFinder.cs
  3. 2
      src/Libraries/NRefactory/Test/Output/VBNet/CSharpToVBConverterTest.cs
  4. 474
      src/Main/Base/Test/GenericResolverTests.cs
  5. 208
      src/Main/Base/Test/InnerClassesResolverTests.cs
  6. 1848
      src/Main/Base/Test/NRefactoryResolverTests.cs
  7. 124
      src/Main/Base/Test/OverloadFinding.cs
  8. 281
      src/Main/Base/Test/ReflectionLayerTests.cs
  9. 248
      src/Main/Base/Test/SearchClassTests.cs
  10. 160
      src/Main/Base/Test/SearchGenericClassTests.cs
  11. 1
      src/Main/Base/Test/Services_Navigation/NavigationServiceTestFixture.cs
  12. 2
      src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/ReflectionLayer/DomPersistence.cs

859
src/AddIns/BackendBindings/Boo/BooBinding/Test/ResolverTests.cs
Unescape View File

@ -10,6 +10,7 @@ using System.Collections;
using System.Reflection; using System.Reflection;
using NUnit.Framework; using NUnit.Framework;
using ICSharpCode.Core; using ICSharpCode.Core;
using ICSharpCode.SharpDevelop;
using ICSharpCode.SharpDevelop.Dom; using ICSharpCode.SharpDevelop.Dom;
using ICSharpCode.SharpDevelop.Project; using ICSharpCode.SharpDevelop.Project;
using Grunwald.BooBinding.CodeCompletion; using Grunwald.BooBinding.CodeCompletion;
@ -19,434 +20,434 @@ namespace Grunwald.BooBinding.Tests
[TestFixture] [TestFixture]
public class ResolverTests public class ResolverTests
{ {
// #region Helper #region Helper
// T Resolve<T>(string code) where T : ResolveResult T Resolve<T>(string code) where T : ResolveResult
// { {
// return Resolve<T>(code, "/*1*/"); return Resolve<T>(code, "/*1*/");
// } }
//
// T Resolve<T>(string code, string marker) where T : ResolveResult T Resolve<T>(string code, string marker) where T : ResolveResult
// { {
// return Resolve<T>(normalProg, code, marker); return Resolve<T>(normalProg, code, marker);
// } }
//
// T Resolve<T>(string prog, string code, string marker) where T : ResolveResult T Resolve<T>(string prog, string code, string marker) where T : ResolveResult
// { {
// ResolveResult rr = Resolve(prog, new ExpressionResult(code), marker); ResolveResult rr = Resolve(prog, new ExpressionResult(code), marker);
// Assert.IsNotNull(rr, "Resolve must not return null"); Assert.IsNotNull(rr, "Resolve must not return null");
// Assert.IsInstanceOfType(typeof(T), rr, "Resolve must return instance of type " + typeof(T).Name); Assert.IsInstanceOfType(typeof(T), rr, "Resolve must return instance of type " + typeof(T).Name);
// return (T)rr; return (T)rr;
// } }
//
// IProjectContent booLangPC; IProjectContent booLangPC;
//
// public ResolverTests() { public ResolverTests() {
// booLangPC = new ReflectionProjectContent(Assembly.Load("Boo.Lang"), "Boo.Lang.dll"); booLangPC = new ReflectionProjectContent(Assembly.Load("Boo.Lang"), "Boo.Lang.dll", ParserService.DefaultProjectContentRegistry);
// booLangPC.ReferencedContents.Add(ProjectContentRegistry.Mscorlib); booLangPC.ReferencedContents.Add(ParserService.DefaultProjectContentRegistry.Mscorlib);
// } }
//
// const string fileName = "tempFile.boo"; const string fileName = "tempFile.boo";
// DefaultProjectContent lastPC; DefaultProjectContent lastPC;
//
// void Register(string prog) void Register(string prog)
// { {
// DefaultProjectContent pc = new DefaultProjectContent(); DefaultProjectContent pc = new DefaultProjectContent();
// lastPC = pc; lastPC = pc;
// HostCallback.GetCurrentProjectContent = delegate { return pc; }; HostCallback.GetCurrentProjectContent = delegate { return pc; };
// pc.ReferencedContents.Add(ProjectContentRegistry.Mscorlib); pc.ReferencedContents.Add(ParserService.DefaultProjectContentRegistry.Mscorlib);
// pc.ReferencedContents.Add(ProjectContentRegistry.GetProjectContentForReference("System.Windows.Forms", "System.Windows.Forms")); pc.ReferencedContents.Add(ParserService.DefaultProjectContentRegistry.GetProjectContentForReference("System.Windows.Forms", "System.Windows.Forms"));
// pc.ReferencedContents.Add(booLangPC); pc.ReferencedContents.Add(booLangPC);
// ICompilationUnit cu = new BooParser().Parse(pc, fileName, prog); ICompilationUnit cu = new BooParser().Parse(pc, fileName, prog);
// ParserService.UpdateParseInformation(cu, fileName, false, false); ParserService.UpdateParseInformation(cu, fileName, false, false);
// cu.Classes.ForEach(pc.AddClassToNamespaceList); cu.Classes.ForEach(pc.AddClassToNamespaceList);
// } }
//
// void GetPos(string prog, string marker, out int line, out int column) void GetPos(string prog, string marker, out int line, out int column)
// { {
// int index = prog.IndexOf(marker); int index = prog.IndexOf(marker);
// line = 1; line = 1;
// column = 0; column = 0;
// for (int i = 0; i < index; i++) { for (int i = 0; i < index; i++) {
// column++; column++;
// if (prog[i]=='\n') { if (prog[i]=='\n') {
// line++; line++;
// column = 0; column = 0;
// } }
// } }
// } }
//
// ResolveResult Resolve(string prog, ExpressionResult er, string marker) ResolveResult Resolve(string prog, ExpressionResult er, string marker)
// { {
// Register(prog); Register(prog);
// int line, column; int line, column;
// GetPos(prog, marker, out line, out column); GetPos(prog, marker, out line, out column);
//
// BooResolver r = new BooResolver(); BooResolver r = new BooResolver();
// return r.Resolve(er, line, column, fileName, prog); return r.Resolve(er, line, column, fileName, prog);
// } }
// #endregion #endregion
//
// #region Basic tests #region Basic tests
// const string normalProg = const string normalProg =
// "import System\n" + "import System\n" +
// "def MyMethod(arg as string):\n" + "def MyMethod(arg as string):\n" +
// "\tlocalVar = arg\n" + "\tlocalVar = arg\n" +
// "\t/*1*/\n" + "\t/*1*/\n" +
// "\tclosure = { e as string | arg.IndexOf(e) /*inClosure*/ }\n" + "\tclosure = { e as string | arg.IndexOf(e) /*inClosure*/ }\n" +
// "\tindex = closure('.')\n" + "\tindex = closure('.')\n" +
// "\t/*2*/\n" + "\t/*2*/\n" +
// "\tclosure2 = def(e as DateTime):\n" + "\tclosure2 = def(e as DateTime):\n" +
// "\t\treturn e.Year\n" + "\t\treturn e.Year\n" +
// "\trecursiveClosure = def(myObject):/*inRecursiveClosure*/\n" + "\trecursiveClosure = def(myObject):/*inRecursiveClosure*/\n" +
// "\t\treturn recursiveClosure(myObject)\n" + "\t\treturn recursiveClosure(myObject)\n" +
// "\t/*3*/\n"; "\t/*3*/\n";
//
// [Test] [Test]
// public void MethodParameter() public void MethodParameter()
// { {
// LocalResolveResult rr = Resolve<LocalResolveResult>("arg"); LocalResolveResult rr = Resolve<LocalResolveResult>("arg");
// Assert.IsTrue(rr.IsParameter); Assert.IsTrue(rr.IsParameter);
// Assert.AreEqual("System.String", rr.ResolvedType.FullyQualifiedName); Assert.AreEqual("System.String", rr.ResolvedType.FullyQualifiedName);
// } }
//
// [Test] [Test]
// public void LocalVariable() public void LocalVariable()
// { {
// LocalResolveResult rr = Resolve<LocalResolveResult>("localVar"); LocalResolveResult rr = Resolve<LocalResolveResult>("localVar");
// Assert.IsFalse(rr.IsParameter); Assert.IsFalse(rr.IsParameter);
// Assert.AreEqual("System.String", rr.ResolvedType.FullyQualifiedName); Assert.AreEqual("System.String", rr.ResolvedType.FullyQualifiedName);
// } }
//
// [Test] [Test]
// public void NullCoalescing() public void NullCoalescing()
// { {
// ResolveResult rr = Resolve<ResolveResult>("localVar or arg"); ResolveResult rr = Resolve<ResolveResult>("localVar or arg");
// Assert.AreEqual("System.String", rr.ResolvedType.FullyQualifiedName); Assert.AreEqual("System.String", rr.ResolvedType.FullyQualifiedName);
// } }
//
// [Test] [Test]
// public void InnerClassEnum() public void InnerClassEnum()
// { {
// TypeResolveResult trr = Resolve<TypeResolveResult>("Environment.SpecialFolder"); TypeResolveResult trr = Resolve<TypeResolveResult>("Environment.SpecialFolder");
// Assert.AreEqual("System.Environment.SpecialFolder", trr.ResolvedClass.FullyQualifiedName); Assert.AreEqual("System.Environment.SpecialFolder", trr.ResolvedClass.FullyQualifiedName);
//
// MemberResolveResult mrr = Resolve<MemberResolveResult>("Environment.SpecialFolder.Desktop"); MemberResolveResult mrr = Resolve<MemberResolveResult>("Environment.SpecialFolder.Desktop");
// Assert.AreEqual("System.Environment.SpecialFolder.Desktop", mrr.ResolvedMember.FullyQualifiedName); Assert.AreEqual("System.Environment.SpecialFolder.Desktop", mrr.ResolvedMember.FullyQualifiedName);
// } }
//
// [Test] [Test]
// public void ClosureParameter() public void ClosureParameter()
// { {
// LocalResolveResult rr = Resolve<LocalResolveResult>("e", "/*inClosure*/"); LocalResolveResult rr = Resolve<LocalResolveResult>("e", "/*inClosure*/");
// Assert.AreEqual("System.String", rr.ResolvedType.FullyQualifiedName); Assert.AreEqual("System.String", rr.ResolvedType.FullyQualifiedName);
//
// Assert.IsNull(Resolve(normalProg, new ExpressionResult("e"), "/*1*/")); Assert.IsNull(Resolve(normalProg, new ExpressionResult("e"), "/*1*/"));
// } }
//
// [Test] [Test]
// public void ClosureCall() public void ClosureCall()
// { {
// LocalResolveResult rr = Resolve<LocalResolveResult>("closure('.')", "/*2*/"); LocalResolveResult rr = Resolve<LocalResolveResult>("closure('.')", "/*2*/");
// Assert.IsFalse(rr.IsParameter); Assert.IsFalse(rr.IsParameter);
// Assert.AreEqual("closure", rr.Field.Name); Assert.AreEqual("closure", rr.Field.Name);
// Assert.AreEqual("System.Int32", rr.ResolvedType.FullyQualifiedName); Assert.AreEqual("System.Int32", rr.ResolvedType.FullyQualifiedName);
// } }
//
// [Test] [Test]
// public void ClosureCall2() public void ClosureCall2()
// { {
// LocalResolveResult rr = Resolve<LocalResolveResult>("closure2(DateTime.Now)", "/*3*/"); LocalResolveResult rr = Resolve<LocalResolveResult>("closure2(DateTime.Now)", "/*3*/");
// Assert.IsFalse(rr.IsParameter); Assert.IsFalse(rr.IsParameter);
// Assert.AreEqual("closure2", rr.Field.Name); Assert.AreEqual("closure2", rr.Field.Name);
// Assert.AreEqual("System.Int32", rr.ResolvedType.FullyQualifiedName); Assert.AreEqual("System.Int32", rr.ResolvedType.FullyQualifiedName);
// } }
//
// [Test] [Test]
// public void RecursiveClosure() public void RecursiveClosure()
// { {
// // Code-completion cannot work here, test if SharpDevelop is correctly // Code-completion cannot work here, test if SharpDevelop is correctly
// // preventing the StackOverflow. // preventing the StackOverflow.
// LocalResolveResult rr = Resolve<LocalResolveResult>("recursiveClosure", "/*3*/"); LocalResolveResult rr = Resolve<LocalResolveResult>("recursiveClosure", "/*3*/");
// Assert.IsFalse(rr.IsParameter); Assert.IsFalse(rr.IsParameter);
// Assert.AreEqual("delegate(myObject:Object):?", rr.ResolvedType.FullyQualifiedName); Assert.AreEqual("delegate(myObject:Object):?", rr.ResolvedType.FullyQualifiedName);
// } }
//
// [Test] [Test]
// public void ClosureTypelessArgument() public void ClosureTypelessArgument()
// { {
// LocalResolveResult rr = Resolve<LocalResolveResult>("myObject", "/*inRecursiveClosure*/"); LocalResolveResult rr = Resolve<LocalResolveResult>("myObject", "/*inRecursiveClosure*/");
// Assert.AreEqual("System.Object", rr.ResolvedType.FullyQualifiedName); Assert.AreEqual("System.Object", rr.ResolvedType.FullyQualifiedName);
// } }
//
// [Test] [Test]
// public void EqualityOperator() public void EqualityOperator()
// { {
// ResolveResult rr = Resolve<ResolveResult>("0 == 0"); ResolveResult rr = Resolve<ResolveResult>("0 == 0");
// Assert.AreEqual("System.Boolean", rr.ResolvedType.FullyQualifiedName); Assert.AreEqual("System.Boolean", rr.ResolvedType.FullyQualifiedName);
// rr = Resolve<ResolveResult>("0 != 1"); rr = Resolve<ResolveResult>("0 != 1");
// Assert.AreEqual("System.Boolean", rr.ResolvedType.FullyQualifiedName); Assert.AreEqual("System.Boolean", rr.ResolvedType.FullyQualifiedName);
// rr = Resolve<ResolveResult>("null is null"); rr = Resolve<ResolveResult>("null is null");
// Assert.AreEqual("System.Boolean", rr.ResolvedType.FullyQualifiedName); Assert.AreEqual("System.Boolean", rr.ResolvedType.FullyQualifiedName);
// rr = Resolve<ResolveResult>("object() is not null"); rr = Resolve<ResolveResult>("object() is not null");
// Assert.AreEqual("System.Boolean", rr.ResolvedType.FullyQualifiedName); Assert.AreEqual("System.Boolean", rr.ResolvedType.FullyQualifiedName);
// } }
//
// [Test] [Test]
// public void ClassMethodAmbiguity() public void ClassMethodAmbiguity()
// { {
// string prog = string prog =
// "class Test:\n" + "class Test:\n" +
// "\tdef constructor():\n" + "\tdef constructor():\n" +
// "\t\tpass\n" + "\t\tpass\n" +
// "class OtherClass:\n" + "class OtherClass:\n" +
// "\tdef Test():\n" + "\tdef Test():\n" +
// "\t\t/*mark*/\n" + "\t\t/*mark*/\n" +
// "\t\tpass\n"; "\t\tpass\n";
// MemberResolveResult rr = Resolve<MemberResolveResult>(prog, "Test()", "/*mark*/"); MemberResolveResult rr = Resolve<MemberResolveResult>(prog, "Test()", "/*mark*/");
// Assert.AreEqual("OtherClass.Test", rr.ResolvedMember.FullyQualifiedName); Assert.AreEqual("OtherClass.Test", rr.ResolvedMember.FullyQualifiedName);
// } }
// #endregion #endregion
//
// #region Regression #region Regression
// const string regressionProg = const string regressionProg =
// "import System\n" + "import System\n" +
// "import System.Reflection\n" + "import System.Reflection\n" +
// "def MyMethod(arg as string):\n" + "def MyMethod(arg as string):\n" +
// "\tif true:\n" + "\tif true:\n" +
// "\t\tboo629 = 'hello'\n" + "\t\tboo629 = 'hello'\n" +
// "\tfor boo640a in [1, 2, 3]:\n" + "\tfor boo640a in [1, 2, 3]:\n" +
// "\t\tif boo640b = boo640a as FieldInfo: /*640*/\n" + "\t\tif boo640b = boo640a as FieldInfo: /*640*/\n" +
// "\t\t\tprint boo640b\n" + "\t\t\tprint boo640b\n" +
// "\t\n" + "\t\n" +
// "\tprint 'end of method'\n" + "\tprint 'end of method'\n" +
// "\t/*1*/\n"; "\t/*1*/\n";
//
// [Test] [Test]
// public void MyMethodCompletion() public void MyMethodCompletion()
// { {
// MethodResolveResult rr = Resolve<MethodResolveResult>(regressionProg, "MyMethod", "/*1*/"); MethodResolveResult rr = Resolve<MethodResolveResult>(regressionProg, "MyMethod", "/*1*/");
// ArrayList arr = rr.GetCompletionData(lastPC); ArrayList arr = rr.GetCompletionData(lastPC);
// Assert.IsNotNull(arr); Assert.IsNotNull(arr);
// bool beginInvoke = false; bool beginInvoke = false;
// bool invoke = false; bool invoke = false;
// foreach (IMember m in arr) { foreach (IMember m in arr) {
// if (m.Name == "BeginInvoke") beginInvoke = true; if (m.Name == "BeginInvoke") beginInvoke = true;
// if (m.Name == "Invoke") invoke = true; if (m.Name == "Invoke") invoke = true;
// } }
// Assert.IsTrue(beginInvoke, "beginInvoke"); Assert.IsTrue(beginInvoke, "beginInvoke");
// Assert.IsTrue(invoke, "invoke"); Assert.IsTrue(invoke, "invoke");
// } }
//
// [Test] [Test]
// public void Boo629VariableScope() public void Boo629VariableScope()
// { {
// LocalResolveResult rr = Resolve<LocalResolveResult>(regressionProg, "boo629", "/*1*/"); LocalResolveResult rr = Resolve<LocalResolveResult>(regressionProg, "boo629", "/*1*/");
// Assert.AreEqual("System.String", rr.ResolvedType.FullyQualifiedName); Assert.AreEqual("System.String", rr.ResolvedType.FullyQualifiedName);
// } }
//
// [Test] [Test]
// public void Boo640ConditionalAssignment() public void Boo640ConditionalAssignment()
// { {
// LocalResolveResult rr = Resolve<LocalResolveResult>(regressionProg, "boo640b", "/*1*/"); LocalResolveResult rr = Resolve<LocalResolveResult>(regressionProg, "boo640b", "/*1*/");
// Assert.AreEqual("System.Reflection.FieldInfo", rr.ResolvedType.FullyQualifiedName); Assert.AreEqual("System.Reflection.FieldInfo", rr.ResolvedType.FullyQualifiedName);
// rr = Resolve<LocalResolveResult>(regressionProg, "boo640a", "/*640*/"); rr = Resolve<LocalResolveResult>(regressionProg, "boo640a", "/*640*/");
// Assert.AreEqual("System.Object", rr.ResolvedType.FullyQualifiedName); Assert.AreEqual("System.Object", rr.ResolvedType.FullyQualifiedName);
// Assert.IsNull(Resolve(regressionProg, new ExpressionResult("boo640a"), "/*1*/")); Assert.IsNull(Resolve(regressionProg, new ExpressionResult("boo640a"), "/*1*/"));
// } }
//
// [Test] [Test]
// public void IndexerRecognition() public void IndexerRecognition()
// { {
// string prog = string prog =
// "class Foo:\n" + "class Foo:\n" +
// "\tself[index as int]:\n" + "\tself[index as int]:\n" +
// "\t\tget:\n" + "\t\tget:\n" +
// "\t\t\treturn true\n" + "\t\t\treturn true\n" +
// "def example():\n" + "def example():\n" +
// "\tfoo = Foo()\n" + "\tfoo = Foo()\n" +
// "\tmybool = foo[1] /*mark*/\n" + "\tmybool = foo[1] /*mark*/\n" +
// "\tprint mybool\n"; "\tprint mybool\n";
// MemberResolveResult rr = Resolve<MemberResolveResult>(prog, "foo[1]", "/*mark*/"); MemberResolveResult rr = Resolve<MemberResolveResult>(prog, "foo[1]", "/*mark*/");
// Assert.IsTrue(((IProperty)rr.ResolvedMember).IsIndexer); Assert.IsTrue(((IProperty)rr.ResolvedMember).IsIndexer);
// Assert.AreEqual("System.Boolean", rr.ResolvedType.FullyQualifiedName); Assert.AreEqual("System.Boolean", rr.ResolvedType.FullyQualifiedName);
// LocalResolveResult rr2 = Resolve<LocalResolveResult>(prog, "mybool", "/*mark*/"); LocalResolveResult rr2 = Resolve<LocalResolveResult>(prog, "mybool", "/*mark*/");
// Assert.AreEqual("System.Boolean", rr2.ResolvedType.FullyQualifiedName); Assert.AreEqual("System.Boolean", rr2.ResolvedType.FullyQualifiedName);
// } }
//
// [Test] [Test]
// public void InfiniteRecursionGenerator() public void InfiniteRecursionGenerator()
// { {
// string prog = string prog =
// "class Test:\n" + "class Test:\n" +
// "\t_testList = []\n" + "\t_testList = []\n" +
// "\tTestProperty:\n" + "\tTestProperty:\n" +
// "\t\tget:\n" + "\t\tget:\n" +
// "\t\t\tfor testobj as Test in _testList:\n" + "\t\t\tfor testobj as Test in _testList:\n" +
// "\t\t\t\tyield testobj.TestProperty /*mark*/\n"; "\t\t\t\tyield testobj.TestProperty /*mark*/\n";
// MemberResolveResult rr = Resolve<MemberResolveResult>(prog, "testobj.TestProperty", "/*mark*/"); MemberResolveResult rr = Resolve<MemberResolveResult>(prog, "testobj.TestProperty", "/*mark*/");
// Assert.AreEqual("Test.TestProperty", rr.ResolvedMember.FullyQualifiedName); Assert.AreEqual("Test.TestProperty", rr.ResolvedMember.FullyQualifiedName);
// Assert.AreEqual("System.Collections.Generic.IEnumerable", rr.ResolvedType.FullyQualifiedName); Assert.AreEqual("System.Collections.Generic.IEnumerable", rr.ResolvedType.FullyQualifiedName);
// // prevent creating self-referring ConstructedReturnType // prevent creating self-referring ConstructedReturnType
// Assert.AreEqual("?", rr.ResolvedType.CastToConstructedReturnType().TypeArguments[0].FullyQualifiedName); Assert.AreEqual("?", rr.ResolvedType.CastToConstructedReturnType().TypeArguments[0].FullyQualifiedName);
// } }
// #endregion #endregion
//
// #region Nested Classes #region Nested Classes
// const string nestedClassProg = const string nestedClassProg =
// "class Outer:\n" + "class Outer:\n" +
// "\tpublic static outerField = 1\n" + "\tpublic static outerField = 1\n" +
// "\tpublic class Inner:\n/*inner*/" + "\tpublic class Inner:\n/*inner*/" +
// "\t\tpublic innerField = 2\n" + "\t\tpublic innerField = 2\n" +
// "class Derived(Outer):\n/*derived*/" + "class Derived(Outer):\n/*derived*/" +
// "\tpublic static derivedField = 3\n" + "\tpublic static derivedField = 3\n" +
// "def Method():\n" + "def Method():\n" +
// "\ti as Outer.Inner\n" + "\ti as Outer.Inner\n" +
// "\ti2 as Derived.Inner\n" + "\ti2 as Derived.Inner\n" +
// "\t/*1*/"; "\t/*1*/";
//
// [Test] [Test]
// public void NestedClassTypeResolution() public void NestedClassTypeResolution()
// { {
// TypeResolveResult trr; TypeResolveResult trr;
// trr = Resolve<TypeResolveResult>(nestedClassProg, "Outer.Inner", "/*1*/"); trr = Resolve<TypeResolveResult>(nestedClassProg, "Outer.Inner", "/*1*/");
// Assert.AreEqual("Outer.Inner", trr.ResolvedClass.FullyQualifiedName); Assert.AreEqual("Outer.Inner", trr.ResolvedClass.FullyQualifiedName);
// trr = Resolve<TypeResolveResult>(nestedClassProg, "Inner", "/*inner*/"); trr = Resolve<TypeResolveResult>(nestedClassProg, "Inner", "/*inner*/");
// Assert.AreEqual("Outer.Inner", trr.ResolvedClass.FullyQualifiedName); Assert.AreEqual("Outer.Inner", trr.ResolvedClass.FullyQualifiedName);
// trr = Resolve<TypeResolveResult>(nestedClassProg, "Inner", "/*derived*/"); trr = Resolve<TypeResolveResult>(nestedClassProg, "Inner", "/*derived*/");
// Assert.AreEqual("Outer.Inner", trr.ResolvedClass.FullyQualifiedName); Assert.AreEqual("Outer.Inner", trr.ResolvedClass.FullyQualifiedName);
// trr = Resolve<TypeResolveResult>(nestedClassProg, "Derived.Inner", "/*1*/"); trr = Resolve<TypeResolveResult>(nestedClassProg, "Derived.Inner", "/*1*/");
// Assert.AreEqual("Outer.Inner", trr.ResolvedClass.FullyQualifiedName); Assert.AreEqual("Outer.Inner", trr.ResolvedClass.FullyQualifiedName);
// } }
//
// [Test] [Test]
// public void NestedClassCtrlSpace() public void NestedClassCtrlSpace()
// { {
// CtrlSpace(nestedClassProg.Replace("/*inner*/", "/*mark*/"), "outerField", "innerField", "Inner", "Outer", "Derived"); CtrlSpace(nestedClassProg.Replace("/*inner*/", "/*mark*/"), "outerField", "innerField", "Inner", "Outer", "Derived");
// CtrlSpace(nestedClassProg.Replace("/*derived*/", "/*mark*/"), "outerField", "derivedField", "Inner", "Outer", "Derived"); CtrlSpace(nestedClassProg.Replace("/*derived*/", "/*mark*/"), "outerField", "derivedField", "Inner", "Outer", "Derived");
// } }
//
// [Test] [Test]
// public void NestedClassParentStaticField() public void NestedClassParentStaticField()
// { {
// MemberResolveResult mrr = Resolve<MemberResolveResult>(nestedClassProg, "outerField", "/*inner*/"); MemberResolveResult mrr = Resolve<MemberResolveResult>(nestedClassProg, "outerField", "/*inner*/");
// Assert.AreEqual("Outer.outerField", mrr.ResolvedMember.FullyQualifiedName); Assert.AreEqual("Outer.outerField", mrr.ResolvedMember.FullyQualifiedName);
// } }
//
// [Test] [Test]
// public void NestedClassCC() public void NestedClassCC()
// { {
// LocalResolveResult rr = Resolve<LocalResolveResult>(nestedClassProg, "i", "/*1*/"); LocalResolveResult rr = Resolve<LocalResolveResult>(nestedClassProg, "i", "/*1*/");
// Assert.AreEqual("Outer.Inner", rr.ResolvedType.FullyQualifiedName); Assert.AreEqual("Outer.Inner", rr.ResolvedType.FullyQualifiedName);
// bool ok = false; bool ok = false;
// foreach (object o in rr.GetCompletionData(lastPC)) { foreach (object o in rr.GetCompletionData(lastPC)) {
// IMember m = o as IMember; IMember m = o as IMember;
// if (m != null && m.Name == "innerField") if (m != null && m.Name == "innerField")
// ok = true; ok = true;
// } }
// Assert.IsTrue(ok); Assert.IsTrue(ok);
// MemberResolveResult mrr = Resolve<MemberResolveResult>(nestedClassProg, "i.innerField", "/*1*/"); MemberResolveResult mrr = Resolve<MemberResolveResult>(nestedClassProg, "i.innerField", "/*1*/");
// Assert.AreEqual("Outer.Inner.innerField", mrr.ResolvedMember.FullyQualifiedName); Assert.AreEqual("Outer.Inner.innerField", mrr.ResolvedMember.FullyQualifiedName);
// } }
//
// [Test] [Test]
// public void NestedClassCC2() public void NestedClassCC2()
// { {
// LocalResolveResult rr = Resolve<LocalResolveResult>(nestedClassProg, "i2", "/*1*/"); LocalResolveResult rr = Resolve<LocalResolveResult>(nestedClassProg, "i2", "/*1*/");
// Assert.AreEqual("Outer.Inner", rr.ResolvedType.FullyQualifiedName); Assert.AreEqual("Outer.Inner", rr.ResolvedType.FullyQualifiedName);
// bool ok = false; bool ok = false;
// foreach (object o in rr.GetCompletionData(lastPC)) { foreach (object o in rr.GetCompletionData(lastPC)) {
// IMember m = o as IMember; IMember m = o as IMember;
// if (m != null && m.Name == "innerField") if (m != null && m.Name == "innerField")
// ok = true; ok = true;
// } }
// Assert.IsTrue(ok); Assert.IsTrue(ok);
// MemberResolveResult mrr = Resolve<MemberResolveResult>(nestedClassProg, "i2.innerField", "/*1*/"); MemberResolveResult mrr = Resolve<MemberResolveResult>(nestedClassProg, "i2.innerField", "/*1*/");
// Assert.AreEqual("Outer.Inner.innerField", mrr.ResolvedMember.FullyQualifiedName); Assert.AreEqual("Outer.Inner.innerField", mrr.ResolvedMember.FullyQualifiedName);
// } }
// #endregion #endregion
//
// #region CtrlSpace #region CtrlSpace
// void CtrlSpace(string prog, params string[] expected) void CtrlSpace(string prog, params string[] expected)
// { {
// CtrlSpace(new string[0], prog, expected); CtrlSpace(new string[0], prog, expected);
// } }
//
// void CtrlSpace(string[] unExpected, string prog, params string[] expected) void CtrlSpace(string[] unExpected, string prog, params string[] expected)
// { {
// Register(prog); Register(prog);
// int line, column; int line, column;
// GetPos(prog, "/*mark*/", out line, out column); GetPos(prog, "/*mark*/", out line, out column);
// BooResolver r = new BooResolver(); BooResolver r = new BooResolver();
// System.Collections.ArrayList ar; System.Collections.ArrayList ar;
// ar = r.CtrlSpace(line, column, fileName, prog, ExpressionContext.Default); ar = r.CtrlSpace(line, column, fileName, prog, ExpressionContext.Default);
// foreach (string e in unExpected) { foreach (string e in unExpected) {
// foreach (object o in ar) { foreach (object o in ar) {
// if (e.Equals(o)) if (e.Equals(o))
// Assert.Fail("Didn't expect " + e); Assert.Fail("Didn't expect " + e);
// if (o is IMember && (o as IMember).Name == e) { if (o is IMember && (o as IMember).Name == e) {
// Assert.Fail("Didn't expect " + e); Assert.Fail("Didn't expect " + e);
// } }
// if (o is IClass && (o as IClass).Name == e) { if (o is IClass && (o as IClass).Name == e) {
// Assert.Fail("Didn't expect " + e); Assert.Fail("Didn't expect " + e);
// } }
// } }
// } }
// foreach (string e in expected) { foreach (string e in expected) {
// bool ok = false; bool ok = false;
// foreach (object o in ar) { foreach (object o in ar) {
// if (e.Equals(o)) { if (e.Equals(o)) {
// if (ok) Assert.Fail("double entry " + e); if (ok) Assert.Fail("double entry " + e);
// ok = true; ok = true;
// } }
// if (o is IMember && (o as IMember).Name == e) { if (o is IMember && (o as IMember).Name == e) {
// if (ok) Assert.Fail("double entry " + e); if (ok) Assert.Fail("double entry " + e);
// ok = true; ok = true;
// } }
// if (o is IClass && (o as IClass).Name == e) { if (o is IClass && (o as IClass).Name == e) {
// if (ok) Assert.Fail("double entry " + e); if (ok) Assert.Fail("double entry " + e);
// ok = true; ok = true;
// } }
// } }
// if (!ok) if (!ok)
// Assert.Fail("Expected " + e); Assert.Fail("Expected " + e);
// } }
// } }
//
// [Test] [Test]
// public void CtrlSpaceScopeExtension() public void CtrlSpaceScopeExtension()
// { {
// string prog = string prog =
// "def Foo():\n" + "def Foo():\n" +
// "\tbar = def():\n" + "\tbar = def():\n" +
// "\t\tx = 0\n" + "\t\tx = 0\n" +
// "\t\t/*mark*/\n"; "\t\t/*mark*/\n";
// CtrlSpace(prog, "bar", "x"); CtrlSpace(prog, "bar", "x");
// } }
//
// [Test] [Test]
// public void DoubleEntryTest() public void DoubleEntryTest()
// { {
// string prog = string prog =
// "class MyClass:\n" + "class MyClass:\n" +
// "\t_myInt = 0\n" + "\t_myInt = 0\n" +
// "\tdef Foo():\n" + "\tdef Foo():\n" +
// "\t\t_myInt = 5\n" + "\t\t_myInt = 5\n" +
// "\t\t/*mark*/\n"; "\t\t/*mark*/\n";
// CtrlSpace(prog, "_myInt"); CtrlSpace(prog, "_myInt");
// } }
//
// [Test] [Test]
// public void LoopInClosureTest() public void LoopInClosureTest()
// { {
// string prog = string prog =
// "def Foo():\n" + "def Foo():\n" +
// "\tfor i in range(5):\n" + "\tfor i in range(5):\n" +
// "\t\tbar = def():\n" + "\t\tbar = def():\n" +
// "\t\t\tx = 0\n" + "\t\t\tx = 0\n" +
// "\t\t\t/*mark*/\n" + "\t\t\t/*mark*/\n" +
// "\t\t\tprint x"; "\t\t\tprint x";
// CtrlSpace(prog, "x", "bar", "i"); CtrlSpace(prog, "x", "bar", "i");
// } }
// #endregion #endregion
} }
} }

4
src/AddIns/BackendBindings/CSharpBinding/Test/ExpressionFinder.cs
Unescape View File

@ -9,6 +9,7 @@ using System;
using System.Collections.Generic; using System.Collections.Generic;
using NUnit.Framework; using NUnit.Framework;
using CSharpBinding.Parser; using CSharpBinding.Parser;
using ICSharpCode.SharpDevelop;
using ICSharpCode.SharpDevelop.Dom; using ICSharpCode.SharpDevelop.Dom;
namespace CSharpBinding.Tests namespace CSharpBinding.Tests
@ -130,10 +131,9 @@ class Main {
} }
[Test] [Test]
[Ignore("Temporarily ignored - code no longer compiles")]
public void NewException() 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));
} }
} }
} }

2
src/Libraries/NRefactory/Test/Output/VBNet/CSharpToVBConverterTest.cs
Unescape View File

@ -212,7 +212,7 @@ namespace ICSharpCode.NRefactory.Tests.PrettyPrinter
"End Sub"); "End Sub");
} }
[Test, Ignore] [Test, Ignore("NRefactory cannot guess the anonymous method's return type")]
public void AnonymousMethodInVarDeclaration() public void AnonymousMethodInVarDeclaration()
{ {
TestMember("void A() { Converter<int, int> i = delegate(int argument) { return argument * 2; }; }", TestMember("void A() { Converter<int, int> i = delegate(int argument) { return argument * 2; }; }",

474
src/Main/Base/Test/GenericResolverTests.cs
Unescape View File

@ -14,242 +14,242 @@ namespace ICSharpCode.SharpDevelop.Tests
[TestFixture] [TestFixture]
public class GenericResolverTests public class GenericResolverTests
{ {
// #region Test helper methods #region Test helper methods
// NRefactoryResolverTests nrrt = new NRefactoryResolverTests(); NRefactoryResolverTests nrrt = new NRefactoryResolverTests();
//
// ResolveResult Resolve(string program, string expression, int line) ResolveResult Resolve(string program, string expression, int line)
// { {
// return nrrt.Resolve(program, expression, line); return nrrt.Resolve(program, expression, line);
// } }
//
// ResolveResult ResolveVB(string program, string expression, int line) ResolveResult ResolveVB(string program, string expression, int line)
// { {
// return nrrt.ResolveVB(program, expression, line); return nrrt.ResolveVB(program, expression, line);
// } }
// #endregion #endregion
//
// #region Generic references #region Generic references
// const string listProgram = @"using System.Collections.Generic; const string listProgram = @"using System.Collections.Generic;
//class TestClass { class TestClass {
// void Method() { void Method() {
// List<TestClass> list = new List<TestClass>(); List<TestClass> list = new List<TestClass>();
//
// } }
//
// T CloneIt<T>(T source) where T : ICloneable { T CloneIt<T>(T source) where T : ICloneable {
// if (source == null) return new TestClass(); if (source == null) return new TestClass();
// return source.Clone(); return source.Clone();
// } }
//
// public int PublicField; public int PublicField;
//} }
//"; ";
//
// [Test] [Test]
// public void ListAddTest() public void ListAddTest()
// { {
// ResolveResult result = Resolve(listProgram, "list.Add(new A())", 5); ResolveResult result = Resolve(listProgram, "list.Add(new A())", 5);
// Assert.IsNotNull(result); Assert.IsNotNull(result);
// Assert.IsTrue(result is MemberResolveResult); Assert.IsTrue(result is MemberResolveResult);
// IMethod m = (IMethod)((MemberResolveResult)result).ResolvedMember; IMethod m = (IMethod)((MemberResolveResult)result).ResolvedMember;
// Assert.AreEqual(1, m.Parameters.Count); Assert.AreEqual(1, m.Parameters.Count);
// Assert.AreEqual("TestClass", m.Parameters[0].ReturnType.FullyQualifiedName); Assert.AreEqual("TestClass", m.Parameters[0].ReturnType.FullyQualifiedName);
// } }
//
// [Test] [Test]
// public void ListAddRangeTest() public void ListAddRangeTest()
// { {
// ResolveResult result = Resolve(listProgram, "list.AddRange(new A[0])", 5); ResolveResult result = Resolve(listProgram, "list.AddRange(new A[0])", 5);
// Assert.IsNotNull(result); Assert.IsNotNull(result);
// Assert.IsTrue(result is MemberResolveResult); Assert.IsTrue(result is MemberResolveResult);
// IMethod m = (IMethod)((MemberResolveResult)result).ResolvedMember; IMethod m = (IMethod)((MemberResolveResult)result).ResolvedMember;
// Assert.AreEqual(1, m.Parameters.Count); Assert.AreEqual(1, m.Parameters.Count);
// Assert.IsTrue(m.Parameters[0].ReturnType is ConstructedReturnType); Assert.IsTrue(m.Parameters[0].ReturnType is ConstructedReturnType);
// Assert.AreEqual("System.Collections.Generic.IEnumerable", m.Parameters[0].ReturnType.FullyQualifiedName); Assert.AreEqual("System.Collections.Generic.IEnumerable", m.Parameters[0].ReturnType.FullyQualifiedName);
// Assert.AreEqual("TestClass", ((ConstructedReturnType)m.Parameters[0].ReturnType).TypeArguments[0].FullyQualifiedName); Assert.AreEqual("TestClass", ((ConstructedReturnType)m.Parameters[0].ReturnType).TypeArguments[0].FullyQualifiedName);
// } }
//
// [Test] [Test]
// public void ListToArrayTest() public void ListToArrayTest()
// { {
// ResolveResult result = Resolve(listProgram, "list.ToArray()", 5); ResolveResult result = Resolve(listProgram, "list.ToArray()", 5);
// Assert.IsNotNull(result); Assert.IsNotNull(result);
// Assert.IsTrue(result is MemberResolveResult); Assert.IsTrue(result is MemberResolveResult);
// IMethod m = (IMethod)((MemberResolveResult)result).ResolvedMember; IMethod m = (IMethod)((MemberResolveResult)result).ResolvedMember;
// Assert.AreEqual("TestClass", m.ReturnType.FullyQualifiedName); Assert.AreEqual("TestClass", m.ReturnType.FullyQualifiedName);
// Assert.AreEqual(1, m.ReturnType.CastToArrayReturnType().ArrayDimensions); Assert.AreEqual(1, m.ReturnType.CastToArrayReturnType().ArrayDimensions);
// } }
//
// [Test] [Test]
// public void ClassReferenceTest() public void ClassReferenceTest()
// { {
// ResolveResult result = Resolve(listProgram, "List<string>", 5); ResolveResult result = Resolve(listProgram, "List<string>", 5);
// Assert.IsNotNull(result); Assert.IsNotNull(result);
// Assert.IsTrue(result is TypeResolveResult); Assert.IsTrue(result is TypeResolveResult);
// Assert.AreEqual("System.Collections.Generic.List", ((TypeResolveResult)result).ResolvedClass.FullyQualifiedName); Assert.AreEqual("System.Collections.Generic.List", ((TypeResolveResult)result).ResolvedClass.FullyQualifiedName);
// Assert.IsTrue(result.ResolvedType is ConstructedReturnType); Assert.IsTrue(result.ResolvedType is ConstructedReturnType);
// Assert.AreEqual("System.String", ((ConstructedReturnType)result.ResolvedType).TypeArguments[0].FullyQualifiedName); Assert.AreEqual("System.String", ((ConstructedReturnType)result.ResolvedType).TypeArguments[0].FullyQualifiedName);
// } }
//
// [Test] [Test]
// public void GenericMethodCallTest() public void GenericMethodCallTest()
// { {
// ResolveResult result = Resolve(listProgram, "CloneIt<TestClass>(null)", 5); ResolveResult result = Resolve(listProgram, "CloneIt<TestClass>(null)", 5);
// Assert.IsNotNull(result); Assert.IsNotNull(result);
// Assert.IsTrue(result is MemberResolveResult); Assert.IsTrue(result is MemberResolveResult);
// Assert.AreEqual("TestClass", result.ResolvedType.FullyQualifiedName); Assert.AreEqual("TestClass", result.ResolvedType.FullyQualifiedName);
// MemberResolveResult mrr = (MemberResolveResult) result; MemberResolveResult mrr = (MemberResolveResult) result;
// Assert.AreEqual("TestClass.CloneIt", mrr.ResolvedMember.FullyQualifiedName); Assert.AreEqual("TestClass.CloneIt", mrr.ResolvedMember.FullyQualifiedName);
// } }
//
// [Test] [Test]
// public void FieldReferenceOnGenericMethodTest() public void FieldReferenceOnGenericMethodTest()
// { {
// ResolveResult result = Resolve(listProgram, "CloneIt<TestClass>(null).PublicField", 5); ResolveResult result = Resolve(listProgram, "CloneIt<TestClass>(null).PublicField", 5);
// Assert.IsNotNull(result); Assert.IsNotNull(result);
// Assert.IsTrue(result is MemberResolveResult); Assert.IsTrue(result is MemberResolveResult);
// Assert.AreEqual("System.Int32", result.ResolvedType.FullyQualifiedName); Assert.AreEqual("System.Int32", result.ResolvedType.FullyQualifiedName);
// MemberResolveResult mrr = (MemberResolveResult) result; MemberResolveResult mrr = (MemberResolveResult) result;
// Assert.AreEqual("TestClass.PublicField", mrr.ResolvedMember.FullyQualifiedName); Assert.AreEqual("TestClass.PublicField", mrr.ResolvedMember.FullyQualifiedName);
// } }
//
// [Test] [Test]
// public void TypeInferredGenericMethodCallTest() public void TypeInferredGenericMethodCallTest()
// { {
// ResolveResult result = Resolve(listProgram, "CloneIt(new TestClass())", 5); ResolveResult result = Resolve(listProgram, "CloneIt(new TestClass())", 5);
// Assert.IsNotNull(result); Assert.IsNotNull(result);
// Assert.IsTrue(result is MemberResolveResult); Assert.IsTrue(result is MemberResolveResult);
// Assert.AreEqual("TestClass", result.ResolvedType.FullyQualifiedName); Assert.AreEqual("TestClass", result.ResolvedType.FullyQualifiedName);
// MemberResolveResult mrr = (MemberResolveResult) result; MemberResolveResult mrr = (MemberResolveResult) result;
// Assert.AreEqual("TestClass.CloneIt", mrr.ResolvedMember.FullyQualifiedName); Assert.AreEqual("TestClass.CloneIt", mrr.ResolvedMember.FullyQualifiedName);
// } }
//
// [Test] [Test]
// public void FieldReferenceOnTypeInferredGenericMethodCallTest() public void FieldReferenceOnTypeInferredGenericMethodCallTest()
// { {
// ResolveResult result = Resolve(listProgram, "CloneIt(new TestClass()).PublicField", 5); ResolveResult result = Resolve(listProgram, "CloneIt(new TestClass()).PublicField", 5);
// Assert.IsNotNull(result); Assert.IsNotNull(result);
// Assert.IsTrue(result is MemberResolveResult); Assert.IsTrue(result is MemberResolveResult);
// Assert.AreEqual("System.Int32", result.ResolvedType.FullyQualifiedName); Assert.AreEqual("System.Int32", result.ResolvedType.FullyQualifiedName);
// MemberResolveResult mrr = (MemberResolveResult) result; MemberResolveResult mrr = (MemberResolveResult) result;
// Assert.AreEqual("TestClass.PublicField", mrr.ResolvedMember.FullyQualifiedName); Assert.AreEqual("TestClass.PublicField", mrr.ResolvedMember.FullyQualifiedName);
// } }
//
// [Test] [Test]
// public void ImportAliasClassResolveTest() public void ImportAliasClassResolveTest()
// { {
// string program = @"using COL = System.Collections.Generic.List<string>; string program = @"using COL = System.Collections.Generic.List<string>;
//class TestClass { class TestClass {
// void Test() { void Test() {
// COL a = new COL(); COL a = new COL();
//
// } }
//} }
//"; ";
// TypeResolveResult rr = Resolve(program, "COL", 4) as TypeResolveResult; TypeResolveResult rr = Resolve(program, "COL", 4) as TypeResolveResult;
// Assert.AreEqual("System.Collections.Generic.List", rr.ResolvedClass.FullyQualifiedName, "COL"); Assert.AreEqual("System.Collections.Generic.List", rr.ResolvedClass.FullyQualifiedName, "COL");
// Assert.AreEqual("System.Collections.Generic.List{System.String}", rr.ResolvedType.DotNetName, "COL"); Assert.AreEqual("System.Collections.Generic.List{System.String}", rr.ResolvedType.DotNetName, "COL");
// LocalResolveResult lr = Resolve(program, "a", 5) as LocalResolveResult; LocalResolveResult lr = Resolve(program, "a", 5) as LocalResolveResult;
// Assert.AreEqual("System.Collections.Generic.List{System.String}", lr.ResolvedType.DotNetName, "a"); Assert.AreEqual("System.Collections.Generic.List{System.String}", lr.ResolvedType.DotNetName, "a");
// } }
//
// [Test] [Test]
// public void InheritFromGenericClass() public void InheritFromGenericClass()
// { {
// string program = @"using System; string program = @"using System;
//class BaseClass<T> { class BaseClass<T> {
// public T value; public T value;
//} }
//class DerivedClass : BaseClass<string> { class DerivedClass : BaseClass<string> {
//
//}"; }";
// MemberResolveResult rr = Resolve(program, "value", 6) as MemberResolveResult; MemberResolveResult rr = Resolve(program, "value", 6) as MemberResolveResult;
// Assert.AreEqual("System.String", rr.ResolvedType.FullyQualifiedName); Assert.AreEqual("System.String", rr.ResolvedType.FullyQualifiedName);
// } }
//
// [Test] [Test]
// public void CrossTypeParametersInheritance() public void CrossTypeParametersInheritance()
// { {
// string program = @"using System; string program = @"using System;
//class BaseClass<A,B> { class BaseClass<A,B> {
// public A a; public A a;
// public B b; public B b;
//} }
//class DerivedClass<A,B> : BaseClass<B,A> { class DerivedClass<A,B> : BaseClass<B,A> {
//
//}"; }";
// MemberResolveResult rr = Resolve(program, "a", 7) as MemberResolveResult; MemberResolveResult rr = Resolve(program, "a", 7) as MemberResolveResult;
// Assert.AreEqual("B", rr.ResolvedType.Name); Assert.AreEqual("B", rr.ResolvedType.Name);
// rr = Resolve(program, "b", 7) as MemberResolveResult; rr = Resolve(program, "b", 7) as MemberResolveResult;
// Assert.AreEqual("A", rr.ResolvedType.Name); Assert.AreEqual("A", rr.ResolvedType.Name);
// } }
// #endregion #endregion
//
// #region CodeCompletion inside generic classes #region CodeCompletion inside generic classes
// const string genericClass = @"using System; const string genericClass = @"using System;
//public class GenericClass<T> where T : IDisposable public class GenericClass<T> where T : IDisposable
// void Method<G>(T par1, G par2) where G : IConvertible, IFormattable { void Method<G>(T par1, G par2) where G : IConvertible, IFormattable {
// T var1; G var2; T var1; G var2;
//
// } }
//} }
//"; ";
//
// [Test] [Test]
// public void ClassTypeParameterResolveType() public void ClassTypeParameterResolveType()
// { {
// ResolveResult rr = Resolve(genericClass, "T", 5); ResolveResult rr = Resolve(genericClass, "T", 5);
// Assert.IsNotNull(rr); Assert.IsNotNull(rr);
// Assert.IsTrue(rr is TypeResolveResult); Assert.IsTrue(rr is TypeResolveResult);
// Assert.IsNull((rr as TypeResolveResult).ResolvedClass); Assert.IsNull((rr as TypeResolveResult).ResolvedClass);
// Assert.IsTrue(rr.ResolvedType is GenericReturnType); Assert.IsTrue(rr.ResolvedType is GenericReturnType);
// } }
//
// [Test] [Test]
// public void ClassTypeParameterResolveVariable() public void ClassTypeParameterResolveVariable()
// { {
// ResolveResult rr = Resolve(genericClass, "var1", 5); ResolveResult rr = Resolve(genericClass, "var1", 5);
// Assert.IsNotNull(rr); Assert.IsNotNull(rr);
// Assert.IsTrue(rr is LocalResolveResult); Assert.IsTrue(rr is LocalResolveResult);
// Assert.IsTrue(rr.ResolvedType is GenericReturnType); Assert.IsTrue(rr.ResolvedType is GenericReturnType);
// } }
//
// [Test] [Test]
// public void ClassTypeParameterResolveParameter() public void ClassTypeParameterResolveParameter()
// { {
// ResolveResult rr = Resolve(genericClass, "par1", 5); ResolveResult rr = Resolve(genericClass, "par1", 5);
// Assert.IsNotNull(rr); Assert.IsNotNull(rr);
// Assert.IsTrue(rr is LocalResolveResult); Assert.IsTrue(rr is LocalResolveResult);
// Assert.IsTrue(rr.ResolvedType is GenericReturnType); Assert.IsTrue(rr.ResolvedType is GenericReturnType);
// } }
//
// [Test] [Test]
// public void MethodTypeParameterResolveType() public void MethodTypeParameterResolveType()
// { {
// ResolveResult rr = Resolve(genericClass, "G", 5); ResolveResult rr = Resolve(genericClass, "G", 5);
// Assert.IsNotNull(rr); Assert.IsNotNull(rr);
// Assert.IsTrue(rr is TypeResolveResult); Assert.IsTrue(rr is TypeResolveResult);
// Assert.IsNull((rr as TypeResolveResult).ResolvedClass); Assert.IsNull((rr as TypeResolveResult).ResolvedClass);
// Assert.IsTrue(rr.ResolvedType is GenericReturnType); Assert.IsTrue(rr.ResolvedType is GenericReturnType);
// } }
//
// [Test] [Test]
// public void MethodTypeParameterResolveVariable() public void MethodTypeParameterResolveVariable()
// { {
// ResolveResult rr = Resolve(genericClass, "var2", 5); ResolveResult rr = Resolve(genericClass, "var2", 5);
// Assert.IsNotNull(rr); Assert.IsNotNull(rr);
// Assert.IsTrue(rr is LocalResolveResult); Assert.IsTrue(rr is LocalResolveResult);
// Assert.IsTrue(rr.ResolvedType is GenericReturnType); Assert.IsTrue(rr.ResolvedType is GenericReturnType);
// } }
//
// [Test] [Test]
// public void MethodTypeParameterResolveParameter() public void MethodTypeParameterResolveParameter()
// { {
// ResolveResult rr = Resolve(genericClass, "par2", 5); ResolveResult rr = Resolve(genericClass, "par2", 5);
// Assert.IsNotNull(rr); Assert.IsNotNull(rr);
// Assert.IsTrue(rr is LocalResolveResult); Assert.IsTrue(rr is LocalResolveResult);
// Assert.IsTrue(rr.ResolvedType is GenericReturnType); Assert.IsTrue(rr.ResolvedType is GenericReturnType);
// } }
// #endregion #endregion
} }
} }

208
src/Main/Base/Test/InnerClassesResolverTests.cs
Unescape View File

@ -15,109 +15,109 @@ namespace ICSharpCode.SharpDevelop.Tests
[TestFixture] [TestFixture]
public class InnerClassesResolverTests public class InnerClassesResolverTests
{ {
// #region Test helper methods #region Test helper methods
// NRefactoryResolverTests nrrt = new NRefactoryResolverTests(); NRefactoryResolverTests nrrt = new NRefactoryResolverTests();
//
// ResolveResult Resolve(string program, string expression, int line) ResolveResult Resolve(string program, string expression, int line)
// { {
// return nrrt.Resolve(program, expression, line); return nrrt.Resolve(program, expression, line);
// } }
//
// ResolveResult ResolveVB(string program, string expression, int line) ResolveResult ResolveVB(string program, string expression, int line)
// { {
// return nrrt.ResolveVB(program, expression, line); return nrrt.ResolveVB(program, expression, line);
// } }
// #endregion #endregion
//
// [Test] [Test]
// public void SimpleInnerClass() public void SimpleInnerClass()
// { {
// string program = @"class A { string program = @"class A {
// void Test() { void Test() {
//
// } }
// class B { } class B { }
//} }
//"; ";
// ResolveResult result = Resolve(program, "B", 3); ResolveResult result = Resolve(program, "B", 3);
// Assert.IsTrue(result is TypeResolveResult); Assert.IsTrue(result is TypeResolveResult);
// Assert.AreEqual("A.B", result.ResolvedType.FullyQualifiedName); Assert.AreEqual("A.B", result.ResolvedType.FullyQualifiedName);
// } }
//
// [Test] [Test]
// public void ReflectionInnerClass() public void ReflectionInnerClass()
// { {
// string program = @"using System; string program = @"using System;
//class A { class A {
// void Test() { void Test() {
//
// } }
//} }
//"; ";
// ResolveResult result = Resolve(program, "Environment.SpecialFolder", 3); ResolveResult result = Resolve(program, "Environment.SpecialFolder", 3);
// Assert.IsTrue(result is TypeResolveResult); Assert.IsTrue(result is TypeResolveResult);
// Assert.AreEqual("System.Environment.SpecialFolder", result.ResolvedType.FullyQualifiedName); Assert.AreEqual("System.Environment.SpecialFolder", result.ResolvedType.FullyQualifiedName);
// } }
//
// [Test] [Test]
// public void OuterclassPrivateFieldResolveTest() public void OuterclassPrivateFieldResolveTest()
// { {
// string program = @"class A string program = @"class A
//{ {
// int myField; int myField;
// class B class B
// { {
// void MyMethod(A a) void MyMethod(A a)
// { {
//
// } }
// } }
//} }
//"; ";
// ResolveResult result = Resolve(program, "a", 8); ResolveResult result = Resolve(program, "a", 8);
// Assert.IsNotNull(result, "result"); Assert.IsNotNull(result, "result");
// Assert.IsTrue(result is LocalResolveResult, "result is LocalResolveResult"); Assert.IsTrue(result is LocalResolveResult, "result is LocalResolveResult");
// ArrayList arr = result.GetCompletionData(nrrt.lastPC); ArrayList arr = result.GetCompletionData(nrrt.lastPC);
// Assert.IsNotNull(arr, "arr"); Assert.IsNotNull(arr, "arr");
// foreach (object o in arr) { foreach (object o in arr) {
// if (o is IField) { if (o is IField) {
// Assert.AreEqual("myField", ((IField)o).Name); Assert.AreEqual("myField", ((IField)o).Name);
// return; return;
// } }
// } }
// Assert.Fail("private field not visible from inner class"); Assert.Fail("private field not visible from inner class");
// } }
//
// [Test] [Test]
// public void InheritedInnerClass() public void InheritedInnerClass()
// { {
// string program = @"class A { string program = @"class A {
// class B { } class B { }
//} }
//class C : A { class C : A {
// void Main() { void Main() {
//
// } }
//} }
//"; ";
// ResolveResult result = Resolve(program, "B", 6); ResolveResult result = Resolve(program, "B", 6);
// Assert.IsTrue(result is TypeResolveResult); Assert.IsTrue(result is TypeResolveResult);
// Assert.AreEqual("A.B", result.ResolvedType.FullyQualifiedName); Assert.AreEqual("A.B", result.ResolvedType.FullyQualifiedName);
//
// result = Resolve(program, "C.B", 6); result = Resolve(program, "C.B", 6);
// Assert.IsTrue(result is TypeResolveResult); Assert.IsTrue(result is TypeResolveResult);
// Assert.AreEqual("A.B", result.ResolvedType.FullyQualifiedName); Assert.AreEqual("A.B", result.ResolvedType.FullyQualifiedName);
//
// result = Resolve(program, "C", 6); result = Resolve(program, "C", 6);
// Assert.IsTrue(result is TypeResolveResult); Assert.IsTrue(result is TypeResolveResult);
// Assert.AreEqual("C", result.ResolvedType.FullyQualifiedName); Assert.AreEqual("C", result.ResolvedType.FullyQualifiedName);
// foreach (object o in result.GetCompletionData(nrrt.lastPC)) { foreach (object o in result.GetCompletionData(nrrt.lastPC)) {
// if (o is IClass) { if (o is IClass) {
// Assert.AreEqual("A.B", ((IClass)o).FullyQualifiedName); Assert.AreEqual("A.B", ((IClass)o).FullyQualifiedName);
// return; return;
// } }
// } }
// Assert.Fail("Inherited inner class not visible."); Assert.Fail("Inherited inner class not visible.");
// } }
} }
} }

1848
src/Main/Base/Test/NRefactoryResolverTests.cs
View File

File diff suppressed because it is too large Load Diff

124
src/Main/Base/Test/OverloadFinding.cs
Unescape View File

@ -15,67 +15,67 @@ namespace ICSharpCode.SharpDevelop.Tests
[TestFixture] [TestFixture]
public class OverloadFinding public class OverloadFinding
{ {
// [Test] public void Simple() [Test] public void Simple()
// { {
// Test("(\"Hallo\")", 0, "(string a)", "(int b)"); Test("(\"Hallo\")", 0, "(string a)", "(int b)");
// Test("(2)", 1, "(string a)", "(int b)"); Test("(2)", 1, "(string a)", "(int b)");
// } }
//
// [Test] public void WinForms() [Test] public void WinForms()
// { {
// string[] overloads = {"(object a)", "(TextBoxBase a)", "(Control a)", "(RichTextBox a)"}; string[] overloads = {"(object a)", "(TextBoxBase a)", "(Control a)", "(RichTextBox a)"};
// Test("(new RichTextBox())", 3, overloads); Test("(new RichTextBox())", 3, overloads);
// Test("(new Control())", 2, overloads); Test("(new Control())", 2, overloads);
// Test("(new TextBox())", 1, overloads); Test("(new TextBox())", 1, overloads);
// Test("(new Button())", 2, overloads); Test("(new Button())", 2, overloads);
// Test("(3)", 0, overloads); Test("(3)", 0, overloads);
// } }
//
// [Test] public void Params() [Test] public void Params()
// { {
// string[] overloads = {"(params int[] a)", "(int a, params int[] b)"}; string[] overloads = {"(params int[] a)", "(int a, params int[] b)"};
// Test("()", 0, overloads); Test("()", 0, overloads);
// Test("(1)", 1, overloads); Test("(1)", 1, overloads);
// Test("(1, 2)", 1, overloads); Test("(1, 2)", 1, overloads);
// } }
//
// [Test] public void IntegerConversion() [Test] public void IntegerConversion()
// { {
// string[] overloads = {"<T>(T a)", "(int a)"}; string[] overloads = {"<T>(T a)", "(int a)"};
// Test("(1)", 1, overloads); Test("(1)", 1, overloads);
// Test("(short.MaxValue)", 1, overloads); Test("(short.MaxValue)", 1, overloads);
// Test("(long.MaxValue)", 0, overloads); Test("(long.MaxValue)", 0, overloads);
// } }
//
// NRefactoryResolverTests nrrt = new NRefactoryResolverTests(); NRefactoryResolverTests nrrt = new NRefactoryResolverTests();
//
// void Test(string callExpr, int num, params string[] signatures) void Test(string callExpr, int num, params string[] signatures)
// { {
// StringBuilder b = new StringBuilder(); StringBuilder b = new StringBuilder();
// int lineNumber = 0; int lineNumber = 0;
// ++lineNumber; b.AppendLine("using System;"); ++lineNumber; b.AppendLine("using System;");
// ++lineNumber; b.AppendLine("using System.Windows.Forms;"); ++lineNumber; b.AppendLine("using System.Windows.Forms;");
// ++lineNumber; b.AppendLine("class TestClass {"); ++lineNumber; b.AppendLine("class TestClass {");
// ++lineNumber; b.AppendLine(" void callingMethod() {"); ++lineNumber; b.AppendLine(" void callingMethod() {");
// ++lineNumber; b.AppendLine(" "); ++lineNumber; b.AppendLine(" ");
// int callPosition = lineNumber; int callPosition = lineNumber;
// ++lineNumber; b.AppendLine(" }"); ++lineNumber; b.AppendLine(" }");
// int[] positions = new int[signatures.Length]; int[] positions = new int[signatures.Length];
// for (int i = 0; i < signatures.Length; i++) { for (int i = 0; i < signatures.Length; i++) {
// b.Append(" void Method"); b.Append(" void Method");
// b.Append(signatures[i]); b.Append(signatures[i]);
// ++lineNumber; b.AppendLine(" {"); ++lineNumber; b.AppendLine(" {");
// positions[i] = lineNumber; positions[i] = lineNumber;
// ++lineNumber; b.AppendLine(" }"); ++lineNumber; b.AppendLine(" }");
// } }
// b.AppendLine("}"); b.AppendLine("}");
// MemberResolveResult mrr = nrrt.Resolve<MemberResolveResult>(b.ToString(), "Method" + callExpr, callPosition); MemberResolveResult mrr = nrrt.Resolve<MemberResolveResult>(b.ToString(), "Method" + callExpr, callPosition);
// string msg = "wrong overload: "; string msg = "wrong overload: ";
// for (int i = 0; i < positions.Length; i++) { for (int i = 0; i < positions.Length; i++) {
// if (positions[i] == mrr.ResolvedMember.Region.BeginLine) if (positions[i] == mrr.ResolvedMember.Region.BeginLine)
// msg += signatures[i]; msg += signatures[i];
// } }
// Assert.AreEqual(positions[num], mrr.ResolvedMember.Region.BeginLine, msg); Assert.AreEqual(positions[num], mrr.ResolvedMember.Region.BeginLine, msg);
// } }
} }
} }

281
src/Main/Base/Test/ReflectionLayerTests.cs
Unescape View File

@ -20,142 +20,149 @@ namespace ICSharpCode.SharpDevelop.Tests
[TestFixture] [TestFixture]
public class ReflectionLayerTests public class ReflectionLayerTests
{ {
// IProjectContent pc = ProjectContentRegistry.Mscorlib; IProjectContent pc = ParserService.DefaultProjectContentRegistry.Mscorlib;
//
// [Test] [Test]
// public void InheritanceTest() public void InheritanceTest()
// { {
// IClass c = pc.GetClass("System.SystemException"); IClass c = pc.GetClass("System.SystemException");
// IClass c2 = pc.GetClass("System.Exception"); IClass c2 = pc.GetClass("System.Exception");
// Assert.IsNotNull(c, "c is null"); Assert.IsNotNull(c, "c is null");
// Assert.IsNotNull(c2, "c2 is null"); Assert.IsNotNull(c2, "c2 is null");
// Assert.AreEqual(3, c.BaseTypes.Count); // 2 interfaces //Assert.AreEqual(3, c.BaseTypes.Count); // Inherited interfaces are not reported by Cecil
// Assert.AreEqual("System.Exception", c.BaseTypes[0].FullyQualifiedName); // which matches the behaviour of our C#/VB parsers
// Assert.AreSame(c2, c.BaseClass); Assert.AreEqual("System.Exception", c.BaseTypes[0].FullyQualifiedName);
// Assert.AreSame(c2, c.BaseClass);
// List<IClass> subClasses = new List<IClass>();
// foreach (IClass subClass in c.ClassInheritanceTree) { List<IClass> subClasses = new List<IClass>();
// subClasses.Add(subClass); 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(5, subClasses.Count, "ClassInheritanceTree length");
// Assert.AreEqual("System.Exception", subClasses[1].FullyQualifiedName); Assert.AreEqual("System.SystemException", subClasses[0].FullyQualifiedName);
// Assert.AreEqual("System.Runtime.Serialization.ISerializable", subClasses[2].FullyQualifiedName); Assert.AreEqual("System.Exception", subClasses[1].FullyQualifiedName);
// Assert.AreEqual("System.Runtime.InteropServices._Exception", subClasses[3].FullyQualifiedName); if (subClasses[2].FullyQualifiedName == "System.Object") {
// Assert.AreEqual("System.Object", subClasses[4].FullyQualifiedName); 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);
// [Test] } else {
// public void ParameterComparisonTest() Assert.AreEqual("System.Runtime.Serialization.ISerializable", subClasses[2].FullyQualifiedName);
// { Assert.AreEqual("System.Runtime.InteropServices._Exception", subClasses[3].FullyQualifiedName);
// DefaultParameter p1 = new DefaultParameter("a", pc.GetClass("System.String").DefaultReturnType, DomRegion.Empty); Assert.AreEqual("System.Object", subClasses[4].FullyQualifiedName);
// DefaultParameter p2 = new DefaultParameter("b", new GetClassReturnType(pc, "System.String", 0), DomRegion.Empty); }
// IList<IParameter> a1 = new List<IParameter>(); }
// IList<IParameter> a2 = new List<IParameter>();
// a1.Add(p1); [Test]
// a2.Add(p2); public void ParameterComparisonTest()
// Assert.AreEqual(0, DiffUtility.Compare(a1, a2)); {
// } 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);
// DefaultMethod GetMethod(IClass c, string name) { IList<IParameter> a1 = new List<IParameter>();
// IMethod result = c.Methods.Find(delegate(IMethod m) { return m.Name == name; }); IList<IParameter> a2 = new List<IParameter>();
// Assert.IsNotNull(result, "Method " + name + " not found"); a1.Add(p1);
// return (DefaultMethod)result; a2.Add(p2);
// } Assert.AreEqual(0, DiffUtility.Compare(a1, a2));
// }
// [Test]
// public void GenericDocumentationTagNamesTest() DefaultMethod GetMethod(IClass c, string name) {
// { IMethod result = c.Methods.Find(delegate(IMethod m) { return m.Name == name; });
// DefaultClass c = (DefaultClass)pc.GetClass("System.Collections.Generic.List"); Assert.IsNotNull(result, "Method " + name + " not found");
// Assert.AreEqual("T:System.Collections.Generic.List`1", return (DefaultMethod)result;
// c.DocumentationTag); }
// Assert.AreEqual("M:System.Collections.Generic.List`1.Add(`0)",
// GetMethod(c, "Add").DocumentationTag); [Test]
// Assert.AreEqual("M:System.Collections.Generic.List`1.AddRange(System.Collections.Generic.IEnumerable{`0})", public void GenericDocumentationTagNamesTest()
// GetMethod(c, "AddRange").DocumentationTag); {
// Assert.AreEqual("M:System.Collections.Generic.List`1.ConvertAll``1(System.Converter{`0,``0})", DefaultClass c = (DefaultClass)pc.GetClass("System.Collections.Generic.List");
// GetMethod(c, "ConvertAll").DocumentationTag); Assert.AreEqual("T:System.Collections.Generic.List`1",
// } c.DocumentationTag);
// Assert.AreEqual("M:System.Collections.Generic.List`1.Add(`0)",
// [Test] GetMethod(c, "Add").DocumentationTag);
// public void InnerClassReferenceTest() Assert.AreEqual("M:System.Collections.Generic.List`1.AddRange(System.Collections.Generic.IEnumerable{`0})",
// { GetMethod(c, "AddRange").DocumentationTag);
// IClass c = pc.GetClass("System.Environment"); Assert.AreEqual("M:System.Collections.Generic.List`1.ConvertAll``1(System.Converter{`0,``0})",
// Assert.IsNotNull(c, "System.Environment not found"); GetMethod(c, "ConvertAll").DocumentationTag);
// IReturnType rt = GetMethod(c, "GetFolderPath").Parameters[0].ReturnType; }
// Assert.IsNotNull(rt, "ReturnType is null");
// Assert.AreEqual("System.Environment.SpecialFolder", rt.FullyQualifiedName); [Test]
// IClass inner = rt.GetUnderlyingClass(); public void InnerClassReferenceTest()
// Assert.IsNotNull(inner, "UnderlyingClass"); {
// Assert.AreEqual("System.Environment.SpecialFolder", inner.FullyQualifiedName); IClass c = pc.GetClass("System.Environment");
// } Assert.IsNotNull(c, "System.Environment not found");
// IReturnType rt = GetMethod(c, "GetFolderPath").Parameters[0].ReturnType;
// [Test] Assert.IsNotNull(rt, "ReturnType is null");
// public void InnerClassesTest() Assert.AreEqual("System.Environment.SpecialFolder", rt.FullyQualifiedName);
// { IClass inner = rt.GetUnderlyingClass();
// IClass c = pc.GetClass("System.Environment.SpecialFolder"); Assert.IsNotNull(inner, "UnderlyingClass");
// Assert.IsNotNull(c, "c is null"); Assert.AreEqual("System.Environment.SpecialFolder", inner.FullyQualifiedName);
// Assert.AreEqual("System.Environment.SpecialFolder", c.FullyQualifiedName); }
// }
// [Test]
// [Test] public void InnerClassesTest()
// public void VoidTest() {
// { IClass c = pc.GetClass("System.Environment.SpecialFolder");
// IClass c = pc.GetClass("System.Void"); Assert.IsNotNull(c, "c is null");
// Assert.IsNotNull(c, "System.Void not found"); Assert.AreEqual("System.Environment.SpecialFolder", c.FullyQualifiedName);
// Assert.AreSame(c.DefaultReturnType, VoidReturnType.Instance, "VoidReturnType.Instance is c.DefaultReturnType"); }
// }
// [Test]
// class TestClass<A, B> where A : B { public void VoidTest()
// public void TestMethod<K, V>(string param) where V: K where K: IComparable {} {
// IClass c = pc.GetClass("System.Void");
// public void GetIndex<T>(T element) where T: IEquatable<T> {} Assert.IsNotNull(c, "System.Void not found");
// } Assert.AreSame(c.DefaultReturnType, VoidReturnType.Instance, "VoidReturnType.Instance is c.DefaultReturnType");
// }
// [Test]
// public void ReflectionParserTest() class TestClass<A, B> where A : B {
// { public void TestMethod<K, V>(string param) where V: K where K: IComparable {}
// ICompilationUnit cu = new ReflectionProjectContent("TestName", "testlocation", new AssemblyName[0]).AssemblyCompilationUnit;
// IClass c = new ReflectionClass(cu, typeof(TestClass<,>), typeof(TestClass<,>).FullName, null); public void GetIndex<T>(T element) where T: IEquatable<T> {}
// cu.ProjectContent.AddClassToNamespaceList(c); }
//
// CheckClass(c); [Test]
// MemoryStream memory = new MemoryStream(); public void ReflectionParserTest()
// DomPersistence.WriteProjectContent((ReflectionProjectContent)cu.ProjectContent, memory); {
// ICompilationUnit cu = new ReflectionProjectContent("TestName", "testlocation", new AssemblyName[0], ParserService.DefaultProjectContentRegistry).AssemblyCompilationUnit;
// memory.Position = 0; IClass c = new ReflectionClass(cu, typeof(TestClass<,>), typeof(TestClass<,>).FullName, null);
// foreach (IClass c2 in DomPersistence.LoadProjectContent(memory).Classes) { cu.ProjectContent.AddClassToNamespaceList(c);
// CheckClass(c2);
// } CheckClass(c);
// } MemoryStream memory = new MemoryStream();
// DomPersistence.WriteProjectContent((ReflectionProjectContent)cu.ProjectContent, memory);
// void CheckClass(IClass c)
// { memory.Position = 0;
// Assert.AreSame(c, c.TypeParameters[0].Class); foreach (IClass c2 in DomPersistence.LoadProjectContent(memory, ParserService.DefaultProjectContentRegistry).Classes) {
// Assert.AreSame(c, c.TypeParameters[1].Class); CheckClass(c2);
// 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); void CheckClass(IClass c)
// Assert.AreEqual("K", m.TypeParameters[0].Name); {
// Assert.AreEqual("V", m.TypeParameters[1].Name); Assert.AreSame(c, c.TypeParameters[0].Class);
// Assert.AreSame(m, m.TypeParameters[0].Method); Assert.AreSame(c, c.TypeParameters[1].Class);
// Assert.AreSame(m, m.TypeParameters[1].Method); Assert.AreSame(c.TypeParameters[1], ((GenericReturnType)c.TypeParameters[0].Constraints[0]).TypeParameter);
//
// Assert.AreEqual("IComparable", m.TypeParameters[0].Constraints[0].Name); IMethod m = c.Methods.Find(delegate(IMethod me) { return me.Name == "TestMethod"; });
// GenericReturnType kConst = (GenericReturnType)m.TypeParameters[1].Constraints[0]; Assert.IsNotNull(m);
// Assert.AreSame(m.TypeParameters[0], kConst.TypeParameter); Assert.AreEqual("K", m.TypeParameters[0].Name);
// Assert.AreEqual("V", m.TypeParameters[1].Name);
// m = c.Methods.Find(delegate(IMethod me) { return me.Name == "GetIndex"; }); Assert.AreSame(m, m.TypeParameters[0].Method);
// Assert.IsNotNull(m); Assert.AreSame(m, m.TypeParameters[1].Method);
// Assert.AreEqual("T", m.TypeParameters[0].Name);
// Assert.AreSame(m, m.TypeParameters[0].Method); Assert.AreEqual("IComparable", m.TypeParameters[0].Constraints[0].Name);
// GenericReturnType kConst = (GenericReturnType)m.TypeParameters[1].Constraints[0];
// Assert.AreEqual("IEquatable", m.TypeParameters[0].Constraints[0].Name); Assert.AreSame(m.TypeParameters[0], kConst.TypeParameter);
// Assert.AreEqual(1, m.TypeParameters[0].Constraints[0].TypeParameterCount);
// Assert.AreEqual(1, m.TypeParameters[0].Constraints[0].CastToConstructedReturnType().TypeArguments.Count); m = c.Methods.Find(delegate(IMethod me) { return me.Name == "GetIndex"; });
// GenericReturnType grt = (GenericReturnType)m.TypeParameters[0].Constraints[0].CastToConstructedReturnType().TypeArguments[0]; Assert.IsNotNull(m);
// Assert.AreSame(m.TypeParameters[0], grt.TypeParameter); 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);
}
} }
} }

248
src/Main/Base/Test/SearchClassTests.cs
Unescape View File

@ -15,128 +15,130 @@ namespace ICSharpCode.SharpDevelop.Tests
[TestFixture] [TestFixture]
public class SearchClassTests public class SearchClassTests
{ {
// #region Helper methods ProjectContentRegistry projectContentRegistry = ParserService.DefaultProjectContentRegistry;
// ICompilationUnit Prepare(LanguageProperties language)
// { #region Helper methods
// DefaultProjectContent pc = new DefaultProjectContent(); ICompilationUnit Prepare(LanguageProperties language)
// pc.ReferencedContents.Add(ProjectContentRegistry.Mscorlib); {
// pc.Language = language; DefaultProjectContent pc = new DefaultProjectContent();
// DefaultCompilationUnit cu = new DefaultCompilationUnit(pc); pc.ReferencedContents.Add(projectContentRegistry.Mscorlib);
// if (language == LanguageProperties.VBNet) pc.Language = language;
// cu.Usings.Add(CreateUsing(pc, "syStEm")); DefaultCompilationUnit cu = new DefaultCompilationUnit(pc);
// else if (language == LanguageProperties.VBNet)
// cu.Usings.Add(CreateUsing(pc, "System")); cu.Usings.Add(CreateUsing(pc, "syStEm"));
// return cu; else
// } cu.Usings.Add(CreateUsing(pc, "System"));
// return cu;
// IUsing CreateUsing(IProjectContent pc, string @namespace) }
// {
// DefaultUsing @using = new DefaultUsing(pc); IUsing CreateUsing(IProjectContent pc, string @namespace)
// @using.Usings.Add(@namespace); {
// return @using; DefaultUsing @using = new DefaultUsing(pc);
// } @using.Usings.Add(@namespace);
// return @using;
// IReturnType SearchType(string type) }
// {
// ICompilationUnit cu = Prepare(LanguageProperties.CSharp); IReturnType SearchType(string type)
// IReturnType c = cu.ProjectContent.SearchType(new SearchTypeRequest(type, 0, null, cu, 1, 1)).Result; {
// Assert.IsNotNull(c, type + "not found"); ICompilationUnit cu = Prepare(LanguageProperties.CSharp);
// return c; 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 SearchTypeVB(string type)
// IReturnType c = cu.ProjectContent.SearchType(new SearchTypeRequest(type, 0, null, cu, 1, 1)).Result; {
// Assert.IsNotNull(c, type + "not found"); ICompilationUnit cu = Prepare(LanguageProperties.VBNet);
// return c; 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 CheckNamespace(string @namespace, string className)
// } {
// CheckNamespace(@namespace, className, LanguageProperties.CSharp);
// void CheckNamespaceVB(string @namespace, string className) }
// {
// CheckNamespace(@namespace, className, LanguageProperties.VBNet); void CheckNamespaceVB(string @namespace, string className)
// } {
// CheckNamespace(@namespace, className, LanguageProperties.VBNet);
// void CheckNamespace(string @namespace, string className, LanguageProperties language) }
// {
// ICompilationUnit cu = Prepare(language); void CheckNamespace(string @namespace, string className, LanguageProperties language)
// string ns = cu.ProjectContent.SearchNamespace(@namespace, null, cu, 1, 1); {
// Assert.IsNotNull(ns, @namespace + " not found"); ICompilationUnit cu = Prepare(language);
// foreach (object o in cu.ProjectContent.GetNamespaceContents(ns)) { string ns = cu.ProjectContent.SearchNamespace(@namespace, null, cu, 1, 1);
// IClass c = o as IClass; Assert.IsNotNull(ns, @namespace + " not found");
// if (c != null && c.Name == className) foreach (object o in cu.ProjectContent.GetNamespaceContents(ns)) {
// return; IClass c = o as IClass;
// } if (c != null && c.Name == className)
// } return;
// #endregion }
// }
// [Test] #endregion
// public void SearchFullyQualifiedClass()
// { [Test]
// Assert.AreEqual("System.Reflection.Assembly", SearchType("System.Reflection.Assembly").FullyQualifiedName); public void SearchFullyQualifiedClass()
// } {
// Assert.AreEqual("System.Reflection.Assembly", SearchType("System.Reflection.Assembly").FullyQualifiedName);
// [Test] }
// public void SearchFullyQualifiedClassVB()
// { [Test]
// Assert.AreEqual("System.Reflection.Assembly", SearchTypeVB("SYStem.RefleCtion.asSembly").FullyQualifiedName); public void SearchFullyQualifiedClassVB()
// } {
// Assert.AreEqual("System.Reflection.Assembly", SearchTypeVB("SYStem.RefleCtion.asSembly").FullyQualifiedName);
// [Test] }
// public void SearchFullyQualifiedNamespace()
// { [Test]
// CheckNamespace("System.Collections.Generic", "KeyNotFoundException"); public void SearchFullyQualifiedNamespace()
// } {
// CheckNamespace("System.Collections.Generic", "KeyNotFoundException");
// [Test] }
// public void SearchFullyQualifiedNamespaceVB()
// { [Test]
// CheckNamespaceVB("SyStem.COllEctions.GeNEric", "KeyNotFoundException"); public void SearchFullyQualifiedNamespaceVB()
// } {
// CheckNamespaceVB("SyStem.COllEctions.GeNEric", "KeyNotFoundException");
// [Test] }
// public void SearchEnvironment()
// { [Test]
// Assert.AreEqual("System.Environment", SearchType("Environment").FullyQualifiedName); public void SearchEnvironment()
// } {
// Assert.AreEqual("System.Environment", SearchType("Environment").FullyQualifiedName);
// [Test] }
// public void SearchEnvironmentVB()
// { [Test]
// Assert.AreEqual("System.Environment", SearchTypeVB("EnVIroNmEnt").FullyQualifiedName); public void SearchEnvironmentVB()
// } {
// Assert.AreEqual("System.Environment", SearchTypeVB("EnVIroNmEnt").FullyQualifiedName);
// [Test] }
// public void SearchArrayList()
// { [Test]
// ICompilationUnit cu = Prepare(LanguageProperties.CSharp); public void SearchArrayList()
// 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#"); 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()
// { [Test]
// Assert.AreEqual("System.Collections.ArrayList", SearchTypeVB("CoLLections.ArrAyLiSt").FullyQualifiedName); public void SearchArrayListVB()
// } {
// Assert.AreEqual("System.Collections.ArrayList", SearchTypeVB("CoLLections.ArrAyLiSt").FullyQualifiedName);
// [Test] }
// public void SearchNestedNamespace()
// { [Test]
// ICompilationUnit cu = Prepare(LanguageProperties.CSharp); public void SearchNestedNamespace()
// string ns = cu.ProjectContent.SearchNamespace("Collections.Generic", null, cu, 1, 1); {
// Assert.IsNull(ns, "Nested namespaces should not be found in C#"); 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()
// { [Test]
// CheckNamespaceVB("COllEctions.GeNEric", "KeyNotFoundException"); public void SearchNestedNamespaceVB()
// } {
CheckNamespaceVB("COllEctions.GeNEric", "KeyNotFoundException");
}
} }
} }

160
src/Main/Base/Test/SearchGenericClassTests.cs
Unescape View File

@ -16,84 +16,86 @@ namespace ICSharpCode.SharpDevelop.Tests
[TestFixture] [TestFixture]
public class SearchGenericClassTests public class SearchGenericClassTests
{ {
// #region Helper methods ProjectContentRegistry projectContentRegistry = ParserService.DefaultProjectContentRegistry;
// ICompilationUnit Prepare(LanguageProperties language)
// { #region Helper methods
// DefaultProjectContent pc = new DefaultProjectContent(); ICompilationUnit Prepare(LanguageProperties language)
// pc.ReferencedContents.Add(ProjectContentRegistry.Mscorlib); {
// pc.Language = language; DefaultProjectContent pc = new DefaultProjectContent();
// DefaultCompilationUnit cu = new DefaultCompilationUnit(pc); pc.ReferencedContents.Add(projectContentRegistry.Mscorlib);
// if (language == LanguageProperties.VBNet) { pc.Language = language;
// cu.Usings.Add(CreateUsing(pc, "syStEm.coLLectIons")); DefaultCompilationUnit cu = new DefaultCompilationUnit(pc);
// pc.DefaultImports = new DefaultUsing(pc); if (language == LanguageProperties.VBNet) {
// pc.DefaultImports.Usings.Add("syStEm"); cu.Usings.Add(CreateUsing(pc, "syStEm.coLLectIons"));
// pc.DefaultImports.Usings.Add("syStEm.coLLEctionS.GeNeRic"); pc.DefaultImports = new DefaultUsing(pc);
// } else { pc.DefaultImports.Usings.Add("syStEm");
// cu.Usings.Add(CreateUsing(pc, "System")); pc.DefaultImports.Usings.Add("syStEm.coLLEctionS.GeNeRic");
// cu.Usings.Add(CreateUsing(pc, "System.Collections")); } else {
// cu.Usings.Add(CreateUsing(pc, "System.Collections.Generic")); cu.Usings.Add(CreateUsing(pc, "System"));
// } cu.Usings.Add(CreateUsing(pc, "System.Collections"));
// return cu; cu.Usings.Add(CreateUsing(pc, "System.Collections.Generic"));
// } }
// return cu;
// IUsing CreateUsing(IProjectContent pc, string @namespace) }
// {
// DefaultUsing @using = new DefaultUsing(pc); IUsing CreateUsing(IProjectContent pc, string @namespace)
// @using.Usings.Add(@namespace); {
// return @using; DefaultUsing @using = new DefaultUsing(pc);
// } @using.Usings.Add(@namespace);
// return @using;
// IReturnType SearchType(string type, int typeParameterCount) }
// {
// ICompilationUnit cu = Prepare(LanguageProperties.CSharp); IReturnType SearchType(string type, int typeParameterCount)
// IReturnType c = cu.ProjectContent.SearchType(new SearchTypeRequest(type, typeParameterCount, null, cu, 1, 1)).Result; {
// Assert.IsNotNull(c, type + "not found"); ICompilationUnit cu = Prepare(LanguageProperties.CSharp);
// return c; 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 SearchTypeVB(string type, int typeParameterCount)
// IReturnType c = cu.ProjectContent.SearchType(new SearchTypeRequest(type, typeParameterCount, null, cu, 1, 1)).Result; {
// Assert.IsNotNull(c, type + "not found"); ICompilationUnit cu = Prepare(LanguageProperties.VBNet);
// return c; 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); void CheckType(string shortName, string vbShortName, string fullType, int typeParameterCount)
// Assert.AreEqual(fullType, type.FullyQualifiedName); {
// Assert.AreEqual(typeParameterCount, type.TypeParameterCount); IReturnType type = SearchType(shortName, typeParameterCount);
// type = SearchTypeVB(vbShortName, typeParameterCount); Assert.AreEqual(fullType, type.FullyQualifiedName);
// Assert.AreEqual(fullType, type.FullyQualifiedName); Assert.AreEqual(typeParameterCount, type.TypeParameterCount);
// Assert.AreEqual(typeParameterCount, type.TypeParameterCount); type = SearchTypeVB(vbShortName, typeParameterCount);
// } Assert.AreEqual(fullType, type.FullyQualifiedName);
// #endregion Assert.AreEqual(typeParameterCount, type.TypeParameterCount);
// }
// // EventHandler vs. EventHandler<TEventArgs> #endregion
// // both mscorlib, both namespace System
// [Test] public void FindEventHandler() { // EventHandler vs. EventHandler<TEventArgs>
// CheckType("EventHandler", "EvEnThAndler", "System.EventHandler", 0); // both mscorlib, both namespace System
// } [Test] public void FindEventHandler() {
// [Test] public void FindGenericEventHandler() { CheckType("EventHandler", "EvEnThAndler", "System.EventHandler", 0);
// CheckType("EventHandler", "EvEnThAndler", "System.EventHandler", 1); }
// } [Test] public void FindGenericEventHandler() {
// CheckType("EventHandler", "EvEnThAndler", "System.EventHandler", 1);
// }
// [Test] public void FindNullableClass() {
// CheckType("Nullable", "NuLLable", "System.Nullable", 0);
// } [Test] public void FindNullableClass() {
// [Test] public void FindNullableStruct() { CheckType("Nullable", "NuLLable", "System.Nullable", 0);
// CheckType("Nullable", "NuLLable", "System.Nullable", 1); }
// } [Test] public void FindNullableStruct() {
// CheckType("Nullable", "NuLLable", "System.Nullable", 1);
// // ICollection vs. ICollection<T> }
// // both mscorlib, different namespaces
// [Test] public void FindCollection() { // ICollection vs. ICollection<T>
// CheckType("ICollection", "IColLEction", "System.Collections.ICollection", 0); // both mscorlib, different namespaces
// } [Test] public void FindCollection() {
// [Test] public void FindGenericCollection() { CheckType("ICollection", "IColLEction", "System.Collections.ICollection", 0);
// CheckType("ICollection", "IColLEction", "System.Collections.Generic.ICollection", 1); }
// } [Test] public void FindGenericCollection() {
CheckType("ICollection", "IColLEction", "System.Collections.Generic.ICollection", 1);
}
} }
} }

1
src/Main/Base/Test/Services_Navigation/NavigationServiceTestFixture.cs
Unescape View File

@ -477,7 +477,6 @@ namespace NavigationServiceTests
} }
[Test] [Test]
[Ignore("System.NullReferenceException: Object reference not set to an instance of an object.")]
/// <summary> /// <summary>
/// The <see cref="NavigationService"/> must /// The <see cref="NavigationService"/> must
/// expose a method to generate an /// expose a method to generate an

2
src/Main/ICSharpCode.SharpDevelop.Dom/Project/Src/ReflectionLayer/DomPersistence.cs
Unescape View File

@ -171,7 +171,7 @@ namespace ICSharpCode.SharpDevelop.Dom
return LoadProjectContent(stream, registry); return LoadProjectContent(stream, registry);
} }
internal static ReflectionProjectContent LoadProjectContent(Stream stream, ProjectContentRegistry registry) public static ReflectionProjectContent LoadProjectContent(Stream stream, ProjectContentRegistry registry)
{ {
ReflectionProjectContent pc; ReflectionProjectContent pc;
BinaryReader reader = new BinaryReader(stream); BinaryReader reader = new BinaryReader(stream);

Write Preview
Loading…
Cancel
Save