Implement more EnvDTE.CodeClass2 tests.

src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeClass.cs

@@ -11,11 +11,6 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 {
 	public class CodeClass : CodeType, global::EnvDTE.CodeClass
 	{
-		public CodeClass(CodeModelContext context, ITypeDefinitionModel typeModel)
-			: base(context, typeModel)
-		{
-		}
-		
 		public CodeClass(CodeModelContext context, ITypeDefinition typeDefinition)
 			: base(context, typeDefinition)
 		{
@@ -31,16 +26,14 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 		
 		public virtual global::EnvDTE.CodeElements ImplementedInterfaces {
 			get {
-				var list = new CodeElementsList<CodeType>();
-				var td = typeModel.Resolve();
-				if (td != null) {
-					foreach (var baseType in td.GetAllBaseTypes().Where(t => t.Kind == TypeKind.Interface)) {
-						CodeType element = Create(context, baseType);
-						if (element != null)
-							list.Add(element);
+				var interfaces = new CodeElementsList<CodeType>();
+				foreach (IType baseType in typeDefinition.DirectBaseTypes.Where(t => t.Kind == TypeKind.Interface)) {
+					CodeType element = Create(context, baseType);
+					if (element != null) {
+						interfaces.Add(element);
 					}
 				}
-				return list;
+				return interfaces;
 			}
 		}
 		

src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeClass2.cs

@@ -4,17 +4,11 @@
 using System;
 using System.Linq;
 using ICSharpCode.NRefactory.TypeSystem;
-using ICSharpCode.SharpDevelop.Dom;
 
 namespace ICSharpCode.PackageManagement.EnvDTE
 {
 	public class CodeClass2 : CodeClass, global::EnvDTE.CodeClass2
 	{
-		public CodeClass2(CodeModelContext context, ITypeDefinitionModel typeModel)
-			: base(context, typeModel)
-		{
-		}
-		
 		public CodeClass2(CodeModelContext context, ITypeDefinition typeDefinition)
 			: base(context, typeDefinition)
 		{
@@ -22,50 +16,50 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 		
 		public global::EnvDTE.CodeElements PartialClasses {
 			get {
-				var list = new CodeElementsList<CodeType>();
-				ITypeDefinition typeDefinition = typeModel.Resolve();
-				if (typeDefinition != null) {
-					foreach (string fileName in typeDefinition.Parts.Select(p => p.UnresolvedFile.FileName).Distinct()) {
-						CodeModelContext newContext = context.WithFilteredFileName(fileName);
-						list.Add(CodeType.Create(newContext, typeModel));
-					}
-				} else {
-					list.Add(this);
-				}
-				return list;
+				var partialClasses = new CodeElementsList<CodeType>();
+//				ITypeDefinition typeDefinition = typeModel.Resolve();
+//				if (typeDefinition != null) {
+//					foreach (string fileName in typeDefinition.Parts.Select(p => p.UnresolvedFile.FileName).Distinct()) {
+//						CodeModelContext newContext = context.WithFilteredFileName(fileName);
+//						list.Add(CodeType.Create(newContext, typeDefinition));
+//					}
+//				} else {
+					partialClasses.Add(this);
+//				}
+				return partialClasses;
 			}
 		}
 		
 		public bool IsGeneric {
-			get { return typeModel.FullTypeName.TypeParameterCount > 0; }
+			get { return typeDefinition.FullTypeName.TypeParameterCount > 0; }
 		}
 		
 		public global::EnvDTE.vsCMClassKind ClassKind {
 			get {
-				if (typeModel.IsPartial) {
-					return global::EnvDTE.vsCMClassKind.vsCMClassKindPartialClass;
-				}
+				//if (typeDefinition.IsPartial) {
+				//	return global::EnvDTE.vsCMClassKind.vsCMClassKindPartialClass;
+				//}
 				return global::EnvDTE.vsCMClassKind.vsCMClassKindMainClass;
 			}
 			set {
-				if (value == this.ClassKind) {
-					return;
-				}
-				
-				if (value == global::EnvDTE.vsCMClassKind.vsCMClassKindPartialClass) {
-					ITypeDefinition typeDefinition = typeModel.Resolve();
-					if (typeDefinition == null) {
-						throw new NotSupportedException();
-					}
-					context.CodeGenerator.MakePartial(typeDefinition);
-				} else {
-					throw new NotSupportedException();
-				}
+//				if (value == this.ClassKind) {
+//					return;
+//				}
+//				
+//				if (value == global::EnvDTE.vsCMClassKind.vsCMClassKindPartialClass) {
+//					ITypeDefinition typeDefinition = typeModel.Resolve();
+//					if (typeDefinition == null) {
+//						throw new NotSupportedException();
+//					}
+//					context.CodeGenerator.MakePartial(typeDefinition);
+//				} else {
+					throw new NotImplementedException();
+//				}
 			}
 		}
 		
 		public bool IsAbstract {
-			get { return typeModel.IsAbstract; }
+			get { return typeDefinition.IsAbstract; }
 		}
 	}
 }

src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeElement.cs

@@ -42,11 +42,11 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 			}
 		}
 		
-		internal static CodeElement CreateMember(CodeModelContext context, IMemberModel m)
+		internal static CodeElement CreateMember(CodeModelContext context, IMember member)
 		{
-			switch (m.SymbolKind) {
+			switch (member.SymbolKind) {
 				case SymbolKind.Field:
-					return new CodeVariable(context, m.Resolve() as IField);
+					return new CodeVariable(context, (IField)member);
 				case SymbolKind.Property:
 				case SymbolKind.Indexer:
 //					return new CodeProperty2(m);
@@ -57,7 +57,7 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 				case SymbolKind.Operator:
 				case SymbolKind.Constructor:
 				case SymbolKind.Destructor:
-					return new CodeFunction2(context, (IMethodModel)m);
+					return new CodeFunction2(context, (IMethod)member);
 				default:
 					throw new NotSupportedException("Invalid value for SymbolKind");
 			}
@@ -107,7 +107,7 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 			return context.FilteredFileName == region.FileName;
 		}
 		
-		protected CodeElementsList<CodeAttribute2> GetAttributes(IEntityModel entityModel)
+		protected CodeElementsList<CodeAttribute2> GetAttributes(IEntity entity)
 		{
 			var attributes = new CodeElementsList<CodeAttribute2>();
 			foreach (IAttribute attribute in entity.Attributes) {

src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeFunction.cs

@@ -3,16 +3,15 @@
 
 using System;
 using ICSharpCode.NRefactory.TypeSystem;
-using ICSharpCode.SharpDevelop.Dom;
 
 namespace ICSharpCode.PackageManagement.EnvDTE
 {
 	public class CodeFunction : CodeElement, global::EnvDTE.CodeFunction
 	{
-		protected readonly IMethodModel methodModel;
+		protected readonly IMethod method;
 		
-		public CodeFunction(CodeModelContext context, IMethodModel methodModel)
-			: base(context, methodModel)
+		public CodeFunction(CodeModelContext context, IMethod method)
+			: base(context, method)
 		{
 		}
 		
@@ -25,49 +24,40 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 		}
 		
 		public virtual global::EnvDTE.vsCMAccess Access {
-			get { return methodModel.Accessibility.ToAccess(); }
+			get { return method.Accessibility.ToAccess(); }
 			set {
-				var method = methodModel.Resolve();
-				if (method == null)
-					throw new NotSupportedException();
-				context.CodeGenerator.ChangeAccessibility(method, value.ToAccessibility());
+//				var method = method.Resolve();
+//				if (method == null)
+//					throw new NotSupportedException();
+//				context.CodeGenerator.ChangeAccessibility(method, value.ToAccessibility());
 			}
 		}
 		
 		public virtual global::EnvDTE.CodeElements Parameters {
 			get {
-				var list = new CodeElementsList<CodeParameter2>();
-				var method = (IParameterizedMember)methodModel.Resolve();
-				if (method != null) {
-					foreach (var p in method.Parameters) {
-						list.Add(new CodeParameter2(context, p));
-					}
+				var parameters = new CodeElementsList<CodeParameter2>();
+				foreach (IParameter parameter in method.Parameters) {
+					parameters.Add(new CodeParameter2(context, parameter));
 				}
-				return list;
+				return parameters;
 			}
 		}
 		
 		public virtual global::EnvDTE.CodeTypeRef2 Type {
 			get {
-				var method = methodModel.Resolve();
-				if (method == null)
-					return null;
 				return new CodeTypeRef2(context, this, method.ReturnType);
 			}
 		}
 		
 		public virtual global::EnvDTE.CodeElements Attributes {
-			get { return GetAttributes(methodModel); }
+			get { return GetAttributes(method); }
 		}
 		
 		public virtual bool CanOverride {
-			get { return methodModel.IsOverridable; }
+			get { return method.IsOverridable; }
 			set {
-				if (value && !methodModel.IsOverridable) {
-					var method = methodModel.Resolve();
-					if (method != null) {
-						context.CodeGenerator.MakeVirtual(method);
-					}
+				if (value && !method.IsOverridable) {
+					context.CodeGenerator.MakeVirtual(method);
 				}
 			}
 		}
@@ -78,7 +68,7 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 		
 		global::EnvDTE.vsCMFunction GetFunctionKind()
 		{
-			switch (methodModel.SymbolKind) {
+			switch (method.SymbolKind) {
 				case SymbolKind.Constructor:
 					return global::EnvDTE.vsCMFunction.vsCMFunctionConstructor;
 				//case SymbolKind.Destructor:
@@ -90,11 +80,11 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 		}
 		
 		public virtual bool IsShared {
-			get { return methodModel.IsStatic; }
+			get { return method.IsStatic; }
 		}
 		
 		public virtual bool MustImplement {
-			get { return methodModel.IsAbstract; }
+			get { return method.IsAbstract; }
 		}
 	}
 }

src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeFunction2.cs

@@ -2,19 +2,19 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
-using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.NRefactory.TypeSystem;
 
 namespace ICSharpCode.PackageManagement.EnvDTE
 {
 	public class CodeFunction2 : CodeFunction, global::EnvDTE.CodeFunction2
 	{
-		public CodeFunction2(CodeModelContext context, IMethodModel methodModel)
-			: base(context, methodModel)
+		public CodeFunction2(CodeModelContext context, IMethod method)
+			: base(context, method)
 		{
 		}
 		
 		public virtual bool IsGeneric {
-			get { return methodModel.TypeParameterCount > 0; }
+			get { return method.TypeParameters.Count > 0; }
 		}
 		
 		public virtual global::EnvDTE.vsCMOverrideKind OverrideKind {
@@ -24,15 +24,15 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 		global::EnvDTE.vsCMOverrideKind GetOverrideKind()
 		{
 			global::EnvDTE.vsCMOverrideKind kind = 0;
-			if (methodModel.IsAbstract)
+			if (method.IsAbstract)
 				kind |= global::EnvDTE.vsCMOverrideKind.vsCMOverrideKindAbstract;
-			if (methodModel.IsOverride)
+			if (method.IsOverride)
 				kind |= global::EnvDTE.vsCMOverrideKind.vsCMOverrideKindOverride;
-			if (methodModel.IsVirtual && !methodModel.IsAbstract && !methodModel.IsOverride)
+			if (method.IsVirtual && !method.IsAbstract && !method.IsOverride)
 				kind |= global::EnvDTE.vsCMOverrideKind.vsCMOverrideKindVirtual;
-			if (methodModel.IsSealed)
+			if (method.IsSealed)
 				kind |= global::EnvDTE.vsCMOverrideKind.vsCMOverrideKindSealed;
-			if (methodModel.IsShadowing)
+			if (method.IsShadowing)
 				kind |= global::EnvDTE.vsCMOverrideKind.vsCMOverrideKindNew;
 			return kind;
 		}

src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeInterface.cs

@@ -2,6 +2,8 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
+using System.Linq;
+using System.Text;
 using ICSharpCode.NRefactory.TypeSystem;
 using ICSharpCode.SharpDevelop.Dom;
 
@@ -11,28 +13,27 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 	{
 		string fullName;
 		
-//		public CodeInterface(IProjectContent projectContent, IClass c)
-//			: base(projectContent, c)
-//		{
-//		}
-		
-		public CodeInterface(CodeModelContext context, ITypeDefinitionModel typeModel)
-			: base(context, typeModel)
+		public CodeInterface(CodeModelContext context, ITypeDefinition typeDefinition, params IType[] typeArguments)
+			: base(context, typeDefinition)
 		{
-//			fullName = base.FullName;
+			fullName = GetFullName(typeArguments);
 		}
 		
-		public CodeInterface(CodeModelContext context, ITypeDefinition typeDefinition)
-			: base(context, typeDefinition)
+		string GetFullName(IType[] typeArguments)
 		{
-//			fullName = base.FullName;
+			if (typeArguments.Length > 0)
+			{
+				return base.FullName + GetParameterisedTypeName(typeArguments);
+			}
+			return base.FullName;
 		}
 		
-//		public CodeInterface(IProjectContent projectContent, IReturnType type, IClass c)
-//			: base(projectContent, c)
-//		{
-//			fullName = type.GetFullName();
-//		}
+		string GetParameterisedTypeName(IType[] typeArguments)
+		{
+			return String.Format(
+				"<{0}>",
+				String.Join(", ", typeArguments.Select(type => type.FullName)));
+		}
 //		
 //		public override global::EnvDTE.vsCMElement Kind {
 //			get { return global::EnvDTE.vsCMElement.vsCMElementInterface; }
@@ -56,9 +57,9 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 		//	return codeGenerator.AddPublicMethod(name, (string)type);
 			return null;
 		}
-//		
-//		public override string FullName {
-//			get { return fullName; }
-//		}
+		
+		public override string FullName {
+			get { return fullName; }
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeType.cs

@@ -20,35 +20,32 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 		
 		CodeElementsList<CodeElement> members;
 		
-		public static CodeType Create(CodeModelContext context, IType type)
+		internal static CodeType Create(CodeModelContext context, IType type)
 		{
-			ITypeDefinition typeDef = type.GetDefinition();
-			if (typeDef != null) {
-				ITypeDefinitionModel typeModel = typeDef.GetModel();
-				if (typeModel != null) {
-					return Create(context.WithFilteredFileName(null), typeModel);
-				}
+			ITypeDefinition typeDefinition = type.GetDefinition();
+			if (typeDefinition != null) {
+				return Create(context.WithFilteredFileName(null), typeDefinition, type.TypeArguments.ToArray());
 			}
 			return null;
 		}
 		
-		public static CodeType Create(CodeModelContext context, ITypeDefinitionModel typeModel)
+		internal static CodeType Create(
+			CodeModelContext context,
+			ITypeDefinition typeDefinition,
+			params IType[] typeArguments)
 		{
-			switch (typeModel.TypeKind) {
+			switch (typeDefinition.Kind) {
 				case TypeKind.Class:
-				case TypeKind.Module:
-					goto default;
+					return new CodeClass2(context, typeDefinition);
 				case TypeKind.Interface:
-					goto default;
+					return new CodeInterface(context, typeDefinition, typeArguments);
+				case TypeKind.Module:
 				case TypeKind.Struct:
 				case TypeKind.Void:
-					goto default;
 				case TypeKind.Delegate:
-					goto default;
 				case TypeKind.Enum:
-					goto default;
 				default:
-					return new CodeType(context, typeModel);
+					return new CodeType(context, typeDefinition);
 			}
 		}
 		
@@ -123,10 +120,11 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 		public virtual global::EnvDTE.CodeElements Members {
 			get {
 				if (members == null) {
-					members = typeModel.Members
-						.Where(m => IsInFilter(m.Region))
-						.Select(m => CreateMember(context, m))
-						.AsCodeElements();
+					members = new CodeElementsList<CodeElement>();
+					members.AddRange(typeDefinition.Members
+						.Where(member => IsInFilter(member.Region))
+						.Where(member => !member.Region.End.IsEmpty)
+						.Select(member => CreateMember(context, member)));
 				}
 				return members;
 			}
@@ -134,29 +132,28 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 		
 		public virtual global::EnvDTE.CodeElements Bases {
 			get {
-				var list = new CodeElementsList<CodeType>();
-				ITypeDefinition typeDefinition = typeModel.Resolve();
-				if (typeDefinition != null) {
-					IEnumerable<IType> baseTypes;
-					if (typeDefinition.Kind == TypeKind.Interface) {
-						baseTypes = typeDefinition.DirectBaseTypes;
-					} else {
-						baseTypes = typeDefinition.DirectBaseTypes.Where(type => type.Kind != TypeKind.Interface);
-					}
-					foreach (IType baseType in baseTypes) {
-						CodeType element = Create(context, baseType);
-						if (element != null) {
-							list.Add(element);
-						}
+				var types = new CodeElementsList<CodeType>();
+				foreach (IType baseType in GetBaseTypes()) {
+					CodeType element = Create(context, baseType);
+					if (element != null) {
+						types.Add(element);
 					}
 				}
-				return list;
+				return types;
+			}
+		}
+		
+		IEnumerable<IType> GetBaseTypes()
+		{
+			if (typeDefinition.Kind == TypeKind.Interface) {
+				return typeDefinition.DirectBaseTypes;
 			}
+			return typeDefinition.DirectBaseTypes.Where(type => type.Kind != TypeKind.Interface);
 		}
 		
 		public virtual global::EnvDTE.CodeElements Attributes {
 			get {
-				return GetAttributes(typeModel);
+				return GetAttributes(typeDefinition);
 			}
 		}
 		
@@ -166,7 +163,7 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 					return new FileCodeModel2(context, null).GetNamespace(typeModel.Namespace);
 				} else {
 					throw new NotImplementedException();
-				//    return new CodeNamespace(context, typeModel.Namespace);
+				//	return new CodeNamespace(context, typeDefinition.Namespace);
 				}
 			}
 		}

src/AddIns/Misc/PackageManagement/Project/Src/IProjectContentExtensions.cs

@@ -39,15 +39,5 @@ namespace ICSharpCode.PackageManagement
 					throw new Exception("Invalid value for vsCMAccess");
 			}
 		}
-		
-		public static CodeElementsList<T> AsCodeElements<T>(this IModelCollection<T> input)
-			where T : global::EnvDTE.CodeElement
-		{
-			var list = new CodeElementsList<T>();
-			// TODO: react to changes
-			foreach (var element in input)
-				list.Add(element);
-			return list;
-		}
 	}
 }

src/AddIns/Misc/PackageManagement/Test/Src/EnvDTE/CodeClass2Tests.cs

@@ -22,7 +22,17 @@ namespace PackageManagement.Tests.EnvDTE
 		void CreateClass(string code)
 		{
 			AddCodeFile("class.cs", code);
-			ITypeDefinition typeDefinition = assemblyModel.TopLevelTypeDefinitions.Single().Resolve();
+			ITypeDefinition typeDefinition = GetFirstTypeDefinition();
+			CreateClass(typeDefinition);
+		}
+		
+		ITypeDefinition GetFirstTypeDefinition()
+		{
+			return assemblyModel.TopLevelTypeDefinitions.First().Resolve();
+		}
+		
+		void CreateClass(ITypeDefinition typeDefinition)
+		{
 			codeClass = new CodeClass2(codeModelContext, typeDefinition);
 		}
 		
@@ -67,118 +77,123 @@ namespace PackageManagement.Tests.EnvDTE
 			Assert.AreEqual(global::EnvDTE.vsCMAccess.vsCMAccessPrivate, access);
 		}
 		
+		[Test]
+		public void ImplementedInterfaces_ClassImplementsGenericICollectionOfString_ReturnsCodeInterfaceForICollection()
+		{
+			CreateClass(
+				"using System;\r\n" +
+				"using System.Collections.Generic;\r\n" +
+				"class MyClass : ICollection<string> {}");
+			
+			global::EnvDTE.CodeElements codeElements = codeClass.ImplementedInterfaces;
+			
+			CodeInterface codeInterface = codeElements.FirstCodeInterfaceOrDefault();
+			Assert.AreEqual(1, codeElements.Count);
+			Assert.AreEqual("System.Collections.Generic.ICollection<System.String>", codeInterface.FullName);
+		}
+		
+		[Test]
+		public void ImplementedInterfaces_ClassHasBaseTypeButNoInterfaces_ReturnsNoItems()
+		{
+			CreateClass(
+				"namespace MyNamespace {\r\n" +
+				"    public class MyClass : MyBaseClass {}\r\n" +
+				"    public class MyBaseClass {}\r\n" +
+				"}");
+			
+			global::EnvDTE.CodeElements codeElements = codeClass.ImplementedInterfaces;
+			
+			Assert.AreEqual(0, codeElements.Count);
+		}
+		
+		[Test]
+		public void BaseTypes_ClassBaseTypeIsSystemObject_ReturnsSystemObject()
+		{
+			CreateClass("public class MyClass {}");
+			
+			global::EnvDTE.CodeElements codeElements = codeClass.Bases;
+			
+			CodeClass2 baseClass = codeElements.FirstCodeClass2OrDefault();
+			Assert.AreEqual(1, codeElements.Count);
+			Assert.AreEqual("System.Object", baseClass.FullName);
+			Assert.AreEqual("Object", baseClass.Name);
+		}
+		
+		[Test]
+		public void BaseTypes_ClassIsSystemObject_ReturnsNoCodeElements()
+		{
+			CreateClass("public class MyClass {}");
+			ITypeDefinition myClassType = GetFirstTypeDefinition();
+			ITypeDefinition systemObject = myClassType.DirectBaseTypes.First().GetDefinition();
+			CreateClass(systemObject);
+		
+			global::EnvDTE.CodeElements codeElements = codeClass.Bases;
+			
+			Assert.AreEqual(0, codeElements.Count);
+		}
+		
+		[Test]
+		public void Members_ClassHasOneMethod_ReturnsOneMethod()
+		{
+			CreateClass(
+				"public class MyClass {\r\n" +
+				"    public void MyMethod() {}\r\n" +
+				"}");
+			
+			global::EnvDTE.CodeElements codeElements = codeClass.Members;
+			
+			CodeFunction2 codeFunction = codeElements.FirstCodeFunction2OrDefault();
+			Assert.AreEqual(1, codeElements.Count);
+			Assert.AreEqual("MyMethod", codeFunction.Name);
+		}
+		
 //		[Test]
-//		public void ImplementedInterfaces_ClassImplementsGenericICollectionOfString_ReturnsCodeInterfaceForICollection()
+//		public void Members_ClassHasOneProperty_ReturnsOneProperty()
 //		{
 //			CreateClass(
-//				"using System.Collection.Generic;" +
-//				"class MyClass : ICollection<string> {}");
-//			
-//			global::EnvDTE.CodeElements codeElements = codeClass.ImplementedInterfaces;
-//			CodeInterface codeInterface = codeElements.FirstCodeInterfaceOrDefault();
-//			
-//			Assert.AreEqual(1, codeElements.Count);
-//			Assert.AreEqual("System.Collections.Generic.ICollection<System.String>", codeInterface.FullName);
-//		}
-//		
-//		[Test]
-//		public void ImplementedInterfaces_ClassHasBaseTypeButNoInterfaces_ReturnsNoItems()
-//		{
-//			CreateProjectContent();
-//			CreatePublicClass("MyClass");
-//			AddClassToClassBaseTypes("MyNamespace.MyBaseClass");
-//			
-//			global::EnvDTE.CodeElements codeElements = codeClass.ImplementedInterfaces;
-//			
-//			Assert.AreEqual(0, codeElements.Count);
-//		}
-//		
-//		[Test]
-//		public void BaseTypes_ClassBaseTypeIsSystemObject_ReturnsSystemObject()
-//		{
-//			CreateProjectContent();
-//			CreatePublicClass("MyClass");
-//			AddBaseTypeToClass("System.Object");
-//			
-//			global::EnvDTE.CodeElements codeElements = codeClass.Bases;
-//			CodeClass2 baseClass = codeElements.FirstCodeClass2OrDefault();
-//			
-//			Assert.AreEqual(1, codeElements.Count);
-//			Assert.AreEqual("System.Object", baseClass.FullName);
-//			Assert.AreEqual("Object", baseClass.Name);
-//		}
-//		
-//		[Test]
-//		public void BaseTypes_ClassBaseTypeIsNull_ReturnsNoCodeElements()
-//		{
-//			CreateProjectContent();
-//			CreatePublicClass("System.Object");
-//			
-//			global::EnvDTE.CodeElements codeElements = codeClass.Bases;
-//			
-//			Assert.AreEqual(0, codeElements.Count);
-//		}
-//		
-//		[Test]
-//		public void Members_ClassHasOneMethod_ReturnsOneMethod()
-//		{
-//			CreateProjectContent();
-//			CreatePublicClass("MyClass");
-//			AddMethodToClass("MyClass.MyMethod");
+//				"public class MyClass {\r\n" +
+//				"    public int MyProperty { get; set; }\r\n" +
+//				"}");
 //			
 //			global::EnvDTE.CodeElements codeElements = codeClass.Members;
-//			CodeFunction2 codeFunction = codeElements.FirstCodeFunction2OrDefault();
 //			
-//			Assert.AreEqual(1, codeElements.Count);
-//			Assert.AreEqual("MyMethod", codeFunction.Name);
-//		}
-//		
-//		[Test]
-//		public void Members_ClassHasOneProperty_ReturnsOneProperty()
-//		{
-//			CreateProjectContent();
-//			CreatePublicClass("MyClass");
-//			AddPropertyToClass("MyClass.MyProperty");
-//			
-//			global::EnvDTE.CodeElements codeElements = codeClass.Members;
 //			CodeProperty2 codeFunction = codeElements.FirstCodeProperty2OrDefault();
-//			
 //			Assert.AreEqual(1, codeElements.Count);
 //			Assert.AreEqual("MyProperty", codeFunction.Name);
 //		}
-//		
-//		[Test]
-//		public void Members_ClassHasOneField_ReturnsOneField()
-//		{
-//			CreateProjectContent();
-//			CreatePublicClass("MyClass");
-//			AddFieldToClass("MyClass.MyField");
-//			
-//			global::EnvDTE.CodeElements codeElements = codeClass.Members;
-//			CodeVariable codeVariable = codeElements.FirstCodeVariableOrDefault();
-//			
-//			Assert.AreEqual(1, codeElements.Count);
-//			Assert.AreEqual("MyField", codeVariable.Name);
-//		}
-//		
-//		[Test]
-//		public void Kind_PublicClass_ReturnsClass()
-//		{
-//			CreateProjectContent();
-//			CreatePublicClass("MyClass");
-//			
-//			global::EnvDTE.vsCMElement kind = codeClass.Kind;
-//			
-//			Assert.AreEqual(global::EnvDTE.vsCMElement.vsCMElementClass, kind);
-//		}
-//		
+		
+		[Test]
+		public void Members_ClassHasOneField_ReturnsOneField()
+		{
+			CreateClass(
+				"public class MyClass {\r\n" +
+				"    public int MyField;\r\n" +
+				"}");
+			
+			global::EnvDTE.CodeElements codeElements = codeClass.Members;
+			
+			CodeVariable codeVariable = codeElements.FirstCodeVariableOrDefault();
+			Assert.AreEqual(1, codeElements.Count);
+			Assert.AreEqual("MyField", codeVariable.Name);
+		}
+		
+		[Test]
+		public void Kind_PublicClass_ReturnsClass()
+		{
+			CreateClass("public class MyClass {}");
+			
+			global::EnvDTE.vsCMElement kind = codeClass.Kind;
+			
+			Assert.AreEqual(global::EnvDTE.vsCMElement.vsCMElementClass, kind);
+		}
+		
 //		[Test]
 //		public void Namespace_PublicClass_ReturnsClassNamespace()
 //		{
-//			CreateProjectContent();
-//			helper.CreatePublicClass("MyNamespace.Test.MyClass");
-//			helper.AddClassNamespace("MyNamespace.Test");
-//			CreateClass();
+//			CreateClass(
+//				"namespace MyNamespace.Test {\r\n" +
+//				"    public class MyClass {}\r\n" +
+//				"}");
 //			
 //			global::EnvDTE.CodeNamespace codeNamespace = codeClass.Namespace;
 //			
@@ -197,20 +212,18 @@ namespace PackageManagement.Tests.EnvDTE
 //			
 //			Assert.AreEqual("MyNamespace.Test", codeNamespace.Name);
 //		}
-//		
-//		[Test]
-//		public void PartialClasses_ClassIsNotPartial_ReturnsClass()
-//		{
-//			CreateProjectContent();
-//			CreatePublicClass("MyNamespace.MyClass");
-//			CreateClass();
-//			
-//			global::EnvDTE.CodeElements partialClasses = codeClass.PartialClasses;
-//			CodeClass firstClass = partialClasses.FirstCodeClass2OrDefault();
-//			
-//			Assert.AreEqual(1, partialClasses.Count);
-//			Assert.AreEqual(codeClass, firstClass);
-//		}
+		
+		[Test]
+		public void PartialClasses_ClassIsNotPartial_ReturnsClass()
+		{
+			CreateClass("public class MyClass {}");
+			
+			global::EnvDTE.CodeElements partialClasses = codeClass.PartialClasses;
+			
+			CodeClass firstClass = partialClasses.FirstCodeClass2OrDefault();
+			Assert.AreEqual(1, partialClasses.Count);
+			Assert.AreEqual(codeClass, firstClass);
+		}
 //		
 //		[Test]
 //		public void Members_GetFirstPropertyTwice_PropertiesAreConsideredEqualWhenAddedToList()
@@ -227,29 +240,26 @@ namespace PackageManagement.Tests.EnvDTE
 //			bool contains = properties.Contains(property2);
 //			Assert.IsTrue(contains);
 //		}
-//		
-//		[Test]
-//		public void IsAbstract_ClassIsAbstract_ReturnsTrue()
-//		{
-//			CreateProjectContent();
-//			CreatePublicClass("MyClass");
-//			ClassIsAbstract();
-//			
-//			bool isAbstract = codeClass.IsAbstract;
-//			
-//			Assert.IsTrue(isAbstract);
-//		}
-//		
-//		[Test]
-//		public void IsAbstract_ClassIsNotAbstract_ReturnsFalse()
-//		{
-//			CreateProjectContent();
-//			CreatePublicClass("MyClass");
-//			
-//			bool isAbstract = codeClass.IsAbstract;
-//			
-//			Assert.IsFalse(isAbstract);
-//		}
+		
+		[Test]
+		public void IsAbstract_ClassIsAbstract_ReturnsTrue()
+		{
+			CreateClass("public abstract class MyClass {}");
+			
+			bool isAbstract = codeClass.IsAbstract;
+			
+			Assert.IsTrue(isAbstract);
+		}
+		
+		[Test]
+		public void IsAbstract_ClassIsNotAbstract_ReturnsFalse()
+		{
+			CreateClass("public class MyClass {}");
+			
+			bool isAbstract = codeClass.IsAbstract;
+			
+			Assert.IsFalse(isAbstract);
+		}
 //		
 //		[Test]
 //		public void ClassKind_ClassIsPartial_ReturnsPartialClassKind()
@@ -262,41 +272,36 @@ namespace PackageManagement.Tests.EnvDTE
 //			
 //			Assert.AreEqual(global::EnvDTE.vsCMClassKind.vsCMClassKindPartialClass, kind);
 //		}
-//		
-//		[Test]
-//		public void ClassKind_ClassIsNotPartial_ReturnsMainClassKind()
-//		{
-//			CreateProjectContent();
-//			CreatePublicClass("MyClass");
-//			
-//			global::EnvDTE.vsCMClassKind kind = codeClass.ClassKind;
-//			
-//			Assert.AreEqual(global::EnvDTE.vsCMClassKind.vsCMClassKindMainClass, kind);
-//		}
-//		
-//		[Test]
-//		public void IsGeneric_ClassIsGeneric_ReturnsTrue()
-//		{
-//			CreateProjectContent();
-//			CreatePublicClass("MyClass");
-//			ClassIsGeneric();
-//			
-//			bool generic = codeClass.IsGeneric;
-//			
-//			Assert.IsTrue(generic);
-//		}
-//		
-//		[Test]
-//		public void IsGeneric_ClassIsNotGeneric_ReturnsFalse()
-//		{
-//			CreateProjectContent();
-//			CreatePublicClass("MyClass");
-//			ClassIsNotGeneric();
-//			
-//			bool generic = codeClass.IsGeneric;
-//			
-//			Assert.IsFalse(generic);
-//		}
+		
+		[Test]
+		public void ClassKind_ClassIsNotPartial_ReturnsMainClassKind()
+		{
+			CreateClass("public class MyClass {}");
+			
+			global::EnvDTE.vsCMClassKind kind = codeClass.ClassKind;
+			
+			Assert.AreEqual(global::EnvDTE.vsCMClassKind.vsCMClassKindMainClass, kind);
+		}
+		
+		[Test]
+		public void IsGeneric_ClassIsGeneric_ReturnsTrue()
+		{
+			CreateClass("public class MyClass<T> {}");
+			
+			bool generic = codeClass.IsGeneric;
+			
+			Assert.IsTrue(generic);
+		}
+		
+		[Test]
+		public void IsGeneric_ClassIsNotGeneric_ReturnsFalse()
+		{
+			CreateClass("public class MyClass {}");
+			
+			bool generic = codeClass.IsGeneric;
+			
+			Assert.IsFalse(generic);
+		}
 //		
 //		[Test]
 //		public void ClassKind_ChangeClassToBePartial_UsesClassKindUpdaterToModifyClass()
@@ -308,14 +313,27 @@ namespace PackageManagement.Tests.EnvDTE
 //			
 //			classKindUpdater.AssertWasCalled(updater => updater.MakeClassPartial());
 //		}
-//		
-//		[Test]
-//		public void ClassKind_ChangeClassToBeMainClass_ThrowsNotImplementedException()
-//		{
-//			CreateProjectContent();
-//			CreatePublicClass("MyClass");
-//			
-//			Assert.Throws<NotImplementedException>(() => codeClass.ClassKind = global::EnvDTE.vsCMClassKind.vsCMClassKindMainClass);
-//		}
+		
+		[Test]
+		public void ClassKind_ChangeClassToBeMainClass_ThrowsNotImplementedException()
+		{
+			CreateClass("public class MyClass {}");
+			
+			Assert.Throws<NotImplementedException>(() => codeClass.ClassKind = global::EnvDTE.vsCMClassKind.vsCMClassKindMainClass);
+		}
+		
+		[Test]
+		public void ImplementedInterfaces_ClassImplementsIDisposable_ReturnsCodeInterfaceForIDisposable()
+		{
+			CreateClass(
+				"using System;\r\n" +
+				"class MyClass : IDisposable {}");
+			
+			global::EnvDTE.CodeElements codeElements = codeClass.ImplementedInterfaces;
+			
+			CodeInterface codeInterface = codeElements.FirstCodeInterfaceOrDefault();
+			Assert.AreEqual(1, codeElements.Count);
+			Assert.AreEqual("System.IDisposable", codeInterface.FullName);
+		}
 	}
 }