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

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

@ -89,7 +89,6 @@ @@ -89,7 +89,6 @@
<Compile Include="Src\EnvDTE\CodeDelegateTests.cs" />
<Compile Include="Src\EnvDTE\CodeFunction2Tests.cs" />
<Compile Include="Src\EnvDTE\CodeFunctionTests.cs" />
<Compile Include="Src\EnvDTE\CodeImportTests.cs" />
<Compile Include="Src\EnvDTE\CodeInterfaceTests.cs" />
<Compile Include="Src\EnvDTE\CodeModelTestBase.cs" />
<Compile Include="Src\EnvDTE\CodeModelTests.cs" />

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

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

Write Preview
Loading…
Cancel
Save