nrefactoryresolvertests.cs

SharpDevelop2.0.0 c#开发免费工具

	public string Property {
		set {
			
		}
	}
}
";
			LocalResolveResult result = Resolve<LocalResolveResult>(program, "value", 4);
			Assert.AreEqual("System.String", result.ResolvedType.FullyQualifiedName);
			MemberResolveResult mrr = Resolve<MemberResolveResult>(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<LocalResolveResult>(program, "e", 5);
			Assert.AreEqual("System.EventArgs", result.ResolvedType.FullyQualifiedName);
		}
		
		[Test]
		public void DefaultTypeCSharp()
		{
			string program = @"class A {
	void Method() {
		
	} }
";
			ResolveResult result = Resolve<TypeResolveResult>(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<TypeResolveResult>(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<TypeResolveResult>(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<TypeResolveResult>(program, "Activator", 5);
			Assert.AreEqual("System.Activator", result.ResolvedType.FullyQualifiedName);
		}

		[Test]
		public void FullyQualifiedTypeOutsideClass()
		{
			string program = @"class A {
	
}

class B {
	
}
";
			ResolveResult result = Resolve<TypeResolveResult>(program, "System.Activator", 4);
			Assert.AreEqual("System.Activator", result.ResolvedType.FullyQualifiedName);
		}
		
		[Test]
		public void InnerClassTest()
		{
			string program = @"using System;
class A {
	
}
";
			ResolveResult result = Resolve<TypeResolveResult>(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<TypeResolveResult>(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<TypeResolveResult>(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(ICSharpCode.NRefactory.Parser.SupportedLanguage.CSharp);
			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<LocalResolveResult>(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<TypeResolveResult>(program, "Collections.ArrayList", 4);
			Assert.AreEqual("System.Collections.ArrayList", type.ResolvedClass.FullyQualifiedName, "TypeResolveResult");
			LocalResolveResult local = ResolveVB<LocalResolveResult>(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<TypeResolveResult>(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<LocalResolveResult>(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<NamespaceResolveResult>(program, "COL", 3);
			Assert.AreEqual("System.Collections", ns.Name, "COL");
			ns = Resolve<NamespaceResolveResult>(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<TypeResolveResult>(program, "COL", 4);
			Assert.AreEqual("System.Collections.ArrayList", rr.ResolvedClass.FullyQualifiedName, "COL");
			LocalResolveResult lr = Resolve<LocalResolveResult>(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<MemberResolveResult>(importClassProgram, "Pi", 6);
			Assert.AreEqual("System.Math.PI", mrr.ResolvedMember.FullyQualifiedName);
			mrr = ResolveVB<MemberResolveResult>(importClassProgram, "Pi.ToString()", 6);
			Assert.AreEqual("System.Double.ToString", mrr.ResolvedMember.FullyQualifiedName);
		}
		
		[Test]
		public void TestImportClassMethod()
		{
			MemberResolveResult mrr = ResolveVB<MemberResolveResult>(importClassProgram, "Sin(3)", 6);
			Assert.AreEqual("System.Math.Sin", mrr.ResolvedMember.FullyQualifiedName);
			mrr = ResolveVB<MemberResolveResult>(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
	}
}