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

Update tests for EnvDTE.CodeTypeRef2

pull/375/head
Matt Ward 12 years ago
parent
dea25f9bbf
commit
a0bedbb4c6
7 changed files with 452 additions and 420 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. 2
      src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeClass.cs
  2. 25
      src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeInterface.cs
  3. 19
      src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeType.cs
  4. 41
      src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeTypeRef.cs
  5. 4
      src/AddIns/Misc/PackageManagement/Test/PackageManagement.Tests.csproj
  6. 13
      src/AddIns/Misc/PackageManagement/Test/Src/EnvDTE/CodeClass2Tests.cs
  7. 766
      src/AddIns/Misc/PackageManagement/Test/Src/EnvDTE/CodeTypeRef2Tests.cs

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

@ -12,7 +12,7 @@ namespace ICSharpCode.PackageManagement.EnvDTE
public class CodeClass : CodeType, global::EnvDTE.CodeClass public class CodeClass : CodeType, global::EnvDTE.CodeClass
{ {
public CodeClass(CodeModelContext context, ITypeDefinition typeDefinition) public CodeClass(CodeModelContext context, ITypeDefinition typeDefinition)
: base(context, typeDefinition) : base(context, typeDefinition, typeDefinition.TypeArguments.ToArray())
{ {
} }

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

@ -11,28 +11,9 @@ namespace ICSharpCode.PackageManagement.EnvDTE
{ {
public class CodeInterface : CodeType, global::EnvDTE.CodeInterface public class CodeInterface : CodeType, global::EnvDTE.CodeInterface
{ {
string fullName;
public CodeInterface(CodeModelContext context, ITypeDefinition typeDefinition, params IType[] typeArguments) public CodeInterface(CodeModelContext context, ITypeDefinition typeDefinition, params IType[] typeArguments)
: base(context, typeDefinition) : base(context, typeDefinition, typeArguments)
{
fullName = GetFullName(typeArguments);
}
string GetFullName(IType[] typeArguments)
{
if (typeArguments.Length > 0)
{ {
return base.FullName + GetParameterisedTypeName(typeArguments);
}
return base.FullName;
}
string GetParameterisedTypeName(IType[] typeArguments)
{
return String.Format(
"<{0}>",
String.Join(", ", typeArguments.Select(type => type.FullName)));
} }
// //
// public override global::EnvDTE.vsCMElement Kind { // public override global::EnvDTE.vsCMElement Kind {
@ -57,9 +38,5 @@ namespace ICSharpCode.PackageManagement.EnvDTE
// return codeGenerator.AddPublicMethod(name, (string)type); // return codeGenerator.AddPublicMethod(name, (string)type);
return null; return null;
} }
public override string FullName {
get { return fullName; }
}
} }
} }

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

@ -17,6 +17,7 @@ namespace ICSharpCode.PackageManagement.EnvDTE
{ {
protected readonly ITypeDefinitionModel typeModel; protected readonly ITypeDefinitionModel typeModel;
protected readonly ITypeDefinition typeDefinition; protected readonly ITypeDefinition typeDefinition;
IType[] typeArguments;
CodeElementsList<CodeElement> members; CodeElementsList<CodeElement> members;
@ -45,7 +46,7 @@ namespace ICSharpCode.PackageManagement.EnvDTE
case TypeKind.Delegate: case TypeKind.Delegate:
case TypeKind.Enum: case TypeKind.Enum:
default: default:
return new CodeType(context, typeDefinition); return new CodeType(context, typeDefinition, typeArguments);
} }
} }
@ -56,10 +57,11 @@ namespace ICSharpCode.PackageManagement.EnvDTE
this.InfoLocation = GetInfoLocationOld(); this.InfoLocation = GetInfoLocationOld();
} }
public CodeType(CodeModelContext context, ITypeDefinition typeDefinition) public CodeType(CodeModelContext context, ITypeDefinition typeDefinition, params IType[] typeArguments)
: base(context, typeDefinition) : base(context, typeDefinition)
{ {
this.typeDefinition = typeDefinition; this.typeDefinition = typeDefinition;
this.typeArguments = typeArguments;
this.InfoLocation = GetInfoLocation(); this.InfoLocation = GetInfoLocation();
} }
@ -105,7 +107,7 @@ namespace ICSharpCode.PackageManagement.EnvDTE
fullName.Append('.'); fullName.Append('.');
fullName.Append(fullTypeName.GetNestedTypeName(i)); fullName.Append(fullTypeName.GetNestedTypeName(i));
} }
return fullName.ToString(); return fullName.ToString() + GetTypeArguments();
} }
} }
@ -117,6 +119,17 @@ namespace ICSharpCode.PackageManagement.EnvDTE
return typeDefinition.FullTypeName; return typeDefinition.FullTypeName;
} }
string GetTypeArguments()
{
if (typeArguments.Length == 0) {
return String.Empty;
}
return String.Format(
"<{0}>",
String.Join(", ", typeArguments.Select(type => type.FullName)));
}
public virtual global::EnvDTE.CodeElements Members { public virtual global::EnvDTE.CodeElements Members {
get { get {
if (members == null) { if (members == null) {

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

@ -27,13 +27,16 @@ namespace ICSharpCode.PackageManagement.EnvDTE
} }
public virtual string AsFullName { public virtual string AsFullName {
get { return type.ReflectionName; } get { return CodeType.FullName; }
} }
public virtual string AsString { public virtual string AsString {
get { get {
if (TypeKind != global::EnvDTE.vsCMTypeRef.vsCMTypeRefCodeType) {
return new CSharpAmbience().ConvertType(type); return new CSharpAmbience().ConvertType(type);
} }
return AsFullName;
}
} }
public virtual global::EnvDTE.CodeElement Parent { public virtual global::EnvDTE.CodeElement Parent {
@ -50,16 +53,14 @@ namespace ICSharpCode.PackageManagement.EnvDTE
get { get {
switch (type.Kind) { switch (type.Kind) {
case NRefactory.TypeSystem.TypeKind.Class: case NRefactory.TypeSystem.TypeKind.Class:
if (type.IsKnownType(KnownTypeCode.String)) return GetClassType(type);
return global::EnvDTE.vsCMTypeRef.vsCMTypeRefString;
else
return global::EnvDTE.vsCMTypeRef.vsCMTypeRefObject;
case NRefactory.TypeSystem.TypeKind.Struct: case NRefactory.TypeSystem.TypeKind.Struct:
var typeDef = type.GetDefinition(); ITypeDefinition typeDef = type.GetDefinition();
if (typeDef != null) if (typeDef != null) {
return GetStructTypeKind(typeDef.KnownTypeCode); return GetStructTypeKind(typeDef.KnownTypeCode);
else } else {
return global::EnvDTE.vsCMTypeRef.vsCMTypeRefOther; return global::EnvDTE.vsCMTypeRef.vsCMTypeRefOther;
}
case NRefactory.TypeSystem.TypeKind.Delegate: case NRefactory.TypeSystem.TypeKind.Delegate:
case NRefactory.TypeSystem.TypeKind.Interface: case NRefactory.TypeSystem.TypeKind.Interface:
case NRefactory.TypeSystem.TypeKind.Module: case NRefactory.TypeSystem.TypeKind.Module:
@ -71,13 +72,25 @@ namespace ICSharpCode.PackageManagement.EnvDTE
case NRefactory.TypeSystem.TypeKind.Pointer: case NRefactory.TypeSystem.TypeKind.Pointer:
return global::EnvDTE.vsCMTypeRef.vsCMTypeRefPointer; return global::EnvDTE.vsCMTypeRef.vsCMTypeRefPointer;
default: default:
if (type.IsReferenceType == true) if (type.IsReferenceType == true) {
return global::EnvDTE.vsCMTypeRef.vsCMTypeRefObject; return global::EnvDTE.vsCMTypeRef.vsCMTypeRefObject;
else } else {
return global::EnvDTE.vsCMTypeRef.vsCMTypeRefOther; return global::EnvDTE.vsCMTypeRef.vsCMTypeRefOther;
} }
} }
} }
}
global::EnvDTE.vsCMTypeRef GetClassType(IType type)
{
if (type.IsKnownType(KnownTypeCode.String)) {
return global::EnvDTE.vsCMTypeRef.vsCMTypeRefString;
} else if (type.IsKnownType(KnownTypeCode.Object)) {
return global::EnvDTE.vsCMTypeRef.vsCMTypeRefObject;
} else {
return global::EnvDTE.vsCMTypeRef.vsCMTypeRefCodeType;
}
}
global::EnvDTE.vsCMTypeRef GetStructTypeKind(KnownTypeCode knownTypeCode) global::EnvDTE.vsCMTypeRef GetStructTypeKind(KnownTypeCode knownTypeCode)
{ {
@ -104,11 +117,9 @@ namespace ICSharpCode.PackageManagement.EnvDTE
return global::EnvDTE.vsCMTypeRef.vsCMTypeRefDouble; return global::EnvDTE.vsCMTypeRef.vsCMTypeRefDouble;
case KnownTypeCode.Decimal: case KnownTypeCode.Decimal:
return global::EnvDTE.vsCMTypeRef.vsCMTypeRefDecimal; return global::EnvDTE.vsCMTypeRef.vsCMTypeRefDecimal;
case KnownTypeCode.Void: // case KnownTypeCode.IntPtr:
return global::EnvDTE.vsCMTypeRef.vsCMTypeRefVoid; // case KnownTypeCode.UIntPtr:
case KnownTypeCode.IntPtr: // return global::EnvDTE.vsCMTypeRef.vsCMTypeRefPointer;
case KnownTypeCode.UIntPtr:
return global::EnvDTE.vsCMTypeRef.vsCMTypeRefPointer;
default: default:
return global::EnvDTE.vsCMTypeRef.vsCMTypeRefOther; return global::EnvDTE.vsCMTypeRef.vsCMTypeRefOther;
} }

4
src/AddIns/Misc/PackageManagement/Test/PackageManagement.Tests.csproj
Unescape View File

@ -94,9 +94,7 @@
<Compile Include="Src\EnvDTE\CodeImportTests.cs" /> <Compile Include="Src\EnvDTE\CodeImportTests.cs" />
<Compile Include="Src\EnvDTE\CodeInterfaceTests.cs" /> <Compile Include="Src\EnvDTE\CodeInterfaceTests.cs" />
<Compile Include="Src\EnvDTE\CodeModelTestBase.cs" /> <Compile Include="Src\EnvDTE\CodeModelTestBase.cs" />
<Compile Include="Src\EnvDTE\CodeModelTests.cs"> <Compile Include="Src\EnvDTE\CodeModelTests.cs" />
<DependentUpon>CodeTypeTests.cs</DependentUpon>
</Compile>
<Compile Include="Src\EnvDTE\CodeNamespaceTests.cs" /> <Compile Include="Src\EnvDTE\CodeNamespaceTests.cs" />
<Compile Include="Src\EnvDTE\CodeParameter2Tests.cs" /> <Compile Include="Src\EnvDTE\CodeParameter2Tests.cs" />
<Compile Include="Src\EnvDTE\CodeProperty2Tests.cs" /> <Compile Include="Src\EnvDTE\CodeProperty2Tests.cs" />

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

@ -336,5 +336,18 @@ namespace PackageManagement.Tests.EnvDTE
Assert.AreEqual(1, codeElements.Count); Assert.AreEqual(1, codeElements.Count);
Assert.AreEqual("System.IDisposable", codeInterface.FullName); Assert.AreEqual("System.IDisposable", codeInterface.FullName);
} }
[Test]
public void FullName_GenericClass_ReturnsTypeArguments()
{
CreateClass(
"namespace Test {\r\n" +
" class MyClass<T> {}\r\n" +
"}");
string name = codeClass.FullName;
Assert.AreEqual("Test.MyClass<T>", name);
}
} }
} }

766
src/AddIns/Misc/PackageManagement/Test/Src/EnvDTE/CodeTypeRef2Tests.cs
Unescape View File

@ -1,169 +1,154 @@
//// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt) // 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) // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
//
//using System; using System;
//using ICSharpCode.PackageManagement.EnvDTE; using System.Linq;
//using ICSharpCode.SharpDevelop.Dom; using ICSharpCode.NRefactory.TypeSystem;
//using NUnit.Framework; using ICSharpCode.PackageManagement.EnvDTE;
//using PackageManagement.Tests.Helpers; using NUnit.Framework;
//
//namespace PackageManagement.Tests.EnvDTE namespace PackageManagement.Tests.EnvDTE
//{ {
// [TestFixture] [TestFixture]
// public class CodeTypeRef2Tests public class CodeTypeRef2Tests : CodeModelTestBase
// { {
// CodeTypeRef2 typeRef; CodeTypeRef2 typeRef;
// ReturnTypeHelper helper; CodeFunction2 parent;
// CodeElement parent;
// ClassHelper classHelper; void CreateCodeTypeRef2(string code)
// {
// [SetUp] AddCodeFile("class.cs", code);
// public void Init() IMethod method = assemblyModel
// { .TopLevelTypeDefinitions
// helper = new ReturnTypeHelper(); .First()
// classHelper = new ClassHelper(); .Members
// parent = new CodeElement(); .First()
// } .Resolve() as IMethod;
//
// void AddUnderlyingClassToReturnType(string fullyQualifiedName) parent = new CodeFunction2(codeModelContext, method);
// { typeRef = parent.Type as CodeTypeRef2;
// classHelper.CreatePublicClass(fullyQualifiedName); }
// helper.AddUnderlyingClass(classHelper.Class);
// } [Test]
// public void CodeType_ReturnTypeIsSystemString_ReturnsCodeClass2ForSystemStringType()
// void CreateCodeTypeRef2() {
// { CreateCodeTypeRef2(
// typeRef = new CodeTypeRef2(classHelper.ProjectContentHelper.ProjectContent, parent, helper.ReturnType); "using System;\r\n" +
// } "class MyClass {\r\n" +
// " string MyMethod() { return null; }\r\n" +
// void ReturnTypeUsesDifferentProjectContent() "}");
// {
// classHelper = new ClassHelper(); CodeClass2 codeClass = typeRef.CodeType as CodeClass2;
// classHelper.ProjectContentHelper.SetProjectForProjectContent(ProjectHelper.CreateTestProject()); string name = codeClass.FullName;
// }
// Assert.AreEqual("System.String", name);
// void ReturnTypeSameProjectContent() }
// {
// var project = ProjectHelper.CreateTestProject(); [Test]
// classHelper.ProjectContentHelper.SetProjectForProjectContent(project); public void CodeType_ReturnTypeFromDifferentAssemblyFromProjectt_CodeTypeLocationIsExternal()
// } {
// CreateCodeTypeRef2(
// void ProjectContentIsForVisualBasicProject() "using System;\r\n" +
// { "class MyClass {\r\n" +
// classHelper.ProjectContentHelper.ProjectContentIsForVisualBasicProject(); " string MyMethod() { return null; }\r\n" +
// } "}");
//
// void ProjectContentIsForCSharpProject() CodeClass2 codeClass = typeRef.CodeType as CodeClass2;
// { global::EnvDTE.vsCMInfoLocation location = codeClass.InfoLocation;
// classHelper.ProjectContentHelper.ProjectContentIsForCSharpProject();
// } Assert.AreEqual(global::EnvDTE.vsCMInfoLocation.vsCMInfoLocationExternal, location);
// }
// [Test]
// public void CodeType_ReturnTypeIsSystemString_ReturnsCodeClass2ForSystemStringType() [Test]
// { public void CodeType_ReturnTypeFromSameProjectContent_CodeTypeLocationIsProject()
// helper.CreateReturnType("System.String"); {
// AddUnderlyingClassToReturnType("System.String"); CreateCodeTypeRef2(
// CreateCodeTypeRef2(); "using System;\r\n" +
// "class MyClass {\r\n" +
// CodeClass2 codeClass = typeRef.CodeType as CodeClass2; " MyType MyMethod() { return null; }\r\n" +
// string name = codeClass.FullName; "}\r\n" +
// "class MyType {}");
// Assert.AreEqual("System.String", name);
// } CodeClass2 codeClass = typeRef.CodeType as CodeClass2;
// global::EnvDTE.vsCMInfoLocation location = codeClass.InfoLocation;
// [Test]
// public void CodeType_ReturnTypeFromDifferentProjectContent_CodeTypeLocationIsExternal() Assert.AreEqual(global::EnvDTE.vsCMInfoLocation.vsCMInfoLocationProject, location);
// { }
// helper.CreateReturnType("System.String");
// AddUnderlyingClassToReturnType("System.String"); [Test]
// ReturnTypeUsesDifferentProjectContent(); public void IsGeneric_NotGenericReturnType_ReturnsFalse()
// CreateCodeTypeRef2(); {
// CreateCodeTypeRef2(
// CodeClass2 codeClass = typeRef.CodeType as CodeClass2; "using System;\r\n" +
// global::EnvDTE.vsCMInfoLocation location = codeClass.InfoLocation; "class MyClass {\r\n" +
// " string MyMethod() { return null; }\r\n" +
// Assert.AreEqual(global::EnvDTE.vsCMInfoLocation.vsCMInfoLocationExternal, location); "}");
// }
// bool generic = typeRef.IsGeneric;
// [Test]
// public void CodeType_ReturnTypeFromSameProjectContent_CodeTypeLocationIsProject() Assert.IsFalse(generic);
// { }
// helper.CreateReturnType("MyType");
// AddUnderlyingClassToReturnType("MyType"); [Test]
// ReturnTypeSameProjectContent(); public void IsGeneric_GenericReturnType_ReturnsTrue()
// CreateCodeTypeRef2(); {
// CreateCodeTypeRef2(
// CodeClass2 codeClass = typeRef.CodeType as CodeClass2; "using System;\r\n" +
// global::EnvDTE.vsCMInfoLocation location = codeClass.InfoLocation; "class MyClass {\r\n" +
// " Nullable<int> MyMethod() { return null; }\r\n" +
// Assert.AreEqual(global::EnvDTE.vsCMInfoLocation.vsCMInfoLocationProject, location); "}");
// }
// bool generic = typeRef.IsGeneric;
// [Test]
// public void IsGeneric_NotGenericReturnType_ReturnsFalse() Assert.IsTrue(generic);
// { }
// helper.CreateReturnType("MyType");
// helper.AddDotNetName("MyType"); [Test]
// CreateCodeTypeRef2(); public void AsFullName_GenericReturnType_ReturnsDotNetNameWithCurlyBracesReplacedWithAngleBrackets()
// {
// bool generic = typeRef.IsGeneric; CreateCodeTypeRef2(
// "using System;\r\n" +
// Assert.IsFalse(generic); "class MyClass {\r\n" +
// } " Nullable<int> MyMethod() { return null; }\r\n" +
// "}");
// [Test]
// public void IsGeneric_GenericReturnType_ReturnsTrue() string name = typeRef.AsFullName;
// {
// helper.CreateReturnType("System.Nullable"); Assert.AreEqual("System.Nullable<System.Int32>", name);
// helper.AddDotNetName("System.Nullable{System.String}"); }
// CreateCodeTypeRef2();
// [Test]
// bool generic = typeRef.IsGeneric; public void AsString_ReturnTypeIsSystemStringInCSharpProject_ReturnsString()
// {
// Assert.IsTrue(generic); CreateCodeTypeRef2(
// } "using System;\r\n" +
// "class MyClass {\r\n" +
// [Test] " string MyMethod() { return null; }\r\n" +
// public void AsFullName_GenericReturnType_ReturnsDotNetNameWithCurlyBracesReplacedWithAngleBrackets() "}");
// {
// helper.CreateReturnType("System.Nullable"); string name = typeRef.AsString;
// helper.AddDotNetName("System.Nullable{System.String}");
// CreateCodeTypeRef2(); Assert.AreEqual("string", name);
// }
// string name = typeRef.AsFullName;
// [Test]
// Assert.AreEqual("System.Nullable<System.String>", name); public void AsString_ReturnTypeIsSystemInt32InCSharpProject_ReturnsInt()
// } {
// CreateCodeTypeRef2(
// [Test] "using System;\r\n" +
// public void AsString_ReturnTypeIsSystemStringInCSharpProject_ReturnsString() "class MyClass {\r\n" +
// { " System.Int32 MyMethod() { return 10; }\r\n" +
// helper.CreateReturnType("System.String"); "}");
// ProjectContentIsForCSharpProject();
// AddUnderlyingClassToReturnType("System.String"); string name = typeRef.AsString;
// CreateCodeTypeRef2();
// Assert.AreEqual("int", name);
// string name = typeRef.AsString; }
//
// Assert.AreEqual("string", name); [Test]
// } [Ignore("VB.NET not supported")]
// public void AsString_ReturnTypeIsSystemInt32InVisualBasicProject_ReturnsInteger()
// [Test] {
// public void AsString_ReturnTypeIsSystemInt32InCSharpProject_ReturnsInt()
// {
// helper.CreateReturnType("System.Int32");
// AddUnderlyingClassToReturnType("System.Int32");
// ProjectContentIsForCSharpProject();
// CreateCodeTypeRef2();
//
// string name = typeRef.AsString;
//
// Assert.AreEqual("int", name);
// }
//
// [Test]
// public void AsString_ReturnTypeIsSystemInt32InVisualBasicProject_ReturnsInteger()
// {
// helper.CreateReturnType("System.Int32"); // helper.CreateReturnType("System.Int32");
// AddUnderlyingClassToReturnType("System.Int32"); // AddUnderlyingClassToReturnType("System.Int32");
// ProjectContentIsForVisualBasicProject(); // ProjectContentIsForVisualBasicProject();
@ -172,210 +157,245 @@
// string name = typeRef.AsString; // string name = typeRef.AsString;
// //
// Assert.AreEqual("Integer", name); // Assert.AreEqual("Integer", name);
// } }
//
// [Test] [Test]
// public void AsString_ReturnTypeIsCustomType_ReturnsFullTypeName() public void AsString_ReturnTypeIsCustomType_ReturnsFullTypeName()
// { {
// helper.CreateReturnType("Test.MyClass"); CreateCodeTypeRef2(
// AddUnderlyingClassToReturnType("Test.MyClass"); "using System;\r\n" +
// ProjectContentIsForCSharpProject(); "namespace Test {\r\n" +
// helper.AddDotNetName("Test.MyClass"); " class MyClass {\r\n" +
// CreateCodeTypeRef2(); " CustomType MyMethod() { return null; }\r\n" +
// " }\r\n" +
// string name = typeRef.AsString; " class CustomType {}\r\n" +
// "}");
// Assert.AreEqual("Test.MyClass", name);
// } string name = typeRef.AsString;
//
// [Test] Assert.AreEqual("Test.CustomType", name);
// public void TypeKind_ReturnTypeIsReferenceType_ReturnsClassType() }
// {
// helper.CreateReturnType("Test.MyClass"); [Test]
// AddUnderlyingClassToReturnType("Test.MyClass"); public void TypeKind_ReturnTypeIsReferenceType_ReturnsClassType()
// helper.MakeReferenceType(); {
// CreateCodeTypeRef2(); CreateCodeTypeRef2(
// "class MyClass {\r\n" +
// global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind; " MyType MyMethod() { return null; }\r\n" +
// "}\r\n" +
// Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefCodeType, kind); "class MyType {}");
// }
// global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind;
// [Test]
// public void TypeKind_ReturnTypeIsNotReferenceType_ReturnsNonClassType() Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefCodeType, kind);
// { }
// helper.CreateReturnType("Test.MyClass");
// CreateCodeTypeRef2(); [Test]
// public void TypeKind_ReturnTypeIsUnknownTypeAndNotReferenceType_ReturnsNonClassType()
// global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind; {
// CreateCodeTypeRef2(
// Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefOther, kind); "class MyClass {\r\n" +
// } " MyType MyMethod() { return null; }\r\n" +
// "}");
// [Test]
// public void TypeKind_ReturnTypeIsSystemVoid_ReturnsVoidType() global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind;
// {
// helper.CreateReturnType("System.Void"); Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefOther, kind);
// CreateCodeTypeRef2(); }
//
// global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind; [Test]
// public void TypeKind_ReturnTypeIsSystemVoid_ReturnsVoidType()
// Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefVoid, kind); {
// } CreateCodeTypeRef2(
// "class MyClass {\r\n" +
// [Test] " void MyMethod() { }\r\n" +
// public void TypeKind_ReturnTypeIsSystemString_ReturnsStringType() "}");
// {
// helper.CreateReturnType("System.String"); global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind;
// helper.MakeReferenceType();
// CreateCodeTypeRef2(); Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefVoid, kind);
// }
// global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind;
// [Test]
// Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefString, kind); public void TypeKind_ReturnTypeIsSystemString_ReturnsStringType()
// } {
// CreateCodeTypeRef2(
// [Test] "class MyClass {\r\n" +
// public void TypeKind_ReturnTypeIsSystemBoolean_ReturnsBooleanType() " string MyMethod() { return null; }\r\n" +
// { "}");
// helper.CreateReturnType("System.Boolean");
// CreateCodeTypeRef2(); global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind;
//
// global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind; Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefString, kind);
// }
// Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefBool, kind);
// } [Test]
// public void TypeKind_ReturnTypeIsSystemBoolean_ReturnsBooleanType()
// [Test] {
// public void TypeKind_ReturnTypeIsSystemByte_ReturnsByteType() CreateCodeTypeRef2(
// { "class MyClass {\r\n" +
// helper.CreateReturnType("System.Byte"); " bool MyMethod() { return false; }\r\n" +
// CreateCodeTypeRef2(); "}");
//
// global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind; global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind;
//
// Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefByte, kind); Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefBool, kind);
// } }
//
// [Test] [Test]
// public void TypeKind_ReturnTypeIsSystemChar_ReturnsCharType() public void TypeKind_ReturnTypeIsSystemByte_ReturnsByteType()
// { {
// helper.CreateReturnType("System.Char"); CreateCodeTypeRef2(
// CreateCodeTypeRef2(); "class MyClass {\r\n" +
// " byte MyMethod() { return 0x1; }\r\n" +
// global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind; "}");
//
// Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefChar, kind); global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind;
// }
// Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefByte, kind);
// [Test] }
// public void TypeKind_ReturnTypeIsSystemDecimal_ReturnsDecimalType()
// { [Test]
// helper.CreateReturnType("System.Decimal"); public void TypeKind_ReturnTypeIsSystemChar_ReturnsCharType()
// CreateCodeTypeRef2(); {
// CreateCodeTypeRef2(
// global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind; "class MyClass {\r\n" +
// " char MyMethod() { return 'a'; }\r\n" +
// Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefDecimal, kind); "}");
// }
// global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind;
// [Test]
// public void TypeKind_ReturnTypeIsSystemDouble_ReturnsDoubleType() Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefChar, kind);
// { }
// helper.CreateReturnType("System.Double");
// CreateCodeTypeRef2(); [Test]
// public void TypeKind_ReturnTypeIsSystemDecimal_ReturnsDecimalType()
// global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind; {
// CreateCodeTypeRef2(
// Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefDouble, kind); "class MyClass {\r\n" +
// } " decimal MyMethod() { return 0; }\r\n" +
// "}");
// [Test]
// public void TypeKind_ReturnTypeIsSystemSingle_ReturnsFloatType() global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind;
// {
// helper.CreateReturnType("System.Single"); Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefDecimal, kind);
// CreateCodeTypeRef2(); }
//
// global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind; [Test]
// public void TypeKind_ReturnTypeIsSystemDouble_ReturnsDoubleType()
// Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefFloat, kind); {
// } CreateCodeTypeRef2(
// "class MyClass {\r\n" +
// [Test] " double MyMethod() { return 0; }\r\n" +
// public void TypeKind_ReturnTypeIsSystemInt32_ReturnsIntType() "}");
// {
// helper.CreateReturnType("System.Int32"); global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind;
// CreateCodeTypeRef2();
// Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefDouble, kind);
// global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind; }
//
// Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefInt, kind); [Test]
// } public void TypeKind_ReturnTypeIsSystemSingle_ReturnsFloatType()
// {
// [Test] CreateCodeTypeRef2(
// public void TypeKind_ReturnTypeIsSystemInt16_ReturnsShortType() "class MyClass {\r\n" +
// { " System.Single MyMethod() { return 0.1; }\r\n" +
// helper.CreateReturnType("System.Int16"); "}");
// CreateCodeTypeRef2();
// global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind;
// global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind;
// Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefFloat, kind);
// Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefShort, kind); }
// }
// [Test]
// [Test] public void TypeKind_ReturnTypeIsSystemInt32_ReturnsIntType()
// public void TypeKind_ReturnTypeIsSystemInt64_ReturnsLongType() {
// { CreateCodeTypeRef2(
// helper.CreateReturnType("System.Int64"); "class MyClass {\r\n" +
// CreateCodeTypeRef2(); " System.Int32 MyMethod() { return 0; }\r\n" +
// "}");
// global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind;
// global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind;
// Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefLong, kind);
// } Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefInt, kind);
// }
// [Test]
// public void TypeKind_ReturnTypeIsSystemUInt32_ReturnsIntType() [Test]
// { public void TypeKind_ReturnTypeIsSystemInt16_ReturnsShortType()
// helper.CreateReturnType("System.UInt32"); {
// CreateCodeTypeRef2(); CreateCodeTypeRef2(
// "class MyClass {\r\n" +
// global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind; " System.Int16 MyMethod() { return 0; }\r\n" +
// "}");
// Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefInt, kind);
// } global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind;
//
// [Test] Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefShort, kind);
// public void TypeKind_ReturnTypeIsSystemUInt16_ReturnsShortType() }
// {
// helper.CreateReturnType("System.UInt16"); [Test]
// CreateCodeTypeRef2(); public void TypeKind_ReturnTypeIsSystemInt64_ReturnsLongType()
// {
// global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind; CreateCodeTypeRef2(
// "class MyClass {\r\n" +
// Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefShort, kind); " System.Int64 MyMethod() { return 0; }\r\n" +
// } "}");
//
// [Test] global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind;
// public void TypeKind_ReturnTypeIsSystemUInt64_ReturnsLongType()
// { Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefLong, kind);
// helper.CreateReturnType("System.UInt64"); }
// CreateCodeTypeRef2();
// [Test]
// global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind; public void TypeKind_ReturnTypeIsSystemUInt32_ReturnsIntType()
// {
// Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefLong, kind); CreateCodeTypeRef2(
// } "class MyClass {\r\n" +
// " System.UInt32 MyMethod() { return 0; }\r\n" +
// [Test] "}");
// public void TypeKind_ReturnTypeIsSystemObject_ReturnsObjectType()
// { global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind;
// helper.CreateReturnType("System.Object");
// CreateCodeTypeRef2(); Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefInt, kind);
// }
// global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind;
// [Test]
// Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefObject, kind); public void TypeKind_ReturnTypeIsSystemUInt16_ReturnsShortType()
// } {
// } CreateCodeTypeRef2(
//} "class MyClass {\r\n" +
" System.UInt16 MyMethod() { return 0; }\r\n" +
"}");
global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind;
Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefShort, kind);
}
[Test]
public void TypeKind_ReturnTypeIsSystemUInt64_ReturnsLongType()
{
CreateCodeTypeRef2(
"class MyClass {\r\n" +
" System.UInt64 MyMethod() { return 0; }\r\n" +
"}");
global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind;
Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefLong, kind);
}
[Test]
public void TypeKind_ReturnTypeIsSystemObject_ReturnsObjectType()
{
CreateCodeTypeRef2(
"class MyClass {\r\n" +
" System.Object MyMethod() { return null; }\r\n" +
"}");
global::EnvDTE.vsCMTypeRef kind = typeRef.TypeKind;
Assert.AreEqual(global::EnvDTE.vsCMTypeRef.vsCMTypeRefObject, kind);
}
}
}

Write Preview
Loading…
Cancel
Save