public void Cleanup()
{
engine.UnloadProject(project);
engine.UnloadAllProjects();
ObjectModelHelpers.DeleteTempProjectDirectory();
}
public void Dispose()
{
// Remove any temp files that have been created by each test
ObjectModelHelpers.DeleteTempProjectDirectory();
ProjectCollection.GlobalProjectCollection.UnloadAllProjects();
GC.Collect();
}
public void Initialize()
{
ObjectModelHelpers.DeleteTempProjectDirectory();
engine = new Engine();
project = new Project(engine);
}
/// <summary>
/// Helper Method to create a Main project that imports 2 other projects, each with build property groups
/// </summary>
/// <returns>Project</returns>
private static Project GetProjectWithTwoImportProjects()
{
string subProjectContents = @"
<Project xmlns=`msbuildnamespace`>
<PropertyGroup>
<n1>v1</n1>
</PropertyGroup>
<PropertyGroup>
<n2>v2</n2>
</PropertyGroup>
</Project>
";
string projectContents = @"
<Project xmlns=`msbuildnamespace`>
<PropertyGroup>
<n>v</n>
</PropertyGroup>
<Import Project=`import1.proj` />
<Import Project=`import2.proj` />
<Target Name=`Build`>
<WashCar/>
</Target>
</Project>
";
ObjectModelHelpers.DeleteTempProjectDirectory();
ObjectModelHelpers.CreateFileInTempProjectDirectory("import1.proj", subProjectContents);
ObjectModelHelpers.CreateFileInTempProjectDirectory("import2.proj", subProjectContents);
ObjectModelHelpers.CreateFileInTempProjectDirectory("main.proj", projectContents);
Project p = ObjectModelHelpers.LoadProjectFileInTempProjectDirectory("main.proj", null);
return(p);
}
/// <summary>
/// Helper Method to create a Main project that imports 1 other project. Each project contains only one Build Property Group
/// and each of those Build Property Groups contain a Build Property of a specific name (which is used as a flag/key) to
/// identify which Build Property Group we're working with.
/// </summary>
/// <returns>Project</returns>
private static Project GetProjectWithOneImportProject()
{
string importProjectContents = @"
<Project xmlns=`msbuildnamespace`>
<PropertyGroup>
<imported>v</imported>
</PropertyGroup>
</Project>
";
string projectContents = @"
<Project xmlns=`msbuildnamespace`>
<PropertyGroup>
<main>v</main>
</PropertyGroup>
<Import Project=`import1.proj` />
<Target Name=`Build`>
<WashCar/>
</Target>
</Project>
";
ObjectModelHelpers.DeleteTempProjectDirectory();
ObjectModelHelpers.CreateFileInTempProjectDirectory("import1.proj", importProjectContents);
ObjectModelHelpers.CreateFileInTempProjectDirectory("main.proj", projectContents);
Project p = ObjectModelHelpers.LoadProjectFileInTempProjectDirectory("main.proj", null);
return(p);
}
public void Initialize()
{
ObjectModelHelpers.DeleteTempProjectDirectory();
engine = new Engine();
engine.DefaultToolsVersion = "4.0";
project = new Project(engine);
logger = new MockLogger();
project.ParentEngine.RegisterLogger(logger);
}
public void SemicolonInConfiguration()
{
ObjectModelHelpers.DeleteTempProjectDirectory();
// ---------------------
// Foo.csproj
// ---------------------
ObjectModelHelpers.CreateFileInTempProjectDirectory("foo.csproj", @"
<Project DefaultTargets=`Build` ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<PropertyGroup>
<Configuration Condition=` '$(Configuration)' == '' `>Debug</Configuration>
<Platform Condition=` '$(Platform)' == '' `>AnyCPU</Platform>
<OutputType>Library</OutputType>
<AssemblyName>ClassLibrary16</AssemblyName>
</PropertyGroup>
<PropertyGroup Condition=` '$(Configuration)|$(Platform)' == 'a%3bb%27c|AnyCPU' `>
<OutputPath>bin\a%3bb%27c\</OutputPath>
</PropertyGroup>
<ItemGroup>
<Reference Include=`System` />
<Compile Include=`Class1.cs` />
</ItemGroup>
<Import Project=`$(MSBuildBinPath)\Microsoft.CSharp.targets` />
</Project>
");
// ---------------------
// Class1.cs
// ---------------------
ObjectModelHelpers.CreateFileInTempProjectDirectory("Class1.cs", @"
namespace ClassLibrary16
{
public class Class1
{
}
}
");
// Create a logger.
MockLogger logger = new MockLogger();
Project project = ObjectModelHelpers.LoadProjectFileInTempProjectDirectory("foo.csproj", logger);
// Build the default targets using the Configuration "a;b'c".
project.GlobalProperties.SetProperty("Configuration", "a;b'c", true /* literal value */);
bool success = project.Build(null, null);
Assertion.Assert("Build failed. See Standard Out tab for details", success);
ObjectModelHelpers.AssertFileExistsInTempProjectDirectory(@"obj\a;b'c\ClassLibrary16.dll");
ObjectModelHelpers.AssertFileExistsInTempProjectDirectory(@"bin\a;b'c\ClassLibrary16.dll");
logger.AssertLogContains(String.Format("foo -> {0}", Path.Combine(ObjectModelHelpers.TempProjectDir, @"bin\a;b'c\ClassLibrary16.dll")));
}
public void GetImportPathsAndImportPathsIncludingDuplicates(bool useDirectConstruction, ProjectLoadSettings projectLoadSettings)
{
try
{
string projectFileContent = @"
<Project>
<Import Project='{0}'/>
<Import Project='{1}'/>
<Import Project='{0}'/>
</Project>";
string import1Content = @"
<Project>
<Import Project='{0}'/>
<Import Project='{1}'/>
</Project>";
string import2Content = @"<Project />";
string import3Content = @"<Project />";
string import2Path = ObjectModelHelpers.CreateFileInTempProjectDirectory("import2.targets", import2Content);
string import3Path = ObjectModelHelpers.CreateFileInTempProjectDirectory("import3.targets", import3Content);
import1Content = string.Format(import1Content, import2Path, import3Path);
string import1Path = ObjectModelHelpers.CreateFileInTempProjectDirectory("import1.targets", import1Content);
projectFileContent = string.Format(projectFileContent, import1Path, import2Path);
ProjectCollection projectCollection = new ProjectCollection();
BuildParameters buildParameters = new BuildParameters(projectCollection)
{
ProjectLoadSettings = projectLoadSettings
};
BuildEventContext buildEventContext = new BuildEventContext(0, BuildEventContext.InvalidTargetId, BuildEventContext.InvalidProjectContextId, BuildEventContext.InvalidTaskId);
ProjectRootElement rootElement = ProjectRootElement.Create(XmlReader.Create(new StringReader(projectFileContent)));
ProjectInstance projectInstance = useDirectConstruction
? new ProjectInstance(rootElement, globalProperties: null, toolsVersion: null, buildParameters, projectCollection.LoggingService, buildEventContext, sdkResolverService: null, 0)
: new Project(rootElement, globalProperties: null, toolsVersion: null, projectCollection, projectLoadSettings).CreateProjectInstance();
string[] expectedImportPaths = new string[] { import1Path, import2Path, import3Path };
string[] expectedImportPathsIncludingDuplicates = projectLoadSettings.HasFlag(ProjectLoadSettings.RecordDuplicateButNotCircularImports)
? new string[] { import1Path, import2Path, import3Path, import2Path, import1Path }
: expectedImportPaths;
Helpers.AssertListsValueEqual(expectedImportPaths, projectInstance.ImportPaths.ToList());
Helpers.AssertListsValueEqual(expectedImportPathsIncludingDuplicates, projectInstance.ImportPathsIncludingDuplicates.ToList());
}
finally
{
ObjectModelHelpers.DeleteTempProjectDirectory();
}
}
public void SemicolonInSourceCodeFilename()
{
ObjectModelHelpers.DeleteTempProjectDirectory();
// ---------------------
// Foo.csproj
// ---------------------
ObjectModelHelpers.CreateFileInTempProjectDirectory("foo.csproj", @"
<Project DefaultTargets=`Build` ToolsVersion=`msbuilddefaulttoolsversion` xmlns=`msbuildnamespace`>
<PropertyGroup>
<Configuration Condition=` '$(Configuration)' == '' `>Debug</Configuration>
<Platform Condition=` '$(Platform)' == '' `>AnyCPU</Platform>
<OutputType>Library</OutputType>
<AssemblyName>ClassLibrary16</AssemblyName>
</PropertyGroup>
<PropertyGroup Condition=` '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' `>
<OutputPath>bin\Debug\</OutputPath>
</PropertyGroup>
<ItemGroup>
<Reference Include=`System` />
<Compile Include=`Class%3b1.cs` />
</ItemGroup>
<Import Project=`$(MSBuildBinPath)\Microsoft.CSharp.targets` />
</Project>
");
// ---------------------
// Class1.cs
// ---------------------
ObjectModelHelpers.CreateFileInTempProjectDirectory("Class;1.cs", @"
namespace ClassLibrary16
{
public class Class1
{
}
}
");
MockLogger log = ObjectModelHelpers.BuildTempProjectFileExpectSuccess("foo.csproj");
Assertion.Assert(@"Did not find expected file obj\debug\ClassLibrary16.dll",
File.Exists(Path.Combine(ObjectModelHelpers.TempProjectDir, @"obj\debug\ClassLibrary16.dll")));
Assertion.Assert(@"Did not find expected file obj\debug\ClassLibrary16.pdb",
File.Exists(Path.Combine(ObjectModelHelpers.TempProjectDir, @"obj\debug\ClassLibrary16.pdb")));
Assertion.Assert(@"Did not find expected file bin\debug\ClassLibrary16.dll",
File.Exists(Path.Combine(ObjectModelHelpers.TempProjectDir, @"bin\debug\ClassLibrary16.dll")));
Assertion.Assert(@"Did not find expected file bin\debug\ClassLibrary16.pdb",
File.Exists(Path.Combine(ObjectModelHelpers.TempProjectDir, @"bin\debug\ClassLibrary16.pdb")));
log.AssertLogContains(String.Format("foo -> {0}", Path.Combine(ObjectModelHelpers.TempProjectDir, @"bin\Debug\ClassLibrary16.dll")));
}
/// <summary>
/// Saves a given Project to disk and compares what's saved to disk with expected contents. Assertion handled within
/// ObjectModelHelpers.CompareProjectContents.
/// </summary>
/// <param name="p">Project to save</param>
/// <param name="expectedProjectContents">The Project content that you expect</param>
private static void SaveProjectToDiskAndCompareAgainstExpectedContents(Project p, string expectedProjectContents)
{
string savePath = Path.Combine(ObjectModelHelpers.TempProjectDir, "p.proj");
p.Save(savePath);
Engine e = new Engine();
Project savedProject = new Project(e);
savedProject.Load(savePath);
ObjectModelHelpers.CompareProjectContents(savedProject, expectedProjectContents);
ObjectModelHelpers.DeleteTempProjectDirectory();
}
public void InitialTargetsDefaultTargetsEscaped()
{
try
{
string projectFileContent = @"
<Project DefaultTargets='d0a%3bd0b' InitialTargets='i0a%3bi0b' xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
</Project>";
ProjectInstance project = new Project(ProjectRootElement.Create(XmlReader.Create(new StringReader(projectFileContent)))).CreateProjectInstance();
Helpers.AssertListsValueEqual(new string[] { "d0a;d0b" }, project.DefaultTargets);
Helpers.AssertListsValueEqual(new string[] { "i0a;i0b" }, project.InitialTargets);
}
finally
{
ObjectModelHelpers.DeleteTempProjectDirectory();
}
}
public void GetTaskRegistrations()
{
try
{
string projectFileContent = @"
<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
<UsingTask TaskName='t0' AssemblyFile='af0'/>
<UsingTask TaskName='t1' AssemblyFile='af1a'/>
<ItemGroup>
<i Include='i0'/>
</ItemGroup>
<Import Project='{0}'/>
</Project>";
string importContent = @"
<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
<UsingTask TaskName='t1' AssemblyName='an1' Condition=""'$(p)'=='v'""/>
<UsingTask TaskName='t2' AssemblyName='an2' Condition=""'@(i)'=='i0'""/>
<UsingTask TaskName='t3' AssemblyFile='af' Condition='false'/>
<PropertyGroup>
<p>v</p>
</PropertyGroup>
</Project>";
string importPath = ObjectModelHelpers.CreateFileInTempProjectDirectory("import.targets", importContent);
projectFileContent = String.Format(projectFileContent, importPath);
ProjectInstance project = new Project(ProjectRootElement.Create(XmlReader.Create(new StringReader(projectFileContent)))).CreateProjectInstance();
Assert.Equal(3, project.TaskRegistry.TaskRegistrations.Count);
Assert.Equal(Path.Combine(Directory.GetCurrentDirectory(), "af0"), project.TaskRegistry.TaskRegistrations[new TaskRegistry.RegisteredTaskIdentity("t0", null)][0].TaskFactoryAssemblyLoadInfo.AssemblyFile);
Assert.Equal(Path.Combine(Directory.GetCurrentDirectory(), "af1a"), project.TaskRegistry.TaskRegistrations[new TaskRegistry.RegisteredTaskIdentity("t1", null)][0].TaskFactoryAssemblyLoadInfo.AssemblyFile);
Assert.Equal("an1", project.TaskRegistry.TaskRegistrations[new TaskRegistry.RegisteredTaskIdentity("t1", null)][1].TaskFactoryAssemblyLoadInfo.AssemblyName);
Assert.Equal("an2", project.TaskRegistry.TaskRegistrations[new TaskRegistry.RegisteredTaskIdentity("t2", null)][0].TaskFactoryAssemblyLoadInfo.AssemblyName);
}
finally
{
ObjectModelHelpers.DeleteTempProjectDirectory();
}
}
public void InitialTargetsDefaultTargets()
{
try
{
string projectFileContent = @"
<Project DefaultTargets='d0a;d0b' InitialTargets='i0a;i0b' xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
<Import Project='{0}'/>
<Import Project='{1}'/>
</Project>";
string import1Content = @"
<Project DefaultTargets='d1a;d1b' InitialTargets='i1a;i1b' xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
<Import Project='{0}'/>
</Project>";
string import2Content = @"<Project DefaultTargets='d2a;2db' InitialTargets='i2a;i2b' xmlns='http://schemas.microsoft.com/developer/msbuild/2003'/>";
string import3Content = @"<Project DefaultTargets='d3a;d3b' InitialTargets='i3a;i3b' xmlns='http://schemas.microsoft.com/developer/msbuild/2003'/>";
string import2Path = ObjectModelHelpers.CreateFileInTempProjectDirectory("import2.targets", import2Content);
string import3Path = ObjectModelHelpers.CreateFileInTempProjectDirectory("import3.targets", import3Content);
import1Content = String.Format(import1Content, import3Path);
string import1Path = ObjectModelHelpers.CreateFileInTempProjectDirectory("import1.targets", import1Content);
projectFileContent = String.Format(projectFileContent, import1Path, import2Path);
ProjectInstance project = new Project(ProjectRootElement.Create(XmlReader.Create(new StringReader(projectFileContent)))).CreateProjectInstance();
Helpers.AssertListsValueEqual(new string[] { "d0a", "d0b" }, project.DefaultTargets);
Helpers.AssertListsValueEqual(new string[] { "i0a", "i0b", "i1a", "i1b", "i3a", "i3b", "i2a", "i2b" }, project.InitialTargets);
}
finally
{
ObjectModelHelpers.DeleteTempProjectDirectory();
}
}
public void SolutionWithLotsaCrazyCharacters()
{
if (ToolLocationHelper.GetPathToDotNetFramework(TargetDotNetFrameworkVersion.Version35) == null)
{
Assert.Ignore(".NET Framework 3.5 is required to be installed for this test, but it is not installed.");
}
ObjectModelHelpers.DeleteTempProjectDirectory();
// ---------------------------------------------------------------------
// Console;!@(foo)'^(Application1.sln
// ---------------------------------------------------------------------
ObjectModelHelpers.CreateFileInTempProjectDirectory(
@"SLN;!@(foo)'^1\Console;!@(foo)'^(Application1.sln",
@"Microsoft Visual Studio Solution File, Format Version 10.00
# Visual Studio 2005
Project(`{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}`) = `Cons.ole;!@(foo)'^(Application1`, `Console;!@(foo)'^(Application1\Cons.ole;!@(foo)'^(Application1.csproj`, `{770F2381-8C39-49E9-8C96-0538FA4349A7}`
EndProject
Project(`{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}`) = `Class;!@(foo)'^(Library1`, `Class;!@(foo)'^(Library1\Class;!@(foo)'^(Library1.csproj`, `{0B4B78CC-C752-43C2-BE9A-319D20216129}`
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Release|Any CPU = Release|Any CPU
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{770F2381-8C39-49E9-8C96-0538FA4349A7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{770F2381-8C39-49E9-8C96-0538FA4349A7}.Debug|Any CPU.Build.0 = Debug|Any CPU
{770F2381-8C39-49E9-8C96-0538FA4349A7}.Release|Any CPU.ActiveCfg = Release|Any CPU
{770F2381-8C39-49E9-8C96-0538FA4349A7}.Release|Any CPU.Build.0 = Release|Any CPU
{0B4B78CC-C752-43C2-BE9A-319D20216129}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{0B4B78CC-C752-43C2-BE9A-319D20216129}.Debug|Any CPU.Build.0 = Debug|Any CPU
{0B4B78CC-C752-43C2-BE9A-319D20216129}.Release|Any CPU.ActiveCfg = Release|Any CPU
{0B4B78CC-C752-43C2-BE9A-319D20216129}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal
");
// ---------------------------------------------------------------------
// Console;!@(foo)'^(Application1.csproj
// ---------------------------------------------------------------------
ObjectModelHelpers.CreateFileInTempProjectDirectory(
@"SLN;!@(foo)'^1\Console;!@(foo)'^(Application1\Cons.ole;!@(foo)'^(Application1.csproj",
@"
<Project DefaultTargets=`Build` ToolsVersion=`3.5` xmlns=`msbuildnamespace`>
<PropertyGroup>
<Configuration Condition=` '$(Configuration)' == '' `>Debug</Configuration>
<Platform Condition=` '$(Platform)' == '' `>AnyCPU</Platform>
<ProductVersion>8.0.50510</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{770F2381-8C39-49E9-8C96-0538FA4349A7}</ProjectGuid>
<OutputType>Exe</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>Console____foo____Application1</RootNamespace>
<AssemblyName>Console%3b!%40%28foo%29%27^%28Application1</AssemblyName>
</PropertyGroup>
<PropertyGroup Condition=` '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' `>
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=` '$(Configuration)|$(Platform)' == 'Release|AnyCPU' `>
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<ItemGroup>
<Reference Include=`System` />
<Reference Include=`System.Data` />
<Reference Include=`System.Xml` />
</ItemGroup>
<ItemGroup>
<Compile Include=`Program.cs` />
</ItemGroup>
<ItemGroup>
<ProjectReference Include=`..\Class%3b!%40%28foo%29%27^%28Library1\Class%3b!%40%28foo%29%27^%28Library1.csproj`>
<Project>{0B4B78CC-C752-43C2-BE9A-319D20216129}</Project>
<Name>Class%3b!%40%28foo%29%27^%28Library1</Name>
</ProjectReference>
</ItemGroup>
<Import Project=`$(MSBuildBinPath)\Microsoft.CSharp.targets` />
</Project>
");
// ---------------------------------------------------------------------
// Program.cs
// ---------------------------------------------------------------------
ObjectModelHelpers.CreateFileInTempProjectDirectory(
@"SLN;!@(foo)'^1\Console;!@(foo)'^(Application1\Program.cs",
@"
using System;
using System.Collections.Generic;
using System.Text;
namespace Console____foo____Application1
{
class Program
{
static void Main(string[] args)
{
Class____foo____Library1.Class1 foo = new Class____foo____Library1.Class1();
}
}
}
");
// ---------------------------------------------------------------------
// Class;!@(foo)'^(Library1.csproj
// ---------------------------------------------------------------------
ObjectModelHelpers.CreateFileInTempProjectDirectory(
@"SLN;!@(foo)'^1\Class;!@(foo)'^(Library1\Class;!@(foo)'^(Library1.csproj",
@"
<Project DefaultTargets=`Build` ToolsVersion=`3.5` xmlns=`msbuildnamespace`>
<PropertyGroup>
<Configuration Condition=` '$(Configuration)' == '' `>Debug</Configuration>
<Platform Condition=` '$(Platform)' == '' `>AnyCPU</Platform>
<ProductVersion>8.0.50510</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{0B4B78CC-C752-43C2-BE9A-319D20216129}</ProjectGuid>
<OutputType>Library</OutputType>
<AppDesignerFolder>Properties</AppDesignerFolder>
<RootNamespace>Class____foo____Library1</RootNamespace>
<AssemblyName>Class%3b!%40%28foo%29%27^%28Library1</AssemblyName>
</PropertyGroup>
<PropertyGroup Condition=` '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' `>
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug\</OutputPath>
<DefineConstants>DEBUG;TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition=` '$(Configuration)|$(Platform)' == 'Release|AnyCPU' `>
<DebugType>pdbonly</DebugType>
<Optimize>true</Optimize>
<OutputPath>bin\Release\</OutputPath>
<DefineConstants>TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
</PropertyGroup>
<ItemGroup>
<Reference Include=`System` />
<Reference Include=`System.Data` />
<Reference Include=`System.Xml` />
</ItemGroup>
<ItemGroup>
<Compile Include=`Class1.cs` />
</ItemGroup>
<Import Project=`$(MSBuildBinPath)\Microsoft.CSharp.targets` />
<!-- The old OM, which is what this solution is being built under, doesn't understand
BeforeTargets, so this test was failing, because _AssignManagedMetadata was set
up as a BeforeTarget for Build. Copied here so that build will return the correct
information again. -->
<Target Name=`BeforeBuild`>
<ItemGroup>
<BuiltTargetPath Include=`$(TargetPath)`>
<ManagedAssembly>$(ManagedAssembly)</ManagedAssembly>
</BuiltTargetPath>
</ItemGroup>
</Target>
</Project>
");
// ---------------------------------------------------------------------
// Class1.cs
// ---------------------------------------------------------------------
ObjectModelHelpers.CreateFileInTempProjectDirectory(
@"SLN;!@(foo)'^1\Class;!@(foo)'^(Library1\Class1.cs",
@"
namespace Class____foo____Library1
{
public class Class1
{
}
}
");
// Cons.ole;!@(foo)'^(Application1
string targetForFirstProject = "Cons_ole_!__foo__^_Application1";
MockLogger log = ObjectModelHelpers.BuildTempProjectFileWithTargetsExpectSuccess(@"SLN;!@(foo)'^1\Console;!@(foo)'^(Application1.sln", new string[] { targetForFirstProject }, new BuildPropertyGroup());
Assertion.Assert(@"Did not find expected file Console;!@(foo)'^(Application1.exe",
File.Exists(Path.Combine(ObjectModelHelpers.TempProjectDir,
@"SLN;!@(foo)'^1\Console;!@(foo)'^(Application1\bin\debug\Console;!@(foo)'^(Application1.exe")));
}
public void Dispose()
{
ObjectModelHelpers.DeleteTempProjectDirectory();
}
public OutputPathTests(ITestOutputHelper output)
{
_output = output;
ObjectModelHelpers.DeleteTempProjectDirectory();
}
