public void Publish()
{
string projectFile = Path.Combine(_rootDir, @"src\project.csproj");
ProjectRootElement projectRootElement = ProjectRootElement.Create(projectFile);
projectRootElement.DefaultTargets = "Publish";
projectRootElement.AddProperty(GetCopyToPublishDirectoryItemsGraphPredictor.PublishDirPropertyName, @"bin\Publish");
const bool shouldCopy = true;
ProjectRootElement dep1 = CreateDependencyProject("dep1", shouldCopy);
ProjectRootElement dep2 = CreateDependencyProject("dep2", shouldCopy);
ProjectRootElement dep3 = CreateDependencyProject("dep3", shouldCopy);
// The main project depends on 1 and 2; 2 depends on 3; 3 depends on 1. Note that this should *not* be transitive
projectRootElement.AddItem("ProjectReference", @"..\dep1\dep1.proj");
projectRootElement.AddItem("ProjectReference", @"..\dep2\dep2.proj");
dep2.AddItem("ProjectReference", @"..\dep3\dep3.proj");
dep3.AddItem("ProjectReference", @"..\dep1\dep1.proj");
projectRootElement.Save();
dep1.Save();
dep2.Save();
dep3.Save();
var expectedInputFiles = new[]
{
new PredictedItem(@"dep1\dep1.xml", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)),
new PredictedItem(@"dep1\dep1.resx", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)),
new PredictedItem(@"dep1\dep1.cs", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)),
new PredictedItem(@"dep1\dep1.txt", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)),
new PredictedItem(@"dep2\dep2.xml", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)),
new PredictedItem(@"dep2\dep2.resx", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)),
new PredictedItem(@"dep2\dep2.cs", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)),
new PredictedItem(@"dep2\dep2.txt", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)),
};
var expectedOutputFiles = new[]
{
new PredictedItem(@"src\bin\Publish\dep1.xml", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)),
new PredictedItem(@"src\bin\Publish\dep1.resx", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)),
new PredictedItem(@"src\bin\Publish\dep1.cs", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)),
new PredictedItem(@"src\bin\Publish\dep1.txt", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)),
new PredictedItem(@"src\bin\Publish\dep2.xml", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)),
new PredictedItem(@"src\bin\Publish\dep2.resx", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)),
new PredictedItem(@"src\bin\Publish\dep2.cs", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)),
new PredictedItem(@"src\bin\Publish\dep2.txt", nameof(GetCopyToPublishDirectoryItemsGraphPredictor)),
};
new GetCopyToPublishDirectoryItemsGraphPredictor()
.GetProjectPredictions(projectFile)
.AssertPredictions(
_rootDir,
expectedInputFiles,
null,
expectedOutputFiles,
null);
}
public void Roslyn_Settings_ValidSetup()
{
// Arrange
BuildLogger logger = new BuildLogger();
// Set the config directory so the targets know where to look for the analysis config file
string confDir = TestUtils.CreateTestSpecificFolder(this.TestContext, "config");
// Create a valid config file containing analyzer settings
string[] expectedAssemblies = new string[] { "c:\\data\\config.analyzer1.dll", "c:\\config2.dll" };
string[] expectedAdditionalFiles = new string[] { "c:\\config.1.txt", "c:\\config.2.txt" };
AnalysisConfig config = new AnalysisConfig();
AnalyzerSettings analyzerSettings = new AnalyzerSettings();
analyzerSettings.Language = "cs";
analyzerSettings.RuleSetFilePath = "d:\\my.ruleset";
analyzerSettings.AnalyzerAssemblyPaths = expectedAssemblies.ToList();
analyzerSettings.AdditionalFilePaths = expectedAdditionalFiles.ToList();
config.AnalyzersSettings = new List <AnalyzerSettings>();
config.AnalyzersSettings.Add(analyzerSettings);
string configFilePath = Path.Combine(confDir, FileConstants.ConfigFileName);
config.Save(configFilePath);
// Create the project
WellKnownProjectProperties properties = new WellKnownProjectProperties();
properties.SonarQubeConfigPath = confDir;
properties.ResolvedCodeAnalysisRuleset = "c:\\should.be.overridden.ruleset";
ProjectRootElement projectRoot = CreateValidProjectSetup(properties);
projectRoot.AddItem(TargetProperties.AnalyzerItemType, "should.be.removed.analyzer1.dll");
projectRoot.AddItem(TargetProperties.AnalyzerItemType, "c:\\should.be.removed.analyzer2.dll");
projectRoot.AddItem(TargetProperties.AdditionalFilesItemType, "should.be.removed.additional1.txt");
projectRoot.AddItem(TargetProperties.AdditionalFilesItemType, "should.be.removed.additional2.txt");
// Act
BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger, TargetConstants.OverrideRoslynAnalysisTarget);
// Assert
logger.AssertTargetExecuted(TargetConstants.OverrideRoslynAnalysisTarget);
logger.AssertTargetExecuted(TargetConstants.SetRoslynAnalysisPropertiesTarget);
BuildAssertions.AssertTargetSucceeded(result, TargetConstants.OverrideRoslynAnalysisTarget);
// Check the error log and ruleset properties are set
AssertErrorLogIsSetBySonarQubeTargets(result);
AssertExpectedResolvedRuleset(result, "d:\\my.ruleset");
AssertExpectedItemValuesExists(result, TargetProperties.AdditionalFilesItemType, expectedAdditionalFiles);
AssertExpectedItemValuesExists(result, TargetProperties.AnalyzerItemType, expectedAssemblies);
BuildAssertions.AssertWarningsAreNotTreatedAsErrorsNorIgnored(result);
}
public void E2E_FxCop_NoFilesToAnalyse()
{
// Arrange
string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs");
string rootOutputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Outputs");
string fxCopLogFile = Path.Combine(rootInputFolder, "FxCopResults.xml");
WellKnownProjectProperties preImportProperties = new WellKnownProjectProperties();
preImportProperties.SonarQubeTempPath = rootOutputFolder; // FIXME
preImportProperties.SonarQubeOutputPath = rootOutputFolder;
preImportProperties.RunCodeAnalysis = "false";
preImportProperties.CodeAnalysisLogFile = fxCopLogFile;
preImportProperties.CodeAnalysisRuleset = "specifiedInProject.ruleset";
preImportProperties[TargetProperties.SonarQubeConfigPath] = rootInputFolder;
CreateValidFxCopRuleset(rootInputFolder, string.Format(TargetProperties.SonarQubeRulesetFormat, "cs"));
ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, preImportProperties);
// Add some files to the project
string itemPath = CreateTextFile(rootInputFolder, "content1.txt", "aaaa");
projectRoot.AddItem("Content", itemPath);
itemPath = CreateTextFile(rootInputFolder, "code1.cs", "class myclassXXX{} // wrong item type");
projectRoot.AddItem("CompileXXX", itemPath);
projectRoot.Save();
BuildLogger logger = new BuildLogger();
// Act
BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger);
// Assert
BuildAssertions.AssertTargetSucceeded(result, TargetConstants.DefaultBuildTarget);
logger.AssertExpectedTargetOrdering(
TargetConstants.CategoriseProjectTarget,
TargetConstants.OverrideFxCopSettingsTarget,
TargetConstants.FxCopTarget,
TargetConstants.SetFxCopResultsTarget, // should set the FxCop results after the platform "run Fx Cop" target
TargetConstants.DefaultBuildTarget,
TargetConstants.CalculateFilesToAnalyzeTarget,
TargetConstants.WriteProjectDataTarget);
logger.AssertTargetExecuted(TargetConstants.SetFxCopResultsTarget);
ProjectInfo projectInfo = ProjectInfoAssertions.AssertProjectInfoExists(rootOutputFolder, projectRoot.FullPath);
ProjectInfoAssertions.AssertAnalysisResultDoesNotExists(projectInfo, AnalysisType.FxCop.ToString());
}
private static ProjectInstance CreateTestProjectInstance(string fileName)
{
ProjectRootElement projectRootElement = ProjectRootElement.Create(fileName);
#pragma warning disable SA1118 // Parameter should not span multiple lines. Justification: Used to help match formatting in real projects
projectRootElement.AddItemDefinitionGroup()
.AddItemDefinition(AdditionalIncludeDirectoriesPredictor.ClCompileItemName)
.AddMetadata(
AdditionalIncludeDirectoriesPredictor.AdditionalIncludeDirectoriesMetadata,
@"..\ClCompileIncludes
;%(AdditionalIncludeDirectories)");
projectRootElement.AddItemDefinitionGroup()
.AddItemDefinition(AdditionalIncludeDirectoriesPredictor.FxCompileItemName)
.AddMetadata(
AdditionalIncludeDirectoriesPredictor.AdditionalIncludeDirectoriesMetadata,
@"..\FxCompileIncludes
;%(AdditionalIncludeDirectories)");
projectRootElement.AddItemDefinitionGroup()
.AddItemDefinition(AdditionalIncludeDirectoriesPredictor.MidlItemName)
.AddMetadata(
AdditionalIncludeDirectoriesPredictor.AdditionalIncludeDirectoriesMetadata,
@"..\MidlIncludes
;%(AdditionalIncludeDirectories)");
projectRootElement.AddItemDefinitionGroup()
.AddItemDefinition(AdditionalIncludeDirectoriesPredictor.ResourceCompileItemName)
.AddMetadata(
AdditionalIncludeDirectoriesPredictor.AdditionalIncludeDirectoriesMetadata,
@"..\ResourceCompileIncludes
;%(AdditionalIncludeDirectories)");
#pragma warning restore SA1118 // Parameter should not span multiple lines
// No change to AdditionalIncludeDirectories
projectRootElement.AddItem(AdditionalIncludeDirectoriesPredictor.ClCompileItemName, "foo.cpp");
// Overrieds AdditionalIncludeDirectories
projectRootElement.AddItem(AdditionalIncludeDirectoriesPredictor.FxCompileItemName, "foo.fx")
.AddMetadata(
AdditionalIncludeDirectoriesPredictor.AdditionalIncludeDirectoriesMetadata,
@"..\ReplacedFxCompileIncludes");
// Appends to AdditionalIncludeDirectories
projectRootElement.AddItem(AdditionalIncludeDirectoriesPredictor.MidlItemName, "foo.idl")
.AddMetadata(
AdditionalIncludeDirectoriesPredictor.AdditionalIncludeDirectoriesMetadata,
@"..\AnotherMidlIncludes;%(AdditionalIncludeDirectories)");
// Has duplicates and spaces
projectRootElement.AddItem(AdditionalIncludeDirectoriesPredictor.ResourceCompileItemName, "foo.rc")
.AddMetadata(
AdditionalIncludeDirectoriesPredictor.AdditionalIncludeDirectoriesMetadata,
@"%(AdditionalIncludeDirectories); ;;%(AdditionalIncludeDirectories);..\AnotherResourceCompileIncludes;%(AdditionalIncludeDirectories)");
return(TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement));
}
protected virtual void ProjectFiles_InsertedItem(object sender, CollectionChangedEventArgs e)
{
var file = (e.TargetObject as ProjectFileEntry);
string hintPath = file.FilePath.GetRelativePath(file.ParentProject);
var item = _msBuildProject.AddItem(GetItemType(hintPath), hintPath);
AddFileEventHandlers(file);
foreach (var dependency in file.Dependencies)
{
item.AddMetadata("DependentUpon", dependency);
}
}
public void SkipOtherProjectTypes()
{
string projectFile = Path.Combine(_rootDir, @"src\project.csproj");
ProjectRootElement projectRootElement = ProjectRootElement.Create(projectFile);
projectRootElement.AddProperty(ServiceFabricPackageRootFilesGraphPredictor.ServicePackageRootFolderPropertyName, "PackageRoot");
projectRootElement.AddItem("ProjectReference", @"..\dep1\dep1.csproj");
projectRootElement.AddItem("ProjectReference", @"..\dep2\dep2.csproj");
projectRootElement.AddItem("ProjectReference", @"..\dep3\dep3.csproj");
projectRootElement.AddItem("ProjectReference", @"..\dep4\dep4.csproj");
// Content package file
string dependency1File = Path.Combine(_rootDir, @"dep1\dep1.csproj");
ProjectRootElement dependency1RootElement = ProjectRootElement.Create(dependency1File);
dependency1RootElement.AddItem(ContentItemsPredictor.ContentItemName, @"PackageRoot\Config\Settings.xml");
Directory.CreateDirectory(Path.Combine(_rootDir, @"dep1\PackageRoot"));
// None package file
string dependency2File = Path.Combine(_rootDir, @"dep2\dep2.csproj");
ProjectRootElement dependency2RootElement = ProjectRootElement.Create(dependency2File);
dependency2RootElement.AddItem(NoneItemsPredictor.NoneItemName, @"PackageRoot\Config\Settings.xml");
Directory.CreateDirectory(Path.Combine(_rootDir, @"dep2\PackageRoot"));
// Linked package file
string dependency3File = Path.Combine(_rootDir, @"dep3\dep3.csproj");
ProjectRootElement dependency3RootElement = ProjectRootElement.Create(dependency3File);
dependency3RootElement.AddItem(ContentItemsPredictor.ContentItemName, @"..\dep3_linked\PackageRoot\Config\Settings.xml")
.AddMetadata("Link", @"PackageRoot\Config\Settings.xml");
Directory.CreateDirectory(Path.Combine(_rootDir, @"dep3\PackageRoot"));
// Package file on disk
string dependency4File = Path.Combine(_rootDir, @"dep4\dep4.csproj");
ProjectRootElement dependency4RootElement = ProjectRootElement.Create(dependency4File);
Directory.CreateDirectory(Path.Combine(_rootDir, @"dep4\PackageRoot\Config"));
File.WriteAllText(Path.Combine(_rootDir, @"dep4\PackageRoot\Config\Settings.xml"), "dummy");
projectRootElement.Save();
dependency1RootElement.Save();
dependency2RootElement.Save();
dependency3RootElement.Save();
dependency4RootElement.Save();
new ServiceFabricPackageRootFilesGraphPredictor()
.GetProjectPredictions(projectFile)
.AssertNoPredictions();
}
public void SkipOtherProjectTypes()
{
ProjectRootElement projectRootElement = ProjectRootElement.Create(Path.Combine(_rootDir, @"project.csproj"));
projectRootElement.AddItem(LinkItemsPredictor.LinkItemName, "foo.lib");
projectRootElement.AddItem(LinkItemsPredictor.LinkItemName, "bar.lib");
projectRootElement.AddItem(LinkItemsPredictor.LinkItemName, "baz.lib");
ProjectInstance projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement);
new AdditionalIncludeDirectoriesPredictor()
.GetProjectPredictions(projectInstance)
.AssertNoPredictions();
}
public void Roslyn_Settings_SettingsMissing_NoError()
{
// Arrange
BuildLogger logger = new BuildLogger();
// Set the config directory so the targets know where to look for the analysis config file
string confDir = TestUtils.CreateTestSpecificFolder(this.TestContext, "config");
// Create a valid config file that does not contain analyzer settings
AnalysisConfig config = new AnalysisConfig();
string configFilePath = Path.Combine(confDir, FileConstants.ConfigFileName);
config.Save(configFilePath);
// Create the project
WellKnownProjectProperties properties = new WellKnownProjectProperties
{
SonarQubeConfigPath = confDir,
ResolvedCodeAnalysisRuleset = "c:\\should.be.overridden.ruleset"
};
ProjectRootElement projectRoot = CreateValidProjectSetup(properties);
projectRoot.AddItem(TargetProperties.AnalyzerItemType, "should.be.removed.analyzer1.dll");
const string additionalFileName = "should.not.be.removed.additional1.txt";
projectRoot.AddItem(TargetProperties.AdditionalFilesItemType, additionalFileName);
// Act
BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger, TargetConstants.OverrideRoslynAnalysisTarget);
string projectSpecificConfFilePath = result.ProjectStateAfterBuild.GetPropertyValue(TargetProperties.ProjectConfFilePath);
string[] expectedRoslynAdditionalFiles = new string[] {
projectSpecificConfFilePath,
additionalFileName /* additional files are not removed any longer */
};
// Assert
logger.AssertTargetExecuted(TargetConstants.OverrideRoslynAnalysisTarget);
logger.AssertTargetExecuted(TargetConstants.SetRoslynAnalysisPropertiesTarget);
BuildAssertions.AssertTargetSucceeded(result, TargetConstants.OverrideRoslynAnalysisTarget);
// Check the error log and ruleset properties are set
AssertErrorLogIsSetBySonarQubeTargets(result);
AssertExpectedResolvedRuleset(result, string.Empty);
BuildAssertions.AssertExpectedItemGroupCount(result, TargetProperties.AnalyzerItemType, 0);
AssertExpectedItemValuesExists(result, TargetProperties.AdditionalFilesItemType, expectedRoslynAdditionalFiles);
}
public void FindItemsForClickOnceWithBaseApplicationManifests()
{
ProjectRootElement projectRootElement = CreateProjectRootElement();
// This is generally set by the toolset for certain output types
projectRootElement.AddProperty(ManifestsPredictor.GenerateClickOnceManifestsPropertyName, "true");
projectRootElement.AddItem(ManifestsPredictor.BaseApplicationManifestItemName, @"Properties\app.manifest");
ProjectInstance projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement);
var expectedInputFiles = new[]
{
new PredictedItem(@"Properties\app.manifest", nameof(ManifestsPredictor)),
};
var expectedOutputFiles = new[]
{
new PredictedItem(@"obj\Release\MyApplication.exe.manifest", nameof(ManifestsPredictor)),
new PredictedItem(@"bin\Release\MyApplication.exe.manifest", nameof(ManifestsPredictor)),
new PredictedItem(@"obj\Release\MyApplication.application", nameof(ManifestsPredictor)),
new PredictedItem(@"bin\Release\MyApplication.application", nameof(ManifestsPredictor)),
};
new ManifestsPredictor()
.GetProjectPredictions(projectInstance)
.AssertPredictions(
projectInstance,
expectedInputFiles.MakeAbsolute(_rootDir),
null,
expectedOutputFiles.MakeAbsolute(_rootDir),
null);
}
public void UseCommonOutputDirectory()
{
string projectFile = Path.Combine(_rootDir, @"src\project.csproj");
ProjectRootElement projectRootElement = ProjectRootElement.Create(projectFile);
projectRootElement.AddProperty(GetCopyToOutputDirectoryItemsGraphPredictor.OutDirPropertyName, @"bin\");
projectRootElement.AddProperty(GetCopyToOutputDirectoryItemsGraphPredictor.UseCommonOutputDirectoryPropertyName, "true");
const bool shouldCopy = true;
ProjectRootElement dep1 = CreateDependencyProject("dep1", shouldCopy);
ProjectRootElement dep2 = CreateDependencyProject("dep2", shouldCopy);
ProjectRootElement dep3 = CreateDependencyProject("dep3", shouldCopy);
// The main project depends on 1 and 2; 2 depends on 3; 3 depends on 1. Note that this predictor should *not* be transitive
projectRootElement.AddItem("ProjectReference", @"..\dep1\dep1.proj");
projectRootElement.AddItem("ProjectReference", @"..\dep2\dep2.proj");
dep2.AddItem("ProjectReference", @"..\dep3\dep3.proj");
dep3.AddItem("ProjectReference", @"..\dep1\dep1.proj");
projectRootElement.Save();
dep1.Save();
dep2.Save();
dep3.Save();
new GetCopyToOutputDirectoryItemsGraphPredictor()
.GetProjectPredictions(projectFile)
.AssertNoPredictions();
}
private static ProjectItemElement AddVirtualEnvironment(
ProjectRootElement project,
string sourcePath,
string id,
InterpreterConfiguration config
)
{
var prefixPath = config.PrefixPath ?? string.Empty;
var interpreterPath = string.IsNullOrEmpty(config.InterpreterPath) ?
string.Empty :
PathUtils.GetRelativeFilePath(prefixPath, config.InterpreterPath);
var windowInterpreterPath = string.IsNullOrEmpty(config.WindowsInterpreterPath) ?
string.Empty :
PathUtils.GetRelativeFilePath(prefixPath, config.WindowsInterpreterPath);
prefixPath = PathUtils.GetRelativeDirectoryPath(sourcePath, prefixPath);
return(project.AddItem(
MSBuildConstants.InterpreterItem,
prefixPath,
new Dictionary <string, string> {
{ MSBuildConstants.IdKey, id },
{ MSBuildConstants.DescriptionKey, config.Description },
{ MSBuildConstants.InterpreterPathKey, interpreterPath },
{ MSBuildConstants.WindowsPathKey, windowInterpreterPath },
{ MSBuildConstants.VersionKey, config.Version.ToString() },
{ MSBuildConstants.ArchitectureKey, config.Architecture.ToString("X") },
{ MSBuildConstants.PathEnvVarKey, config.PathEnvironmentVariable }
}
));
}
private ProjectRootElement CreateProject()
{
Microsoft.Build.Evaluation.Project project = null;
try
{
project = Microsoft.Expression.Project.Build.BuildManager.GetProject(DocumentReference.Create(this.originalProjectFilePath));
}
catch (ArgumentException argumentException)
{
}
ProjectRootElement projectRootElement = ProjectRootElement.Create();
projectRootElement.ToolsVersion = "4.0";
this.AddBuildProperties(projectRootElement, project);
projectRootElement.AddItemGroup();
projectRootElement.AddPropertyGroup();
projectRootElement.AddProperty("IntermediateOutputPath", Microsoft.Expression.Framework.Documents.PathHelper.GetDirectoryNameOrRoot(this.xamlPath));
this.AddAssemblyReferences(projectRootElement, project);
this.AddImports(projectRootElement, project);
if (!this.IsSilverlightApplication(project))
{
this.AddWpfImports(projectRootElement);
}
projectRootElement.AddItem("Page", this.xamlPath);
string str = Microsoft.Expression.Framework.Documents.PathHelper.ResolveCombinedPath(Microsoft.Expression.Framework.Documents.PathHelper.GetDirectoryNameOrRoot(this.xamlPath), "MarkupCompileAssembly.proj");
projectRootElement.Save(str);
return(projectRootElement);
}
private static ProjectItemElement AddVirtualEnvironment(
ProjectRootElement project,
string sourcePath,
InterpreterFactoryCreationOptions options
)
{
var prefixPath = options.PrefixPath ?? string.Empty;
var interpreterPath = string.IsNullOrEmpty(options.InterpreterPath) ?
string.Empty :
CommonUtils.GetRelativeFilePath(prefixPath, options.InterpreterPath);
var windowInterpreterPath = string.IsNullOrEmpty(options.WindowInterpreterPath) ?
string.Empty :
CommonUtils.GetRelativeFilePath(prefixPath, options.WindowInterpreterPath);
var libraryPath = string.IsNullOrEmpty(options.LibraryPath) ?
string.Empty :
CommonUtils.GetRelativeDirectoryPath(prefixPath, options.LibraryPath);
prefixPath = CommonUtils.GetRelativeDirectoryPath(sourcePath, prefixPath);
return(project.AddItem(
MSBuildProjectInterpreterFactoryProvider.InterpreterItem,
prefixPath,
new Dictionary <string, string> {
{ MSBuildProjectInterpreterFactoryProvider.IdKey, Guid.NewGuid().ToString("B") },
{ MSBuildProjectInterpreterFactoryProvider.DescriptionKey, options.Description },
{ MSBuildProjectInterpreterFactoryProvider.BaseInterpreterKey, options.IdString },
{ MSBuildProjectInterpreterFactoryProvider.InterpreterPathKey, interpreterPath },
{ MSBuildProjectInterpreterFactoryProvider.WindowsPathKey, windowInterpreterPath },
{ MSBuildProjectInterpreterFactoryProvider.LibraryPathKey, libraryPath },
{ MSBuildProjectInterpreterFactoryProvider.VersionKey, options.LanguageVersionString },
{ MSBuildProjectInterpreterFactoryProvider.ArchitectureKey, options.ArchitectureString },
{ MSBuildProjectInterpreterFactoryProvider.PathEnvVarKey, options.PathEnvironmentVariableName }
}
));
}
public void SaveWithTransformsToFile()
{
ProjectRootElement project = ProjectRootElement.Create();
project.AddItem("i", "@(h->'%(x)')");
string file = null;
try
{
file = Microsoft.Build.Shared.FileUtilities.GetTemporaryFile();
project.Save(file);
string expected = ObjectModelHelpers.CleanupFileContents(
@"<?xml version=""1.0"" encoding=""utf-8""?>
<Project ToolsVersion=""msbuilddefaulttoolsversion"" xmlns=""msbuildnamespace"">
<ItemGroup>
<i Include=""@(h->'%(x)')"" />
</ItemGroup>
</Project>");
string actual = File.ReadAllText(file);
Helpers.VerifyAssertLineByLine(expected, actual);
}
finally
{
File.Delete(file);
}
}
public static void AddItemChecked(this ProjectRootElement root, string itemType, string include)
{
if (!root.HasItem(itemType, include))
{
root.AddItem(itemType, include);
}
}
private static void GenAssemblyInfoFile(ProjectRootElement root, string dir, string name, string[] assemblyLines = null, string[] usingDirectives = null)
{
string propertiesDir = Path.Combine(dir, "Properties");
if (!Directory.Exists(propertiesDir))
{
Directory.CreateDirectory(propertiesDir);
}
string usingDirectivesText = string.Empty;
if (usingDirectives != null)
{
foreach (var usingDirective in usingDirectives)
{
usingDirectivesText += "\nusing " + usingDirective + ";";
}
}
string assemblyLinesText = string.Empty;
if (assemblyLines != null)
{
assemblyLinesText += string.Join("\n", assemblyLines) + "\n";
}
string content = string.Format(AssemblyInfoTemplate, usingDirectivesText, name, assemblyLinesText);
string assemblyInfoFile = Path.Combine(propertiesDir, "AssemblyInfo.cs");
File.WriteAllText(assemblyInfoFile, content);
root.AddItem("Compile", assemblyInfoFile.RelativeToPath(dir).Replace("/", "\\"));
}
public void FindRobocopyForExistingFile()
{
ProjectRootElement projectRootElement = ProjectRootElement.Create(Path.Combine(_rootDir, @"src\project.csproj"));
projectRootElement.AddProperty(ArtifactsSdkPredictor.UsingMicrosoftArtifactsSdkPropertyName, "true");
projectRootElement.AddProperty("ArtifactsPath", Path.Combine(_rootDir, "out"));
var artifactItem = projectRootElement.AddItem(ArtifactsSdkPredictor.RobocopyItemName, "Robocopy.txt");
artifactItem.AddMetadata(ArtifactsSdkPredictor.DestinationFolderMetadata, @"$(ArtifactsPath)\Project");
Directory.CreateDirectory(Path.Combine(_rootDir, "src"));
File.WriteAllText(Path.Combine(_rootDir, @"src\Robocopy.txt"), "SomeContent");
ProjectInstance projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement);
var expectedInputFiles = new[]
{
new PredictedItem(@"src\Robocopy.txt", nameof(ArtifactsSdkPredictor)),
};
var expectedOutputFiles = new[]
{
new PredictedItem(@"out\Project\Robocopy.txt", nameof(ArtifactsSdkPredictor)),
};
new ArtifactsSdkPredictor()
.GetProjectPredictions(projectInstance)
.AssertPredictions(
projectInstance,
expectedInputFiles.MakeAbsolute(_rootDir),
null,
expectedOutputFiles.MakeAbsolute(_rootDir),
null);
}
public void FindArtifactsForGeneratedDirectory()
{
ProjectRootElement projectRootElement = ProjectRootElement.Create(Path.Combine(_rootDir, @"foo\foo.csproj"));
projectRootElement.AddProperty(ArtifactsSdkPredictor.UsingMicrosoftArtifactsSdkPropertyName, "true");
projectRootElement.AddProperty("EnlistmentRoot", _rootDir);
projectRootElement.AddProperty("OutputPath", @"bin\x64");
// Copying another project's output dir to this project's output dir
var artifactItem = projectRootElement.AddItem(ArtifactsSdkPredictor.ArtifactsItemName, @"$(EnlistmentRoot)\bar\$(OutputPath)");
artifactItem.AddMetadata(ArtifactsSdkPredictor.DestinationFolderMetadata, @"$(OutputPath)");
artifactItem.AddMetadata(ArtifactsSdkPredictor.FileMatchMetadata, "*.dll *.pdb");
ProjectInstance projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement);
var expectedInputDirectories = new[]
{
new PredictedItem(@"bar\bin\x64", nameof(ArtifactsSdkPredictor)),
};
var expectedOutputDirectories = new[]
{
new PredictedItem(@"foo\bin\x64", nameof(ArtifactsSdkPredictor)),
};
new ArtifactsSdkPredictor()
.GetProjectPredictions(projectInstance)
.AssertPredictions(
projectInstance,
null,
expectedInputDirectories.MakeAbsolute(_rootDir),
null,
expectedOutputDirectories.MakeAbsolute(_rootDir));
}
public void ValidXmlXmlTextReaderNotCache()
{
string content = @"
<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
</Project>
";
string path = null;
try
{
path = Microsoft.Build.Shared.FileUtilities.GetTemporaryFile();
File.WriteAllText(path, content);
XmlTextReader reader1 = new XmlTextReader(path);
ProjectRootElement root1 = ProjectRootElement.Create(reader1);
root1.AddItem("type", "include");
// If it's in the cache, then the 2nd document won't see the add.
XmlTextReader reader2 = new XmlTextReader(path);
ProjectRootElement root2 = ProjectRootElement.Create(reader2);
Assert.AreEqual(1, root1.Items.Count);
Assert.AreEqual(0, root2.Items.Count);
reader1.Close();
reader2.Close();
}
finally
{
File.Delete(path);
}
}
public void FindItems()
{
string projectFile = Path.Combine(_rootDir, @"src\project.csproj");
ProjectRootElement projectRootElement = ProjectRootElement.Create(projectFile);
ProjectRootElement dep1 = CreateDependencyProject("dep1");
ProjectRootElement dep2 = CreateDependencyProject("dep2");
ProjectRootElement dep3 = CreateDependencyProject("dep3");
ProjectRootElement dep4 = CreateDependencyProject("dep4");
// The main project depends on 1 and 2; 2 depends on 3; 3 depends on 1 and 4.
// This tests both transitivity and deduping.
projectRootElement.AddItem("ProjectReference", @"..\dep1\dep1.proj");
projectRootElement.AddItem("ProjectReference", @"..\dep2\dep2.proj");
dep2.AddItem("ProjectReference", @"..\dep3\dep3.proj");
dep3.AddItem("ProjectReference", @"..\dep1\dep1.proj");
dep3.AddItem("ProjectReference", @"..\dep4\dep4.proj");
projectRootElement.Save();
dep1.Save();
dep2.Save();
dep3.Save();
dep4.Save();
var expectedInputFiles = new[]
{
new PredictedItem(@"dep1\dep1.proj", nameof(ProjectFileAndImportsGraphPredictor)),
new PredictedItem(@"dep1\dep1.targets", nameof(ProjectFileAndImportsGraphPredictor)),
new PredictedItem(@"dep2\dep2.proj", nameof(ProjectFileAndImportsGraphPredictor)),
new PredictedItem(@"dep2\dep2.targets", nameof(ProjectFileAndImportsGraphPredictor)),
new PredictedItem(@"dep3\dep3.proj", nameof(ProjectFileAndImportsGraphPredictor)),
new PredictedItem(@"dep3\dep3.targets", nameof(ProjectFileAndImportsGraphPredictor)),
new PredictedItem(@"dep4\dep4.proj", nameof(ProjectFileAndImportsGraphPredictor)),
new PredictedItem(@"dep4\dep4.targets", nameof(ProjectFileAndImportsGraphPredictor)),
};
new ProjectFileAndImportsGraphPredictor()
.GetProjectPredictions(projectFile)
.AssertPredictions(
_rootDir,
expectedInputFiles,
null,
null,
null);
}
private static ProjectInstance CreateTestProjectInstance(string fileName)
{
ProjectRootElement projectRootElement = ProjectRootElement.Create(fileName);
projectRootElement.AddItemDefinitionGroup()
.AddItemDefinition(ModuleDefinitionFilePredictor.LinkItemName)
.AddMetadata(ModuleDefinitionFilePredictor.ModuleDefinitionFileMetadata, @".\Link.def");
projectRootElement.AddItem(ModuleDefinitionFilePredictor.LinkItemName, "Link.lib");
projectRootElement.AddItem(ModuleDefinitionFilePredictor.LibItemName, "Lib.lib")
.AddMetadata(ModuleDefinitionFilePredictor.ModuleDefinitionFileMetadata, @".\Lib.def");
// Has spaces
projectRootElement.AddItem(ModuleDefinitionFilePredictor.ImpLibItemName, "ImpLib.lib")
.AddMetadata(ModuleDefinitionFilePredictor.ModuleDefinitionFileMetadata, @" .\ImpLib.def ");
return(TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement));
}
public void Globs()
{
ProjectRootElement projectRootElement = ProjectRootElement.Create(Path.Combine(_rootDir, @"project.csproj"));
projectRootElement.AddItem(TsConfigPredictor.ContentItemName, TsConfigPredictor.TsConfigFileName);
const string TsConfigContent = @"
{
""compilerOptions"": {
""outFile"": ""dist/out.js"",
},
""include"": [
""**/*.ts""
],
""exclude"": [
""node_modules"",
""**/*.spec.ts""
]
}";
File.WriteAllText(Path.Combine(_rootDir, TsConfigPredictor.TsConfigFileName), TsConfigContent);
WriteDummyFiles(
"foo.ts",
"foo.spec.ts",
"bar.ts",
"bar.spec.ts",
"baz.ts",
"baz.spec.ts",
"unrelatedFile.txt",
@"node_modules\a\index.ts",
@"node_modules\b\index.ts",
@"node_modules\c\index.ts");
ProjectInstance projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement);
var expectedInputFiles = new[]
{
new PredictedItem(@"foo.ts", nameof(TsConfigPredictor)),
new PredictedItem(@"bar.ts", nameof(TsConfigPredictor)),
new PredictedItem(@"baz.ts", nameof(TsConfigPredictor)),
};
var expectedOutputFiles = new[]
{
new PredictedItem(@"dist\out.js", nameof(TsConfigPredictor)),
};
new TsConfigPredictor()
.GetProjectPredictions(projectInstance)
.AssertPredictions(
projectInstance,
expectedInputFiles.MakeAbsolute(_rootDir),
null,
expectedOutputFiles.MakeAbsolute(_rootDir),
null);
}
public void FindItems()
{
string projectFile = Path.Combine(_rootDir, @"src\project.sfproj");
ProjectRootElement projectRootElement = ProjectRootElement.Create(projectFile);
projectRootElement.AddProperty(GetCopyToPublishDirectoryItemsGraphPredictor.PublishDirPropertyName, @"bin\Publish");
ProjectRootElement service1 = CreateServiceProject("service1");
ProjectRootElement service2 = CreateServiceProject("service2");
ProjectRootElement service3 = CreateServiceProject("service3");
projectRootElement.AddItem("ProjectReference", @"..\service1\service1.csproj");
projectRootElement.AddItem("ProjectReference", @"..\service2\service2.csproj");
projectRootElement.AddItem("ProjectReference", @"..\service3\service3.csproj");
projectRootElement.Save();
service1.Save();
service2.Save();
service3.Save();
var expectedInputFiles = new[]
{
new PredictedItem(@"service1_dep1\service1_dep1.xml", nameof(ServiceFabricCopyFilesToPublishDirectoryGraphPredictor)),
new PredictedItem(@"service1_dep2\service1_dep2.xml", nameof(ServiceFabricCopyFilesToPublishDirectoryGraphPredictor)),
new PredictedItem(@"service2_dep1\service2_dep1.xml", nameof(ServiceFabricCopyFilesToPublishDirectoryGraphPredictor)),
new PredictedItem(@"service2_dep2\service2_dep2.xml", nameof(ServiceFabricCopyFilesToPublishDirectoryGraphPredictor)),
new PredictedItem(@"service3_dep1\service3_dep1.xml", nameof(ServiceFabricCopyFilesToPublishDirectoryGraphPredictor)),
new PredictedItem(@"service3_dep2\service3_dep2.xml", nameof(ServiceFabricCopyFilesToPublishDirectoryGraphPredictor)),
};
var expectedOutputDirectories = new[]
{
new PredictedItem(@"src\bin\Publish", nameof(ServiceFabricCopyFilesToPublishDirectoryGraphPredictor)),
};
new ServiceFabricCopyFilesToPublishDirectoryGraphPredictor()
.GetProjectPredictions(projectFile)
.AssertPredictions(
_rootDir,
expectedInputFiles,
null,
null,
expectedOutputDirectories);
}
/// <summary>
/// Creates and returns an empty MSBuild project using the data in the supplied descriptor.
/// The project will import the SonarQube analysis targets file and the standard C# targets file.
/// The project name and GUID will be set if the values are supplied in the descriptor.
/// </summary>
private static ProjectRootElement CreateAnalysisProject(TestContext testContext, ProjectDescriptor descriptor,
IDictionary <string, string> preImportProperties)
{
if (testContext == null)
{
throw new ArgumentNullException("testContext");
}
if (descriptor == null)
{
throw new ArgumentNullException("descriptor");
}
string sqTargetFile = TestUtils.EnsureAnalysisTargetsExists(testContext);
Assert.IsTrue(File.Exists(sqTargetFile), "Test error: the SonarQube analysis targets file could not be found. Full path: {0}", sqTargetFile);
testContext.AddResultFile(sqTargetFile);
IDictionary <string, string> properties = preImportProperties ?? new Dictionary <string, string>();
// Disable the standard "ImportBefore/ImportAfter" behaviour if the caller
// hasn't defined what they want to happen explicitly
if (!properties.ContainsKey(StandardImportBeforePropertyName))
{
DisableStandardTargetsWildcardImporting(properties);
}
ProjectRootElement root = CreateMinimalBuildableProject(properties, descriptor.IsVbProject, sqTargetFile);
// Set the location of the task assembly
if (!properties.ContainsKey(TargetProperties.SonarBuildTasksAssemblyFile))
{
root.AddProperty(TargetProperties.SonarBuildTasksAssemblyFile, typeof(WriteProjectInfoFile).Assembly.Location);
}
if (descriptor.ProjectGuid != Guid.Empty)
{
root.AddProperty(TargetProperties.ProjectGuid, descriptor.ProjectGuid.ToString("D"));
}
foreach (ProjectDescriptor.FileInProject file in descriptor.Files)
{
root.AddItem(file.ItemGroup, file.FilePath);
}
if (descriptor.IsTestProject && !root.Properties.Any(p => string.Equals(p.Name, TargetProperties.SonarQubeTestProject)))
{
root.AddProperty(TargetProperties.SonarQubeTestProject, "true");
}
if (descriptor.Encoding != null)
{
root.AddProperty(TargetProperties.CodePage, descriptor.Encoding.CodePage.ToString());
}
return(root);
}
public void E2E_FxCop_AllConditionsMet_VB()
{
// Arrange
string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs");
string rootOutputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Outputs");
string fxCopLogFile = Path.Combine(rootInputFolder, "FxCopResults.xml");
WellKnownProjectProperties preImportProperties = new WellKnownProjectProperties();
preImportProperties.SonarQubeTempPath = rootOutputFolder; // FIXME
preImportProperties.SonarQubeOutputPath = rootOutputFolder;
preImportProperties.RunCodeAnalysis = "false";
preImportProperties.CodeAnalysisLogFile = fxCopLogFile;
preImportProperties.CodeAnalysisRuleset = "specifiedInProject.ruleset";
preImportProperties[TargetProperties.SonarQubeConfigPath] = rootInputFolder;
CreateValidFxCopRuleset(rootInputFolder, string.Format(TargetProperties.SonarQubeRulesetFormat, "vbnet"));
ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, preImportProperties, isVBProject: true);
string itemPath = TestUtils.CreateTextFile(rootInputFolder, "my.vb",
@"Public Class Class1
Public Sub DoStuff()
End Sub
End Class");
projectRoot.AddItem(TargetProperties.ItemType_Compile, itemPath);
projectRoot.Save();
BuildLogger logger = new BuildLogger();
// Act
BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger);
// Assert
BuildAssertions.AssertTargetSucceeded(result, TargetConstants.DefaultBuildTarget);
logger.AssertExpectedTargetOrdering(
TargetConstants.DetectFxCopRulesetTarget,
TargetConstants.CategoriseProjectTarget,
TargetConstants.OverrideFxCopSettingsTarget,
TargetConstants.FxCopTarget,
TargetConstants.SetFxCopResultsTarget,
TargetConstants.DefaultBuildTarget,
TargetConstants.CalculateFilesToAnalyzeTarget,
TargetConstants.WriteProjectDataTarget);
AssertAllFxCopTargetsExecuted(logger);
Assert.IsTrue(File.Exists(fxCopLogFile), "FxCop log file should have been produced");
ProjectInfo projectInfo = ProjectInfoAssertions.AssertProjectInfoExists(rootOutputFolder, projectRoot.FullPath);
ProjectInfoAssertions.AssertAnalysisResultExists(projectInfo, AnalysisType.FxCop.ToString(), fxCopLogFile);
}
public static bool AddItemChecked(this ProjectRootElement root, string itemType, string include)
{
if (!root.HasItem(itemType, include, noCondition: true))
{
root.AddItem(itemType, include);
return(true);
}
return(false);
}
/// <summary>
/// Adds a file to the project, and optionally adds a reference to the project file
/// </summary>
/// <param name="path"></param>
/// <param name="stream"></param>
public override void AddFile(string path, System.IO.Stream stream)
{
base.AddFile(path, stream);
if (AddReferenceToProject)
{
ProjectRootElement rootElement = ProjectRootElement.Open(ProjectPath);
rootElement.AddItem("Content", path);
}
}
public void WithCopy()
{
ProjectRootElement projectRootElement = ProjectRootElement.Create();
projectRootElement.AddProperty(EmbeddedResourceItemsPredictor.OutDirPropertyName, @"bin\");
ProjectItemElement item1 = projectRootElement.AddItem(EmbeddedResourceItemsPredictor.EmbeddedResourceItemName, "Resource1.resx");
item1.AddMetadata("CopyToOutputDirectory", "PreserveNewest");
ProjectItemElement item2 = projectRootElement.AddItem(EmbeddedResourceItemsPredictor.EmbeddedResourceItemName, "Resource2.resx");
item2.AddMetadata("CopyToOutputDirectory", "PreserveNewest");
ProjectItemElement item3 = projectRootElement.AddItem(EmbeddedResourceItemsPredictor.EmbeddedResourceItemName, "Resource3.resx");
item3.AddMetadata("CopyToOutputDirectory", "PreserveNewest");
ProjectInstance projectInstance = TestHelpers.CreateProjectInstanceFromRootElement(projectRootElement);
var expectedInputFiles = new[]
{
new PredictedItem("Resource1.resx", nameof(EmbeddedResourceItemsPredictor)),
new PredictedItem("Resource2.resx", nameof(EmbeddedResourceItemsPredictor)),
new PredictedItem("Resource3.resx", nameof(EmbeddedResourceItemsPredictor)),
};
var expectedoutputFiles = new[]
{
new PredictedItem(@"bin\Resource1.resx", nameof(EmbeddedResourceItemsPredictor)),
new PredictedItem(@"bin\Resource2.resx", nameof(EmbeddedResourceItemsPredictor)),
new PredictedItem(@"bin\Resource3.resx", nameof(EmbeddedResourceItemsPredictor)),
};
new EmbeddedResourceItemsPredictor()
.GetProjectPredictions(projectInstance)
.AssertPredictions(
projectInstance,
expectedInputFiles,
null,
expectedoutputFiles,
null);
}
public void EmptyPredictionsResultInEmptyAggregateResult()
{
var graphPredictors = new IProjectGraphPredictor[]
{
new MockGraphPredictor(null, null, null, null),
new MockGraphPredictor(null, null, null, null),
};
var predictors = new IProjectPredictor[]
{
new MockPredictor(null, null, null, null),
new MockPredictor(null, null, null, null),
};
var executor = new ProjectGraphPredictionExecutor(graphPredictors, predictors);
ProjectRootElement projectA = CreateProject("a");
ProjectRootElement projectB = CreateProject("b");
ProjectRootElement projectC = CreateProject("c");
ProjectRootElement projectD = CreateProject("d");
// A depends on B, D; B depends on C, D; C depends on D
projectA.AddItem("ProjectReference", @"..\b\b.proj");
projectA.AddItem("ProjectReference", @"..\d\d.proj");
projectB.AddItem("ProjectReference", @"..\c\c.proj");
projectB.AddItem("ProjectReference", @"..\d\d.proj");
projectC.AddItem("ProjectReference", @"..\d\d.proj");
projectA.Save();
projectB.Save();
projectC.Save();
projectD.Save();
var projectGraph = new ProjectGraph(projectA.FullPath, new ProjectCollection());
ProjectGraphPredictions graphPredictions = executor.PredictInputsAndOutputs(projectGraph);
AssertPredictionsMadeForEveryNode(projectGraph, graphPredictions);
foreach (ProjectPredictions projectPredictions in graphPredictions.PredictionsPerNode.Values)
{
projectPredictions.AssertNoPredictions();
}
}
public void E2E_FxCop_TestProject_TestProjectTypeGuid()
{
// Arrange
string rootInputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs");
string rootOutputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Outputs");
string fxCopLogFile = Path.Combine(rootInputFolder, "FxCopResults.xml");
WellKnownProjectProperties preImportProperties = new WellKnownProjectProperties();
preImportProperties.SonarQubeTempPath = rootOutputFolder; // FIXME
preImportProperties.SonarQubeOutputPath = rootOutputFolder;
preImportProperties.CodeAnalysisLogFile = fxCopLogFile;
preImportProperties.CodeAnalysisRuleset = "specifiedInProject.ruleset";
preImportProperties.ProjectTypeGuids = "X;" + TargetConstants.MsTestProjectTypeGuid.ToUpperInvariant() + ";Y";
preImportProperties[TargetProperties.SonarQubeConfigPath] = rootInputFolder;
CreateValidFxCopRuleset(rootInputFolder, string.Format(TargetProperties.SonarQubeRulesetFormat, "cs"));
ProjectRootElement projectRoot = BuildUtilities.CreateValidProjectRoot(this.TestContext, rootInputFolder, preImportProperties);
// Add a file to the project
string itemPath = CreateTextFile(rootInputFolder, "code1.cs", "class myclassXXX{}");
projectRoot.AddItem(TargetProperties.ItemType_Compile, itemPath);
projectRoot.Save();
BuildLogger logger = new BuildLogger();
// Act
BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger);
// Assert
BuildAssertions.AssertTargetSucceeded(result, TargetConstants.DefaultBuildTarget);
logger.AssertExpectedTargetOrdering(
TargetConstants.CategoriseProjectTarget,
TargetConstants.OverrideFxCopSettingsTarget,
TargetConstants.FxCopTarget,
TargetConstants.DefaultBuildTarget,
TargetConstants.CalculateFilesToAnalyzeTarget,
TargetConstants.WriteProjectDataTarget);
// We expect the FxCop target to be executed...
logger.AssertTargetExecuted(TargetConstants.FxCopTarget);
// ... but we don't expect the FxCop *task* to have executed
logger.AssertTaskNotExecuted(TargetConstants.FxCopTask);
logger.AssertTargetNotExecuted(TargetConstants.SetFxCopResultsTarget);
ProjectInfo projectInfo = ProjectInfoAssertions.AssertProjectInfoExists(rootOutputFolder, projectRoot.FullPath);
ProjectInfoAssertions.AssertAnalysisResultDoesNotExists(projectInfo, AnalysisType.FxCop.ToString());
}
