Implement CodeType.Members for fields, methods and properties.

src/AddIns/Misc/PackageManagement/Project/PackageManagement.csproj

@@ -96,6 +96,7 @@
     <Compile Include="Src\EnvDTE\CodeStruct.cs" />
     <Compile Include="Src\EnvDTE\CodeType.cs" />
     <Compile Include="Src\EnvDTE\CodeTypeBaseTypes.cs" />
+    <Compile Include="Src\EnvDTE\CodeTypeMembers.cs" />
     <Compile Include="Src\EnvDTE\CodeTypeRef.cs" />
     <Compile Include="Src\EnvDTE\CodeTypeRef2.cs" />
     <Compile Include="Src\EnvDTE\CodeVariable.cs" />

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

@@ -46,7 +46,7 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 		}
 		
 		public virtual CodeElements Members {
-			get { throw new NotImplementedException(); }
+			get { return new CodeTypeMembers(ProjectContent, Class); }
 		}
 		
 		public virtual CodeElements Bases {

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

@@ -0,0 +1,49 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.SharpDevelop.Dom;
+
+namespace ICSharpCode.PackageManagement.EnvDTE
+{
+	public class CodeTypeMembers : CodeElementsList
+	{
+		IProjectContent projectContent;
+		IClass c;
+		
+		public CodeTypeMembers(IProjectContent projectContent, IClass c)
+		{
+			this.projectContent = projectContent;
+			this.c = c;
+			AddMembers();
+		}
+		
+		void AddMembers()
+		{
+			foreach (IProperty property in c.Properties) {
+				AddProperty(property);
+			}
+			foreach (IField field in c.Fields) {
+				AddField(field);
+			}
+			foreach (IMethod method in c.Methods) {
+				AddMethod(method);
+			}
+		}
+		
+		void AddMethod(IMethod method)
+		{
+			AddCodeElement(new CodeFunction(method));
+		}
+		
+		void AddField(IField field)
+		{
+			AddCodeElement(new CodeVariable(field));
+		}
+		
+		void AddProperty(IProperty property)
+		{
+			AddCodeElement(new CodeProperty2(property));
+		}
+	}
+}

src/AddIns/Misc/PackageManagement/Test/PackageManagement.Tests.csproj

@@ -87,11 +87,14 @@
     <Compile Include="Src\EnvDTE\NamespaceNameTests.cs" />
     <Compile Include="Src\EnvDTE\SolutionTests.cs" />
     <Compile Include="Src\Helpers\AttributeHelper.cs" />
+    <Compile Include="Src\Helpers\ClassHelper.cs" />
     <Compile Include="Src\Helpers\CodeElementsHelpers.cs" />
+    <Compile Include="Src\Helpers\FieldHelper.cs" />
     <Compile Include="Src\Helpers\FakeSelectProjectsService.cs" />
     <Compile Include="Src\Helpers\FakeSolutionPackageRepositoryFactory.cs" />
     <Compile Include="Src\Helpers\FakeUpdatePackageActions.cs" />
     <Compile Include="Src\Helpers\FakeUpdatePackageActionsFactory.cs" />
+    <Compile Include="Src\Helpers\MethodHelper.cs" />
     <Compile Include="Src\Helpers\ProjectContentHelper.cs" />
     <Compile Include="Src\Helpers\PropertiesHelper.cs" />
     <Compile Include="Src\Helpers\PropertyHelper.cs" />

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

@@ -98,7 +98,7 @@ namespace PackageManagement.Tests.EnvDTE
 			
 			CodeElements args = codeAttribute.Arguments;
 			
-			CodeAttributeArgument attributeArg = args.ToList().FirstOrDefault() as CodeAttributeArgument;
+			CodeAttributeArgument attributeArg = args.FirstCodeAttributeArgumentOrDefault();
 			
 			Assert.AreEqual(1, args.Count);
 			Assert.AreEqual(String.Empty, attributeArg.Name);
@@ -114,7 +114,7 @@ namespace PackageManagement.Tests.EnvDTE
 			
 			CodeElements args = codeAttribute.Arguments;
 			
-			CodeAttributeArgument attributeArg = args.ToList().FirstOrDefault() as CodeAttributeArgument;
+			CodeAttributeArgument attributeArg = args.FirstCodeAttributeArgumentOrDefault();
 			
 			Assert.AreEqual("Name", attributeArg.Name);
 			Assert.AreEqual("\"StringValue\"", attributeArg.Value);

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

@@ -14,31 +14,28 @@ namespace PackageManagement.Tests.EnvDTE
 	[TestFixture]
 	public class CodeAttributesTests
 	{
-		IClass fakeClass;
 		CodeAttributes attributes;
-		ProjectContentHelper helper;
+		ClassHelper helper;
 		
 		[SetUp]
 		public void Init()
 		{
-			helper = new ProjectContentHelper();
+			helper = new ClassHelper();
 		}
 		
 		void CreateCodeAttributes()
 		{
-			attributes = new CodeAttributes(fakeClass);
+			attributes = new CodeAttributes(helper.Class);
 		}
 		
 		void CreateMSBuildClass()
 		{
-			fakeClass = helper.AddClassToProjectContent("MyClass");
+			helper.CreateClass("MyClass");
 		}
 		
 		void AddAttributeToClass(string name)
 		{
-			var attributeHelper = new AttributeHelper();
+			helper.AddAttributeToClass(name);
-			attributeHelper.CreateAttribute(name);
-			attributeHelper.AddAttributeToClass(fakeClass);
 		}
 		
 		List<CodeElement> GetEnumerator()
@@ -53,11 +50,9 @@ namespace PackageManagement.Tests.EnvDTE
 			AddAttributeToClass("TestAttribute");
 			CreateCodeAttributes();
 		
-			List<CodeElement> attributeList = GetEnumerator();
+			CodeAttribute2 attribute = attributes.FirstCodeAttribute2OrDefault();
 			
-			CodeAttribute2 attribute = attributeList.FirstOrDefault() as CodeAttribute2;
+			Assert.AreEqual(1, attributes.Count);
-			
-			Assert.AreEqual(1, attributeList.Count);
 			Assert.AreEqual("Test", attribute.Name);
 		}
 		

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

@@ -14,67 +14,81 @@ namespace PackageManagement.Tests.EnvDTE
 	public class CodeClass2Tests
 	{
 		CodeClass2 codeClass;
-		ProjectContentHelper helper;
+		ClassHelper helper;
-		IClass fakeClass;
 		
 		void CreateProjectContent()
 		{
-			helper = new ProjectContentHelper();
+			helper = new ClassHelper();
 		}
 		
 		void CreateClass(string name)
 		{
-			fakeClass = helper.AddClassToProjectContent(name);
+			helper.CreateClass(name);
 			CreateClass();
 		}
 		
 		void CreatePublicClass(string name)
 		{
-			fakeClass = helper.AddPublicClassToProjectContent(name);
+			helper.CreatePublicClass(name);
 			CreateClass();
 		}
 		
 		void CreatePrivateClass(string name)
 		{
-			fakeClass = helper.AddPrivateClassToProjectContent(name);
+			helper.CreatePrivateClass(name);
 			CreateClass();
 		}
 		
 		void CreateClass()
 		{
-			codeClass = new CodeClass2(helper.FakeProjectContent, fakeClass);
+			codeClass = new CodeClass2(helper.ProjectContentHelper.FakeProjectContent, helper.Class);
 		}
 		
 		void AddInterfaceToProjectContent(string fullName)
 		{
-			helper.AddInterfaceToProjectContent(fullName);
+			helper.ProjectContentHelper.AddInterfaceToProjectContent(fullName);
 		}
 		
 		void AddClassToProjectContent(string fullName)
 		{
-			helper.AddClassToProjectContent(fullName);
+			helper.CreateClass(fullName);
 		}
 		
 		void AddInterfaceToClassBaseTypes(string fullName, string dotNetName)
 		{
-			helper.AddInterfaceToClassBaseTypes(fakeClass, fullName, dotNetName);
+			helper.AddInterfaceToClassBaseTypes(fullName, dotNetName);
 		}
 		
 		void AddClassToClassBaseTypes(string fullName)
 		{
-			helper.AddClassToClassBaseTypes(fakeClass, fullName);
+			helper.AddClassToClassBaseTypes(fullName);
 		}
 		
 		void AddBaseTypeToClass(string fullName)
 		{
-			helper.AddBaseTypeToClass(fakeClass, fullName);
+			helper.AddBaseTypeToClass(fullName);
+		}
+		
+		void AddMethodToClass(string fullyQualifiedName)
+		{
+			helper.AddMethodToClass(fullyQualifiedName);
+		}
+		
+		void AddPropertyToClass(string fullyQualifiedName)
+		{
+			helper.AddPropertyToClass(fullyQualifiedName);
+		}
+		
+		void AddFieldToClass(string fullyQualifiedName)
+		{
+			helper.AddFieldToClass(fullyQualifiedName);
 		}
 		
 		[Test]
 		public void Language_CSharpProject_ReturnsCSharpModelLanguage()
 		{
 			CreateProjectContent();
-			helper.ProjectContentIsForCSharpProject();
+			helper.ProjectContentHelper.ProjectContentIsForCSharpProject();
 			CreateClass("MyClass");
 			
 			string language = codeClass.Language;
@@ -86,7 +100,7 @@ namespace PackageManagement.Tests.EnvDTE
 		public void Language_VisualBasicProject_ReturnsVisualBasicModelLanguage()
 		{
 			CreateProjectContent();
-			helper.ProjectContentIsForVisualBasicProject();
+			helper.ProjectContentHelper.ProjectContentIsForVisualBasicProject();
 			CreateClass("MyClass");
 			
 			string language = codeClass.Language;
@@ -124,7 +138,7 @@ namespace PackageManagement.Tests.EnvDTE
 			AddInterfaceToClassBaseTypes("System.Collections.Generic.ICollection", "System.Collections.Generic.ICollection{System.String}");
 			
 			CodeElements codeElements = codeClass.ImplementedInterfaces;
-			CodeInterface codeInterface = codeElements.FirstOrDefault() as CodeInterface;
+			CodeInterface codeInterface = codeElements.FirstCodeInterfaceOrDefault();
 			
 			Assert.AreEqual(1, codeElements.Count);
 			Assert.AreEqual("System.Collections.Generic.ICollection<System.String>", codeInterface.FullName);
@@ -150,11 +164,53 @@ namespace PackageManagement.Tests.EnvDTE
 			AddBaseTypeToClass("System.Object");
 			
 			CodeElements codeElements = codeClass.Bases;
-			CodeClass2 baseClass = codeElements.FirstOrDefault() as CodeClass2;
+			CodeClass2 baseClass = codeElements.FirstCodeClass2OrDefault();
 			
 			Assert.AreEqual(1, codeElements.Count);
 			Assert.AreEqual("System.Object", baseClass.FullName);
 			Assert.AreEqual("Object", baseClass.Name);
 		}
+		
+		[Test]
+		public void Members_ClassHasOneMethod_ReturnsOneMethod()
+		{
+			CreateProjectContent();
+			CreatePublicClass("MyClass");
+			AddMethodToClass("MyClass.MyMethod");
+			
+			CodeElements codeElements = codeClass.Members;
+			CodeFunction codeFunction = codeElements.FirstCodeFunctionOrDefault();
+			
+			Assert.AreEqual(1, codeElements.Count);
+			Assert.AreEqual("MyMethod", codeFunction.Name);
+		}
+		
+		[Test]
+		public void Members_ClassHasOneProperty_ReturnsOneProperty()
+		{
+			CreateProjectContent();
+			CreatePublicClass("MyClass");
+			AddPropertyToClass("MyClass.MyProperty");
+			
+			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");
+			
+			CodeElements codeElements = codeClass.Members;
+			CodeVariable codeVariable = codeElements.FirstCodeVariableOrDefault();
+			
+			Assert.AreEqual(1, codeElements.Count);
+			Assert.AreEqual("MyField", codeVariable.Name);
+		}
 	}
 }

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

@@ -55,7 +55,7 @@ namespace PackageManagement.Tests.EnvDTE
 			helper.AddNamespaceCompletionEntryInNamespace("Parent", "Child");
 			CreateCodeElements("Parent");
 			
-			CodeNamespace codeNamespace = codeElements.ToList().FirstOrDefault() as CodeNamespace;
+			CodeNamespace codeNamespace = codeElements.FirstCodeNamespaceOrDefault();
 			
 			Assert.AreEqual(1, codeElements.Count);
 			Assert.AreEqual("Child", codeNamespace.Name);
@@ -105,8 +105,8 @@ namespace PackageManagement.Tests.EnvDTE
 			helper.NoCompletionItemsInNamespace("Parent.Child.GrandChild");
 			CreateCodeElements("Parent");
 			
-			CodeNamespace codeNamespace = codeElements.ToList().FirstOrDefault() as CodeNamespace;
+			CodeNamespace codeNamespace = codeElements.FirstCodeNamespaceOrDefault();
-			CodeNamespace grandChildNamespace = codeNamespace.Members.ToList().FirstOrDefault() as CodeNamespace;
+			CodeNamespace grandChildNamespace = codeNamespace.Members.FirstCodeNamespaceOrDefault();
 			
 			Assert.AreEqual("GrandChild", grandChildNamespace.Name);
 		}

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

@@ -14,55 +14,35 @@ namespace PackageManagement.Tests.EnvDTE
 	public class CodeFunctionTests
 	{
 		CodeFunction codeFunction;
-		IMethod method;
+		MethodHelper helper;
-		ProjectContentHelper helper;
 		
 		[SetUp]
 		public void Init()
 		{
-			helper = new ProjectContentHelper();
+			helper = new MethodHelper();
-		}
-		
-		void CreateMSBuildMethod(string name)
-		{
-			method = MockRepository.GenerateMock<IMethod, IEntity>();
-			method.Stub(m => m.ProjectContent).Return(helper.FakeProjectContent);
-		}
-		
-		void CreateMSBuildPublicMethod(string name)
-		{
-			CreateMSBuildMethod(name);
-			method.Stub(m => m.IsPublic).Return(true);
-		}
-		
-		void CreateMSBuildPrivateMethod(string name)
-		{
-			CreateMSBuildMethod(name);
-			method.Stub(m => m.IsPublic).Return(false);
-			method.Stub(m => m.IsPrivate).Return(true);
 		}
 		
 		void CreatePublicFunction(string name)
 		{
-			CreateMSBuildPublicMethod(name);
+			helper.CreatePublicMethod(name);
 			CreateFunction();
 		}
 		
 		void CreatePrivateFunction(string name)
 		{
-			CreateMSBuildPrivateMethod(name);
+			helper.CreatePrivateMethod(name);
 			CreateFunction();
 		}
 		
 		void CreateFunction()
 		{
-			codeFunction = new CodeFunction(method);
+			codeFunction = new CodeFunction(helper.Method);
 		}
 		
 		[Test]
 		public void Access_PublicFunction_ReturnsPublic()
 		{
-			CreatePublicFunction("MyFunction");
+			CreatePublicFunction("Class1.MyFunction");
 			
 			vsCMAccess access = codeFunction.Access;
 			
@@ -72,7 +52,7 @@ namespace PackageManagement.Tests.EnvDTE
 		[Test]
 		public void Access_PrivateFunction_ReturnsPrivate()
 		{
-			CreatePrivateFunction("MyFunction");
+			CreatePrivateFunction("Class1.MyFunction");
 			
 			vsCMAccess access = codeFunction.Access;
 			

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

@@ -103,7 +103,7 @@ namespace PackageManagement.Tests.EnvDTE
 			helper.AddNamespaceCompletionEntryInNamespace(String.Empty, "Test");
 			
 			CodeElements codeElements = codeModel.CodeElements;
-			CodeNamespace codeNamespace = codeElements.FirstOrDefault() as CodeNamespace;
+			CodeNamespace codeNamespace = codeElements.FirstCodeNamespaceOrDefault();
 			
 			Assert.AreEqual(1, codeElements.Count);
 			Assert.AreEqual("Test", codeNamespace.FullName);
@@ -118,7 +118,7 @@ namespace PackageManagement.Tests.EnvDTE
 			helper.AddNamespaceCompletionEntryInNamespace("First", "Second");
 			
 			CodeElements codeElements = codeModel.CodeElements;
-			CodeNamespace codeNamespace = codeElements.FirstOrDefault() as CodeNamespace;
+			CodeNamespace codeNamespace = codeElements.FirstCodeNamespaceOrDefault();
 			
 			Assert.AreEqual(1, codeElements.Count);
 			Assert.AreEqual("First", codeNamespace.FullName);
@@ -132,7 +132,7 @@ namespace PackageManagement.Tests.EnvDTE
 			AddClassToProjectContent(String.Empty, "TestClass");
 			
 			CodeElements codeElements = codeModel.CodeElements;
-			CodeClass2 codeClass = codeElements.FirstOrDefault() as CodeClass2;
+			CodeClass2 codeClass = codeElements.FirstCodeClass2OrDefault();
 			
 			Assert.AreEqual(1, codeElements.Count);
 			Assert.AreEqual("TestClass", codeClass.FullName);
@@ -148,11 +148,11 @@ namespace PackageManagement.Tests.EnvDTE
 			helper.NoCompletionItemsInNamespace("First.B");
 			
 			CodeElements codeElements = codeModel.CodeElements;
-			CodeNamespace codeNamespace = codeElements.FirstOrDefault() as CodeNamespace;
+			CodeNamespace codeNamespace = codeElements.FirstCodeNamespaceOrDefault();
 			
-			List<CodeElement> members = codeNamespace.Members.ToList();
+			CodeElements members = codeNamespace.Members;
-			CodeNamespace firstChildNamespace = members.FirstOrDefault() as CodeNamespace;
+			CodeNamespace firstChildNamespace = members.FirstCodeNamespaceOrDefault();
-			CodeNamespace secondChildNamespace = members.LastOrDefault() as CodeNamespace;
+			CodeNamespace secondChildNamespace = members.LastCodeNamespaceOrDefault();
 			
 			Assert.AreEqual(1, codeElements.Count);
 			Assert.AreEqual("First", codeNamespace.FullName);
@@ -168,7 +168,7 @@ namespace PackageManagement.Tests.EnvDTE
 			helper.AddNamespaceCompletionEntriesInNamespace(String.Empty, String.Empty, "Tests");
 			
 			CodeElements members = codeModel.CodeElements;
-			CodeNamespace codeNamespace = members.ToList().FirstOrDefault() as CodeNamespace;
+			CodeNamespace codeNamespace = members.FirstCodeNamespaceOrDefault();
 			
 			Assert.AreEqual(1, members.Count);
 			Assert.AreEqual("Tests", codeNamespace.Name);

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

@@ -43,7 +43,7 @@ namespace PackageManagement.Tests.EnvDTE
 			CreateCodeNamespace("Tests");
 			
 			CodeElements members = codeNamespace.Members;
-			CodeClass2 codeClass = members.FirstOrDefault() as CodeClass2;
+			CodeClass2 codeClass = members.FirstCodeClass2OrDefault();
 			
 			Assert.AreEqual(1, members.Count);
 			Assert.AreEqual("Tests.MyClass", codeClass.FullName); 
@@ -57,7 +57,7 @@ namespace PackageManagement.Tests.EnvDTE
 			CreateCodeNamespace("First");
 			
 			CodeElements members = codeNamespace.Members;
-			CodeNamespace childNamespace = members.FirstOrDefault() as CodeNamespace;
+			CodeNamespace childNamespace = members.FirstCodeNamespaceOrDefault();
 			
 			Assert.AreEqual("First", codeNamespace.Name);
 			Assert.AreEqual(1, members.Count);
@@ -84,8 +84,8 @@ namespace PackageManagement.Tests.EnvDTE
 			CreateCodeNamespace("First");
 			
 			CodeElements members = codeNamespace.Members;
-			CodeNamespace secondNamespace = members.FirstOrDefault() as CodeNamespace;
+			CodeNamespace secondNamespace = members.FirstCodeNamespaceOrDefault();
-			CodeNamespace thirdNamespace = secondNamespace.Members.FirstOrDefault() as CodeNamespace;
+			CodeNamespace thirdNamespace = secondNamespace.Members.FirstCodeNamespaceOrDefault();
 			
 			Assert.AreEqual("First", codeNamespace.Name);
 			Assert.AreEqual(1, members.Count);

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

@@ -13,29 +13,26 @@ namespace PackageManagement.Tests.EnvDTE
 	public class CodeTypeTests
 	{
 		CodeType codeType;
-		ProjectContentHelper helper;
+		ClassHelper helper;
-		IClass fakeClass;
 		
 		void CreateProjectContent()
 		{
-			helper = new ProjectContentHelper();
+			helper = new ClassHelper();
 		}
 		
 		void CreateClass(string name)
 		{
-			fakeClass = helper.AddClassToProjectContent(name);
+			helper.CreateClass(name);
 		}
 		
 		void CreateCodeType()
 		{
-			codeType = new CodeType(helper.FakeProjectContent, fakeClass);
+			codeType = new CodeType(helper.ProjectContentHelper.FakeProjectContent, helper.Class);
 		}
 		
 		void AddAttributeToClass(string name)
 		{
-			var attributeHelper = new AttributeHelper();
+			helper.AddAttributeToClass(name);
-			attributeHelper.CreateAttribute(name);
-			attributeHelper.AddAttributeToClass(fakeClass);
 		}
 		
 		[Test]

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

@@ -14,49 +14,29 @@ namespace PackageManagement.Tests.EnvDTE
 	public class CodeVariableTests
 	{
 		CodeVariable codeVariable;
-		IField field;
+		FieldHelper helper;
-		ProjectContentHelper helper;
 		
 		[SetUp]
 		public void Init()
 		{
-			helper = new ProjectContentHelper();
+			helper = new FieldHelper();
 		}
-		
+				
-		void CreateMSBuildField(string name)
-		{
-			field = MockRepository.GenerateMock<IField, IEntity>();
-			field.Stub(f => f.ProjectContent).Return(helper.FakeProjectContent);
-		}
-		
-		void CreateMSBuildPublicField(string name)
-		{
-			CreateMSBuildField(name);
-			field.Stub(f => f.IsPublic).Return(true);
-		}
-		
-		void CreateMSBuildPrivateField(string name)
-		{
-			CreateMSBuildField(name);
-			field.Stub(f => f.IsPublic).Return(false);
-			field.Stub(f => f.IsPrivate).Return(true);
-		}
-		
 		void CreatePublicVariable(string name)
 		{
-			CreateMSBuildPublicField(name);
+			helper.CreatePublicField(name);
 			CreateVariable();
 		}
 		
 		void CreatePrivateVariable(string name)
 		{
-			CreateMSBuildPrivateField(name);
+			helper.CreatePrivateField(name);
 			CreateVariable();
 		}
 		
 		void CreateVariable()
 		{
-			codeVariable = new CodeVariable(field);
+			codeVariable = new CodeVariable(helper.Field);
 		}
 		
 		[Test]

src/AddIns/Misc/PackageManagement/Test/Src/Helpers/ClassHelper.cs

@@ -0,0 +1,125 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using System.Collections.Generic;
+using ICSharpCode.SharpDevelop.Dom;
+using Rhino.Mocks;
+
+namespace PackageManagement.Tests.Helpers
+{
+	public class ClassHelper
+	{
+		public IClass Class;
+		public ProjectContentHelper ProjectContentHelper = new ProjectContentHelper();
+		
+		List<IMethod> methods = new List<IMethod>();
+		List<IProperty> properties = new List<IProperty>();
+		List<IField> fields = new List<IField>();
+		
+		public void CreateClass(string name)
+		{
+			Class = ProjectContentHelper.AddClassToProjectContent(name);
+			InitializeClassCommon();
+		}
+		
+		void InitializeClassCommon()
+		{
+			Class.Stub(c => c.Methods).Return(methods);
+			Class.Stub(c => c.Properties).Return(properties);
+			Class.Stub(c => c.Fields).Return(fields);
+		}
+		
+		public void AddAttributeToClass(string name)
+		{
+			var attributeHelper = new AttributeHelper();
+			attributeHelper.CreateAttribute(name);
+			attributeHelper.AddAttributeToClass(Class);
+		}
+		
+		public void CreatePublicClass(string name)
+		{
+			Class = ProjectContentHelper.AddPublicClassToProjectContent(name);
+			InitializeClassCommon();
+		}
+		
+		public void CreatePrivateClass(string name)
+		{
+			Class = ProjectContentHelper.AddPrivateClassToProjectContent(name);
+			InitializeClassCommon();
+		}
+		
+		public void AddInterfaceToClassBaseTypes(string interfaceFullName, string dotNetName)
+		{
+			IClass interfaceClass = ProjectContentHelper.AddInterfaceToProjectContent(interfaceFullName);
+			AddClassToClassBaseTypes(interfaceClass, interfaceFullName, dotNetName);
+		}
+		
+		public void AddClassToClassBaseTypes(IClass baseTypeClass, string baseTypeFullName, string baseTypeDotNetName)
+		{
+			IReturnType baseType = CreateBaseType(baseTypeClass, baseTypeFullName, baseTypeDotNetName);
+			var baseTypes = new List<IReturnType>();
+			baseTypes.Add(baseType);
+			
+			Class.Stub(c => c.BaseTypes).Return(baseTypes);
+		}
+		
+		IReturnType CreateBaseType(IClass baseTypeClass, string baseTypeFullName, string baseTypeDotNetName)
+		{
+			IReturnType baseType = MockRepository.GenerateStub<IReturnType>();
+			baseType.Stub(b => b.GetUnderlyingClass()).Return(baseTypeClass);
+			baseType.Stub(b => b.FullyQualifiedName).Return(baseTypeFullName);
+			baseType.Stub(b => b.DotNetName).Return(baseTypeDotNetName);
+			return baseType;
+		}
+		
+		public void AddClassToClassBaseTypes(string fullName)
+		{
+			IClass baseTypeClass = ProjectContentHelper.AddClassToProjectContent(fullName);
+			AddClassToClassBaseTypes(baseTypeClass, fullName, fullName);
+		}
+		
+		public void AddBaseTypeToClass(string fullName)
+		{
+			IClass baseTypeClass = ProjectContentHelper.AddClassToProjectContent(fullName);
+			IReturnType baseType = CreateBaseType(baseTypeClass, fullName, fullName);
+			
+			Class.Stub(c => c.BaseType).Return(baseType);
+		}
+		
+		/// <summary>
+		/// Name should include the class prefix (e.g. "Class1.MyMethod");
+		/// </summary>
+		public void AddMethodToClass(string fullyQualifiedName)
+		{
+			var helper = new MethodHelper();
+			helper.ProjectContentHelper = ProjectContentHelper;
+			helper.CreateMethod(fullyQualifiedName);
+			methods.Add(helper.Method);
+		}
+		
+		/// <summary>
+		/// Name should include the class prefix (e.g. "Class1.MyProperty");
+		/// </summary>
+		public void AddPropertyToClass(string fullyQualifiedName)
+		{
+			var helper = new PropertyHelper();
+			helper.ProjectContentHelper = ProjectContentHelper;
+			helper.CreateProperty(fullyQualifiedName);
+			
+			properties.Add(helper.Property);
+		}
+		
+		/// <summary>
+		/// Name should include the class prefix (e.g. "Class1.MyField");
+		/// </summary>
+		public void AddFieldToClass(string fullyQualifiedName)
+		{
+			var helper = new FieldHelper();
+			helper.ProjectContentHelper = ProjectContentHelper;
+			helper.CreateField(fullyQualifiedName);
+			
+			fields.Add(helper.Field);
+		}
+	}
+}

src/AddIns/Misc/PackageManagement/Test/Src/Helpers/CodeElementsHelpers.cs

@@ -10,11 +10,6 @@ namespace PackageManagement.Tests.Helpers
 {
 	public static class CodeElementsHelpers
 	{
-		public static CodeElement FirstOrDefault(this CodeElements codeElements)
-		{
-			return ToList(codeElements).FirstOrDefault();
-		}
-		
 		public static List<CodeElement> ToList(this CodeElements codeElements)
 		{
 			var list = new List<CodeElement>();
@@ -23,5 +18,60 @@ namespace PackageManagement.Tests.Helpers
 			}
 			return list;
 		}
+		
+		public static CodeElement FirstOrDefault(this CodeElements codeElements)
+		{
+			return ToList(codeElements).FirstOrDefault();
+		}
+		
+		public static CodeFunction FirstCodeFunctionOrDefault(this CodeElements codeElements)
+		{
+			return codeElements.FirstOrDefault() as CodeFunction;
+		}
+		
+		public static CodeClass2 FirstCodeClass2OrDefault(this CodeElements codeElements)
+		{
+			return codeElements.FirstOrDefault() as CodeClass2;
+		}
+		
+		public static CodeInterface FirstCodeInterfaceOrDefault(this CodeElements codeElements)
+		{
+			return codeElements.FirstOrDefault() as CodeInterface;
+		}
+		
+		public static CodeAttributeArgument FirstCodeAttributeArgumentOrDefault(this CodeElements codeElements)
+		{
+			return codeElements.FirstOrDefault() as CodeAttributeArgument;
+		}
+		
+		public static CodeNamespace FirstCodeNamespaceOrDefault(this CodeElements codeElements)
+		{
+			return codeElements.FirstOrDefault() as CodeNamespace;
+		}
+		
+		public static CodeNamespace LastCodeNamespaceOrDefault(this CodeElements codeElements)
+		{
+			return codeElements.LastOrDefault() as CodeNamespace;
+		}
+		
+		public static CodeElement LastOrDefault(this CodeElements codeElements)
+		{
+			return codeElements.ToList().LastOrDefault();
+		}
+		
+		public static CodeAttribute2 FirstCodeAttribute2OrDefault(this CodeElements codeElements)
+		{
+			return codeElements.FirstOrDefault() as CodeAttribute2;
+		}
+		
+		public static CodeProperty2 FirstCodeProperty2OrDefault(this CodeElements codeElements)
+		{
+			return codeElements.FirstOrDefault() as CodeProperty2;
+		}
+		
+		public static CodeVariable FirstCodeVariableOrDefault(this CodeElements codeElements)
+		{
+			return codeElements.FirstOrDefault() as CodeVariable;
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Test/Src/Helpers/FieldHelper.cs

@@ -0,0 +1,38 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.SharpDevelop.Dom;
+using Rhino.Mocks;
+
+namespace PackageManagement.Tests.Helpers
+{
+	public class FieldHelper
+	{
+		public IField Field;
+		public ProjectContentHelper ProjectContentHelper = new ProjectContentHelper();
+		
+		/// <summary>
+		/// Field name should include the class prefix (e.g. "Class1.MyField")
+		/// </summary>
+		public void CreateField(string fullyQualifiedName)
+		{
+			Field = MockRepository.GenerateMock<IField, IEntity>();
+			Field.Stub(f => f.ProjectContent).Return(ProjectContentHelper.FakeProjectContent);
+			Field.Stub(f => f.FullyQualifiedName).Return(fullyQualifiedName);
+		}
+		
+		public void CreatePublicField(string fullyQualifiedName)
+		{
+			CreateField(fullyQualifiedName);
+			Field.Stub(f => f.IsPublic).Return(true);
+		}
+		
+		public void CreatePrivateField(string fullyQualifiedName)
+		{
+			CreateField(fullyQualifiedName);
+			Field.Stub(f => f.IsPublic).Return(false);
+			Field.Stub(f => f.IsPrivate).Return(true);
+		}
+	}
+}

src/AddIns/Misc/PackageManagement/Test/Src/Helpers/MethodHelper.cs

@@ -0,0 +1,38 @@
+// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
+// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
+
+using System;
+using ICSharpCode.SharpDevelop.Dom;
+using Rhino.Mocks;
+
+namespace PackageManagement.Tests.Helpers
+{
+	public class MethodHelper
+	{
+		public IMethod Method;
+		public ProjectContentHelper ProjectContentHelper = new ProjectContentHelper();
+		
+		/// <summary>
+		/// Method name should include class prefix (e.g. "Class1.MyMethod")
+		/// </summary>
+		public void CreateMethod(string fullyQualifiedName)
+		{
+			Method = MockRepository.GenerateMock<IMethod, IEntity>();
+			Method.Stub(m => m.ProjectContent).Return(ProjectContentHelper.FakeProjectContent);
+			Method.Stub(m => m.FullyQualifiedName).Return(fullyQualifiedName);
+		}
+		
+		public void CreatePublicMethod(string name)
+		{
+			CreateMethod(name);
+			Method.Stub(m => m.IsPublic).Return(true);
+		}
+		
+		public void CreatePrivateMethod(string name)
+		{
+			CreateMethod(name);
+			Method.Stub(m => m.IsPublic).Return(false);
+			Method.Stub(m => m.IsPrivate).Return(true);
+		}
+	}
+}

src/AddIns/Misc/PackageManagement/Test/Src/Helpers/ProjectContentHelper.cs

@@ -223,43 +223,5 @@ namespace PackageManagement.Tests.Helpers
 			MakeClassPrivate(fakeDelegate);
 			return fakeDelegate;
 		}
-		
-		public void AddInterfaceToClassBaseTypes(IClass fakeClass, string interfaceFullName, string dotNetName)
-		{
-			IClass interfaceClass = AddInterfaceToProjectContent(interfaceFullName);
-			AddClassToClassBaseTypes(fakeClass, interfaceClass, interfaceFullName, dotNetName);
-		}
-		
-		public void AddClassToClassBaseTypes(IClass fakeClass, IClass baseTypeClass, string baseTypeFullName, string baseTypeDotNetName)
-		{
-			IReturnType baseType = CreateBaseType(baseTypeClass, baseTypeFullName, baseTypeDotNetName);
-			var baseTypes = new List<IReturnType>();
-			baseTypes.Add(baseType);
-			
-			fakeClass.Stub(c => c.BaseTypes).Return(baseTypes);
-		}
-		
-		IReturnType CreateBaseType(IClass baseTypeClass, string baseTypeFullName, string baseTypeDotNetName)
-		{
-			IReturnType baseType = MockRepository.GenerateStub<IReturnType>();
-			baseType.Stub(b => b.GetUnderlyingClass()).Return(baseTypeClass);
-			baseType.Stub(b => b.FullyQualifiedName).Return(baseTypeFullName);
-			baseType.Stub(b => b.DotNetName).Return(baseTypeDotNetName);
-			return baseType;
-		}
-		
-		public void AddClassToClassBaseTypes(IClass fakeClass, string fullName)
-		{
-			IClass baseTypeClass = AddClassToProjectContent(fullName);
-			AddClassToClassBaseTypes(fakeClass, baseTypeClass, fullName, fullName);
-		}
-		
-		public void AddBaseTypeToClass(IClass fakeClass, string fullName)
-		{
-			IClass baseTypeClass = AddClassToProjectContent(fullName);
-			IReturnType baseType = CreateBaseType(baseTypeClass, fullName, fullName);
-			
-			fakeClass.Stub(c => c.BaseType).Return(baseType);
-		}
 	}
 }

src/AddIns/Misc/PackageManagement/Test/Src/Helpers/PropertyHelper.cs

@@ -14,11 +14,13 @@ namespace PackageManagement.Tests.Helpers
 		public List<IAttribute> Attributes = new List<IAttribute>();
 		public ProjectContentHelper ProjectContentHelper = new ProjectContentHelper();
 		
-		public void CreateProperty(string name)
+		/// <summary>
+		/// Property name should include class prefix (e.g. "Class1.MyProperty")
+		/// </summary>
+		public void CreateProperty(string fullyQualifiedName)
 		{
 			Property = MockRepository.GenerateMock<IProperty, IEntity>();
-			Property.Stub(p => p.Name).Return(name);
+			Property.Stub(p => p.FullyQualifiedName).Return(fullyQualifiedName);
-			Property.Stub(p => p.FullyQualifiedName).Return(name);
 			Property.Stub(p => p.Attributes).Return(Attributes);
 			Property.Stub(p => p.ProjectContent).Return(ProjectContentHelper.FakeProjectContent);
 		}