public void GetMetadataValuesFromDefinition() { string content = @" <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003' > <ItemDefinitionGroup> <i> <m0>v0</m0> <m1>v1</m1> </i> </ItemDefinitionGroup> <ItemGroup> <i Include='i1'> <m1>v1b</m1> <m2>v2</m2> </i> </ItemGroup> </Project> "; ProjectItemInstance item = GetOneItem(content); Assert.Equal("v0", item.GetMetadataValue("m0")); Assert.Equal("v1b", item.GetMetadataValue("m1")); Assert.Equal("v2", item.GetMetadataValue("m2")); Assert.Equal(3, Helpers.MakeList(item.Metadata).Count); Assert.Equal(3 + BuiltInMetadataCount, Helpers.MakeList(item.MetadataNames).Count); Assert.Equal(3 + BuiltInMetadataCount, item.MetadataCount); }
/// <summary> /// Gets the effective global properties for a project reference item. /// </summary> /// <remarks> /// The behavior of this method should match the logic in the SDK /// </remarks> private static GlobalPropertyPartsForMSBuildTask ProjectReferenceGlobalPropertiesModifier( GlobalPropertyPartsForMSBuildTask defaultParts, ProjectItemInstance projectReference ) { // ProjectReference defines yet another metadata name containing properties to undefine. Merge it in if non empty. var globalPropertiesToRemove = SplitPropertyNames(projectReference.GetMetadataValue(GlobalPropertiesToRemoveMetadataName)); var newUndefineProperties = defaultParts.UndefineProperties; newUndefineProperties = newUndefineProperties.AddRange(defaultParts.UndefineProperties); newUndefineProperties = newUndefineProperties.AddRange(globalPropertiesToRemove); newUndefineProperties.Add("InnerBuildProperty"); var newProperties = defaultParts.Properties; // The properties on the project reference supersede the ones from the MSBuild task instead of appending. if (newProperties.Count == 0) { // TODO: Mimic AssignProjectConfiguration's behavior for determining the values for these. var setConfigurationString = projectReference.GetMetadataValue(SetConfigurationMetadataName); var setPlatformString = projectReference.GetMetadataValue(SetPlatformMetadataName); var setTargetFrameworkString = projectReference.GetMetadataValue(SetTargetFrameworkMetadataName); if (!String.IsNullOrEmpty(setConfigurationString) || !String.IsNullOrEmpty(setPlatformString) || !String.IsNullOrEmpty(setTargetFrameworkString)) { newProperties = SplitPropertyNameValuePairs( ItemMetadataNames.PropertiesMetadataName, $"{setConfigurationString};{setPlatformString};{setTargetFrameworkString}").ToImmutableDictionary(); } } return(new GlobalPropertyPartsForMSBuildTask(newProperties, defaultParts.AdditionalProperties, newUndefineProperties)); }
public Matcher(ProjectItemInstance item, string source) { _sourceFolder = source; ParsePatterns( item.GetMetadataValue(FileMatchMetadata), out _doMatchAll, out _fileMatches, out _fileRegexMatches, out string fileWildcardMatch); ParsePatterns( item.GetMetadataValue(FileExcludeMetadata), out _, out _fileExcludes, out _fileRegexExcludes, out _); ParsePatterns( item.GetMetadataValue(DirExcludeMetadata), out _, out _dirExcludes, out _dirRegexExcludes, out _); // Optimization to only enumerate files which match the pattern. // This can only be done if there's exactly one pattern though. SearchPattern = _fileMatches.Count + _fileRegexMatches.Count == 1 ? _fileMatches.Count == 1 ? _fileMatches[0] : fileWildcardMatch : "*"; }
public void AccessorsWithMetadata() { ProjectItemInstance item = GetItemInstance(); item.SetMetadata("m1", "v0"); item.SetMetadata("m1", "v1"); item.SetMetadata("m2", "v2"); Assert.Equal("m1", item.GetMetadata("m1").Name); Assert.Equal("m2", item.GetMetadata("m2").Name); Assert.Equal("v1", item.GetMetadataValue("m1")); Assert.Equal("v2", item.GetMetadataValue("m2")); }
public int get_CanonicalName(out string pbstrCanonicalName) { // Get the output assembly path (including the name) pbstrCanonicalName = output.GetMetadataValue("FullPath"); Debug.Assert(!String.IsNullOrEmpty(pbstrCanonicalName), "Output Assembly not defined"); // Make sure we have a full path if (!System.IO.Path.IsPathRooted(pbstrCanonicalName)) { pbstrCanonicalName = new Url(project.BaseURI, pbstrCanonicalName).AbsoluteUrl; } return(VSConstants.S_OK); }
private bool IsValidItem(ProjectItemInstance outputItem) { Version version = null; Version version1 = null; if (Version.TryParse(outputItem.GetMetadataValue("Version"), out version) && Version.TryParse(outputItem.GetMetadataValue("HighestVersionInRedist"), out version1) && version > version1) { return(false); } if (!string.IsNullOrEmpty(outputItem.GetMetadataValue("OutOfRangeDependencies"))) { return(false); } return(true); }
/// <summary> /// Determins what the TargetPath metadata would be set to after calling the AssignTargetPath task. /// </summary> /// <remarks> /// See: https://github.com/microsoft/msbuild/blob/master/src/Tasks/AssignTargetPath.cs. /// </remarks> public static string GetTargetPath(this ProjectItemInstance item) { string link = item.GetMetadataValue("Link"); // If file has a link, use that. if (!string.IsNullOrEmpty(link)) { return(link); } var evaluatedInclude = item.EvaluatedInclude; // If the file path is relative and doesn't contain any relative specifiers then just use the file path as-is if (!Path.IsPathRooted(evaluatedInclude) && !evaluatedInclude.Contains(RelativeSpecifier, StringComparison.Ordinal)) { return(evaluatedInclude); } // Normalize the path string evaluatedIncludeFullPath = Path.GetFullPath(evaluatedInclude); string projectDir = item.Project.Directory; bool projectDirHasTrailingSlash = projectDir[projectDir.Length - 1] == Path.DirectorySeparatorChar; // If the item is under the project dir, return the relative path from the project dir. if (evaluatedIncludeFullPath.StartsWith(projectDir, StringComparison.OrdinalIgnoreCase) && (projectDirHasTrailingSlash || (evaluatedIncludeFullPath.Length > projectDir.Length && evaluatedIncludeFullPath[projectDir.Length] == Path.DirectorySeparatorChar))) { return(evaluatedIncludeFullPath.Substring(projectDir.Length + (projectDirHasTrailingSlash ? 0 : 1))); } // The item is not under the project dir. Return the filename only. return(Path.GetFileName(evaluatedInclude)); }
public void GetMissingMetadata() { ProjectItemInstance item = GetItemInstance(); Assert.Equal(null, item.GetMetadata("X")); Assert.Equal(String.Empty, item.GetMetadataValue("X")); }
internal void SetHintPathAndPrivateValue(ProjectInstance instance, ProjectItemInstance iteminstance) { // Private means local copy; we want to know if it is already set to not override the default string privateValue = this.ItemNode.GetMetadata(ProjectFileConstants.Private); string originalHintPath = this.ItemNode.GetMetadata(ProjectFileConstants.HintPath); this.ResolvedAssembly = AssemblyName.GetAssemblyName(this.AssemblyPath); resolvedProperties = new HashSet <string>(StringComparer.OrdinalIgnoreCase); foreach (var str in iteminstance.MetadataNames) { resolvedProperties.Add(str); } prjitem = iteminstance; string hintPath = iteminstance.GetMetadataValue(ProjectFileConstants.HintPath); if (hintPath != originalHintPath) { if (Path.IsPathRooted(hintPath)) { hintPath = PackageUtilities.GetPathDistance(this.ProjectMgr.BaseURI.Uri, new Uri(hintPath)); } if (hintPath != originalHintPath) { this.ItemNode.SetMetadata(ProjectFileConstants.HintPath, hintPath); } // If this is not already set, we default to true if (String.IsNullOrEmpty(privateValue)) { this.ItemNode.SetMetadata(ProjectFileConstants.Private, true.ToString()); } } }
public void SetMetadata() { ProjectItemInstance item = GetItemInstance(); item.SetMetadata("m", "m1"); Assert.Equal("m1", item.GetMetadataValue("m")); }
public void SetMetadataEmptyString() { ProjectItemInstance item = GetItemInstance(); item.SetMetadata("m", String.Empty); Assert.AreEqual(String.Empty, item.GetMetadataValue("m")); }
/// <summary> /// Gets the effective global properties for an item that will get passed to <see cref="MSBuild.Projects"/>. /// </summary> /// <remarks> /// The behavior of this method matches the hardcoded behaviour of the msbuild task /// and the <paramref name="globalPropertyModifiers"/> parameter can contain other mutations done at build time in targets / tasks /// </remarks> private static PropertyDictionary <ProjectPropertyInstance> GetGlobalPropertiesForItem( ProjectItemInstance projectReference, PropertyDictionary <ProjectPropertyInstance> requesterGlobalProperties, IEnumerable <GlobalPropertiesModifier> globalPropertyModifiers = null) { ErrorUtilities.VerifyThrowInternalNull(projectReference, nameof(projectReference)); ErrorUtilities.VerifyThrowArgumentNull(requesterGlobalProperties, nameof(requesterGlobalProperties)); var properties = SplitPropertyNameValuePairs(ItemMetadataNames.PropertiesMetadataName, projectReference.GetMetadataValue(ItemMetadataNames.PropertiesMetadataName)); var additionalProperties = SplitPropertyNameValuePairs(ItemMetadataNames.AdditionalPropertiesMetadataName, projectReference.GetMetadataValue(ItemMetadataNames.AdditionalPropertiesMetadataName)); var undefineProperties = SplitPropertyNames(projectReference.GetMetadataValue(ItemMetadataNames.UndefinePropertiesMetadataName)); var defaultParts = new GlobalPropertyPartsForMSBuildTask(properties.ToImmutableDictionary(), additionalProperties.ToImmutableDictionary(), undefineProperties.ToImmutableList()); var globalPropertyParts = globalPropertyModifiers?.Aggregate(defaultParts, (currentProperties, modifier) => modifier(currentProperties, projectReference)) ?? defaultParts; if (globalPropertyParts.AllEmpty()) { return(requesterGlobalProperties); } // Make a copy to avoid mutating the requester var globalProperties = new PropertyDictionary <ProjectPropertyInstance>(requesterGlobalProperties); // Append and remove properties as specified by the various metadata MergeIntoPropertyDictionary(globalProperties, globalPropertyParts.Properties); MergeIntoPropertyDictionary(globalProperties, globalPropertyParts.AdditionalProperties); RemoveFromPropertyDictionary(globalProperties, globalPropertyParts.UndefineProperties); return(globalProperties); }
public int get_CanonicalName(out string pbstrCanonicalName) { if (output == null) { pbstrCanonicalName = project.Url; return(VSConstants.S_OK); } // Get the output assembly path (including the name) pbstrCanonicalName = output.GetMetadataValue("FullPath"); Debug.Assert(!String.IsNullOrEmpty(pbstrCanonicalName), "Output Assembly not defined"); // Make sure we have a full path pbstrCanonicalName = CommonUtils.GetAbsoluteFilePath(project.ProjectHome, pbstrCanonicalName); return(VSConstants.S_OK); }
public void SetNullMetadataValue() { ProjectItemInstance item = GetItemInstance(); item.SetMetadata("m", null); Assert.Equal(String.Empty, item.GetMetadataValue("m")); }
private void ReportOutputs(ProjectPredictionReporter reporter, ProjectItemInstance masmItem) { reporter.ReportOutputFile(masmItem.GetMetadataValue(ObjectFileNameMetadata)); string assembledCodeListingFile = masmItem.GetMetadataValue(AssembledCodeListingFileMetadata); if (!string.IsNullOrWhiteSpace(assembledCodeListingFile)) { reporter.ReportOutputFile(assembledCodeListingFile); } string browseFile = masmItem.GetMetadataValue(BrowseFileMetadata); if (!string.IsNullOrWhiteSpace(browseFile)) { reporter.ReportOutputFile(browseFile); } }
public void BuiltInMetadataInMetadataCondition() { string content = @" <Project> <ItemGroup> <i Include='i1'> <m Condition=""'%(Identity)'=='i1'"">m1</m> <n Condition=""'%(Identity)'=='i2'"">n1</n> </i> </ItemGroup> </Project> "; ProjectItemInstance item = GetOneItem(content); Assert.Equal("m1", item.GetMetadataValue("m")); Assert.Equal(String.Empty, item.GetMetadataValue("n")); }
/// <summary> /// Get the file location as seen in the IDE, used for ResourceDictionary.Source resolution. /// </summary> private string GetSourceLink(ProjectItemInstance projectItemInstance) { if (projectItemInstance.HasMetadata("Link")) { return(projectItemInstance.GetMetadataValue("Link")); } return(projectItemInstance.EvaluatedInclude); }
private static void AssertItemHasMetadata(Dictionary <string, string> expected, ProjectItemInstance item) { Assert.Equal(expected.Keys.Count, item.DirectMetadataCount); foreach (var key in expected.Keys) { Assert.Equal(expected[key], item.GetMetadataValue(key)); } }
/// <summary> /// Returns a value indicating if the specified <see cref="ProjectItemInstance"/> /// originated in an imported file. /// </summary> /// <returns> /// <see langword="true"/> if <paramref name="item"/> originated in an imported file; /// otherwise, <see langword="false"/> if it was defined in the project being built. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="item"/> is <see langword="null"/>. /// </exception> public static bool IsImported(this ProjectItemInstance item) { Requires.NotNull(item, nameof(item)); string definingProjectFullPath = item.GetMetadataValue("DefiningProjectFullPath"); string projectFullPath = item.Project.FullPath; // NOTE: This returns project being built, not owning target return(!StringComparers.Paths.Equals(definingProjectFullPath, projectFullPath)); }
public void BuiltInMetadataInMetadataCondition() { string content = @" <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003' > <ItemGroup> <i Include='i1'> <m Condition=""'%(Identity)'=='i1'"">m1</m> <n Condition=""'%(Identity)'=='i2'"">n1</n> </i> </ItemGroup> </Project> "; ProjectItemInstance item = GetOneItem(content); Assert.Equal("m1", item.GetMetadataValue("m")); Assert.Equal(String.Empty, item.GetMetadataValue("n")); }
public static string SafeGetMetadataValue(this ProjectItemInstance item, string name) { string result = null; try { result = item.GetMetadataValue(name); } catch (Exception) { } return(result); }
internal string GetMsBuildProperty(string propName) { if (resolvedProperties != null && prjitem != null) { if (resolvedProperties.Contains(propName)) { return(prjitem.GetMetadataValue(propName)); } } return(""); }
public static bool ShouldCopyToOutputDirectory(this ProjectItemInstance item) { var copyToOutputDirectoryValue = item.GetMetadataValue("CopyToOutputDirectory"); if (copyToOutputDirectoryValue.Equals("Always", StringComparison.OrdinalIgnoreCase) || copyToOutputDirectoryValue.Equals("PreserveNewest", StringComparison.OrdinalIgnoreCase)) { return(true); } return(false); }
// Internal for testing internal static string[] GetConfiguredExtensionNames(ProjectItemInstance configurationItem) { var extensionNamesValue = configurationItem.GetMetadataValue(RazorConfigurationItemTypeExtensionsProperty); if (string.IsNullOrEmpty(extensionNamesValue)) { return(Array.Empty <string>()); } var configuredExtensionNames = extensionNamesValue.Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries); return(configuredExtensionNames); }
public void CreateItemWithNullMetadataValue() { Project project = new Project(); ProjectInstance projectInstance = project.CreateProjectInstance(); IDictionary <string, string> metadata = new Dictionary <string, string>(); metadata.Add("m", null); ProjectItemInstance item = projectInstance.AddItem("i", "i1", metadata); Assert.Equal(String.Empty, item.GetMetadataValue("m")); }
private static void AssertExpectedStyleCopSetting(string expectedValue, BuildResult actualResult) { Assert.IsNotNull(actualResult.ProjectStateAfterBuild, "Test error: ProjectStateAfterBuild should not be null"); IEnumerable <ProjectItemInstance> matches = actualResult.ProjectStateAfterBuild.GetItemsByItemTypeAndEvaluatedInclude(BuildTaskConstants.SettingItemName, TargetConstants.StyleCopProjectPathItemName); Assert.AreNotEqual(0, matches.Count(), "Expected SonarQubeSetting with include value of '{0}' does not exist", TargetConstants.StyleCopProjectPathItemName); Assert.AreEqual(1, matches.Count(), "Only expecting one SonarQubeSetting with include value of '{0}' to exist", TargetConstants.StyleCopProjectPathItemName); ProjectItemInstance item = matches.Single(); string value = item.GetMetadataValue(BuildTaskConstants.SettingValueMetadataName); Assert.AreEqual(expectedValue, value, "SonarQubeSetting with include value '{0}' does not have the expected value"); }
public void CastToITaskItem() { ProjectItemInstance item = GetItemInstance(); item.SetMetadata("m", "m1"); ITaskItem taskItem = (ITaskItem)item; Assert.Equal(item.EvaluatedInclude, taskItem.ItemSpec); Assert.Equal(1 + BuiltInMetadataCount, taskItem.MetadataCount); Assert.Equal(1 + BuiltInMetadataCount, taskItem.MetadataNames.Count); Assert.Equal("m1", taskItem.GetMetadata("m")); taskItem.SetMetadata("m", "m2"); Assert.Equal("m2", item.GetMetadataValue("m")); }
public void BuiltInMisqualifiedMetadataExpression() { string content = @" <Project> <ItemGroup> <i Include='i1'> <m>%(j.Identity)</m> </i> </ItemGroup> </Project> "; ProjectItemInstance item = GetOneItem(content); Assert.Equal(String.Empty, item.GetMetadataValue("m")); }
public void BuiltInMisqualifiedMetadataExpression() { string content = @" <Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003' > <ItemGroup> <i Include='i1'> <m>%(j.Identity)</m> </i> </ItemGroup> </Project> "; ProjectItemInstance item = GetOneItem(content); Assert.Equal(String.Empty, item.GetMetadataValue("m")); }
private void ReportInputs(ProjectPredictionReporter reporter, ProjectItemInstance masmItem, HashSet <string> reportedIncludes) { reporter.ReportInputFile(masmItem.EvaluatedInclude); string[] includePaths = masmItem.GetMetadataValue(IncludePathsMetadata) .Split(IncludePathsSeparator, StringSplitOptions.RemoveEmptyEntries); // Avoid reporting paths that we've already reported for this project. foreach (string includePath in includePaths) { string trimmedPath = includePath.Trim(); if (!string.IsNullOrEmpty(trimmedPath) && reportedIncludes.Add(trimmedPath)) { reporter.ReportInputDirectory(trimmedPath); } } }