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

Implement more EnvDTE.CodeClass2 tests.

pull/375/head
Matt Ward 12 years ago
parent
e8338ae539
commit
73eb90fe9d
9 changed files with 322 additions and 339 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. 17
      src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeClass.cs
  2. 64
      src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeClass2.cs
  3. 10
      src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeElement.cs
  4. 46
      src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeFunction.cs
  5. 18
      src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeFunction2.cs
  6. 41
      src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeInterface.cs
  7. 65
      src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeType.cs
  8. 10
      src/AddIns/Misc/PackageManagement/Project/Src/IProjectContentExtensions.cs
  9. 380
      src/AddIns/Misc/PackageManagement/Test/Src/EnvDTE/CodeClass2Tests.cs

17
src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeClass.cs
Unescape View File

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

64
src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeClass2.cs
Unescape View File

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

10
src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeElement.cs
Unescape View File

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

46
src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeFunction.cs
Unescape View File

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

18
src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeFunction2.cs
Unescape View File

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

41
src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeInterface.cs
Unescape View File

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

65
src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeType.cs
Unescape View File

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

10
src/AddIns/Misc/PackageManagement/Project/Src/IProjectContentExtensions.cs
Unescape View File

@ -39,15 +39,5 @@ namespace ICSharpCode.PackageManagement
throw new Exception("Invalid value for vsCMAccess"); 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;
}
} }
} }

380
src/AddIns/Misc/PackageManagement/Test/Src/EnvDTE/CodeClass2Tests.cs
Unescape View File

@ -22,7 +22,17 @@ namespace PackageManagement.Tests.EnvDTE
void CreateClass(string code) void CreateClass(string code)
{ {
AddCodeFile("class.cs", 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); codeClass = new CodeClass2(codeModelContext, typeDefinition);
} }
@ -67,118 +77,123 @@ namespace PackageManagement.Tests.EnvDTE
Assert.AreEqual(global::EnvDTE.vsCMAccess.vsCMAccessPrivate, access); 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] // [Test]
// public void ImplementedInterfaces_ClassImplementsGenericICollectionOfString_ReturnsCodeInterfaceForICollection() // public void Members_ClassHasOneProperty_ReturnsOneProperty()
// { // {
// CreateClass( // CreateClass(
// "using System.Collection.Generic;" + // "public class MyClass {\r\n" +
// "class MyClass : ICollection<string> {}"); // " public int MyProperty { get; set; }\r\n" +
// // "}");
// 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");
// //
// global::EnvDTE.CodeElements codeElements = codeClass.Members; // 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(); // CodeProperty2 codeFunction = codeElements.FirstCodeProperty2OrDefault();
//
// Assert.AreEqual(1, codeElements.Count); // Assert.AreEqual(1, codeElements.Count);
// Assert.AreEqual("MyProperty", codeFunction.Name); // Assert.AreEqual("MyProperty", codeFunction.Name);
// } // }
//
// [Test] [Test]
// public void Members_ClassHasOneField_ReturnsOneField() public void Members_ClassHasOneField_ReturnsOneField()
// { {
// CreateProjectContent(); CreateClass(
// CreatePublicClass("MyClass"); "public class MyClass {\r\n" +
// AddFieldToClass("MyClass.MyField"); " public int MyField;\r\n" +
// "}");
// global::EnvDTE.CodeElements codeElements = codeClass.Members;
// CodeVariable codeVariable = codeElements.FirstCodeVariableOrDefault(); global::EnvDTE.CodeElements codeElements = codeClass.Members;
//
// Assert.AreEqual(1, codeElements.Count); CodeVariable codeVariable = codeElements.FirstCodeVariableOrDefault();
// Assert.AreEqual("MyField", codeVariable.Name); Assert.AreEqual(1, codeElements.Count);
// } Assert.AreEqual("MyField", codeVariable.Name);
// }
// [Test]
// public void Kind_PublicClass_ReturnsClass() [Test]
// { public void Kind_PublicClass_ReturnsClass()
// CreateProjectContent(); {
// CreatePublicClass("MyClass"); CreateClass("public class MyClass {}");
//
// global::EnvDTE.vsCMElement kind = codeClass.Kind; global::EnvDTE.vsCMElement kind = codeClass.Kind;
//
// Assert.AreEqual(global::EnvDTE.vsCMElement.vsCMElementClass, kind); Assert.AreEqual(global::EnvDTE.vsCMElement.vsCMElementClass, kind);
// } }
//
// [Test] // [Test]
// public void Namespace_PublicClass_ReturnsClassNamespace() // public void Namespace_PublicClass_ReturnsClassNamespace()
// { // {
// CreateProjectContent(); // CreateClass(
// helper.CreatePublicClass("MyNamespace.Test.MyClass"); // "namespace MyNamespace.Test {\r\n" +
// helper.AddClassNamespace("MyNamespace.Test"); // " public class MyClass {}\r\n" +
// CreateClass(); // "}");
// //
// global::EnvDTE.CodeNamespace codeNamespace = codeClass.Namespace; // global::EnvDTE.CodeNamespace codeNamespace = codeClass.Namespace;
// //
@ -197,20 +212,18 @@ namespace PackageManagement.Tests.EnvDTE
// //
// Assert.AreEqual("MyNamespace.Test", codeNamespace.Name); // Assert.AreEqual("MyNamespace.Test", codeNamespace.Name);
// } // }
//
// [Test] [Test]
// public void PartialClasses_ClassIsNotPartial_ReturnsClass() public void PartialClasses_ClassIsNotPartial_ReturnsClass()
// { {
// CreateProjectContent(); CreateClass("public class MyClass {}");
// CreatePublicClass("MyNamespace.MyClass");
// CreateClass(); global::EnvDTE.CodeElements partialClasses = codeClass.PartialClasses;
//
// global::EnvDTE.CodeElements partialClasses = codeClass.PartialClasses; CodeClass firstClass = partialClasses.FirstCodeClass2OrDefault();
// CodeClass firstClass = partialClasses.FirstCodeClass2OrDefault(); Assert.AreEqual(1, partialClasses.Count);
// Assert.AreEqual(codeClass, firstClass);
// Assert.AreEqual(1, partialClasses.Count); }
// Assert.AreEqual(codeClass, firstClass);
// }
// //
// [Test] // [Test]
// public void Members_GetFirstPropertyTwice_PropertiesAreConsideredEqualWhenAddedToList() // public void Members_GetFirstPropertyTwice_PropertiesAreConsideredEqualWhenAddedToList()
@ -227,29 +240,26 @@ namespace PackageManagement.Tests.EnvDTE
// bool contains = properties.Contains(property2); // bool contains = properties.Contains(property2);
// Assert.IsTrue(contains); // Assert.IsTrue(contains);
// } // }
//
// [Test] [Test]
// public void IsAbstract_ClassIsAbstract_ReturnsTrue() public void IsAbstract_ClassIsAbstract_ReturnsTrue()
// { {
// CreateProjectContent(); CreateClass("public abstract class MyClass {}");
// CreatePublicClass("MyClass");
// ClassIsAbstract(); bool isAbstract = codeClass.IsAbstract;
//
// bool isAbstract = codeClass.IsAbstract; Assert.IsTrue(isAbstract);
// }
// Assert.IsTrue(isAbstract);
// } [Test]
// public void IsAbstract_ClassIsNotAbstract_ReturnsFalse()
// [Test] {
// public void IsAbstract_ClassIsNotAbstract_ReturnsFalse() CreateClass("public class MyClass {}");
// {
// CreateProjectContent(); bool isAbstract = codeClass.IsAbstract;
// CreatePublicClass("MyClass");
// Assert.IsFalse(isAbstract);
// bool isAbstract = codeClass.IsAbstract; }
//
// Assert.IsFalse(isAbstract);
// }
// //
// [Test] // [Test]
// public void ClassKind_ClassIsPartial_ReturnsPartialClassKind() // public void ClassKind_ClassIsPartial_ReturnsPartialClassKind()
@ -262,41 +272,36 @@ namespace PackageManagement.Tests.EnvDTE
// //
// Assert.AreEqual(global::EnvDTE.vsCMClassKind.vsCMClassKindPartialClass, kind); // Assert.AreEqual(global::EnvDTE.vsCMClassKind.vsCMClassKindPartialClass, kind);
// } // }
//
// [Test] [Test]
// public void ClassKind_ClassIsNotPartial_ReturnsMainClassKind() public void ClassKind_ClassIsNotPartial_ReturnsMainClassKind()
// { {
// CreateProjectContent(); CreateClass("public class MyClass {}");
// CreatePublicClass("MyClass");
// global::EnvDTE.vsCMClassKind kind = codeClass.ClassKind;
// global::EnvDTE.vsCMClassKind kind = codeClass.ClassKind;
// Assert.AreEqual(global::EnvDTE.vsCMClassKind.vsCMClassKindMainClass, kind);
// Assert.AreEqual(global::EnvDTE.vsCMClassKind.vsCMClassKindMainClass, kind); }
// }
// [Test]
// [Test] public void IsGeneric_ClassIsGeneric_ReturnsTrue()
// public void IsGeneric_ClassIsGeneric_ReturnsTrue() {
// { CreateClass("public class MyClass<T> {}");
// CreateProjectContent();
// CreatePublicClass("MyClass"); bool generic = codeClass.IsGeneric;
// ClassIsGeneric();
// Assert.IsTrue(generic);
// bool generic = codeClass.IsGeneric; }
//
// Assert.IsTrue(generic); [Test]
// } public void IsGeneric_ClassIsNotGeneric_ReturnsFalse()
// {
// [Test] CreateClass("public class MyClass {}");
// public void IsGeneric_ClassIsNotGeneric_ReturnsFalse()
// { bool generic = codeClass.IsGeneric;
// CreateProjectContent();
// CreatePublicClass("MyClass"); Assert.IsFalse(generic);
// ClassIsNotGeneric(); }
//
// bool generic = codeClass.IsGeneric;
//
// Assert.IsFalse(generic);
// }
// //
// [Test] // [Test]
// public void ClassKind_ChangeClassToBePartial_UsesClassKindUpdaterToModifyClass() // public void ClassKind_ChangeClassToBePartial_UsesClassKindUpdaterToModifyClass()
@ -308,14 +313,27 @@ namespace PackageManagement.Tests.EnvDTE
// //
// classKindUpdater.AssertWasCalled(updater => updater.MakeClassPartial()); // classKindUpdater.AssertWasCalled(updater => updater.MakeClassPartial());
// } // }
//
// [Test] [Test]
// public void ClassKind_ChangeClassToBeMainClass_ThrowsNotImplementedException() public void ClassKind_ChangeClassToBeMainClass_ThrowsNotImplementedException()
// { {
// CreateProjectContent(); CreateClass("public class MyClass {}");
// CreatePublicClass("MyClass");
// Assert.Throws<NotImplementedException>(() => codeClass.ClassKind = global::EnvDTE.vsCMClassKind.vsCMClassKindMainClass);
// 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);
}
} }
} }

Write Preview
Loading…
Cancel
Save