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.FileCodeModel2

pull/375/head
Matt Ward 12 years ago
parent
6fa46d4f24
commit
7d12341de4
4 changed files with 194 additions and 269 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. 51
      src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/FileCodeModel2.cs
  2. 1
      src/AddIns/Misc/PackageManagement/Test/PackageManagement.Tests.csproj
  3. 51
      src/AddIns/Misc/PackageManagement/Test/Src/EnvDTE/CodeImportTests.cs
  4. 360
      src/AddIns/Misc/PackageManagement/Test/Src/EnvDTE/FileCodeModel2Tests.cs

51
src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/FileCodeModel2.cs
Unescape View File

@ -4,20 +4,19 @@
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using ICSharpCode.Core; using ICSharpCode.Core;
using ICSharpCode.NRefactory.CSharp;
using ICSharpCode.NRefactory.CSharp.TypeSystem; using ICSharpCode.NRefactory.CSharp.TypeSystem;
using ICSharpCode.NRefactory.TypeSystem; using ICSharpCode.NRefactory.TypeSystem;
using ICSharpCode.SharpDevelop; using ICSharpCode.SharpDevelop;
using ICSharpCode.SharpDevelop.Dom;
using ICSharpCode.SharpDevelop.Project;
namespace ICSharpCode.PackageManagement.EnvDTE namespace ICSharpCode.PackageManagement.EnvDTE
{ {
public class FileCodeModel2 : MarshalByRefObject, global::EnvDTE.FileCodeModel2 public class FileCodeModel2 : MarshalByRefObject, global::EnvDTE.FileCodeModel2
{ {
CodeModelContext context; CodeModelContext context;
CodeElementsList<CodeElement> codeElements = new CodeElementsList<CodeElement>(); Project project;
CodeElementsList<CodeElement> codeElements;
Dictionary<string, FileCodeModelCodeNamespace> namespaces = new Dictionary<string, FileCodeModelCodeNamespace>(); Dictionary<string, FileCodeModelCodeNamespace> namespaces = new Dictionary<string, FileCodeModelCodeNamespace>();
public FileCodeModel2(CodeModelContext context, Project project) public FileCodeModel2(CodeModelContext context, Project project)
@ -27,6 +26,21 @@ namespace ICSharpCode.PackageManagement.EnvDTE
} }
this.context = context; this.context = context;
this.project = project;
}
public global::EnvDTE.CodeElements CodeElements {
get {
if (codeElements == null) {
codeElements = new CodeElementsList<CodeElement>();
AddCodeElements();
}
return codeElements;
}
}
void AddCodeElements()
{
ICompilation compilation = project.GetCompilationUnit(); ICompilation compilation = project.GetCompilationUnit();
var projectContent = compilation.MainAssembly.UnresolvedAssembly as IProjectContent; var projectContent = compilation.MainAssembly.UnresolvedAssembly as IProjectContent;
@ -35,7 +49,7 @@ namespace ICSharpCode.PackageManagement.EnvDTE
if (file != null) { if (file != null) {
var csharpFile = file as CSharpUnresolvedFile; var csharpFile = file as CSharpUnresolvedFile;
if (csharpFile != null) { if (csharpFile != null) {
AddUsings(codeElements, csharpFile.RootUsingScope, compilation); AddUsings(csharpFile.RootUsingScope, compilation);
} }
var resolveContext = new SimpleTypeResolveContext(compilation.MainAssembly); var resolveContext = new SimpleTypeResolveContext(compilation.MainAssembly);
@ -48,17 +62,9 @@ namespace ICSharpCode.PackageManagement.EnvDTE
} }
} }
public global::EnvDTE.CodeElements CodeElements {
get { return codeElements; }
}
void AddTypes(IEnumerable<ITypeDefinition> types) void AddTypes(IEnumerable<ITypeDefinition> types)
{ {
foreach (ITypeDefinition typeDefinition in types) { foreach (ITypeDefinition typeDefinition in types) {
ITypeDefinitionModel model = typeDefinition.GetModel();
if (model == null) {
continue;
}
CodeType codeType = CodeType.Create(context, typeDefinition); CodeType codeType = CodeType.Create(context, typeDefinition);
if (string.IsNullOrEmpty(typeDefinition.Namespace)) { if (string.IsNullOrEmpty(typeDefinition.Namespace)) {
codeElements.Add(codeType); codeElements.Add(codeType);
@ -66,15 +72,22 @@ namespace ICSharpCode.PackageManagement.EnvDTE
GetNamespace(typeDefinition.Namespace).AddMember(codeType); GetNamespace(typeDefinition.Namespace).AddMember(codeType);
} }
} }
codeElements.AddRange(types.Select(typeDefinition => CodeType.Create(context, typeDefinition)));
} }
public static void AddUsings(CodeElementsList<CodeElement> codeElements, UsingScope usingScope, ICompilation compilation) public void AddUsings(UsingScope usingScope, ICompilation compilation)
{ {
ResolvedUsingScope resolvedUsingScope = usingScope.Resolve(compilation); foreach (KeyValuePair<string, TypeOrNamespaceReference> alias in usingScope.UsingAliases) {
foreach (INamespace ns in resolvedUsingScope.Usings) { AddCodeImport(alias.Value.ToString());
codeElements.Add(new CodeImport(ns.FullName));
} }
foreach (TypeOrNamespaceReference typeOrNamespace in usingScope.Usings) {
AddCodeImport(typeOrNamespace.ToString());
}
}
void AddCodeImport(string namespaceName)
{
codeElements.Add(new CodeImport(namespaceName));
} }
public void AddImport(string name, object position = null, string alias = null) public void AddImport(string name, object position = null, string alias = null)
@ -90,7 +103,7 @@ namespace ICSharpCode.PackageManagement.EnvDTE
namespaces.Add(namespaceName, ns); namespaces.Add(namespaceName, ns);
codeElements.Add(ns); codeElements.Add(ns);
} }
return null; return ns;
} }
} }
} }

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

@ -89,7 +89,6 @@
<Compile Include="Src\EnvDTE\CodeDelegateTests.cs" /> <Compile Include="Src\EnvDTE\CodeDelegateTests.cs" />
<Compile Include="Src\EnvDTE\CodeFunction2Tests.cs" /> <Compile Include="Src\EnvDTE\CodeFunction2Tests.cs" />
<Compile Include="Src\EnvDTE\CodeFunctionTests.cs" /> <Compile Include="Src\EnvDTE\CodeFunctionTests.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" />

51
src/AddIns/Misc/PackageManagement/Test/Src/EnvDTE/CodeImportTests.cs
Unescape View File

@ -1,51 +0,0 @@
//// 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.PackageManagement.EnvDTE;
//using NUnit.Framework;
//using PackageManagement.Tests.Helpers;
//using Rhino.Mocks;
//
//namespace PackageManagement.Tests.EnvDTE
//{
// [TestFixture]
// public class CodeImportTests
// {
// CodeImport codeImport;
// UsingHelper helper;
//
// void CreateCodeImport(string namespaceName)
// {
// helper = new UsingHelper();
// helper.AddNamespace(namespaceName);
// codeImport = new CodeImport(helper.Using);
// }
//
// void CreateCodeImportWithNoNamespace()
// {
// helper = new UsingHelper();
// codeImport = new CodeImport(helper.Using);
// }
//
// [Test]
// public void Kind_SystemXmlNamespace_ReturnsImport()
// {
// CreateCodeImport("System.Xml");
//
// global::EnvDTE.vsCMElement kind = codeImport.Kind;
//
// Assert.AreEqual(global::EnvDTE.vsCMElement.vsCMElementImportStmt, kind);
// }
//
// [Test]
// public void Namespace_UsingHasNoNamespacesAndAliasesIsNull_ReturnsEmptyString()
// {
// CreateCodeImportWithNoNamespace();
//
// string name = codeImport.Namespace;
//
// Assert.AreEqual(String.Empty, name);
// }
// }
//}

360
src/AddIns/Misc/PackageManagement/Test/Src/EnvDTE/FileCodeModel2Tests.cs
Unescape View File

@ -1,199 +1,163 @@
//// 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.EasyCodeDom; using System.Linq;
//using ICSharpCode.PackageManagement; using ICSharpCode.EasyCodeDom;
//using ICSharpCode.PackageManagement.EnvDTE; using ICSharpCode.PackageManagement;
//using ICSharpCode.SharpDevelop.Project; using ICSharpCode.PackageManagement.EnvDTE;
//using NUnit.Framework; using ICSharpCode.SharpDevelop.Project;
//using PackageManagement.Tests.Helpers; using NUnit.Framework;
//using Rhino.Mocks; using PackageManagement.Tests.Helpers;
// using Rhino.Mocks;
//namespace PackageManagement.Tests.EnvDTE
//{ namespace PackageManagement.Tests.EnvDTE
// [TestFixture] {
// public class FileCodeModel2Tests [TestFixture]
// { public class FileCodeModel2Tests : CodeModelTestBase
// FileCodeModel2 fileCodeModel; {
// TestableDTEProject project; FileCodeModel2 fileCodeModel;
// TestableProject msbuildProject;
// FakeFileService fakeFileService; void CreateProjectWithOneFile(string code)
// FileProjectItem fileProjectItem; {
// CompilationUnitHelper compilationUnitHelper; CreateProjectWithOneFile(code, @"d:\project\MyProject\MyFile.cs");
// IDocumentNamespaceCreator namespaceCreator; }
//
// void CreateProjectWithOneFile() void CreateProjectWithOneFile(string code, string fileName)
// { {
// CreateProjectWithOneFile(@"d:\project\MyProject\MyFile.cs"); codeModelContext = codeModelContext.WithFilteredFileName(fileName);
// } CreateCodeModel();
// AddCodeFile(fileName, code);
// void CreateProjectWithOneFile(string fileName) }
// {
// project = new TestableDTEProject(); void CreateFileCodeModel()
// msbuildProject = project.TestableProject; {
// fakeFileService = project.FakeFileService; fileCodeModel = new FileCodeModel2(codeModelContext, dteProject);
// }
// fileProjectItem = new FileProjectItem(msbuildProject, ItemType.Compile) {
// FileName = fileName CodeImport GetFirstCodeImportFromCodeElements()
// }; {
// } return fileCodeModel.CodeElements.FirstCodeImportOrDefault();
// }
// void CreateCompilationUnitForFileProjectItem()
// { global::EnvDTE.CodeNamespace GetFirstCodeNamespaceFromCodeElements()
// compilationUnitHelper = new CompilationUnitHelper(); {
// fakeFileService.CompilationUnitToReturnFromGetCompilationUnit = compilationUnitHelper.CompilationUnit; return fileCodeModel
// } .CodeElements
// .OfType<global::EnvDTE.CodeNamespace>()
// void CreateFileCodeModel() .FirstOrDefault();
// { }
// namespaceCreator = MockRepository.GenerateStub<IDocumentNamespaceCreator>();
// fileCodeModel = new FileCodeModel2(project, fileProjectItem, namespaceCreator); global::EnvDTE.CodeNamespace GetLastCodeNamespaceFromCodeElements()
// } {
// return fileCodeModel
// CodeImport GetFirstCodeImportFromCodeElements() .CodeElements
// { .OfType<global::EnvDTE.CodeNamespace>()
// return fileCodeModel.CodeElements.FirstCodeImportOrDefault(); .LastOrDefault();
// } }
//
// CodeNamespace GetFirstCodeNamespaceFromCodeElements() [Test]
// { public void CodeElements_OneNamespaceInFile_ReturnsOneCodeImport()
// return fileCodeModel.CodeElements.FirstCodeNamespaceOrDefault(); {
// } string code = "using System.Security;";
// CreateProjectWithOneFile(code);
// void AddNamespaceToCompilationUnit(string namespaceName) CreateFileCodeModel();
// {
// compilationUnitHelper.AddNamespace(namespaceName); CodeImport import = GetFirstCodeImportFromCodeElements();
// }
// Assert.AreEqual("System.Security", import.Namespace);
// void AddNamespaceAliasToCompilationUnit(string alias, string namespaceName) Assert.AreEqual(global::EnvDTE.vsCMElement.vsCMElementImportStmt, import.Kind);
// { }
// compilationUnitHelper.AddNamespaceAlias(alias, namespaceName);
// } [Test]
// public void CodeElements_UnknownNamespaceInFile_ReturnsOneCodeImport()
// void AddClassToCompilationUnit(string namespaceName, string className) {
// { string code = "using Tests.CodeModel;";
// var classHelper = new ClassHelper(); CreateProjectWithOneFile(code);
// classHelper.CreatePublicClass(className); CreateFileCodeModel();
// classHelper.AddNamespaceUsingScopeToClass(namespaceName);
// classHelper.AddClassNamespace(namespaceName); CodeImport import = GetFirstCodeImportFromCodeElements();
// compilationUnitHelper.AddClass(classHelper.Class);
// } Assert.AreEqual("Tests.CodeModel", import.Namespace);
// }
// CodeNamespace GetLastCodeNamespaceFromCodeElements()
// { [Test]
// return fileCodeModel.CodeElements.LastCodeNamespaceOrDefault(); public void CodeElements_OneNamespaceAliasInFile_ReturnsOneCodeImport()
// } {
// string code = "using TCM = Tests.CodeModel;";
// [Test] CreateProjectWithOneFile(code);
// public void CodeElements_OneNamespaceInFile_FileNameUsedToGetCompilationUnit() CreateFileCodeModel();
// {
// CreateProjectWithOneFile(@"d:\projects\MyProject\MyFile.cs"); CodeImport import = GetFirstCodeImportFromCodeElements();
// CreateCompilationUnitForFileProjectItem();
// CreateFileCodeModel(); Assert.AreEqual("Tests.CodeModel", import.Namespace);
// AddNamespaceToCompilationUnit("Test.CodeModel"); }
//
// CodeImport import = GetFirstCodeImportFromCodeElements(); [Test]
// [Ignore("TODO - Not implemented")]
// Assert.AreEqual(@"d:\projects\MyProject\MyFile.cs", fakeFileService.FileNamePassedToGetCompilationUnit); public void AddImport_AddSystemXmlNamespace_NamespaceAndcompilationUnitPassedToNamespaceCreator()
// } {
// CreateProjectWithOneFile("");
// [Test] CreateFileCodeModel();
// public void CodeElements_OneNamespaceInFile_ReturnsOneCodeImport()
// { fileCodeModel.AddImport("System.Xml");
// CreateProjectWithOneFile();
// CreateCompilationUnitForFileProjectItem();
// CreateFileCodeModel();
// AddNamespaceToCompilationUnit("Test.CodeModel");
//
// CodeImport import = GetFirstCodeImportFromCodeElements();
//
// Assert.AreEqual("Test.CodeModel", import.Namespace);
// }
//
// [Test]
// public void CodeElements_OneNamespaceAliasInFile_ReturnsOneCodeImport()
// {
// CreateProjectWithOneFile();
// CreateCompilationUnitForFileProjectItem();
// CreateFileCodeModel();
// AddNamespaceAliasToCompilationUnit("TCM", "Test.CodeModel");
//
// CodeImport import = GetFirstCodeImportFromCodeElements();
//
// Assert.AreEqual("Test.CodeModel", import.Namespace);
// }
//
// [Test]
// public void AddImport_AddSystemXmlNamespace_NamespaceAndcompilationUnitPassedToNamespaceCreator()
// {
// CreateProjectWithOneFile();
// CreateCompilationUnitForFileProjectItem();
// CreateFileCodeModel();
//
// fileCodeModel.AddImport("System.Xml");
//
// namespaceCreator.AssertWasCalled(creator => creator.AddNamespace(compilationUnitHelper.CompilationUnit, "System.Xml")); // namespaceCreator.AssertWasCalled(creator => creator.AddNamespace(compilationUnitHelper.CompilationUnit, "System.Xml"));
// } }
//
// [Test] [Test]
// public void CodeElements_OneClassInFileWithNamespace_ReturnsOneCodeNamespace() public void CodeElements_OneClassInFileWithNamespace_ReturnsOneClassInsideCodeNamespace()
// { {
// CreateProjectWithOneFile(); string code =
// CreateCompilationUnitForFileProjectItem(); "namespace Test.CodeModel {\r\n" +
// AddClassToCompilationUnit("Test.CodeModel", "Test.CodeModel.Class1"); " public class Class1 {}\r\n" +
// CreateFileCodeModel(); "}";
// CreateProjectWithOneFile(code);
// CodeNamespace ns = GetFirstCodeNamespaceFromCodeElements(); CreateFileCodeModel();
//
// Assert.AreEqual("Test.CodeModel", ns.Name); global::EnvDTE.CodeNamespace ns = GetFirstCodeNamespaceFromCodeElements();
// } CodeClass2 codeClass = ns.Members.FirstCodeClass2OrDefault();
//
// [Test] Assert.AreEqual("Test.CodeModel.Class1", codeClass.FullName);
// public void CodeElements_OneClassInFileWithNamespace_ReturnsOneClassInsideCodeNamespace() }
// {
// CreateProjectWithOneFile(); [Test]
// CreateCompilationUnitForFileProjectItem(); public void CodeElements_TwoClassesInFileWithNamespace_ReturnsTwoClassesInsideCodeNamespace()
// AddClassToCompilationUnit("Test.CodeModel", "Test.CodeModel.Class1"); {
// CreateFileCodeModel(); string code =
// "namespace Test.CodeModel {\r\n" +
// CodeNamespace ns = GetFirstCodeNamespaceFromCodeElements(); " public class Class1 {}\r\n" +
// CodeClass2 codeClass = ns.Members.FirstCodeClass2OrDefault(); " public class Class2 {}\r\n" +
// "}";
// Assert.AreEqual("Test.CodeModel.Class1", codeClass.FullName); CreateProjectWithOneFile(code);
// } CreateFileCodeModel();
//
// [Test] global::EnvDTE.CodeNamespace ns = GetFirstCodeNamespaceFromCodeElements();
// public void CodeElements_TwoClassesInFileWithNamespace_ReturnsTwoClassesInsideCodeNamespace() CodeClass2 codeClass1 = ns.Members.FirstCodeClass2OrDefault();
// { CodeClass2 codeClass2 = ns.Members.LastCodeClass2OrDefault();
// CreateProjectWithOneFile();
// CreateCompilationUnitForFileProjectItem(); Assert.AreEqual("Test.CodeModel.Class1", codeClass1.FullName);
// AddClassToCompilationUnit("Test.CodeModel", "Test.CodeModel.Class1"); Assert.AreEqual("Test.CodeModel.Class2", codeClass2.FullName);
// AddClassToCompilationUnit("Test.CodeModel", "Test.CodeModel.Class2"); }
// CreateFileCodeModel();
// [Test]
// CodeNamespace ns = GetFirstCodeNamespaceFromCodeElements(); public void CodeElements_TwoClassesInFileEachWithDifferentNamespace_ReturnsTwoCodeNamespaces()
// CodeClass2 codeClass1 = ns.Members.FirstCodeClass2OrDefault(); {
// CodeClass2 codeClass2 = ns.Members.LastCodeClass2OrDefault(); string code =
// "namespace Test.CodeModel1 {\r\n" +
// Assert.AreEqual("Test.CodeModel.Class1", codeClass1.FullName); " public class Class1 {}\r\n" +
// Assert.AreEqual("Test.CodeModel.Class2", codeClass2.FullName); "}\r\n" +
// } "namespace Test.CodeModel2 {\r\n" +
// " public class Class2 {}\r\n" +
// [Test] "}";
// public void CodeElements_TwoClassesInFileEachWithDifferentNamespace_ReturnsTwoCodeNamespaces() CreateProjectWithOneFile(code);
// { CreateFileCodeModel();
// CreateProjectWithOneFile();
// CreateCompilationUnitForFileProjectItem(); global::EnvDTE.CodeNamespace ns1 = GetFirstCodeNamespaceFromCodeElements();
// AddClassToCompilationUnit("Test.CodeModel1", "Test.CodeModel.Class1"); global::EnvDTE.CodeNamespace ns2 = GetLastCodeNamespaceFromCodeElements();
// AddClassToCompilationUnit("Test.CodeModel2", "Test.CodeModel.Class2");
// CreateFileCodeModel(); Assert.AreEqual("Test.CodeModel1", ns1.Name);
// Assert.AreEqual("Test.CodeModel2", ns2.Name);
// CodeNamespace ns1 = GetFirstCodeNamespaceFromCodeElements(); }
// CodeNamespace ns2 = GetLastCodeNamespaceFromCodeElements(); }
// }
// Assert.AreEqual("Test.CodeModel1", ns1.Name);
// Assert.AreEqual("Test.CodeModel2", ns2.Name);
// }
// }
//}

Write Preview
Loading…
Cancel
Save