8287c54432
Replaced the old VS templates with ones that offer more flexiblity. Started replacing the Content Project for the samples with our custom project type. Inlcuded a basic not yet working AssimpImporter.
737 lines
36 KiB
C#
737 lines
36 KiB
C#
/********************************************************************************************
|
|
|
|
Copyright (c) Microsoft Corporation
|
|
All rights reserved.
|
|
|
|
Microsoft Public License:
|
|
|
|
This license governs use of the accompanying software. If you use the software, you
|
|
accept this license. If you do not accept the license, do not use the software.
|
|
|
|
1. Definitions
|
|
The terms "reproduce," "reproduction," "derivative works," and "distribution" have the
|
|
same meaning here as under U.S. copyright law.
|
|
A "contribution" is the original software, or any additions or changes to the software.
|
|
A "contributor" is any person that distributes its contribution under this license.
|
|
"Licensed patents" are a contributor's patent claims that read directly on its contribution.
|
|
|
|
2. Grant of Rights
|
|
(A) Copyright Grant- Subject to the terms of this license, including the license conditions
|
|
and limitations in section 3, each contributor grants you a non-exclusive, worldwide,
|
|
royalty-free copyright license to reproduce its contribution, prepare derivative works of
|
|
its contribution, and distribute its contribution or any derivative works that you create.
|
|
(B) Patent Grant- Subject to the terms of this license, including the license conditions
|
|
and limitations in section 3, each contributor grants you a non-exclusive, worldwide,
|
|
royalty-free license under its licensed patents to make, have made, use, sell, offer for
|
|
sale, import, and/or otherwise dispose of its contribution in the software or derivative
|
|
works of the contribution in the software.
|
|
|
|
3. Conditions and Limitations
|
|
(A) No Trademark License- This license does not grant you rights to use any contributors'
|
|
name, logo, or trademarks.
|
|
(B) If you bring a patent claim against any contributor over patents that you claim are
|
|
infringed by the software, your patent license from such contributor to the software ends
|
|
automatically.
|
|
(C) If you distribute any portion of the software, you must retain all copyright, patent,
|
|
trademark, and attribution notices that are present in the software.
|
|
(D) If you distribute any portion of the software in source code form, you may do so only
|
|
under this license by including a complete copy of this license with your distribution.
|
|
If you distribute any portion of the software in compiled or object code form, you may only
|
|
do so under a license that complies with this license.
|
|
(E) The software is licensed "as-is." You bear the risk of using it. The contributors give
|
|
no express warranties, guarantees or conditions. You may have additional consumer rights
|
|
under your local laws which this license cannot change. To the extent permitted under your
|
|
local laws, the contributors exclude the implied warranties of merchantability, fitness for
|
|
a particular purpose and non-infringement.
|
|
|
|
********************************************************************************************/
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using EnvDTE;
|
|
using Microsoft.VisualStudio;
|
|
using Microsoft.VisualStudio.Shell;
|
|
using Microsoft.VisualStudio.Shell.Interop;
|
|
using Microsoft.VisualStudio.TestTools.UnitTesting;
|
|
using Microsoft.VSSDK.Tools.VsIdeTesting;
|
|
using Microsoft.VisualStudio.Project.Automation;
|
|
using Microsoft.VisualStudio.Project.Samples.NestedProject;
|
|
|
|
namespace Microsoft.VisualStudio.Project.IntegrationTests
|
|
{
|
|
/// <summary>
|
|
/// Test of the automation classes OAProject and OAProjectItem
|
|
/// </summary>
|
|
[TestClass]
|
|
public class TestAutomation : BaseTest
|
|
{
|
|
#region test EnvDTE.Project
|
|
/// <summary>
|
|
/// Tests the interface methods on ENVDTE.Property
|
|
/// </summary>
|
|
[TestMethod]
|
|
public void TestAutomationOnProject()
|
|
{
|
|
UIThreadInvoker.Invoke((ThreadInvoker)delegate()
|
|
{
|
|
//Get the global service provider and the dte
|
|
IServiceProvider sp = VsIdeTestHostContext.ServiceProvider;
|
|
DTE dte = (DTE)sp.GetService(typeof(DTE));
|
|
|
|
string destination = Path.Combine(TestContext.TestDir, TestContext.TestName);
|
|
Utilities.CreateMyNestedProject(sp, dte, TestContext.TestName, destination, true);
|
|
|
|
EnvDTE.Project automation = Utilities.FindExtObject(sp, Utilities.NestedProjectGuid, TestContext.TestName);
|
|
|
|
// Test save and Save As
|
|
#region Save with bad input
|
|
this.BadFileNameChecks(automation, true);
|
|
string badFileName = "AnotherFileNotThesameAsTheProjectFile.nestedProj";
|
|
Assert.IsTrue(this.CheckForSaveWithBadFileName<InvalidOperationException>(automation, true, badFileName, String.Empty), "The file named " + badFileName + " could be saved");
|
|
#endregion
|
|
|
|
ProjectNode project = ((OANestedProject)automation).Project;
|
|
automation.Save(project.Url);
|
|
int isDirty;
|
|
project.IsDirty(out isDirty);
|
|
Assert.IsTrue(isDirty == 0, "The project was not saved correctly from automation");
|
|
|
|
#region save as bad input
|
|
this.BadFileNameChecks(automation, false);
|
|
badFileName = @"..\..\";
|
|
Assert.IsTrue(this.CheckForSaveWithBadFileName<InvalidOperationException>(automation, true, badFileName, String.Empty), "The file named " + badFileName + " could be saved");
|
|
#endregion
|
|
|
|
string goodFileName = "ANewProjectFile.nestedproj";
|
|
automation.SaveAs(goodFileName);
|
|
Assert.IsTrue((String.Compare(project.ProjectFile, goodFileName, StringComparison.OrdinalIgnoreCase) == 0), "Save as failed since the file comparison test failed");
|
|
|
|
this.TestFileNamesThatShouldPassForSaveAs(automation);
|
|
});
|
|
}
|
|
#endregion
|
|
|
|
#region test EnvDTE.ProjectItem
|
|
/// <summary>
|
|
/// Tests on the EnvDTE.ProjectItem implementation.
|
|
/// </summary>
|
|
[TestMethod()]
|
|
public void TestAutomationOnProjectItem()
|
|
{
|
|
UIThreadInvoker.Invoke((ThreadInvoker)delegate()
|
|
{
|
|
//Get the global service provider and the dte
|
|
IServiceProvider sp = VsIdeTestHostContext.ServiceProvider;
|
|
DTE dte = (DTE)sp.GetService(typeof(DTE));
|
|
|
|
string destination = Path.Combine(TestContext.TestDir, TestContext.TestName);
|
|
Utilities.CreateMyNestedProject(sp, dte, TestContext.TestName, destination, true);
|
|
|
|
OAProject automation = Utilities.FindExtObject(sp, Utilities.NestedProjectGuid, TestContext.TestName) as OAProject;
|
|
Assert.IsNotNull(automation, "Failed to create a project using automation");
|
|
|
|
ProjectNode project = automation.Project;
|
|
|
|
// Get the AssemblyInfo.cs, try to open it and then ask using automation that it is opened.
|
|
EnvDTE.ProjectItem item = automation.ProjectItems.Item("AssemblyInfo.cs");
|
|
Assert.IsNotNull(item, "Could not retrieve AssemblyInfo.cs");
|
|
|
|
EnvDTE.Window window = item.Open(VSConstants.LOGVIEWID_Primary.ToString());
|
|
Assert.IsNotNull(window, "Could not open the AssemblyInfo.cs");
|
|
window.Activate();
|
|
|
|
bool isOpen = item.get_IsOpen(VSConstants.LOGVIEWID_Primary.ToString());
|
|
Assert.IsTrue(isOpen, "The AssemblyInfo.cs file should have been opened");
|
|
|
|
// Now save it
|
|
item.Save("");
|
|
|
|
Assert.IsTrue(item.Saved, "The renamed AssemblyInfo.cs has not been saved");
|
|
|
|
// Get the Document
|
|
EnvDTE.Document document = item.Document;
|
|
Assert.IsNotNull(document, "Could not retrieve the document object");
|
|
Assert.IsTrue(document.Name == "AssemblyInfo.cs", "The document for the file item is incorrect. It's name should be AssemblyInfo.cs");
|
|
|
|
// Try the properties on a nested item
|
|
EnvDTE.ProjectItem nestedProject = automation.ProjectItems.Item("ANestedProject");
|
|
EnvDTE.ProjectItem nestedProjectItem = nestedProject.ProjectItems.Item("Program.cs");
|
|
EnvDTE.Properties nesteditemsProps = nestedProjectItem.Properties;
|
|
EnvDTE.Property nestedItemProperty = nesteditemsProps.Item("BuildAction");
|
|
Assert.IsNotNull(nestedItemProperty, "Could not retrieve the BuildAction property from the nested project item");
|
|
nestedItemProperty.Value = BuildAction.Content;
|
|
Assert.AreEqual((BuildAction)nestedItemProperty.Value, BuildAction.Content);
|
|
|
|
// Now try the properties on the top project item
|
|
EnvDTE.Properties props = item.Properties;
|
|
Assert.IsNotNull(props, "Could not retrieve the BuildAction property from the nested project item");
|
|
|
|
EnvDTE.Property itemProperty = props.Item("BuildAction");
|
|
Assert.IsNotNull(itemProperty, "Could not retrieve the BuildAction property from the nested project item");
|
|
Assert.IsFalse(itemProperty is OANullProperty, "Could not retrieve the BuildAction property from the nested project item");
|
|
itemProperty.Value = BuildAction.Content;
|
|
Assert.AreEqual(itemProperty.Value, BuildAction.Content);
|
|
|
|
// Now save as
|
|
Assert.IsTrue(item.SaveAs("AssemblyInfo1.cs"), "The file AssemblyInfo.cs could not be reanmed to AssemblyInfo1.cs");
|
|
Assert.IsTrue(item.Name == "AssemblyInfo1.cs", "File item has been renamed to AssemblyInfo1.cs but the Name property has not");
|
|
|
|
// Now try the Program.cs. That should not be opened
|
|
EnvDTE.ProjectItem item1 = automation.ProjectItems.Item("Program.cs");
|
|
|
|
Assert.IsNotNull(item1, "Could not retrieve AssemblyInfo.cs");
|
|
|
|
isOpen = item1.get_IsOpen(VSConstants.LOGVIEWID_Primary.ToString());
|
|
|
|
Assert.IsFalse(isOpen, "The Program.cs should not have been opened");
|
|
|
|
// Now get the Reference folder as a project item and expand it.
|
|
EnvDTE.ProjectItem references = automation.ProjectItems.Item("References");
|
|
references.ExpandView();
|
|
|
|
// Check that actually it was expanded.
|
|
IVsUIHierarchyWindow uiHierarchy = VsShellUtilities.GetUIHierarchyWindow(project.Site, HierarchyNode.SolutionExplorer);
|
|
System.Reflection.MethodInfo mi = typeof(ProjectNode).GetMethod("FindChild", BindingFlags.NonPublic | BindingFlags.Instance);
|
|
ReferenceContainerNode containerNode = (ReferenceContainerNode)mi.Invoke(project, new object[] { "References" });
|
|
|
|
__VSHIERARCHYITEMSTATE state;
|
|
uint stateAsInt;
|
|
uiHierarchy.GetItemState(project, (uint)containerNode.ID, (uint)__VSHIERARCHYITEMSTATE.HIS_Expanded, out stateAsInt);
|
|
state = (__VSHIERARCHYITEMSTATE)stateAsInt;
|
|
Assert.IsTrue(state == __VSHIERARCHYITEMSTATE.HIS_Expanded, "The References folder has not been expanded");
|
|
});
|
|
}
|
|
|
|
[TestMethod()]
|
|
public void TestAutomationOnProjectItems()
|
|
{
|
|
UIThreadInvoker.Invoke((ThreadInvoker)delegate()
|
|
{
|
|
//Get the global service provider and the dte
|
|
IServiceProvider sp = VsIdeTestHostContext.ServiceProvider;
|
|
DTE dte = (DTE)sp.GetService(typeof(DTE));
|
|
|
|
string destination = Path.Combine(TestContext.TestDir, TestContext.TestName);
|
|
Utilities.CreateMyNestedProject(sp, dte, TestContext.TestName, destination, true);
|
|
|
|
OAProject automation = Utilities.FindExtObject(sp, Utilities.NestedProjectGuid, TestContext.TestName) as OAProject;
|
|
Assert.IsNotNull(automation, "Failed to create a project using automation");
|
|
|
|
string newModelFilePath = TestUtils.GetNewFileName(TestContext.TestDir, TestContext.TestName, "model");
|
|
EnvDTE.ProjectItem pi = automation.ProjectItems.AddFromFileCopy(Path.GetFullPath(newModelFilePath));
|
|
Assert.IsNotNull(pi, "Failed to create a modeling project item through automation");
|
|
Assert.IsTrue(pi.Name == Path.GetFileName(newModelFilePath), "ProjectItems AddFromFileCopy has not returned the item that was added");
|
|
|
|
bool[] found = new bool[3];
|
|
// Test enumerators on project items
|
|
foreach(EnvDTE.ProjectItem item in automation.ProjectItems)
|
|
{
|
|
if(item.Name == Path.GetFileName(newModelFilePath))
|
|
{
|
|
found[0] = true;
|
|
}
|
|
else if(item.Name == "Program.cs")
|
|
{
|
|
found[1] = true;
|
|
}
|
|
else if(item.Name == "AssemblyInfo.cs")
|
|
{
|
|
found[2] = true;
|
|
}
|
|
}
|
|
|
|
foreach(bool foundValue in found)
|
|
{
|
|
Assert.IsTrue(foundValue, "The iterator on item collection has not been implemented correctly");
|
|
}
|
|
|
|
/*****Test the AddFolder method*****/
|
|
//Add a simple folder to the project
|
|
ProjectItem folder = automation.ProjectItems.AddFolder("directory", null);
|
|
//Add a subfolder to the folder
|
|
ProjectItem subfolder = folder.ProjectItems.AddFolder("subdirectory", string.Empty);
|
|
//Add another subfolder to that folder
|
|
subfolder.ProjectItems.AddFolder("subsubdirectory", EnvDTE.Constants.vsProjectItemKindPhysicalFolder);
|
|
|
|
//Verify that we have the following structure:
|
|
//Project
|
|
// -directory
|
|
// -subdirectory
|
|
// -subsubdirectory
|
|
ProjectItem directory = automation.ProjectItems.Item("directory") as ProjectItem;
|
|
ProjectItem subdirectory = directory.ProjectItems.Item("subdirectory") as ProjectItem;
|
|
ProjectItem subsubdirectory = subdirectory.ProjectItems.Item("subsubdirectory") as ProjectItem;
|
|
Assert.IsNotNull(directory);
|
|
Assert.IsNotNull(subdirectory);
|
|
Assert.IsNotNull(subsubdirectory);
|
|
|
|
|
|
bool argumentExceptionThrown = false;
|
|
try
|
|
{
|
|
//We expect virtual folders to fail this way.
|
|
folder.ProjectItems.AddFolder("virtualfolder", EnvDTE.Constants.vsProjectItemKindVirtualFolder);
|
|
}
|
|
catch(ArgumentException) { argumentExceptionThrown = true; }
|
|
Assert.IsTrue(argumentExceptionThrown);
|
|
|
|
argumentExceptionThrown = false;
|
|
try
|
|
{
|
|
//Verify that you can't add a folder where a node with that name already exists
|
|
folder.ProjectItems.AddFolder("subdirectory", string.Empty);
|
|
}
|
|
catch(ArgumentException) { argumentExceptionThrown = true; }
|
|
Assert.IsTrue(argumentExceptionThrown);
|
|
});
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tests on the EnvDTE.ProjectItem implementation.
|
|
/// </summary>
|
|
[TestMethod()]
|
|
public void TestMoreAutomationOnProjectItems()
|
|
{
|
|
UIThreadInvoker.Invoke((ThreadInvoker)delegate()
|
|
{
|
|
//Get the global service provider and the dte
|
|
IServiceProvider sp = VsIdeTestHostContext.ServiceProvider;
|
|
DTE dte = (DTE)sp.GetService(typeof(DTE));
|
|
|
|
string destination = Path.Combine(TestContext.TestDir, TestContext.TestName);
|
|
ProjectNode projectNode = Utilities.CreateMyNestedProject(sp, dte, TestContext.TestName, destination, true);
|
|
|
|
EnvDTE.Project project = projectNode.GetAutomationObject() as EnvDTE.Project;
|
|
EnvDTE80.Solution2 solution = project.DTE.Solution as EnvDTE80.Solution2;
|
|
string templateName = solution.GetProjectItemTemplate("CodeFile.zip", "CSharp");
|
|
|
|
ProjectItem item = project.ProjectItems.AddFromTemplate(templateName, "TestFile.cs");
|
|
this.CheckForItem(projectNode, item);
|
|
|
|
string oldStyleTemplateName = templateName.Replace("\\CodeFile\\", "\\CodeFile.zip\\");
|
|
item = project.ProjectItems.AddFromTemplate(oldStyleTemplateName, "TestFile1.cs");
|
|
this.CheckForItem(projectNode, item);
|
|
|
|
// Now add a folder and add an item to the folder.
|
|
ProjectItem folder = project.ProjectItems.AddFolder("Directory", null);
|
|
|
|
item = folder.ProjectItems.AddFromTemplate(templateName, "TestFile2.cs");
|
|
this.CheckForItem(projectNode, item);
|
|
|
|
item = folder.ProjectItems.AddFromTemplate(oldStyleTemplateName, "TestFile3.cs");
|
|
this.CheckForItem(projectNode, item);
|
|
});
|
|
}
|
|
#endregion
|
|
|
|
#region test configuration independent Project Properties
|
|
[TestMethod()]
|
|
public void TestAutomationOnProjectProperties()
|
|
{
|
|
UIThreadInvoker.Invoke((ThreadInvoker)delegate()
|
|
{
|
|
//Get the global service provider and the dte
|
|
IServiceProvider sp = VsIdeTestHostContext.ServiceProvider;
|
|
DTE dte = (DTE)sp.GetService(typeof(DTE));
|
|
|
|
string destination = Path.Combine(TestContext.TestDir, TestContext.TestName);
|
|
ProjectNode projectNode = Utilities.CreateMyNestedProject(sp, dte, TestContext.TestName, destination, true);
|
|
|
|
//get the automation model of the project
|
|
EnvDTE.Project project = projectNode.GetAutomationObject() as EnvDTE.Project;
|
|
|
|
//get properties collection
|
|
EnvDTE.Properties projectProperties = project.Properties;
|
|
Assert.IsNotNull(projectProperties, "Could not get an instance of the project properties object");
|
|
|
|
//test the FullPath property returns the actual project path + project filename
|
|
string fullPathFromProjectNode = projectNode.ProjectFolder + "\\";
|
|
EnvDTE.Property fullPath = projectProperties.Item(ProjectAutomationProperyNames.FullPath);
|
|
Assert.IsFalse(String.IsNullOrEmpty(fullPath.Value.ToString()), "FullPath property is null or has not been assigned any value");
|
|
Assert.IsTrue(0 == String.Compare(fullPath.Value.ToString(), fullPathFromProjectNode, true), "FullPath property does not return the correct Value");
|
|
});
|
|
}
|
|
#endregion
|
|
|
|
#region tests for property interafce method calls for EnvDTE.Properties
|
|
/// <summary>
|
|
/// Tests the interface methods on ENVDTE.Property
|
|
/// </summary>
|
|
[TestMethod()]
|
|
public void TestInterfaceMethodsOnProperty()
|
|
{
|
|
UIThreadInvoker.Invoke((ThreadInvoker)delegate()
|
|
{
|
|
//Get the global service provider and the dte
|
|
IServiceProvider sp = VsIdeTestHostContext.ServiceProvider;
|
|
DTE dte = (DTE)sp.GetService(typeof(DTE));
|
|
|
|
string destination = Path.Combine(TestContext.TestDir, TestContext.TestName);
|
|
Utilities.CreateMyNestedProject(sp, dte, TestContext.TestName, destination, true);
|
|
|
|
OAProject automation = Utilities.FindExtObject(sp, Utilities.NestedProjectGuid, TestContext.TestName) as OAProject;
|
|
Assert.IsNotNull(automation, "Failed to create a project using automation");
|
|
|
|
ProjectNode projectNode = automation.Project;
|
|
|
|
// Get Project Property object
|
|
EnvDTE.Property property = automation.Properties.Item("RootNamespace");
|
|
Assert.IsNotNull(property, "Could not retrieve valid RootNamespace property");
|
|
Assert.IsFalse(property is OANullProperty, "Could not retrieve valid RootNamespace property");
|
|
object retValue = property.Application;
|
|
Assert.IsNull(retValue);
|
|
|
|
Assert.IsTrue((string)property.Value == "Application", "Failed to retrieve the Value property.");
|
|
property.Value = "Test1";
|
|
Assert.AreEqual(property.Value, "Test1");
|
|
|
|
|
|
// Get Collection object from property object
|
|
EnvDTE.Properties properties = property.Collection;
|
|
Assert.IsNotNull(properties, "Collection property failed to retrieve an object");
|
|
|
|
// Get the DTE
|
|
retValue = property.DTE;
|
|
Assert.IsNotNull(retValue);
|
|
|
|
// Get the Indexed value
|
|
retValue = property.get_IndexedValue(1, 2, 3, 4);
|
|
Assert.IsNull(retValue);
|
|
|
|
property.let_Value(1);
|
|
Assert.AreEqual(property.Value, "1");
|
|
|
|
// Check the name.
|
|
string name = property.Name;
|
|
Assert.IsNotNull(name);
|
|
Assert.IsTrue(name == "RootNamespace", "RootNamespace property was not set correctly");
|
|
|
|
short numIndeces = property.NumIndices;
|
|
//Currently it gives back 0
|
|
//It must be Assertd when the method changes
|
|
Assert.IsTrue(numIndeces == 0);
|
|
|
|
// Assert the Object property
|
|
retValue = property.Object;
|
|
Assert.AreEqual(retValue, property.Value);
|
|
property.Object = "test1";
|
|
retValue = property.Object;
|
|
Assert.AreEqual(retValue, "test1");
|
|
|
|
// Test the parent property
|
|
EnvDTE.Properties parent = property.Parent;
|
|
Assert.IsTrue(parent is OAProperties, "Parent property failed to return the parent of a property");
|
|
|
|
//It does nothing currently. Cannot be Assertd.
|
|
property.set_IndexedValue(1, 2, 3, 4, 5);
|
|
|
|
// Try a non string value on the Value.
|
|
ArrayList list = new ArrayList();
|
|
property.Value = list;
|
|
retValue = property.Value;
|
|
Assert.AreEqual(retValue, list.ToString());
|
|
|
|
// Test the iterators for enumeration.
|
|
// We are interested to see that we advance with the iteration.
|
|
bool[] found = new bool[2];
|
|
|
|
foreach(EnvDTE.Property aProperty in automation.Properties)
|
|
{
|
|
|
|
if(aProperty.Name == "RootNamespace")
|
|
{
|
|
found[0] = true;
|
|
}
|
|
else if(aProperty.Name == "AssemblyName")
|
|
{
|
|
found[1] = true;
|
|
}
|
|
}
|
|
|
|
foreach(bool foundValue in found)
|
|
{
|
|
Assert.IsTrue(foundValue, "The iterator on property collection has not been implemented correctly");
|
|
}
|
|
});
|
|
}
|
|
#endregion
|
|
|
|
#region test Project Item Properties for hierarchy nodes of type FileNode
|
|
[TestMethod()]
|
|
public void TestFileNodeRelatedItemProperties()
|
|
{
|
|
UIThreadInvoker.Invoke((ThreadInvoker)delegate()
|
|
{
|
|
//Get the global service provider and the dte
|
|
IServiceProvider sp = VsIdeTestHostContext.ServiceProvider;
|
|
DTE dte = (DTE)sp.GetService(typeof(DTE));
|
|
|
|
string destination = Path.Combine(TestContext.TestDir, TestContext.TestName);
|
|
ProjectNode projectNode = Utilities.CreateMyNestedProject(sp, dte, TestContext.TestName, destination, true);
|
|
|
|
// get the project object
|
|
EnvDTE.Project project = projectNode.GetAutomationObject() as EnvDTE.Project;
|
|
|
|
//get the projectitem object of the program.cs file which is part of the project
|
|
string filename = "program.cs";
|
|
ProjectItem projectItem = project.ProjectItems.Item(filename);
|
|
Assert.IsNotNull(projectItem, "Could not retrieve the projectitem object from the collection of items");
|
|
|
|
//get properties collection
|
|
EnvDTE.Properties properties = projectItem.Properties;
|
|
Assert.IsNotNull(properties, "Could not get an instance of the projectitem properties object");
|
|
|
|
CompareProperties(properties, typeof(FileNodeAutomationPropertyNames));
|
|
});
|
|
}
|
|
#endregion
|
|
|
|
#region test Project Item Properties for hierarchy nodes of type ReferenceNode
|
|
[TestMethod()]
|
|
public void TestReferenceNodeRelatedItemProperties()
|
|
{
|
|
UIThreadInvoker.Invoke((ThreadInvoker)delegate()
|
|
{
|
|
//Get the global service provider and the dte
|
|
IServiceProvider sp = VsIdeTestHostContext.ServiceProvider;
|
|
DTE dte = (DTE)sp.GetService(typeof(DTE));
|
|
|
|
string destination = Path.Combine(TestContext.TestDir, TestContext.TestName);
|
|
ProjectNode projectNode = Utilities.CreateMyNestedProject(sp, dte, TestContext.TestName, destination, true);
|
|
|
|
// get the project object
|
|
EnvDTE.Project project = projectNode.GetAutomationObject() as EnvDTE.Project;
|
|
|
|
//get the projectitem object of the first reference object
|
|
string referenceName = "System";
|
|
ProjectItem projectItem = project.ProjectItems.Item("References").ProjectItems.Item(referenceName);
|
|
Assert.IsNotNull(projectItem, "Could not retrieve the projectitem object from the collection of references");
|
|
|
|
//get properties collection
|
|
EnvDTE.Properties properties = projectItem.Properties;
|
|
Assert.IsNotNull(properties, "Could not get an instance of the projectitem properties object");
|
|
|
|
CompareProperties(properties, typeof(ReferenceNodeAutomationPropertyNames));
|
|
});
|
|
}
|
|
#endregion
|
|
|
|
#region test Project Item Properties for hierarchy nodes of type FolderNode
|
|
[TestMethod()]
|
|
public void TestFolderNodeRelatedProjectItemProperties()
|
|
{
|
|
UIThreadInvoker.Invoke((ThreadInvoker)delegate()
|
|
{
|
|
//Get the global service provider and the dte
|
|
IServiceProvider sp = VsIdeTestHostContext.ServiceProvider;
|
|
DTE dte = (DTE)sp.GetService(typeof(DTE));
|
|
|
|
string destination = Path.Combine(TestContext.TestDir, TestContext.TestName);
|
|
ProjectNode projectNode = Utilities.CreateMyNestedProject(sp, dte, TestContext.TestName, destination, true);
|
|
|
|
// get the project object
|
|
EnvDTE.Project project = projectNode.GetAutomationObject() as EnvDTE.Project;
|
|
|
|
// add new folder to the project
|
|
System.Reflection.MethodInfo mi = typeof(HierarchyNode).GetMethod("AddNewFolder", BindingFlags.NonPublic | BindingFlags.Instance);
|
|
mi.Invoke(projectNode, null);
|
|
|
|
//Get the new foldernode object
|
|
mi = typeof(ProjectNode).GetMethod("FindChild", BindingFlags.NonPublic | BindingFlags.Instance);
|
|
FolderNode folderNode = (FolderNode)mi.Invoke(projectNode, new object[] { "NewFolder1" });
|
|
Assert.IsNotNull(folderNode, "Could not find a folder node in the projec");
|
|
|
|
//get automation object from FolderNode
|
|
ProjectItem projectItem = (ProjectItem)folderNode.GetAutomationObject();
|
|
|
|
//get properties collection
|
|
EnvDTE.Properties properties = projectItem.Properties;
|
|
Assert.IsNotNull(properties, "Could not get an instance of the projectitem properties object");
|
|
|
|
CompareProperties(properties, typeof(FolderNodeAutomationPropertyNames));
|
|
});
|
|
}
|
|
#endregion
|
|
|
|
#region test Configuration dependent properties for ProjectNode object
|
|
//[TestMethod()]
|
|
// This test is failing because of a bug in VS 2008 RTM.
|
|
//TODO: Enable after VS 2008 SP1
|
|
public void TestAutomationOnConfigDependentProperties()
|
|
{
|
|
const int expectedConfigs = 2;
|
|
|
|
UIThreadInvoker.Invoke((ThreadInvoker)delegate()
|
|
{
|
|
//Get the global service provider and the dte
|
|
IServiceProvider sp = VsIdeTestHostContext.ServiceProvider;
|
|
DTE dte = (DTE)sp.GetService(typeof(DTE));
|
|
|
|
string destination = Path.Combine(TestContext.TestDir, TestContext.TestName);
|
|
ProjectNode projectNode = Utilities.CreateMyNestedProject(sp, dte, TestContext.TestName, destination, true);
|
|
|
|
// get the config object for active configuration
|
|
EnvDTE.Project project = projectNode.GetAutomationObject() as EnvDTE.Project;
|
|
ConfigurationManager configManager = project.ConfigurationManager;
|
|
Assert.IsNotNull(configManager, "Could not get configutation Manager object from project object");
|
|
Assert.AreEqual(configManager.Count, expectedConfigs, "Wrong number of configs");
|
|
Configuration activeConfig = configManager.ActiveConfiguration;
|
|
Assert.IsNotNull(activeConfig, "Could not get active configuration");
|
|
|
|
//get properties collection
|
|
EnvDTE.Properties properties = activeConfig.Properties;
|
|
Assert.IsNotNull(properties, "Could not get an instance of the properties object from active configuration");
|
|
|
|
CompareProperties(properties, typeof(ProjectConfigPropertyNames));
|
|
});
|
|
}
|
|
#endregion
|
|
|
|
#region helpers
|
|
private void CompareProperties(EnvDTE.Properties properties, Type propertyNamesType)
|
|
{
|
|
// test number of properties in the collection
|
|
FieldInfo[] propertyNamesFieldInfo;
|
|
propertyNamesFieldInfo = propertyNamesType.GetFields();
|
|
Assert.AreEqual(properties.Count, propertyNamesFieldInfo.Length, "Number of properties does not match expected number of properties");
|
|
|
|
//test that we have the expected set of property names
|
|
foreach(FieldInfo info in propertyNamesFieldInfo)
|
|
{
|
|
string propertyName = info.Name as string;
|
|
Property prop = properties.Item(propertyName);
|
|
Assert.IsNotNull(prop, String.Format("Property %0 not for found in collection", propertyName));
|
|
}
|
|
}
|
|
|
|
private bool CheckForSaveWithBadFileName<T>(EnvDTE.Project project, bool isSave, string badFileName, string expectedMessage)
|
|
where T : Exception
|
|
{
|
|
bool badFileNameCaught = false;
|
|
try
|
|
{
|
|
|
|
if(isSave)
|
|
{
|
|
project.Save(badFileName);
|
|
}
|
|
else
|
|
{
|
|
project.SaveAs(badFileName);
|
|
}
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
if((e is T))
|
|
{
|
|
if((expectedMessage.Length > 0) && (e.Message == expectedMessage || e.Message.Contains(expectedMessage)) || expectedMessage.Length == 0)
|
|
{
|
|
badFileNameCaught = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return badFileNameCaught;
|
|
}
|
|
|
|
private void BadFileNameChecks(EnvDTE.Project automation, bool forSave)
|
|
{
|
|
|
|
|
|
string errorMessage = Utilities.GetResourceStringFromTheProjectAssembly("ErrorInvalidFileName");
|
|
foreach(string newBadFileName in Utilities.BadFileNames)
|
|
{
|
|
Assert.IsTrue(this.CheckForSaveWithBadFileName<InvalidOperationException>(automation, forSave, newBadFileName, errorMessage), "The file named " + newBadFileName + " could be saved");
|
|
}
|
|
string badFileName = "....nestedProj";
|
|
Assert.IsTrue(this.CheckForSaveWithBadFileName<InvalidOperationException>(automation, forSave, badFileName, errorMessage), "The file named " + badFileName + " could be saved");
|
|
|
|
badFileName = " ";
|
|
Assert.IsTrue(this.CheckForSaveWithBadFileName<InvalidOperationException>(automation, forSave, badFileName, errorMessage), "The file named " + badFileName + " could be saved");
|
|
|
|
badFileName = ".....";
|
|
Assert.IsTrue(this.CheckForSaveWithBadFileName<InvalidOperationException>(automation, forSave, badFileName, errorMessage), "The file named " + badFileName + " could be saved");
|
|
|
|
errorMessage = String.Format(System.Globalization.CultureInfo.CurrentCulture, Utilities.GetResourceStringFromTheProjectAssembly("PathTooLong"), Path.Combine(Path.GetDirectoryName(automation.FullName), Utilities.LongFileName));
|
|
Assert.IsTrue(this.CheckForSaveWithBadFileName<InvalidOperationException>(automation, forSave, Utilities.LongFileName, errorMessage), "The file named " + Utilities.LongFileName + " could be saved");
|
|
}
|
|
|
|
private void TestFileNamesThatShouldPassForSaveAs(EnvDTE.Project project)
|
|
{
|
|
foreach(string fileName in Utilities.FileNamesThatShouldPass)
|
|
{
|
|
string goodFileName = fileName + ".nestedproj";
|
|
project.SaveAs(goodFileName);
|
|
Assert.IsTrue((String.Compare(project.FileName, goodFileName, StringComparison.OrdinalIgnoreCase) == 0), "Save as failed since the file comparison test failed");
|
|
}
|
|
}
|
|
|
|
private void CheckForItem(ProjectNode projectNode, ProjectItem item)
|
|
{
|
|
Assert.IsTrue(item != null, "No project item has been added from template to the modeling project");
|
|
Assert.IsTrue(String.Compare(Path.GetExtension(item.Name), ".cs", StringComparison.OrdinalIgnoreCase) == 0, "The item has not been added as a moxl file!");
|
|
|
|
VSDOCUMENTPRIORITY[] priority = new VSDOCUMENTPRIORITY[1];
|
|
uint itemid;
|
|
int found;
|
|
projectNode.IsDocumentInProject(item.get_FileNames(1), out found, priority, out itemid);
|
|
Assert.IsTrue(found == 1, "The item " + item.Name + " has not been added to the project");
|
|
}
|
|
#endregion
|
|
}
|
|
|
|
#region internal helper classes
|
|
/// <summary>
|
|
/// A list of named properties returned in the properties collection for a ProjectNode object
|
|
/// </summary>
|
|
internal class ProjectAutomationProperyNames
|
|
{
|
|
public static string FileName = "FileName";
|
|
public static string FullPath = "FullPath";
|
|
}
|
|
|
|
/// <summary>
|
|
/// A list of named properties returned in the properties collection for a FileNode object
|
|
/// </summary>
|
|
internal class FileNodeAutomationPropertyNames
|
|
{
|
|
public static string BuildAction = "BuildAction";
|
|
public static string FileName = "Filename";
|
|
public static string FullPath = "FullPath";
|
|
public static string CustomTool = "CustomTool";
|
|
public static string CustomToolNamespace = "CustomToolNamespace";
|
|
public static string Extension = "Extension";
|
|
public static string ExtenderCATID = "ExtenderCATID";
|
|
}
|
|
|
|
/// <summary>
|
|
/// A list of named properties returned in the properties collection for a ReferenceNode object
|
|
/// </summary>
|
|
internal class ReferenceNodeAutomationPropertyNames
|
|
{
|
|
public static string Name = "Name";
|
|
public static string CopyToLocal = "CopyToLocal";
|
|
public static string FullPath = "FullPath";
|
|
public static string ExtenderCATID = "ExtenderCATID";
|
|
}
|
|
|
|
/// <summary>
|
|
/// A list of named properties returned in the properties collection for a FolderNode object
|
|
/// </summary>
|
|
internal class FolderNodeAutomationPropertyNames
|
|
{
|
|
public static string FileName = "FileName";
|
|
public static string FullPath = "FullPath";
|
|
public static string ExtenderCATID = "ExtenderCATID";
|
|
}
|
|
|
|
internal class ProjectConfigPropertyNames
|
|
{
|
|
public const string OutputPath = "OutputPath";
|
|
}
|
|
#endregion
|
|
|
|
}
|